2019-05-02 09:44:40 slozer 阅读数 128
  • 深度学习基础与TensorFlow实践教程

    本课程主要介绍了深度学习的基础原理和TensorFlow系统基本使用方法。TensorFlow是目前机器学习、深度学习领域优秀的计算系统之一,本课程将结合实例介绍使用TensorFlow开发机器学习应用的详细方法和步骤,着重讲解了用于图像识别的卷积神经网络和用于自然语言处理的循环神经网络的理论知识及其TensorFlow实现方法,并结合实际场景和例子描述了深度学习技术的应用范围与效果。 所有案例均来自讲师团队工作中的亲身实践,所选案例均是深度学习的经典应用,非常具有代表性。

    21447 人正在学习 去看看 AI100讲师

论述及例子来自于《深度学习-基于keras的python实践》

CNTK是微软出品的一个开源的深度学习工具包,Tensorflow就不加以阐述;这两个类库虽然强大,但实际运用中直接使用是非常困难的。本文会介绍一个构建在CNTK和Tensorlow上的,用来快速创建深度学习模型的python类库,就是keras

安装问题

工欲善其事,必先利其器。我在安装时踩了许多坑,花费了不少时间才把环境安装好,在这里把步骤记录下来。

1.按照书上的指示 ,在终端执行如下操作

 pip install …

其中…是CNTK官方安装指南上相应的版本,比如说py36的是https://cntk.ai/PythonWheel/CPU-Only/cntk-2.7.post1-cp36-cp36m-win_amd64.whl
2.但是这样就报错

…is not a supported  wheel on this platform

百度后通过命令

import pip._internal
print(pip.internal.pep425tags.get_supported())

查看可安装格式(还有更改扩展名的方法尝试后发现行不通),后发现cntk现在只支持python3.6及以下版本,但已经下好的anaconda是3.7的,卸载后重新下载3.6版本的太麻烦(后发现无3.6版本)
3.选择在原有anaconda中安装py36版本(anaconda支持多个py版本安装)
通过命令

conda create -n py36 python=3.6 anaconda

安装,后出现问题,HTTPERROR,解决办法:加入清华镜像站。
4.将清华镜像站去除,换为中科大镜像站后发现不能移出
后有评论说,清华大学和中科大已经宣布停止提供anaconda镜像服务,
5.在终端输出python,显示py37版本,后进入tensorflow中,发现py36版本
于是返回第一步,cntk安装完成。
在这里插入图片描述在这里插入图片描述
6.ketas安装无问题,按照书上指示即可。
在这里插入图片描述

另外,可以看到tensorflow中python为3.6版本而系统中python为3.7版本,所以选择在tensorflow中安装相应工具包
在这里插入图片描述

在jupyter notebook中运行成功
在这里插入图片描述

例子

在jupyternotebook中进行操作,学习深度学习工作步骤。
1.印第安人糖料病诊断
2.手写数字识别
3.爱丽丝梦游仙境

2017-09-14 16:55:00 weixin_34186128 阅读数 34
  • 深度学习基础与TensorFlow实践教程

    本课程主要介绍了深度学习的基础原理和TensorFlow系统基本使用方法。TensorFlow是目前机器学习、深度学习领域优秀的计算系统之一,本课程将结合实例介绍使用TensorFlow开发机器学习应用的详细方法和步骤,着重讲解了用于图像识别的卷积神经网络和用于自然语言处理的循环神经网络的理论知识及其TensorFlow实现方法,并结合实际场景和例子描述了深度学习技术的应用范围与效果。 所有案例均来自讲师团队工作中的亲身实践,所选案例均是深度学习的经典应用,非常具有代表性。

    21447 人正在学习 去看看 AI100讲师
定义云深度学习平台什么是云深度学习?随着机器学习的发展,单机运行的机器学习任务存在缺少资源隔离、无法动态伸缩等问题,因此要用到基于云计算的基础架构服务。云机器学习平台并不是一个全新的概念,Google、微软、亚马逊等都有相应的服务,这里列举几个比较典型的例子。

定义云深度学习平台什么是云深度学习?随着机器学习的发展,单机运行的机器学习任务存在缺少资源隔离、无法动态伸缩等问题,因此要用到基于云计算的基础架构服务。云机器学习平台并不是一个全新的概念,Google、微软、亚马逊等都有相应的服务,这里列举几个比较典型的例子。

第一个是Google Cloud Machine Learning Engine,它底层托管在Google Cloud上,上层封装了Training、Prediction、Model Service等机器学习应用的抽象,再上层支持了Google官方的TensorFlow开源框架。

亚马逊也推出了Amzon machine learning平台,它基于AWS的Iaas架构,在Iaas上提供两种不同的服务,分别是可以运行MXNet等框架的EC2虚拟机服务,以及各种图象、语音、自然语言处理的SaaS API。

此外,微软提供了Azure Machine Learning Studio服务,底层也是基于自己可伸缩、可拓展的Microsoft Azure Cloud服务,上层提供了拖拽式的更易用的Studio工具,再上面支持微软官方的CNTK等框架,除此之外微软还有各种感知服务、图象处理等SaaS API,这些服务都是跑在Scalable的云基础平台上面。

云深度学习平台架构与实践的必经之路1

  相关厂商内容

基于卷积神经网络在手机端实现文档检测 阿里巴巴集团千亿级别店铺系统架构平台化技术实践 携程第四代架构之软负载 SLB 实践之路 解读百度PB级数据仓库Palo开源架构 相关赞助商

与100+国内外技术专家探索2017前瞻热点技术

以上这些都是业界比较成熟的云深度学习平台,而在真实的企业环境中,我们为什么还需要实现Cloud Machine Learning服务呢?

首先国外的基础设施并不一定是国内企业可以直接使用的,而如果只是本地安装了TensorFlow,那也只能在裸机上进行训练,本地默认没有资源隔离,如果同时跑两个训练任务就需要自己去解决资源冲突的问题。因为没有资源隔离,所以也做不了资源共享,即使你有多节点的计算集群资源,也需要人工的约定才能保证任务不会冲突,无法充分利用资源共享带来的便利。此外,开源的机器学习框架没有集群级别的编排功能,例如你想用分布式TensorFlow时,需要手动在多台服务器上启动进程,没有自动的Failover和Scaling。因此,很多企业已经有机器学习的业务,但因为缺少Cloud Machine Learning平台,仍会有部署、管理、集群调度等问题。

云深度学习平台架构与实践的必经之路2

  那么如何实现Cloud Machine Learning平台呢?

我们对云深度学习服务做了一个分层,第一层是平台层,类似于Google cloud、Azure、AWS这样的IaaS层,企业内部也可以使用一些开源的方案,如容器编排工具Kubernetes或者虚拟机管理工具OpenStack。有了这层之后,我们还需要支持机器学习相关的功能,例如Training、Prediction、模型上线、模型迭代更新等,我们在Machine Learning Layer层对这些功能进行抽象,实现了对应的API接口。最上面是模型应用层,就可以基于一些开源的机器学习类库,如TensorFlow、MXNet等。

云深度学习平台架构与实践的必经之路3

整个Cloud Machine learning运行在可伸缩的云服务上,包行了模型开发、模型训练,以及模型服务等功能,形成一个完整的机器学习工作流。但这并不是一个闭环,我们在实践中发现,线上的机器学习模型是有时效性的,例如新闻推荐模型就需要及时更新热点新闻的样本特征,这时就需要把闭环打通,把线上的预测结果加入到线下的训练任务里,然后通过在线学习或者模型升级,实现完整的机器学习闭环,这些都是单机版的机器学习平台所不能实现的。

云深度学习平台架构与实践的必经之路4

打造云深度学习平台主要包含以下几个组件:首先是客户端访问的API Service,作为服务提供方,我们需要提供标准的RESTful API服务,后端可以对接一个Kubernetes集群、OpenStack集群、甚至是自研的资源管理系统。客户端请求到API服务后,平台需要解析机器学习任务的参数,通过Kubernetes或者OpenStack来创建任务,调度到后端真正执行运算的集群资源中。如果是训练任务,可以通过起一个训练任务的Container,里面预装了TensorFlow或MXNet运行环境,通过这几层抽象就可以将单机版的TensorFlow训练任务提交到由Kubernetes管理的计算集群中运行。在模型训练结束后,系统可以导出模型对应的文件,通过请求云深度学习平台的API服务,最终翻译成Kubernetes可以理解的资源配置请求,在集群中启动TensorFlow Serving等服务。除此之外,在Google Cloud-ML最新的API里多了一个Prediction功能,预测时既可以启动在线Service,也可以启动离线的Prediction的任务,平台只需要创建对应的Prediction的容器来做Inference和保存预测结果即可 。通过这种简单的封装,就可以实现类似Google Cloud-ML的基础架构了。

云深度学习平台架构与实践的必经之路5

  架构上进行了分层抽象,实现上也只需要三步。

第一步是创建一个Docker镜像,下面的Dockerfile例子是从TensorFlow项目中截取出来的,官方已经提供了一个可以运行的Docker镜像,通过加入定制的启动脚本就可以实现开发环境、模型训练以及模型服务等功能。

第二步是实现一个标准的API服务,下面是一个Python实现的实例,用户发送一个启动训练任务的请求,服务端可以解析请求的参数和内容,并将任务提交到Kubernetes等后端集群中。

第三步是生成Kubernetes所需的文件格式,下面的JSON文件大家也可以在GitHub中找到,实现了将分布式TensorFlow任务提交到Kubernetes集群中运行。

我们通过简单的三个配置就可以完成机器学习任务从本地到云端的迁移过程,也就是实现了Cloud Machine Learning服务。前面提到云深度学习平台需要支持资源隔离和资源共享,这是如何实现的呢,其实Kubernetes本身就有这个抽象,用户可以在请求时申明需要的CPU、内存、甚至是GPU资源,通过cgroups、namespace等容器技术来实现资源隔离,而kube-scheduler实现了资源调度和资源共享等功能。实现自研或者公有云的Cloud Machine Learning平台,开发者可以很容易提交训练任务、创建模型服务等,但在一个真实的机器学习场景中,只解决计算资源的隔离和调度是远远不够的,我们还需要重新思考如何集成数据处理、特征工程等问题。

云深度学习平台架构与实践的必经之路6

重新定义云深度学习平台TensorFlow是一个可用于深度学习的数值计算库,基于TensorFlow可以实现MLP、CNN、RNN等机器学习模型,但有了它是不是就不需要Spark呢?他们的关系是什么?

在生产环境中,我们发现TensorFlow并没有完全取代已有的大数据处理工具,我们需要用Spark做数据分析和特征工程,还需要数据仓库等服务去存储和查询结构化数据。TensorFlow是一个非常优秀的深度学习框架,但在真实场景中用户还需要一些PowerGraph处理的图关系特征作为输入,这都是单独一个框架无法解决的。对于用户的建模流程如何组织、如何做数据清洗、如何做特征抽取、如何上线训练好的模型、如何预估模型效果,这些可以使用Azure ML Studio工具去完成,而且是TensorFlow所缺乏的。

前面我们介绍了Cloud Machine Learning,可以实现一个类似Google的分布式、高可用、带集群编排的计算平台,但这远远不够,因为我们还需要使用大数据处理的框架,包括MapReduce、流式处理、图计算等框架。TensorFlow只是整个机器学习流程里面做模型训练其中一部分,我们可能还需要Kubernetes做CPU、GPU的管理和调度。如果我们要完成一个机器学习的业务,就需要同时掌握TensorFlow、Spark、Hadoop、Hive、Kubernetes等框架的原理和应用,而不只是提供一个Google Cloud-ML或者AWS服务就够了,这也是我们要重新定义Cloud Machine Learning的原因。

前面在客观上我们需要这么多知识,但主观上我们希望有什么呢?我们更希望有一个从数据处理到模型训练再到模型上线的一个全闭环服务,而不仅仅是机器学习框架或者通用计算平台,我们希望不写代码就可以做特征抽取的工作,我们希望机器学习的工作流是很容易描述的,而不需要通过编写代码的方式来实现,我们需要一个很灵活的基础架构可以支持各种异构的计算资源,我们希望平台是可拓展的可以实现自动Failover和Scaling。 除了前面提到的Google、微软、亚马逊做的云机器学习平台,我们还需要从IaaS、PaaS、SaaS多维度上提供使用接口,满足不同层次用户的使用需求,另一方面这应该是低门槛的产品服务,让任意的领域专家都可以轻易使用。

后面我们会介绍在真实场景下如何改造Cloud Machine Learning平台,并且介绍第四范式对外提供的低门槛、分布式、高可用的先知机器学习平台。

云深度学习平台架构与实践的必经之路7

第四范式的云深度学习实践经验第四范式先知平台是一个基于Cloud的全流程机器学习产品,用户通过Web登陆到先知平台就可以使用模型调研、预估服务的功能,并且可以通过拖拽的方式来描述机器学习的工作流 。

它的使用步骤如下,第一步是数据预处理,用户不需要写Spark代码而只需要拖拽出一个图标,我们称之为一个算子,然后就可以提交数据清洗等数据预处理任务了。通过拖拽数据拆分算子,可以将数据集拆分为训练集和测试集两部分,其中一部分留在左边用于特征抽取。一般来说,用Spark、Mapreduce等开源工具也可以做特征抽取,但对编程技能和工程能力有一定的要求,我们通过定义特征抽取的配置或者脚本,让用户可以不写代码也可以实现对原始数据集的特征工程。然后,连接我们自主研发的高维逻辑回归、高维GBDT等模型训练算子,也可以连接基于开源的TensorFlow或者MXNet等框架实现的算法。最后,经过模型训练得到模型文件后,用刚刚拆分出来的测试集进行模型预测,还可以使用通用的模型评估算子进行AUC、ROC、Logloss等指标的可视化展示。

在先知平台上,用户只需要通过构建流程图的方式,就可以实现数据处理、模型训练等功能,真正解决真实场景下机器学习业务的问题。在先知平台的最新版本中,提供了以极高的效率生成特征工程配置脚本,获取自主研发的LR、GBDT算法的最佳参数等AutoML特性。这些特性能够大幅降低在获取一个有效建模方案过程中的重复性劳动,也可以有效辅助数据科学家获得对数据的初步理解。在一些场景下,能够获得媲美甚至超越专家建模的效果。

云深度学习平台架构与实践的必经之路8

  目前先知平台主要解决以下几个目标场景:

1. 简化数据引入,平台不要求数据必须使用分布式存储,也可以直接从RDBMS这类的SQL数据库中导入训练样本数据。

2. 简化数据拆分,用户不需要写Spark代码,只需要提供数据拆分后的存储路径,并且支持按比例拆分或者按规则拆分两种模式。

3. 简化特征抽取,平台支持连续特征、离散特征的抽取和组合,对于连续特征支持自动化的多分桶算法,我们也会归纳常用的特征抽取方法并且封装成脚本或者配置,用户只需了解对应的配置而不需要自己编码实现具体的逻辑。平台还可以根据已有的特征配置自动进行特征组合拓展,提升模型效果。

4. 简化模型训练,平台可以支持开源的机器学习算法实现和第四范式自主研发的超高维度LR算法,这个LR算法实现了Parameter server可以解决几十亿、上百亿特征维度的高速分布式训练问题。对于学习率、正则化参数等可以做到自动调优。另外,平台还提供了线性分形分类器等扩展算法,可以无须人为干预的更加有效利用数值类特征。

5. 简化模型评估,得到模型预估结果后,我们可以计算模型的ROC、Logloss、K-S等指标,不同模型计算指标的方式是类似的,用户就不需要重复编写实现代码,直接通过拖拽算子调用即可,以上都是先知平台所解决的问题。

6. 简化模型上线,对于常见的高维LR/GBDT模型,可以一键发布为线上服务实例,不仅简化了模型的部署和运维,而且上线实例还包括大部分的特征工程逻辑,无须手动再次开发特征处理逻辑的线上版本。

云深度学习平台架构与实践的必经之路9

目前,先知平台已经成功应用于银行、金融和互联网等各行各业,基于“先知平台”的反欺诈模型能够帮助银行在毫秒级识别可疑交易,同时在新闻、视频、音频等内容推荐场景下,“先知平台”也成功大幅度提升关键业务指标。此外,在赋能企业利用机器学习升级运营效率的同时,更有意义的是,“先知平台”也极大地降低了机器学习的使用门槛。

作为一个针对全流程机器学习业务的人工智能平台,先知封装了从数据处理、模型训练到模型上线和反馈更新的系统闭环,用户不再需要很强的编程技术和工程能力,领域专家和业务人员都可以通过推拽方式进行建模和上线,帮助企业快速实现从数据收集到业务价值提升的终极目标。

云深度学习平台架构与实践的必经之路10

随着专利算法的不断更新,更加实时高效的极致工程优化,未来先知平台将进一步降低人工智能工业应用的门槛,帮助越来越多的企业享受人工智能服务。



本文转自d1net(转载)

2016-03-01 14:38:58 qq_33771258 阅读数 2729
  • 深度学习基础与TensorFlow实践教程

    本课程主要介绍了深度学习的基础原理和TensorFlow系统基本使用方法。TensorFlow是目前机器学习、深度学习领域优秀的计算系统之一,本课程将结合实例介绍使用TensorFlow开发机器学习应用的详细方法和步骤,着重讲解了用于图像识别的卷积神经网络和用于自然语言处理的循环神经网络的理论知识及其TensorFlow实现方法,并结合实际场景和例子描述了深度学习技术的应用范围与效果。 所有案例均来自讲师团队工作中的亲身实践,所选案例均是深度学习的经典应用,非常具有代表性。

    21447 人正在学习 去看看 AI100讲师

           Cntk学习日志(一)

微软在二月开源了自己的深度学习框架cntk,以便于更多的开发者可以更快的架构神经网络以完成深度学习,我的一位导师对其寄予很大期望和信心,他认为这个框架可以完成:

以下都是随便举的例子,如有不适请忽略:

·比如根据识别妹子的 语音,给妹子打分(萌妹子值99%,or 腐女70%)。

·比如水果识别,药品 识别,扫一扫就知道这是什么水果,含有那些维生素,或药品说明书。

·比如根据用户上传的 图片,识别出图片里的各种东西,根据图片里的东西编一个故事。

一切学习都要从配置环境开始。首先我们要在github上下载cntk的最新发行版本https://github.com/Microsoft/CNTK/releases。这款框架支持linuxwindows版本,同时微软称其可以用gpu来提升速度,但需要用到cuda并行计算,所以想用gpu运行需要显卡为N卡,由于我是a卡,所以第一次我下载的是这个版本CNTK-2016-02-08-Windows-64bit-CPU-Only.zip,但其中Multigpu.cntk这个附带的demo无法正常运行,后来得知这个版的的此demo是专为gpu并行运算提供的demo,我比较推荐使用这个版本的CNTK-2016-02-08-Windows-64bit-GPU-1bit-SGD.zip cntk因为此版本看起来兼容性更高只要不更改参数依旧可以只是用cpu来跑demo,不会出现错误。下载完包之后应该配置两个环境变量ACML_FMA=0(这个环境变量好像和cpu多线程有关),Path到你的cntk,这个变量只是为了用命令行时使用cntk更方便,还应该安装一个mpi,因为cntk对于cpu多线程要求较高没有mpi有些demo无法运行。

安装完以上之后就可以试一试跑跑cntk压缩包中example文件夹中附带的demo,Other/Simple2d/这个demo是用来合成二维数据的,运行起来也相对简单,应该先进入命令行模式,进入Other/Simple2d/config文件夹,然后输入命令:cntk configFile=Simple.cntk,就可以运行此demo运行完成后将会产生output/model文件夹,在这个文件夹中会有几个深层神经网络文件,如果你对于此比较好奇,可以下载dot.exe,然后更改Simple.cntk文件,command = Simple_Demo_Train:Simple_Demo_Test这条命令变更为command = Simple_Demo_Train:Simple_Demo_Test:topoplot

然后在文件最下端添加

 

 

 

topoplot = [

    action = "plot"

 

#这行命令是你所生成的神经网络的路径    modelPath="D:\CNTK\cntk\Examples\Other\Simple2d\Output\Models\Simple.dnn"

 

 

    #生成dot文件

    outputdotFile = "Output\lstm.model.dot" 

 

    #输出dot文件的位置

    outputFile="Output\lstm.model.jpg" 

 

   #这行命令为你所下载的dot.exe文件路径加要生成图像的dot文件和图像的名称

    renderCmd="D:\CNTK\cntk\cntk\dot\bin\dot.exe -Tjpg <IN> -Output\lstm.model.dot<OUT>-Output\lstm.model.jpg"

]

 

 

 

 

再次运行cntk configFile=Simple.cntk就会得到一张大概的神经网络图像以便于观察。

*文章未完,图为生成的神经网络图,由于笔者是小白,如文章有误,多谢指正。

2018-01-07 19:47:55 qq_34739497 阅读数 133
  • 深度学习基础与TensorFlow实践教程

    本课程主要介绍了深度学习的基础原理和TensorFlow系统基本使用方法。TensorFlow是目前机器学习、深度学习领域优秀的计算系统之一,本课程将结合实例介绍使用TensorFlow开发机器学习应用的详细方法和步骤,着重讲解了用于图像识别的卷积神经网络和用于自然语言处理的循环神经网络的理论知识及其TensorFlow实现方法,并结合实际场景和例子描述了深度学习技术的应用范围与效果。 所有案例均来自讲师团队工作中的亲身实践,所选案例均是深度学习的经典应用,非常具有代表性。

    21447 人正在学习 去看看 AI100讲师

前言

深度学习在计算机视觉上有很大突破,经典的数据集也有很多,比如:ImageNet(李飞飞带领团队收集)、CIFARCOCO(微软赞助)、Open Image(谷歌开源的),而卷积的概念不是深度学习出现才有的,而是计算机图形学中早就有的概念,我认为它能够提取图像有用的信息。其实这里面的东西还是比较复杂的,这一篇算是稍微开个头吧。
MNIST作为入门案例,我们继续以它作为实践例子来实践深度学习的模型。

卷积计算

这里写图片描述
比如我们可以用这种3*3的垂直过滤器和水平过滤器来提取图片的边缘检测,通过最后的加权和来的到最后结果。
池化层的计算也差不多,不同的是,使用最大值操作的池化层称为最大池化层,使用平均值的称为平均池化层,但目前实践中我们一般用最大池化层。

LeNet-5 模型

这是Yann LeCun教授1998年在论文中提出,感兴趣的可以看这里
这里写图片描述
这是论文中模型图的概要,首先输入图片的亮度矩阵,经过第一个卷积层过滤器的尺寸5*5,深度为6,不使用全0填充,计算后的结果就是28*28,深度依旧为6.然后经过长宽为2,步长为2的过滤器,所以长宽变为原来一半,池化层不改变深度。后面还有一个卷积层和一个池化层,最后又经过两层120和84节点数的全连接层,最后输出10个分类的概率。

代码实现

mnist_infernece.py代码

import tensorflow as tf
INPUT_NODE=784#也就是图片28*28*1,由于只有一个通道
OUTPUT_NODE=10#输出分类
IMAGE_SIZE=28#输入图片像素大小
NUM_CHANNELS=1#通道数
NUM_LABELS=10#10个分类标签

CONV1_DEEP=32#第一个卷积层深度
CONV1_SIZE=5#卷积层的长宽

CONV2_DEEP=64#第二个卷积层深度
CONV2_SIZE=5#卷积层长宽

FC_SIZE=512#全连接层节点数

def get_weight_variable(shape,regularizer):#是否正则化
    weights=tf.get_variable("weights",shape,initializer=tf.truncated_normal_initializer(stddev=0.1))
    if regularizer !=None:
        tf.add_to_collection('losses',regularizer(weights))
    return weights

def inference(input_tensor,train,regularizer):#定义LeNet-5模型
    with tf.variable_scope('layer1-conv1'):#命名空间定义第一个卷积层
        conv1_weights=tf.get_variable("weight",[CONV1_SIZE,CONV1_SIZE,NUM_CHANNELS,CONV1_DEEP],initializer=tf.truncated_normal_initializer(stddev=0.1))#卷积层的参数定义成四维矩阵,由卷积层长宽,图片的通道数,由于手写图片是灰白,所以通道数始终是1,以及第一个卷积层深度构成。
        conv1_biases=tf.get_variable("bias",[CONV1_DEEP],initializer=tf.constant_initializer(0.0))#偏差b
        conv1=tf.nn.conv2d(input_tensor,conv1_weights,strides=[1,1,1,1],padding='SAME')#padding=‘SAME’使用0填充,可以保证结果长宽不变
        relu1=tf.nn.relu(tf.nn.bias_add(conv1,conv1_biases))#导入激活函数Relu
    with tf.variable_scope('layer2-pool1'):#第一个池化层
        pool1=tf.nn.max_pool(relu1,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')#使用最大池化层

    with tf.variable_scope('layer3-conv2'):#命名空间定义第二个卷积层
        conv2_weights = tf.get_variable(
            "weight", [CONV2_SIZE, CONV2_SIZE, CONV1_DEEP, CONV2_DEEP],
            initializer=tf.truncated_normal_initializer(stddev=0.1))
        conv2_biases=tf.get_variable("bias",[CONV2_DEEP],initializer=tf.constant_initializer(0.0))
        conv2=tf.nn.conv2d(pool1,conv2_weights,strides=[1,1,1,1],padding='SAME')
        relu2=tf.nn.relu(tf.nn.bias_add(conv2,conv2_biases))

    with tf.name_scope('layer4-pool2'):
        pool2=tf.nn.max_pool(relu2,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')

    pool_shape=pool2.get_shape().as_list()
    nodes=pool_shape[1]*pool_shape[2]*pool_shape[3]
    reshaped=tf.reshape(pool2,[pool_shape[0],nodes])
    with tf.variable_scope('layer5-fc1'):
        fc1_weights=tf.get_variable("weight",[nodes,FC_SIZE],initializer=tf.truncated_normal_initializer(stddev=0.1))
        if regularizer!=None:
            tf.add_to_collection('losses',regularizer(fc1_weights))
        fc1_biases=tf.get_variable("bias",[FC_SIZE],initializer=tf.constant_initializer(0.1))
        fc1=tf.nn.relu(tf.matmul(reshaped,fc1_weights)+fc1_biases)
        if train:
            fc1=tf.nn.dropout(fc1,0.5)#dropout可以随机将节点置为0,可以避免过拟合

    with tf.variable_scope('layer6-fc2'):
        fc2_weights=tf.get_variable("weight",[FC_SIZE,NUM_LABELS],initializer=tf.truncated_normal_initializer(stddev=0.1))
        if regularizer!=None:
            tf.add_to_collection('losses',regularizer(fc2_weights))
        fc2_biases=tf.get_variable("bias",[NUM_LABELS],initializer=tf.constant_initializer(0.1))
        logit=tf.matmul(fc1,fc2_weights)+fc2_biases
    return logit

mnist_train.py代码实现

import os
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_inference
import numpy as np
import pandas as pd
BATCH_SIZE=100#batch大小
LEARNING_RATE_BASE=0.01#学习率初始值
LEARNING_RATE_DECAY=0.99
REGULARAZTION_RATE=0.0001
TRAINING_STEPS=10000#迭代次数
MOVING_AVERAGE_DECAY=0.99
MODEL_SAVE_PATH="C:\\Users\\user\\Desktop"#永久化存储模型路径
MODEL_NAME="model.ckpt"
def train(mnist):
    x=tf.placeholder(tf.float32,[BATCH_SIZE,mnist_inference.IMAGE_SIZE,mnist_inference.IMAGE_SIZE,mnist_inference.NUM_CHANNELS],name='x-input')#定义输入变量结构
    y_=tf.placeholder(tf.float32,[None,mnist_inference.OUTPUT_NODE],name='y-input')

    regularizer=tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)#采用L2正则化防止过拟合
    y=mnist_inference.inference(x,False,regularizer)
    global_step=tf.Variable(0,trainable=False)
    variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)#定义滑动平滑是预测更健壮
    variables_averages_op = variable_averages.apply(tf.trainable_variables())
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_, 1))#定义交叉熵损失函数
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    loss = cross_entropy_mean + tf.add_n(tf.get_collection('losses'))
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
    mnist.train.num_examples / BATCH_SIZE,
        LEARNING_RATE_DECAY,
        staircase=True)
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)#反向传播利用梯度下降最小化损失函数
    with tf.control_dependencies([train_step, variables_averages_op]):
        train_op = tf.no_op(name='train')


    saver = tf.train.Saver()
    with tf.Session() as sess:
        tf.global_variables_initializer().run()

        for i in range(TRAINING_STEPS):
            xs,ys=mnist.train.next_batch(BATCH_SIZE)
            reshaped_xs=np.reshape(xs,(BATCH_SIZE,mnist_inference.IMAGE_SIZE,mnist_inference.IMAGE_SIZE,mnist_inference.NUM_CHANNELS))
            _, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: reshaped_xs, y_: ys})

            if i % 1000 == 0:
                print("After %d training step(s), loss on training batch is %g." % (step, loss_value))
                saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step)
def main(argv=None):
    mnist=input_data.read_data_sets("C:\\Users\\user\\Desktop\\",one_hot=True)
    train(data)

if __name__ == '__main__':
    tf.app.run()

训练结果:
这里写图片描述

mnist.eval.py代码实现

import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_inference
import mnist_train
import numpy as np
EVAL_INTERVAL_SECS=10
def evaluate(mnist):
    with tf.Graph().as_default() as g:
        x=tf.placeholder(tf.float32,[10000,mnist_inference.IMAGE_SIZE,mnist_inference.IMAGE_SIZE,mnist_inference.NUM_CHANNELS],name='x-input')
        y_=tf.placeholder(tf.float32,[None,mnist_inference.OUTPUT_NODE],name='y-input')
        xs,ys=mnist.train.next_batch(BATCH_SIZE)
        reshaped_xs =  np.reshape(xs.values,(10000,mnist_inference.IMAGE_SIZE,mnist_inference.IMAGE_SIZE,mnist_inference.NUM_CHANNELS))
        validate_feed={x:reshaped_xs,y_:ys}
        y=mnist_inference.inference(x,False,None)
        correct_prediction=tf.equal(tf.arg_max(y,1),tf.arg_max(y_,1))
        accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
        variable_averages=tf.train.ExponentialMovingAverage(mnist_train.MOVING_AVERAGE_DECAY)
        variables_to_restore=variable_averages.variables_to_restore()
        saver=tf.train.Saver(variables_to_restore)
        while True:
            with tf.Session() as sess:
                ckpt = tf.train.get_checkpoint_state(mnist_train.MODEL_SAVE_PATH)
                if ckpt and ckpt.model_checkpoint_path:
                    saver.restore(sess, ckpt.model_checkpoint_path)
                    global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
                    accuracy_score = sess.run(accuracy, feed_dict=validate_feed)
                    print("After %s training step(s), validation accuracy = %g" % (global_step, accuracy_score))
                else:
                    print('No checkpoint file found')
                    return
            time.sleep(EVAL_INTERVAL_SECS)

def main(argv=None):
    mnist=input_data.read_data_sets("C:\\Users\\user\\Desktop\\",one_hot=True)
    evaluate(data)
if __name__ == '__main__':
    tf.app.run()

这里写图片描述

2017-09-04 09:12:27 kwame211 阅读数 2617
  • 深度学习基础与TensorFlow实践教程

    本课程主要介绍了深度学习的基础原理和TensorFlow系统基本使用方法。TensorFlow是目前机器学习、深度学习领域优秀的计算系统之一,本课程将结合实例介绍使用TensorFlow开发机器学习应用的详细方法和步骤,着重讲解了用于图像识别的卷积神经网络和用于自然语言处理的循环神经网络的理论知识及其TensorFlow实现方法,并结合实际场景和例子描述了深度学习技术的应用范围与效果。 所有案例均来自讲师团队工作中的亲身实践,所选案例均是深度学习的经典应用,非常具有代表性。

    21447 人正在学习 去看看 AI100讲师

Computational Network Toolkit (CNTK) 是微软出品的开源深度学习工具包。本文介绍CNTK的基本内容,如何写CNTK的网络定义语言,以及跑通一个简单的例子。

 根据微软开发者的描述,CNTK的性能比Caffe,Theano, TensoFlow等主流工具都要强。它支持CPU和GPU模式,所以没有GPU,或者神经网络比较小的实验,直接用CPU版的CNTK跑就行了。 其开源主页在 https://github.com/Microsoft/CNTK  它把神经网络描述成一个有向图的结构,叶子节点代表输入或者网络参数,其他节点计算步骤。 它支持卷积神经网络和递归神经网络。 由于CNTK刚推出不久,大众教程估计不多,而且bug估计也不少。我学习的时候,主要参考三个资料:

1 官方入门教程  https://github.com/Microsoft/CNTK/wiki/Tutorial  本文也主要以这里的教程为例

2 官方论坛 https://github.com/Microsoft/CNTK/issues

3 官方论文 http://research.microsoft.com/pubs/226641/CNTKBook-20160217..pdf  这个有150页,我是当作字典来用,遇到问题的时候就在里面搜

 

安装CNTK: https://github.com/Microsoft/CNTK/wiki/CNTK-Binary-Download-and-Configuration  去这个页面找符合自己系统的版本。 我是Windows用户,CNTK有编译好的CPU和GPU版本。由于本人的显卡不是英伟达的,所以无奈只能用CPU版凑合用用。已经编译好的包最方便了,解压,然后把目录(类似%...%、CNTK-2016-02-08-Windows-64bit-CPU-Only\cntk\cntk)添加到PATH变量中就行了。  有条件的人也可以自己编译源代码,稍微麻烦一些,各种依赖关系,好处是源码更新的比较快,CNTK一大特点就是目前各种小bug比较多,比如我现在用的编译好的包还是两个月前发布的,已经自己填了好多坑了。

安装好CNTK之后,运行一个程序,就是一个简单的命令行:  CNTK configFile=your_config_file , 其中,your_config_file 是网络的定义文件,大概长这样:

复制代码
command=Train:Test
Train=[
        action="train"

        NDLNetworkBuilder = [
        ...
        ]

        SGD = [
        ...
        ]

        reader = [
        ...
    ]

]
 Test=[ ... ]
复制代码

运行的入口就是command命令,command后面接需要依次运行的模块,用冒号分开。 每个模块里面需要定义的事情比较类似,主要是定义输入的格式,网络结构,学习算法(目前只有SGD)和参数。 在定义网络结构的时候,会指明哪些节点是优化目标,哪些是评价指标,以及哪些是输出的点。

众所周知,把神经网络的隐藏层去掉之后,输入直接连到输出层,这样就行成了一个logistics regression分类器。所以https://github.com/Microsoft/CNTK/wiki/Tutorial 这个教程就指导大家如何构建一个LR。 我这里稍微变一下,学习一下如何构建带有一层隐藏层的neural network,如下图:

定义网络结构

CNTK用网络描述语言(network description language, NDL)描述一个神经网络。 简单的说,我们要描述输入的feature,输入的label,一些参数,参数和输入之间的计算关系,以及目标节点是什么。

复制代码
NDLNetworkBuilder=[
    
    run=ndlLR
    
    ndlLR=[
      # sample and label dimensions
      SDim=$dimension$
      LDim=1
    
      features=Input(SDim, 1)
      labels=Input(LDim, 1)
    
      # parameters to learn
      B0 = Parameter(4) 
      W0 = Parameter(4, SDim)
      
      
      B = Parameter(LDim)
      W = Parameter(LDim, 4)
    
      # operations
      t0 = Times(W0, features)
      z0 = Plus(t0, B0)
      s0 = Sigmoid(z0)   
      
      t = Times(W, s0)
      z = Plus(t, B)
      s = Sigmoid(z)    
    
      LR = Logistic(labels, s)
      EP = SquareError(labels, s)
    
      # root nodes
      FeatureNodes=(features)
      LabelNodes=(labels)
      CriteriaNodes=(LR)
      EvalNodes=(EP)
      OutputNodes=(s,t,z,s0,W0)
    ]   
  ]
复制代码
features=Input(SDim, 1)     labels=Input(LDim, 1) 和 B0 = Parameter(4)  等可以想象成是在定义变量。 输入是列向量,CNTK里面的运算全是矩阵运算,所以就把输入当做只有一列的矩阵。  t0 = Times(W0, features) 是做矩阵乘法,t0把输入和权重相乘,z0 是在t0上面加了一个bias,
s0表示经过一个激活函数。 B0,W0,t0,z0,s0构成了隐层的操作,这里定义的隐层有4个节点。 t,z,s是输出层的操作,s就是输出节点的值。 框架定义好之后,还需要指定一些根节点,用来指定特殊的任务,例如 FeatureNodes=(features)  和LabelNodes=(labels)分别规定了输入和输出节点,CriteriaNodes 是训练的
时候优化的目标,EvalNodes 是在做评测的时候输出的参考值。OutputNodes 指定了需要输出到文件的节点。

设置训练算法
复制代码
SGD = [    
        epochSize=0     #  每轮迭代使用的样例数,  =0 表示使用整个训练集
        minibatchSize=25  # 训练25个样本就更新一次参数
        learningRatesPerMB=0.1                # learning rates per MB
        maxEpochs=50    #迭代50次
    ]
    
复制代码

目前只有SGD(以及在SGD上的各种变种),可以在里面设置各种参数。

 

设置输入格式

复制代码
reader = [
        #customDelimiter = " "
        readerType = "UCIFastReader"
        file = "Train.txt"
        miniBatchMode = "partial"        
        verbosity = 1
        randomize = "none"
        
        features=[
            dim = $dimension$
            start = 0
        ]
    
        labels=[
            start = $dimension$              # skip $dimension$ elements before reading the label (i.e. the first two dimensions so we have "x1 x2 y" basically)
            dim = 1                          # label has 1 dimension
            labelType=regression
            labelMappingFile = "SimpleMapping.txt"
        ]
    ]
复制代码

这也是CNTK的一个特点(吐槽点), 指定用什么方式读取数据文件。 readerType = "UCIFastReader" 指定用普通的扁平化表格的格式(一行一个样例,同一行内用空格隔开不同的数值),还有别的格式类型,例如图像格式,文本语料格式等。UCIFastReader 是将被弃用的,而且在目前最新的binary包中是有bug的 (所以说,有条件的同学尽量自己编译最新的源码)。  用官方教程里的设置直接跑回出bug,以上是我修改过的代码。 输入格式主要描述了feature是哪几列,维度是多少,label是哪几列, label的类型等等。

 

综上,Train这个模块就是定义了这几件事情:输入格式,网络内容,训练模式。 运行的时候也是这个步骤: 读取数据-> SGD 训练. 

其他

除了Train之外的模块的流程比较类似,它们不需要再定义网络结构和训练模式,但是输入格式还是要指定的。 例如Test模块的流程是:  读取数据->计算网络->得到预测值->评估.    评估针对的是在网络结构中被定义为EvalNodes 的节点。 SquareError 只是其中的一种评估指标。如果想用别的误差函数,可以去查字典http://research.microsoft.com/pubs/226641/CNTKBook-20160217..pdf 

复制代码
Test=[
    action="test"
    reader=[
        readerType="UCIFastReader"
        file="Test.txt"
        features=[
            dim=2
            start=0
        ]
        labels=[
            start=$dimension$
            dim=1
            labelDim=2
        ]
    ]
]
复制代码

 

Output模块和Test的流程基本一样,只不过最后一个不是评估,而是把属于OutputNodes的值给输出到文件。 Output模块会指定一个输出目录 outputPath = "LR.txt" , 输出的文件以“LR.txt”为前缀,再加上变量命作为文件名。例如"LR.txt.W0"。

 

复制代码
# output the results
Output=[
    action="write"
    reader=[
        readerType="UCIFastReader"
        file="Test.txt"
        features=[
            dim=$dimension$
            start=0
        ]
        labels=[
            start=2
            dim=1
            labelType=regression
        ]
    ]
    outputPath = "LR.txt"       # dump the output as text
]
复制代码

 

dumpNodeInfo  用来输出参数的值。这在调试中很有用,例如去看看网络的参数是如何变化的:

复制代码
dumpNodeInfo=[
        action=dumpnode
        printValues=true
    ]


####################################################################
B=LearnableParameter [1,1]   NeedGradient=true 
 -6.67130613 
 #################################################################### 
EP=SquareError ( labels , s ) 
features=InputValue [ 2 x 1 {1,2} ] 
labels=InputValue [ 1 x 1 {1,1} ] 
LR=Logistic ( labels , s ) 
s=Sigmoid ( z ) 
t=Times ( W , features ) 
W=LearnableParameter [1,2]   NeedGradient=true 
 1.23924482 1.59913719 
 #################################################################### 
z=Plus ( t , B )
复制代码

 

全部的代码如下。 train文件 https://github.com/Microsoft/CNTK/wiki/Tutorial/Train-3Classes.txt  test 文件 https://github.com/Microsoft/CNTK/wiki/Tutorial/Test-3Classes.txt。 数据是2维的:

 

复制代码
# Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license. See LICENSE file in the project root for full license information.

# logistic regression cntk script -- Network Description Language

# which commands to run
command=Train:Output:dumpNodeInfo:Test

#required...
modelPath="Models/LR_reg.dnn"        # where to write the model to
deviceId=-1                                # CPU
dimension=2                 # input data dimensions

# training config
Train=[
    action="train"
    traceLevel = 1
    NDLNetworkBuilder=[
    
    run=ndlLR
    
    ndlLR=[
      # sample and label dimensions
      SDim=$dimension$
      LDim=1
    
      features=Input(SDim, 1)
      labels=Input(LDim, 1)
    
      # parameters to learn
      B0 = Parameter(4)
      W0 = Parameter(4, SDim)
      
      
      B = Parameter(LDim)
      W = Parameter(LDim, 4)
    
      # operations
      t0 = Times(W0, features)
      z0 = Plus(t0, B0)
      s0 = Sigmoid(z0)   
      
      t = Times(W, s0)
      z = Plus(t, B)
      s = Sigmoid(z)    
    
      LR = Logistic(labels, s)
      EP = SquareError(labels, s)
    
      # root nodes
      FeatureNodes=(features)
      LabelNodes=(labels)
      CriteriaNodes=(LR)
      EvalNodes=(EP)
      OutputNodes=(s,t,z,s0,W0)
    ]   
  ]
    
    SGD = [    
        epochSize=0                              # =0 means size of the training set
        minibatchSize=25
        learningRatesPerMB=0.1                # learning rates per MB
        maxEpochs=50
    ]
    
    # parameter values for the reader
    reader = [
        #customDelimiter = " "
        readerType = "UCIFastReader"
        file = "Train.txt"
        miniBatchMode = "partial"        
        verbosity = 1
        randomize = "none"
        
        features=[
            dim = $dimension$
            start = 0
        ]
    
        labels=[
            start = $dimension$              # skip $dimension$ elements before reading the label (i.e. the first two dimensions so we have "x1 x2 y" basically)
            dim = 1                          # label has 1 dimension
            labelType=regression
            labelMappingFile = "SimpleMapping.txt"
        ]
    ]
]

# test
Test=[
    action="test"    
    reader=[
        readerType="UCIFastReader"
        randomize = "none"
        file="Test.txt"
        features=[
            dim=$dimension$
            start=0
        ]
        labels=[
            start = $dimension$              # skip $dimension$ elements before reading the label (i.e. the first two dimensions so we have "x1 x2 y" basically)
            dim = 1                          # label has 1 dimension
            labelType=regression
            labelMappingFile = "SimpleMapping.txt"
        ]
    ]
]

# output the results
Output=[
    action="write"    
    reader=[
        readerType="UCIFastReader"
        file="Test.txt"        
        randomize = "none"
        features=[
            dim=$dimension$
            start=0
        ]
        
        labels=[
            start = $dimension$              # skip $dimension$ elements before reading the label (i.e. the first two dimensions so we have "x1 x2 y" basically)
            dim = 1                          # label has 1 dimension
            labelType=regression
            labelMappingFile = "SimpleMapping.txt"
        ]
    ]    
    outputPath = "LR.txt"        # dump the output as text
]

dumpNodeInfo=[
  action=dumpnode
  printValues=false
]
复制代码
没有更多推荐了,返回首页