2018-01-03 21:00:50 Tong_T 阅读数 53588
  • 玩转深度学习实战教程

    玩转深度学习视频培训课程,详细讲解深度学习的原理和利用深度学习框架TensorFlow进行项目实战。课程通过Kaggle竞赛平台的Titanic问题讲解TensorFlow的基本用法以及问题处理的常用技巧,讲解深度学习图像领域的卷积神经网络CNN和多个经典的网络架构、CNN的应用,讲解自然语言处理领域的RNN、LSTM以及它们的多种变种结构,构建语言模型和对话机器人,介绍损失函数和优化深度学习算法在TensorFlow中的实现。

    2843 人正在学习 去看看 王而川

机器学习算法已经基本学习完了,在这一系列,佛爷将开始着手学习深度学习的各种算法和应用,由于本身难度偏大,我会不定期的更新,基本清楚和更加深入的研究深度学习。代码方面我基本会使用Tensorflow框架去写,原生代码我尽力去完成,查看资料,看看自己能不能搞定。完成的例子和项目,尽量我会设计一个别人都没有实现和想到的项目。因为但凡学习深度学习的同学,一上来肯定会遇到手写数字识别,这是基础。遇到MNIST数据集。
今天这一篇文章就介绍深度学习到底是什么?

什么是深度学习?(Deep Learning)

  • 深度学习是基于机器学习延伸出来的一个新的领域,由以人大脑结构为启发的神经网络算法为起源加之模型结构深度的增加发展,并伴随大数据和计算能力的提高而产生的一系列新的算法。
    这里写图片描述

深度学习什么时间段发展起来的?

  • 其概念由著名科学家Geoffrey Hinton等人在2006年和2007年在《Sciences》等上发表的文章被提出和兴起。
    这里写图片描述这里写图片描述

深度学习能用来干什么?为什么近年来引起如此广泛的关注?

  • 深度学习,作为机器学习中延伸出来的一个领域,被应用在图像处理与计算机视觉,自然语言处理以及语音识别等领域。自2006年至今,学术界和工业界合作在深度学习方面的研究与应用在以上领域取得了突破性的进展。以ImageNet为数据库的经典图像中的物体识别竞赛为例,击败了所有传统算法,取得了前所未有的精确度。
    这里写图片描述这里写图片描述

深度学习目前有哪些代表性的学术机构和公司走在前沿?人才需要如何?

  • 学校以多伦多大学,纽约大学,斯坦福大学为代表,工业界以Google, Facebook, 和百度为代表走在深度学习研究与应用的前沿。Google挖走了Hinton,Facebook挖走了LeCun,百度硅谷的实验室挖走了Andrew Ng,Google去年4月份以超过5亿美金收购了专门研究深度学习的初创公司DeepMind, 深度学习方因技术的发展与人才的稀有造成的人才抢夺战达到了前所未有激烈的程度。诸多的大大小小(如阿里巴巴,雅虎)等公司也都在跟进,开始涉足深度学习领域,深度学习人才需求量会持续快速增长。
    这里写图片描述

深度学习如今和未来将对我们生活造成怎样的影响?

  • 目前我们使用的Android手机中google的语音识别,百度识图,google的图片搜索,都已经使用到了深度学习技术。Facebook在去年名为DeepFace的项目中对人脸识别的准备率第一次接近人类肉眼(97.25% vs 97.5%)。大数据时代,结合深度学习的发展在未来对我们生活的影响无法估量。保守而言,很多目前人类从事的活动都将因为深度学习和相关技术的发展被机器取代,如自动汽车驾驶,无人飞机,以及更加职能的机器人等。深度学习的发展让我们第一次看到并接近人工智能的终极目标。
    这里写图片描述这里写图片描述这里写图片描述

深度学习范畴
这里写图片描述

深度学习基本模型
这里写图片描述

深度学习与传统机器学习
这里写图片描述

深度学习系列参考资料来源:

  1. 深度学习进阶:算法与应用(https://www.youtube.com/playlist?list=PLO5e_-yXpYLDyeADG7xbFaJxvYyeAjHah
  2. 莫烦 Python(https://morvanzhou.github.io/):一个志同道合的机器学习爱好者。
  3. 《TensorFlow实战Google深度学习框架》才云科技 郑泽宇 顾思宇 著
    (顺带手附上彩云科技的在bitTiger平台上的招聘视频【https://www.youtube.com/watch?v=ow4NQR4fdDA】)
2017-11-09 00:00:00 np4rHI455vg29y2 阅读数 869
  • 玩转深度学习实战教程

    玩转深度学习视频培训课程,详细讲解深度学习的原理和利用深度学习框架TensorFlow进行项目实战。课程通过Kaggle竞赛平台的Titanic问题讲解TensorFlow的基本用法以及问题处理的常用技巧,讲解深度学习图像领域的卷积神经网络CNN和多个经典的网络架构、CNN的应用,讲解自然语言处理领域的RNN、LSTM以及它们的多种变种结构,构建语言模型和对话机器人,介绍损失函数和优化深度学习算法在TensorFlow中的实现。

    2843 人正在学习 去看看 王而川

谷歌大脑的Geoffrey E. Hinton的胶囊(Capsule)论文在2017年10月26号发表后深度学习架构似乎又有个新的变革。 到底一些传统的深度学习架构是否仍然有用?怎么用?这是不少深度学习科学家们不断在思索的问题, 也是不少接地气的科技产业化先锋们不断探索的迷思。这里我们综合几位在数据分析、人工智能领域平均20年左右的杰出科学家与架构师们的想法给的一些思路导引。

深度学习之‘道’?

当我们是位以使用深度学习为主的从业者时, 利用深度学习功能的最佳方法是将输入数据与适当的深层网络架构相匹配!! 如果我们能够在这一点上做得好,那我们就可以用创新的和有趣的方式成功应用深度学习。 如果不这样做,我们建的模将除了基本逻辑回归技术外,并不会有其它更强而有力的功能。

做深度学习时面对那么多不同算法:几率分类、决策树、实例为基础的(Instance-Based Methods) 、规则学习(Rule Learners) 、回归、类神经网络。。。已经让执行者、决策者一个头两个大, 再看看里面深度学习相关的算法架构:DBN、GAN、Autoencoders(AES)、CNN、DBM、RNN (Recurrent Neural Networks、Recursive Neural Networks)、SAE、DSN、CHDM、DQN、UPN SDA、RBM、。。。,再加上分支、算法的结合、不断推出的新算法与架构,等等,等等,。。。面对着一堆眼花缭乱的深度学习架构与算法着实让不仅人工智能初学者, 即便是多年的机器学习研究专家也常无所适从,到底哪些架构、哪些算法我们的工作、我们的业务、我们的应用是需要的?怎么用?

这是个至少几千页才说的清楚的话题,欲消化吸收更是得要经年累月的研究与实践。与其将网上大家都搜得到的算法一个一个拿出来说明(或复制?),不如我们对一些较常用的架构与算法说明他们的适用性,而算法本身只是做个粗略的说明,对于每个深度学习算法有兴趣了解的更深入的可以在很多网上搜索得到。

深度学习在应用上最多人提到的是CNN和RNN(含LSTM、BPTT、GRU等)两种架构。第一种CNN(Convolutional Neural Network) 主要是应用到图像、影像等领域,RNN(Recurrent Neural Network) 则比较适合序列建模的应用,比如语言处理(语音合成、语言建模、文本生成模型)、音乐生成、视频游戏等。当然,非常流行的CNN不只有在图像的应用,MRI、3D立体事物、甚至NLP(自然语言处理)等应用也常可以看到它的影子。而RNN也可以在视频分析、音乐信息分析、机器人控制等更深入的领域应用。 另外,若RNN 和CNN结合也可应用到如区域影像信息、影像字幕(文字说明) 等更多的领域。我们先将这两种架构做个说明:

卷积神经网络(CNN):

CNN的目的是通过卷积学习数据中的高阶特征。 它非常适合用于图像中进行物体识别。此算法架构时常赢得国际顶级的图像分类比赛。 他们可以识别面部,个人,街头标志,鸭嘴兽和视觉数据的许多其他方面。 CNN将光学字符识别与文本分析方法重叠,但在将字元中分析离散文本单元时也是很有用的。 CNN在分析声音方面也很擅长。

如下图所示,CNN架构主要分三部分:输入层、特征提取(学习)层、和分类层。

1)输入层:通常以图像的尺寸(宽×高)空间形式接受三维输入,并且具有表示颜色通道的深度(通常为RGB颜色通道三个)。

2)特征提取层:

具有序列的一般重复样式,还包含卷积层和汇集层。这些层在图像中发现了许多特征,并逐渐构建了更高阶的特征。 这直接对应于深度学习中正在进行的主题,通过该主题特征可以被自动学习,而不是经由传统的手工设计的方式。

3)分类层:

我们有一个或多个完全连接的层来获取更高阶的特征并产生类概率或分数。 这些层完全连接到上一层的所有神经元,而它们的输出通常会产生[b×N]的二维输出,其中b是小批量中的示例数,N是我们感兴趣的类的数量。


一些比较受欢迎的CNN实际算法架构有LeNet、AlexNet、ZF Net、GoogLeNet、VRRNet、ResNet等实际存在的架构。

卷积神经网络(CNN)通过插入卷积层显着增强了如MLP(Multilayer Perceptrons)之类的前馈网络的能力。 它们特别适用于使用多维神经元结构的空间数据、目标对象识别、图像分析等应用。 其实CNN架构是最近深度学习能够获得重视并且流行起来的主要原因之一。我们日常生活里一些常见CNN应用是自动驾驶汽车、无人机、电脑视觉、文字分析等。

循环神经网络(Recurrent Neural Network):

一位从事计算机科学与人工智能三十年左右的知名AI科学家Juergen Schmidhuber对循环神经网络的一个有趣的解释:

循环神经网络]允许并行和顺序计算,原则上可以计算传统计算机可以计算的任何内容。 然而,与传统计算机不同,循环神经网络与人类大脑相似,人类大脑是连接神经元的大型反馈网络,以某种方式学习将终身感觉输入流转化为有用的运动输出序列。 大脑是一个显着的典范,因为它可以解决当前机器无法解决的许多问题。


RNN也是一种前馈网络,然而具有从先前和/或相同层或状态获取输入的循环存储器循环。 这给了他们独特的能力,沿时间维度和任意顺序的事件和输入进行建模。 RNN模型中最常见的类型之一是长时间内存(Long Short Term Memory,LSTM)网络。

RNN被认为是图灵完整(Turing complete)的,可以模拟任意(具有权重)的程序。 如果我们将神经网络视为对功能的优化,我们可以将循环神经网络视为“优化程序”。循环神经网络非常适合于输入和/或输出由时间相关的向量值组成的功能建模。 循环神经网络通过在网络中创建周期来建立时间相关数据的模型。

RNN适用于排序数据分析、如时间序列、情绪分析、NLP(自然语言处理)、语言翻译、语音识别、视频分析、视频游戏、对话交流、机器人控制、图像字幕和脚本识别等, 在电影情感分析也是不少的实际应用。

除了上述最流行的深度学习算法架构外,我们再探讨两个也很流行,比较基础的架构:

多层感知器(Multilayer Perceptrons ,MLP)

这是最基本的深度学习网络架构,提供输入来直接创建输出。 它们由输入层和输出层以及输入层和输出层之间的许多互连的隐藏层和神经元组成。 它们通常使用一些非线性激活函数,如Relu或Tanh,并计算均方误差(Mean Square Error,MSE)或Logloss等损失(真实输出与计算输出之间的差异)。 这种损失可以回向传播,以调整权重和训练,以最大限度地减少损失或使模型更准确。

基本算法逻辑:

这个网络通常是构建其他更复杂的深度网络的开始阶段,可以用于任何监督回归或分类问题,如预测销售,违约者,响应概率等等。

Autoencoders(自动编码器?)

我们使用AES(Autoencoders)来学习数据集的压缩表示。 通常,我们使用它们来减少数据集的维度。 自动编码器网络的输出是以最有效的形式重建输入数据。

AES与MLP (多层感知器神经网络) 具有很强的相似性,因为它们一样具有输入层,隐藏的神经元层,然后是输出层。 它俩的关键区别是AES的输出层具有与输入层相同数量的单位。另外两个区别是:他们在无监督学习中使用未标记的数据,并且它们构建的输入数据是压缩形式的。

变体自动编码器(Variational Autoencoders,VAE):

构建一个模型来表示输入数据集可能听起来不太有用。 然而,我们感兴趣的并不是输出本身,而是对输入和输出表示之间的差异更感兴趣。 如果我们可以训练神经网络来学习通常“看到”的数据,那么这个网络也可以让我们知道什么时候“看到”不寻常的或异常的数据。

堆叠autoencoders为特征的学习无监督学习算法,降维的离群点检测。声发射的概念非常简单,这里输入向量用来计算输出向量,但输出向量与输入向量相同。计算了重建误差,认为重建误差较大的数据点为离群点。AES也用于语音和图像识别,工业上也有应用于金融、信用卡骇客、反诈欺等领域。

Autoencoders的基本结构除了可以是自成一体的独立网络外, 它也时常被用作其它较大深度学习网络架构的一部分。

最后我们再来看看刚新发布Geoffrey E. Hinton科学家的:

动态路由胶囊架构

这个动态路由胶囊算法架构最大的特色就是采用一个比较有效的“协议路由”(routing-by-agreement)。这协议路由比之前通过允许一层中的神经元只接受下面层级中的当地池中检测器的最活跃的特征,但却忽略其它特征的max-pooling逻辑所实现的非常原始的路由形式有效许多。

下面是这动态路由胶囊算法的核心逻辑:

卷积神经网络(CNN)使用学习特征检测器的转换副本允许他们转换在图像中的一个位置获得的良好权重值的知识到其他位置。这已经证明在图像解释方面非常有帮助。即使我们是用矢量输出胶囊替代CNN的标量输出特征检测器和最大容量通过协议路由,我们仍然希望跨越空间复制学习的知识,所以我们除了最后一层胶囊外所有曾都还是卷积的。 与CNN算法架构一样,我们制作更高级别的胶囊覆盖较大区域的图像,但不同于最大池,它不会丢弃该地区内实体确切位置的信息。对于低级胶囊,位置信息是胶囊是活动的“位置编码”。随着越来越多的位置上升,信息在胶囊的输出向量的实值分量中被“速率编码”(rate-coded)。这个从位置编码转换到速率编码的逻辑,加上高层胶囊具有更复杂、更多自由度的实体的现象,表明胶囊的维度应该随着层级的升高而增加。

所以,我们清楚知道胶囊系统其实不是个全新的架构,也不若很多刊物的危言耸听说将颠覆CNN架构,他是加强了现有的算法逻辑,CNN先锋Hinton科学家发表的动态路由胶囊逻辑是在现有的CNN算法架构上补强,有其是在目标对象的辨识相关的应用。在胶囊逻辑能够真正获得接受并且有大规模的应用前还有很多‘小’问题需要清楚解析,并且需要更多差异性实验的证明。

让我们对上面提到的目前比较流行的架构与算法做个简单的总结:

要生成数据(例如,图像,音频或文本),我们将使用:

GAN、VAE、RNN、

要图像建模,我们可能会使用:

CNN、DBN

要序列数据的建模,我们可能会使用:

RNN/ LSTM

作者建议目前先将这些比较常用的流行算法先熟悉,稍后还会和读者分享不同算法与架构的适用性,并且分享更多的业界实例来说明人工智能、机器学习的不同架构与算法。

所谓选择比努力重要,如果一个AI架构师或资深技术人员在组织的目标下没有一个(或多个)正确适宜的架构与算法,那可以预期的是即便是团队很努力的经过多时开发出来的产品或项目它的品质与价值一定大打折扣的,,,与其一个错误的抉择造成公司目标的偏差、人员的抱怨、甚至客户的流失、经营管理的冲击,那不如在事先就能彻底了解需求,设计方案时采用适当的架构与算法。


机器学习,深度学习的迷思与不适用性?

人工智能家一AI加

这阵子人工智能机器学习领域变得越来越火热,其中的深度学习也渐渐获得重视与采用,尤其在生物医学领域。尽管深度学习到目前为止在不少包含生物医疗方面的领域取得了一些成功,但是在不少情况下却是非常难运用,本文为大家破解其中一些疑点并列举几种不适合深度学习的情况。

经常存在采用与不采用深度学习的科学家之间最大的争议就是有些科学家做了不少实验证明在采集数据量不大时线性模式比少量层级的神经网络与隐藏单元(hidden units)的深度学习模式来得简单有效。但是一些顶级实验室的科学家也举了不少反证,说明了适当训练后的深度网络比线性模组更精准有效。当人工智能领域里此类争论不休的议题不断出现时,作者根据和一些顶级科学家的交流与自己的经验心得提供一些情况其实是很不适合深度学习的。

做一个科学的突破与技术的推广首先一定是从此科学的目的与适用性着手。所以作者不是从个人多年研究的各种算法去和广大读者讨论那个算法好,而是从一些想进入这个科学领域,或想实际运用此科学造福广大人群、进而突破人工智能科学的角度着手,先讨论一般人对深度学习的疑惑、误区、与适用性。

误区一:小样本、少数据的情况下不适合深度学习?

深度学习刚开始的名声是在大量数据的背景下进行的 (还记得第一个谷歌大脑项目是向深层网络提供大量YouTube视频吧),并且自那时候开始深度学习就一直被渲染成在大量数据中作为复杂算法运行。 不幸的是,这个大数据与深层次的学习就被绑定,并且被解释成了相反的意思:在小样本制度中不能使用。 如果您只有几个样本,可以采用一个具有高参数每采样率的神经网络可能表面上看起来像是杀鸡用牛刀。 然而,无论是监督还是无监督式学习,仅仅考虑样本大小和维度,都像是在空气中没有内容的对数据进行建模。很多情况下,尤其在一些垂直领域的数据建模方式,它对于提供给类神经网络的数据是有不同方式的,比如图形或图像编码等等。

其实在这些情况下,深度学习可以作为一种有意义的选择 - 例如,你可以编码较大的相关数据集的有用表示,并在您的问题中使用这些表示。 在自然语言处理领域里可以常常看到这种经典的例证:你可以在维基百科等大型语料库中学习嵌入词汇,然后将其作为嵌入式语言,用于较小,较窄的语料库进行监督任务(supervised task)。 在极端情况下,您可以拥有一个神经网络,共同学习一种表示方式,并设计在小样本集中重新使用该表示的有效方式。 这被称为一次性学习(one-shot learning),并且已经在包括计算机视觉和新制药物在内的高维数据的许多领域成功应用。

Altae-Tran等科学家2017年用于药物发现的单次学习网络

误区二:深度学习是个万灵丹?

听到最多的第二个误解基本上就是炒作。许多“未来的”实践者因为在其他领域深度学习起作用, 就期望深层网络给他们一个神话般的性能提升。也有很多人的灵感来自于建模和操纵图像,音乐和语言的成功表现,就像仓促的进入这个领域,想训练他们的最新生成对抗网络(GAN)‘凭空’捏造结果来解决他们的问题。炒作在许多方面是真实的。深入学习已经成为机器学习中不可否认的力量,也是任何数据建模者的一个重要工具。它的普及带来了诸如TensorFlow和PyTorch之类的基本框架,即便在深入学习之外也是非常有用的。超级巨星发迹的故事激发了研究人员重新审视其他以前不是很清楚的方法,如进化策略和强化学习。但这不是万能的。深度学习不是免费的午餐,它的模型可以非常细微,需要仔细,有时候还是非常昂贵的超参数搜索,调整和测试。此外,有很多情况下,使用深度学习从实践的角度来看是没有意义的,而更简单的模型工作得更好。

哪时候不适合使用深度学习?

那么,什么时候深度学习不是一项任务的理想选择呢?从我们的角度来看,下面几种主要的情况下,深度学习更多的是一种阻碍而非福音:

·低预算或低承诺问题

深层网络是非常灵活的模型,具有多种架构和节点类型,优化机制和规则化策略。根据应用的不同, 你的模型可能具有卷积层(多大?使用什么样的联营操作?)或循环结构(带或不带门控)?它可能真的很深(沙漏,暹罗或其他架构)?还是只有几层隐藏层(有多少单位?);它可能使用整流线性单元或其他激活功能;它可能有也可能没有漏失信息(dropout)(在什么层次上?用什么分数?)和权重应该是正则化的(l1,l2,或者是某些东西?)。这里只是列举部分考量,还有很多其他类型的节点,连接,甚至丢失的功能都可以尝试。这些对于调整和架构探索都是大量的参数,就算要训练一个大型网络的实例可能都非常耗时。

训练深度网络在计算和调试时都会带来很大的代价。这种消耗对于许多日常预测问题并没有太大的意义,即使在调整小型网络时,调整网络的投资回报率也可能太低。即使有大量的预算和承诺,也没有理由不尝试替代方法。很多时候您可能会惊喜地发现,线性SVM就能满足你的需要的。

·当对一般观众解释和沟通模型参数很重要时

深层网络常因像一个黑匣子一样具有很高的预测能力,但解释力低而臭名昭着。尽管最近有很多工具,如显着图(saliency maps)和激活差异 (activation differences),对某些领域而言是非常有用的,但它们不能会完全转移到其它所有应用领域的。主要是这些工具,当你想确保网络不会通过记住数据集或专注于特定的虚假特征来欺骗你时,你仍然难以解释每个特征对深层整体决策的重要性。在这个领域,因为学习的系数与响应有直接的关系,线性模型是最理想的。欲将一些解释传达给需要根据它们作出决定的一般观众时,这是至关重要的。比如医生, 他们例如需要考量各种不同的数据来给予诊断,将变量和结果之间用更简单和更直接的方式关联起来,而不是低估/高估估值。此外,有些情况下,模型的准确性(通常在深度学习中表现优异)并不像解释性那么重要。例如,策略制定者可能对一些人口统计变量对死亡率的大概关系而非准确性更有兴趣。在这些情况下,与更简单,更易渗透的方法相比,深度学习处于劣势。

·建立因果机制

模型解释的极端情况是当我们试图建立一个机理模型,即一个实际捕获数据背后的现象的模型。 好的例子包括尝试猜测特定细胞环境中两个分子(例如药物,蛋白质,核酸等)是否相互作用,或假设某个特定的营销策略对销售具有实际影响。在这个领域,没有什么能比老式的贝叶斯方法(Bayesian methods)更受专家意见的影响,它们是我们最好的(如果不完美的)方法,我们必须表现和推断因果关系。 另外,在视频游戏任务里更原则的方法也比深度学习更好。

·从“非结构化”特性学习

这点可能是会引起争论的。我发现深度学习擅长的一个领域是为特定任务找到有用的数据表示。一个非常好的例子是上述的词语嵌入。自然语言具有丰富而复杂的结构,可以用“上下文感知”网络来近似:每个单词都可以在编码其主要使用的上下文的向量中表示。在大型语料库中学习的NLP任务中使用单词嵌入有时可以在另一个语料库中的特定任务中提升。然而,如果所讨论的语料库是完全非结构化的,则可能没有任何用处。例如,假设您正在通过查看非结构化关键字列表来对对象进行分类。由于关键字在任何特定的结构中都不被使用(如在一个句子中),所以字嵌入不太可能会有所帮助。在这种情况下,数据是真正的一个单词,这种表示可能足以满足任务。对此的反驳可能是,如果您使用预先训练的字词嵌入并不是那么昂贵,并且可以更好地捕获关键字相似度。但是,我仍然希望从一个单词的表示开始,看看是否可以得到很好的预测。毕竟,这个词包的每个维度比相应的词嵌入槽更容易解释。

将概率编程和Tensorflow 结合后的模型既可以深度学习又可以贝叶斯,取材自ICLR

未来是深的

深入学习领域热门,资金充足,发展快速。 当你阅读在会议上发表的论文时,可能有两到三次迭代已经不赞成那论文了。 这给我以上提出的几点提出了很大的警告:深度学习在不久的将来可能对这些情景来说还是非常有用的。 用于解释图像和离散序列的深度学习模型的工具会越来越好。 最近的软件,如爱德华(Edward) 结合贝叶斯建模和深层框架,允许通过概率编程和自动变分推理量化神经网络参数的不确定性和容易的贝叶斯推理。 从长远来看,可能会有一个减少的建模词汇表,指出深层网络可以具有的显着属性,从而减少需要尝试的内容的参数空间。 所以请保持更新你的相关科学进展,很多理论可能会在一两个月内被废弃掉了。

本文为作者前几天从目前在加州大学做人工智能研究的科学家的观点整理出



人工智能赛博物理操作系统

AI-CPS OS

人工智能赛博物理操作系统新一代技术+商业操作系统“AI-CPS OS:云计算+大数据+物联网+区块链+人工智能)分支用来的今天,企业领导者必须了解如何将“技术”全面渗入整个公司、产品等“商业”场景中,利用AI-CPS OS形成数字化+智能化力量,实现行业的重新布局、企业的重新构建和自我的焕然新生。


AI-CPS OS的真正价值并不来自构成技术或功能,而是要以一种传递独特竞争优势的方式将自动化+信息化、智造+产品+服务数据+分析一体化,这种整合方式能够释放新的业务和运营模式。如果不能实现跨功能的更大规模融合,没有颠覆现状的意愿,这些将不可能实现。


领导者无法依靠某种单一战略方法来应对多维度的数字化变革。面对新一代技术+商业操作系统AI-CPS OS颠覆性的数字化+智能化力量,领导者必须在行业、企业与个人这三个层面都保持领先地位:

  1. 重新行业布局:你的世界观要怎样改变才算足够?你必须对行业典范进行怎样的反思?

  2. 重新构建企业:你的企业需要做出什么样的变化?你准备如何重新定义你的公司?

  3. 重新打造自己:你需要成为怎样的人?要重塑自己并在数字化+智能化时代保有领先地位,你必须如何去做?

AI-CPS OS是数字化智能化创新平台,设计思路是将大数据、物联网、区块链和人工智能等无缝整合在云端,可以帮助企业将创新成果融入自身业务体系,实现各个前沿技术在云端的优势协同。AI-CPS OS形成的字化+智能化力量与行业、企业及个人三个层面的交叉,形成了领导力模式,使数字化融入到领导者所在企业与领导方式的核心位置:

  1. 精细种力量能够使人在更加真实、细致的层面观察与感知现实世界和数字化世界正在发生的一切,进而理解和更加精细地进行产品个性化控制、微观业务场景事件和结果控制。

  2. 智能:模型随着时间(数据)的变化而变化,整个系统就具备了智能(自学习)的能力。

  3. 高效:企业需要建立实时或者准实时的数据采集传输、模型预测和响应决策能力,这样智能就从批量性、阶段性的行为变成一个可以实时触达的行为。

  4. 不确定性:数字化变更颠覆和改变了领导者曾经仰仗的思维方式、结构和实践经验,其结果就是形成了复合不确定性这种颠覆性力量。主要的不确定性蕴含于三个领域:技术、文化、制度。

  5. 边界模糊:数字世界与现实世界的不断融合成CPS不仅让人们所知行业的核心产品、经济学定理和可能性都产生了变化,还模糊了不同行业间的界限。这种效应正在向生态系统、企业、客户、产品快速蔓延。

AI-CPS OS形成的数字化+智能化力量通过三个方式激发经济增长:

  1. 创造虚拟劳动力,承担需要适应性和敏捷性的复杂任务,即“智能自动化”,以区别于传统的自动化解决方案;

  2. 对现有劳动力和实物资产进行有利的补充和提升,提高资本效率

  3. 人工智能的普及,将推动多行业的相关创新,开辟崭新的经济增长空间


给决策制定者和商业领袖的建议:

  1. 超越自动化,开启新创新模式:利用具有自主学习和自我控制能力的动态机器智能,为企业创造新商机;

  2. 迎接新一代信息技术,迎接人工智能:无缝整合人类智慧与机器智能,重新

    评估未来的知识和技能类型;

  3. 制定道德规范:切实为人工智能生态系统制定道德准则,并在智能机器的开

    发过程中确定更加明晰的标准和最佳实践;

  4. 重视再分配效应:对人工智能可能带来的冲击做好准备,制定战略帮助面临

    较高失业风险的人群;

  5. 开发数字化+智能化企业所需新能力:员工团队需要积极掌握判断、沟通及想象力和创造力等人类所特有的重要能力。对于中国企业来说,创造兼具包容性和多样性的文化也非常重要。


子曰:“君子和而不同,小人同而不和。”  《论语·子路》云计算、大数据、物联网、区块链和 人工智能,像君子一般融合,一起体现科技就是生产力。


如果说上一次哥伦布地理大发现,拓展的是人类的物理空间。那么这一次地理大发现,拓展的就是人们的数字空间。在数学空间,建立新的商业文明,从而发现新的创富模式,为人类社会带来新的财富空间。云计算,大数据、物联网和区块链,是进入这个数字空间的船,而人工智能就是那船上的帆,哥伦布之帆!


新一代技术+商业的人工智能赛博物理操作系统AI-CPS OS作为新一轮产业变革的核心驱动力,将进一步释放历次科技革命和产业变革积蓄的巨大能量,并创造新的强大引擎。重构生产、分配、交换、消费等经济活动各环节,形成从宏观到微观各领域的智能化新需求,催生新技术、新产品、新产业、新业态、新模式。引发经济结构重大变革,深刻改变人类生产生活方式和思维模式,实现社会生产力的整体跃升。





产业智能官  AI-CPS



用“人工智能赛博物理操作系统新一代技术+商业操作系统“AI-CPS OS:云计算+大数据+物联网+区块链+人工智能)在场景中构建状态感知-实时分析-自主决策-精准执行-学习提升的认知计算和机器智能;实现产业转型升级、DT驱动业务、价值创新创造的产业互联生态链






长按上方二维码关注微信公众号: AI-CPS,更多信息回复:


新技术“云计算”、“大数据”、“物联网”、“区块链”、“人工智能新产业:智能制造”、“智能农业”、“智能金融”、“智能零售”、“智能城市、“智能驾驶”新模式:“财富空间、“特色小镇”、“赛博物理”、“供应链金融”


点击“阅读原文”,访问AI-CPS OS官网




本文系“产业智能官”(公众号ID:AI-CPS)收集整理,转载请注明出处!



版权声明产业智能官(公众号ID:AI-CPS推荐的文章,除非确实无法确认,我们都会注明作者和来源。部分文章推送时未能与原作者取得联系。若涉及版权问题,烦请原作者联系我们,与您共同协商解决。联系、投稿邮箱:erp_vip@hotmail.com





2017-05-02 16:00:04 lqfarmer 阅读数 1403
  • 玩转深度学习实战教程

    玩转深度学习视频培训课程,详细讲解深度学习的原理和利用深度学习框架TensorFlow进行项目实战。课程通过Kaggle竞赛平台的Titanic问题讲解TensorFlow的基本用法以及问题处理的常用技巧,讲解深度学习图像领域的卷积神经网络CNN和多个经典的网络架构、CNN的应用,讲解自然语言处理领域的RNN、LSTM以及它们的多种变种结构,构建语言模型和对话机器人,介绍损失函数和优化深度学习算法在TensorFlow中的实现。

    2843 人正在学习 去看看 王而川

推荐一套深度学习视频教程,以下是视频部分截图:


百度云下载地址:https://pan.baidu.com/s/1nuMsYZB

扫描博客头像关注微信公众号“深度学习与NLP”,回复:”视频教程"或“密码”即可获得密码

2015-10-28 14:17:57 zhang0311 阅读数 10886
  • 玩转深度学习实战教程

    玩转深度学习视频培训课程,详细讲解深度学习的原理和利用深度学习框架TensorFlow进行项目实战。课程通过Kaggle竞赛平台的Titanic问题讲解TensorFlow的基本用法以及问题处理的常用技巧,讲解深度学习图像领域的卷积神经网络CNN和多个经典的网络架构、CNN的应用,讲解自然语言处理领域的RNN、LSTM以及它们的多种变种结构,构建语言模型和对话机器人,介绍损失函数和优化深度学习算法在TensorFlow中的实现。

    2843 人正在学习 去看看 王而川

1.       深度学习

        深度学习是机器学习研究中的一个新的领域,其动机在于建立、模拟人脑进行分析学习的神经网络,它模仿人脑的机制来解释数据,例如图像,声音和文本。深度学习典型应用为图像识别和语音识别。(由于本人不是深度学习专业人士,对深度学习理论知识不多介绍,说多了就班门弄斧了,后面主要介绍下这些深度学习算法如何进行并行化设计和优化)

2.       CPU+GPU异构协同计算简介

         近年来,计算机图形处理器(GPU,GraphicsProcess Unit)正在以大大超过摩尔定律的速度高速发展(大约每隔半年 GPU 的性能增加一倍),远远超过了CPU 的发展速度。

         CPU+GPU异构协同计算模式(图1),利用CPU进行复杂逻辑和事务处理等串行计算,利用 GPU 完成大规模并行计算,即可以各尽其能,充分发挥计算系统的处理能力。

图1 CPU+GPU异构体系结构

        目前,主流的GPU具有强大的计算能力和内存带宽,如图2所示,无论性能还是内存带宽,均远大于同代的CPU。对于GPU, Gflop/$和Gflops/w均高于CPU。

图2 GPU计算能力

3.       深度学习中的CPU+GPU集群架构

        CPU+GPU集群工作模式(图3),每个节点内采用CPU+GPU异构模式,并且每个节点可以配置多块GPU卡。节点间采用高速InfiniBand网络互连,速度可以达到双向56Gb/s,实测双向5GB/s。后端采用并行文件系统。采用数据划分、任务划分的方式对应用进行并行化,适用于大规模数据并行计算。

图3 CPU+GPU集群架构

4.       利用GPU加速深度学习算法


4.1.       单GPU并行

图4 单GPU计算流程

        针对每次训练数据,模型内计算通过多次GPU 内核的调用完成计算。权重W值一直存在GPU内存中,直到所有训练数据计算完毕之后回传到系统内存中。Data为图像或语音数据。

4.2.       多GPU卡并行

       多GPU并行计算时,各GPU有自己独立的内存,卡之间的并行属于分布式计算模式。针对深度学习算法,采用多GPU卡计算可以采用两种并行方法:数据并行和模型并行。

4.2.1.       数据并行

       数据并行是指不同的GPU计算不同的训练数据,即把训练数据划分给不同的GPU进行分别计算,由于训练是逐步训练的,后一个训练数据的计算需要前一个训练数据更新的W,数据并行改变了这个计算顺序,多GPU计算需要进行W的互相通信,满足训练的特点,使训练可以收敛。

       数据并行如图5所示,多GPU训练不同的数据,每训练一次需要同步W,使得后面的训练始终为最新的W。

图5 数据并行

数据并行的特点:

1)        优点

            a)        实现比较容易,也比较容易扩展

            b)        只需要进行W的通信,模型内的数据不需要通信

2)        缺点

           a)        当模型较大时,GPU内存无法满足存储要求,无法完成计算

        根据多GPU卡之间的W通信,下面介绍两种通信方法:主从模式和令牌环模式。

1)        主从模式

       主从模式:选择一个进程或线程作为主进程或线程,各个GPU把每次训练得到的ΔW发给主进程或线程,主进程或线程进行W更新,然后再发送给GPU,GPU再进行下一个数据的训练。如图6所示。

图6 主从模式

2)        令牌环模式

       令牌环模式:每个GPU把自己训练得到的ΔW更新到W上,并且发送到下一个GPU,保证令牌环上的W始终为最新的W。如图7所示。

图7 令牌环模式

两种模式对比如表1

表1 主从模式和令牌环模式对比

模式

优点

缺点

主从模式

收敛速度更快

GPU计算需要等待,影响GPU计算;主进程或线程压力较大

令牌环模式

GPU计算不需要等待通信,性能更好

通信速度影响收敛的速度

4.2.2.       模型并行

        模型并行是指多个GPU同时计算同一个训练数据,多个GPU对模型内的数据进行划分,如图8所示。Kernel计算和通信流程如图9所示,在一次训练数据多层计算过程中,每个GPU内核计算之后需要互相交换数据才能进行下一次的计算。

图8 模型并行

图9 模型并行:多GPU计算内核和通信示意图

模型并行特点:

1)        优点

           a)        可以处理大模型的情况

2)        缺点

           a)        需要更频繁的通信,增加通信压力

           b)        实现难度较大

4.3.       GPU集群并行

          GPU集群并行模式即为多GPU并行中各种并行模式的扩展,如表2所示。节点间采用InfiniBand通信,节点间的GPU通过RMDA通信,节点内多GPU之间采用P2P通信。

表2 GPU集群并行模式

模式

节点间

节点内

特点

模式1

令牌环

单一模式的缺点放大

模式2

主从

模式3

模型并行

模式4

令牌环

主从

结合各种模式的有点,避免某一模式的缺点放大

模式5

主从

令牌环

模式6

令牌环

模型并行

模式7

主从

模型并行

4.4.       性能分享

4.4.1.       基于GPU集群的Caffe并行加速

图10 Caffe性能

8节点GPU服务器,2 K20mGPU/节点,56Gb/s InfiniBand网络,Lustre并行文件系统

4.4.2.       基于GPU集群的DNN并行加速

图11 DNN测试性能

4节点GPU服务器,4 K20mGPU/节点,56Gb/s InfiniBand网络

5.       CPU+FPGA协同计算加速线上计算

        相对于训练计算,线上识别的计算是小而众多的任务计算,每次请求的计算比较小,但请求的任务数十分庞大,GPU计算虽然获得很好的性能,但功耗仍然是个严峻的问题。

        目前主流的FPGA卡功耗只有主流GPU的十分之一,性能相差2-3倍,FPGA相对于GPU具有更高的GFlops/W。

利用FPGA解决线上识别计算可以采用分布式+FPGA计算的模式,如图12所示,上层可以采用Hadoop或Spark调度,底层利用FPGA进行计算。

图12 分布式计算+FPGA计算

        目前,FPGA已开始支持高级语言,如AlteraFPGA支持OpenCL,Xilinx FPGA支持HLS,这对程序员利用FPGA开发减低了难度。这些新平台的支持还有很多问题,也许后面会支持的越来越好。

 

备注:由于对深度学习算法了解比较肤浅,以上内容难免无误,请大家理解并提出修改意见。

 QQ:331526010

Email:zhang03_11@163.com

 

 

 

2016-09-21 14:52:12 qiuqinjun 阅读数 1014
  • 玩转深度学习实战教程

    玩转深度学习视频培训课程,详细讲解深度学习的原理和利用深度学习框架TensorFlow进行项目实战。课程通过Kaggle竞赛平台的Titanic问题讲解TensorFlow的基本用法以及问题处理的常用技巧,讲解深度学习图像领域的卷积神经网络CNN和多个经典的网络架构、CNN的应用,讲解自然语言处理领域的RNN、LSTM以及它们的多种变种结构,构建语言模型和对话机器人,介绍损失函数和优化深度学习算法在TensorFlow中的实现。

    2843 人正在学习 去看看 王而川

在上篇博文中,我们介绍了深度学习算法的实现,并且以MNIST手写数字识别为例,验证了该算法的有效性。

但是我们学习逻辑回归算法的目的是解决我们的实际问题,而不是学习算法本身。逻辑回归算法在实际中的应用还是很广泛的,例如在医学领域的疾病预测中,我们就可以列出一系疾病相关因素,然后根据某位患者的具体情况,应用逻辑回归算法,判断该患者是否患有某种疾病。当然,逻辑回归算法还是有局限性的,其比较适合于处理线性可分的分类问题,但是对于线性不可分的分类问题,这种算法的价值就会大打折扣了。但是我们可以将逻辑回归算法,视为没有隐藏层的前馈网络,通过增加隐藏层,就可以处理各种线性不可分问题了。借助于Theano的框架,在后面博文中我们会介绍BP网络、多层卷积网络(LeNet),大家可以看到,在Theano中,实现这些模型是一件非常简单的事情。

言归正传,如果我们要用逻辑回归算法解决实际问题,我们主要需要改变的就是load_data函数,使其从我们规定的数据源中读取数据。在此,我们先设计一个训练数据读入的工具类SegLoader,文件名为seg_loader.py,代码如下所示:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. from __future__ import print_function  
  2.   
  3. __docformat__ = 'restructedtext en'  
  4.   
  5. import six.moves.cPickle as pickle  
  6. import gzip  
  7. import os  
  8. import sys  
  9. import timeit  
  10.   
  11. import numpy  
  12.   
  13. import theano  
  14. import theano.tensor as T  
  15.   
  16. class SegLoader(object):  
  17.     def load_data(self, dataset):  
  18.         samplesNumber = 6  
  19.         features = 2  
  20.         train_set = (numpy.ndarray(shape=(samplesNumber, features), dtype=numpy.float32), numpy.ndarray(shape=(samplesNumber), dtype=int))  
  21.         self.prepare_dataset(train_set)  
  22.         valid_set = (train_set[0].copy(), train_set[1].copy())  
  23.         test_set = (train_set[0].copy(), train_set[1].copy())  
  24.         test_set_x, test_set_y = self.shared_dataset(test_set)  
  25.         valid_set_x, valid_set_y = self.shared_dataset(valid_set)  
  26.         train_set_x, train_set_y = self.shared_dataset(train_set)  
  27.         rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y),  
  28.             (test_set_x, test_set_y)]  
  29.         return rval  
  30.   
  31.     def shared_dataset(self, data_xy, borrow=True):  
  32.         data_x, data_y = data_xy  
  33.         shared_x = theano.shared(numpy.asarray(data_x,  
  34.                                                dtype=theano.config.floatX),  
  35.                                  borrow=borrow)  
  36.         shared_y = theano.shared(numpy.asarray(data_y,  
  37.                                                dtype=theano.config.floatX),  
  38.                                  borrow=borrow)  
  39.         return shared_x, T.cast(shared_y, 'int32')  
  40.   
  41.     def prepare_dataset(self, dataset):  
  42.         dataset[0][0][0] = 1.0  
  43.         dataset[0][0][1] = 1.0  
  44.         dataset[1][0] = 1  
  45.   
  46.         dataset[0][1][0] = 2.0  
  47.         dataset[0][1][1] = 2.0  
  48.         dataset[1][1] = 1  
  49.   
  50.         dataset[0][2][0] = 3.0  
  51.         dataset[0][2][1] = 3.0  
  52.         dataset[1][2] = 1  
  53.   
  54.         dataset[0][3][0] = 1.5  
  55.         dataset[0][3][1] = 2.0  
  56.         dataset[1][3] = 0  
  57.   
  58.         dataset[0][4][0] = 2.5  
  59.         dataset[0][4][1] = 4.0  
  60.         dataset[1][4] = 0  
  61.   
  62.         dataset[0][5][0] = 3.5  
  63.         dataset[0][5][1] = 7.0  
  64.         dataset[1][5] = 0  
上面的代码非常简单,生成一个元组train_set,包含两个元素,第一个元素是一个类型为float32的二维数组,每行代表一个样本,第一列代表X坐标,第二列代表Y坐标,train_set元组的第二个元素为一维整数数组,每个元素代表一个样本的分类结果,这里有两个大类,1代表在Y=X的直线上,0代表不在该直线上,prepare_dataset准备了6个训练样。因为这个问题非常简单,所以6个样本基本就够用了,但是对实际问题而言,显然需要相当大的样本量。

接着我们定义这个线性分割的执行引擎LrSegEngine,源码文件为lr_seg_engine.py,代码如下所示:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. from __future__ import print_function  
  2.   
  3. __docformat__ = 'restructedtext en'  
  4.   
  5. import six.moves.cPickle as pickle  
  6. import gzip  
  7. import os  
  8. import sys  
  9. import timeit  
  10.   
  11. import numpy  
  12.   
  13. import theano  
  14. import theano.tensor as T  
  15. from logistic_regression import LogisticRegression  
  16. from seg_loader import SegLoader  
  17.   
  18. class LrSegEngine(object):  
  19.     def __init__(self):  
  20.         print("Logistic Regression MNIST Engine")  
  21.         self.learning_rate = 0.13  
  22.         self.n_epochs = 1000  
  23.         self.batch_size = 1 # 600  
  24.         self.dataset = 'mnist.pkl.gz'  
  25.   
  26.     def train(self):  
  27.         print("Yantao:train the model")  
  28.         loader = SegLoader()  
  29.         datasets = loader.load_data(self.dataset)  
  30.         train_set_x, train_set_y = datasets[0]  
  31.         valid_set_x, valid_set_y = datasets[1]  
  32.         test_set_x, test_set_y = datasets[2]  
  33.         n_train_batches = train_set_x.get_value(borrow=True).shape[0] // self.batch_size  
  34.         n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] // self.batch_size  
  35.         n_test_batches = test_set_x.get_value(borrow=True).shape[0] // self.batch_size  
  36.         index = T.lscalar()  
  37.         x = T.matrix('x')  
  38.         y = T.ivector('y')  
  39.         # in:x,y out: 1 in y=x otherwise 0  
  40.         classifier = LogisticRegression(input=x, n_in=2, n_out=2)  
  41.         cost = classifier.negative_log_likelihood(y)  
  42.         test_model = theano.function(  
  43.             inputs=[index],  
  44.             outputs=classifier.errors(y),  
  45.             givens={  
  46.                 x: test_set_x[index * self.batch_size: (index + 1) * self.batch_size],  
  47.                 y: test_set_y[index * self.batch_size: (index + 1) * self.batch_size]  
  48.             }  
  49.         )  
  50.         validate_model = theano.function(  
  51.             inputs=[index],  
  52.             outputs=classifier.errors(y),  
  53.             givens={  
  54.                 x: valid_set_x[index * self.batch_size: (index + 1) * self.batch_size],  
  55.                 y: valid_set_y[index * self.batch_size: (index + 1) * self.batch_size]  
  56.             }  
  57.         )  
  58.         g_W = T.grad(cost=cost, wrt=classifier.W)  
  59.         g_b = T.grad(cost=cost, wrt=classifier.b)  
  60.         updates = [(classifier.W, classifier.W - self.learning_rate * g_W),  
  61.                (classifier.b, classifier.b - self.learning_rate * g_b)]  
  62.         train_model = theano.function(  
  63.             inputs=[index],  
  64.             outputs=cost,  
  65.             updates=updates,  
  66.             givens={  
  67.                 x: train_set_x[index * self.batch_size: (index + 1) * self.batch_size],  
  68.                 y: train_set_y[index * self.batch_size: (index + 1) * self.batch_size]  
  69.             }  
  70.         )  
  71.         patience = 5000    
  72.         patience_increase = 2    
  73.         improvement_threshold = 0.995    
  74.         validation_frequency = min(n_train_batches, patience // 2)  
  75.         best_validation_loss = numpy.inf  
  76.         test_score = 0.  
  77.         start_time = timeit.default_timer()  
  78.         done_looping = False  
  79.         epoch = 0  
  80.         while (epoch < self.n_epochs) and (not done_looping):  
  81.             epoch = epoch + 1  
  82.             for minibatch_index in range(n_train_batches):  
  83.                 minibatch_avg_cost = train_model(minibatch_index)  
  84.                 # iteration number  
  85.                 iter = (epoch - 1) * n_train_batches + minibatch_index  
  86.                 if (iter + 1) % validation_frequency == 0:  
  87.                     # compute zero-one loss on validation set  
  88.                     validation_losses = [validate_model(i)  
  89.                                      for i in range(n_valid_batches)]  
  90.                     this_validation_loss = numpy.mean(validation_losses)  
  91.                     print(  
  92.                         'epoch %i, minibatch %i/%i, validation error %f %%' %  
  93.                         (  
  94.                             epoch,  
  95.                             minibatch_index + 1,  
  96.                             n_train_batches,  
  97.                             this_validation_loss * 100.  
  98.                         )  
  99.                     )  
  100.                     if this_validation_loss < best_validation_loss:  
  101.                         #improve patience if loss improvement is good enough  
  102.                         if this_validation_loss < best_validation_loss * improvement_threshold:  
  103.                             patience = max(patience, iter * patience_increase)  
  104.                         best_validation_loss = this_validation_loss  
  105.                         # test it on the test set  
  106.                         test_losses = [test_model(i)  
  107.                                    for i in range(n_test_batches)]  
  108.                         test_score = numpy.mean(test_losses)  
  109.                         print(  
  110.                             (  
  111.                                 '     epoch %i, minibatch %i/%i, test error of'  
  112.                                 ' best model %f %%'  
  113.                             ) %  
  114.                             (  
  115.                                 epoch,  
  116.                                 minibatch_index + 1,  
  117.                                 n_train_batches,  
  118.                                 test_score * 100.  
  119.                             )  
  120.                         )  
  121.                         # save the best model  
  122.                         with open('best_model.pkl''wb') as f:  
  123.                             pickle.dump(classifier, f)  
  124.                 if patience <= iter:  
  125.                     done_looping = True  
  126.                     break  
  127.         end_time = timeit.default_timer()  
  128.         print(  
  129.             (  
  130.                 'Optimization complete with best validation score of %f %%,'  
  131.                 'with test performance %f %%'  
  132.             )  
  133.             % (best_validation_loss * 100., test_score * 100.)  
  134.         )  
  135.         print('The code run for %d epochs, with %f epochs/sec' % (  
  136.             epoch, 1. * epoch / (end_time - start_time)))  
  137.         print(('The code for file ' +  
  138.                os.path.split(__file__)[1] +  
  139.                ' ran for %.1fs' % ((end_time - start_time))), file=sys.stderr)  
  140.   
  141.     def run(self, data):  
  142.         print("run the model")  
  143.         classifier = pickle.load(open('best_model.pkl''rb'))  
  144.         predict_model = theano.function(  
  145.             inputs=[classifier.input],  
  146.             outputs=classifier.y_pred  
  147.         )  
  148.         rst = predict_model(data)  
  149.         print(rst)  
在这里的train方法,与上篇博文处理MNIST手写数字识别的代码基本一致,只需要注意以下几点:首先,由于我们只有6个样本,因此将样本批次的大小设置为1(在MNIST手写数字识别中,由于有6万个训练样本,所以批次大小为600);其次,在初始化逻辑回归模型时,输入维度n_in,设置为2,表示样本只有两个特征即x,y坐标,输出维度也为2,表示有两个类别,1是在y=x线上,0代表不在线上。

接着我们定义逻辑回归模型类LogisticRegression,源码文件为logistic_regression.py,代码如下所示:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. from __future__ import print_function  
  2.   
  3. __docformat__ = 'restructedtext en'  
  4.   
  5. import six.moves.cPickle as pickle  
  6. import gzip  
  7. import os  
  8. import sys  
  9. import timeit  
  10.   
  11. import numpy  
  12.   
  13. import theano  
  14. import theano.tensor as T  
  15.   
  16. class LogisticRegression(object):    
  17.     def __init__(self, input, n_in, n_out):    
  18.         self.W = theano.shared(    
  19.             value=numpy.zeros(    
  20.                 (n_in, n_out),    
  21.                 dtype=theano.config.floatX    
  22.             ),    
  23.             name='W',    
  24.             borrow=True    
  25.         )    
  26.         self.b = theano.shared(    
  27.             value=numpy.zeros(    
  28.                 (n_out,),    
  29.                 dtype=theano.config.floatX    
  30.             ),    
  31.             name='b',    
  32.             borrow=True    
  33.         )    
  34.         self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)    
  35.         self.y_pred = T.argmax(self.p_y_given_x, axis=1)    
  36.         self.params = [self.W, self.b]    
  37.         self.input = input    
  38.         print("Yantao: ***********************************")  
  39.     
  40.     def negative_log_likelihood(self, y):    
  41.         return -T.mean(T.log(self.p_y_given_x)[T.arange(y.shape[0]), y])    
  42.     
  43.     def errors(self, y):    
  44.         if y.ndim != self.y_pred.ndim:    
  45.             raise TypeError(    
  46.                 'y should have the same shape as self.y_pred',    
  47.                 ('y', y.type, 'y_pred'self.y_pred.type)    
  48.             )    
  49.         if y.dtype.startswith('int'):    
  50.             return T.mean(T.neq(self.y_pred, y))    
  51.         else:    
  52.             raise NotImplementedError()    
上面的代码与上篇博文几乎没有变化,只是将其单独保存到一个文件中而已。

接下来是模型训练lr_train.py,代码如下所示:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. from __future__ import print_function  
  2.   
  3. __docformat__ = 'restructedtext en'  
  4.   
  5. import six.moves.cPickle as pickle  
  6. import gzip  
  7. import os  
  8. import sys  
  9. import timeit  
  10.   
  11. import numpy  
  12.   
  13. import theano  
  14. import theano.tensor as T  
  15.   
  16. from logistic_regression import LogisticRegression  
  17. from seg_loader import SegLoader  
  18. from lr_seg_engine import LrSegEngine  
  19.   
  20. if __name__ == '__main__':  
  21.     engine = LrSegEngine()  
  22.     engine.train()  
上面代码只是简单调用逻辑回归分割的引擎类的train方法,完成对模型的训练,其会将最佳的结果保存到best_model.pkl文件中。

当模型训练好之后,我们就可以拿模型来进行分类了,lr_run.py的代码如下所示:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. from seg_loader import SegLoader  
  2. from lr_seg_engine import LrSegEngine  
  3.   
  4. if __name__ == '__main__':  
  5.     print("test program v1.0")  
  6.     engine = LrSegEngine()  
  7.     data = [[2.02.0]]  
  8.     print(data)  
  9.     engine.run(data)  
上面代码首先初始化一个二维数组,其中只有一个样本元素,坐标为(2.0, 2.0),然后调用逻辑回归分割引擎的run方法,其将给出分类结果,运行这个程序,会得到类似如下所示的结果:

test program v1.0

Logistic Regression MNIST Engine

[[2.0, 2.0]]

run the model

[1]

没有更多推荐了,返回首页