业界 | 五大主流深度学习框架比较分析：MXNET是最好选择
业界 | 五大主流深度学习框架比较分析：MXNET是最好选择
选自 RevolutionAnalytics机器之心编译作者：Anusua Trivedi参与：YanChen、黄清纬、李亚洲近日，微软数据科学家 Anusua Trivedi 发表系列文章讲解深度学习，这是此系列的第一篇，对主流深度学习框架进行了比较分析。背景和途径本博客系列基于我即将在新加坡 Hadoop+Strata 世界峰会上发表的关于深度学习模型复用性的演讲。该系列分几个部分来描述我的经验，并深入讨论我选择使用深度学习模型背后的原因。深度学习是一个新兴的研究领域，它在很多领域中都有其应用空间。我尝试展示迁移学习和微调策略是如何使得同一个卷积神经网络模型在不同的不相关领域获得复用性。该模型在多种不同领域中的应用，使得使用该微调模型拥有更大的价值。在本博客中，我描述并比较了常用的开源深度学习构架。我深入讨论了每个构架各自的优缺点，以及为什么我选择在我的工作中使用 Theano。符号构架符号计算构架（如 CNTK，MXNET，TensorFlow，Theano）被定义为一个向量运算符的符号图，例如矩阵的加法/乘法或卷积。一个层仅是这些运算符的组合。构造块（运算符）良好的粒度允许用户在不需要在低级语言（如在 Caffe 中）中实现的情况下，开发新的复杂层类型。在我的工作中，我使用了不同的符号计算框架。然而，我发现由于每个框架的设计和目前的实现方法不同，它们都有各自的优缺点，没有一个框架能完美地满足所有的需要。针对我的需要，我选择使用 Theano。我们比较了下列符号计算框架：Theano软件：Theano开发者：Université de Montréal软件证书：BSD 证书是否开源：是平台：跨平台编写语言：Python接口：Python是否支持 CUDA：是自动微分：是是否有预训练模型：通过 &Lasagne 的 model zoo循环网络：是卷积网络：是随机储存器/动态贝叶斯网络：是TensorFlow软件：TensorFlow开发者：Google Brain Team软件证书：Apache 2.0是否开源：是平台：Linux，Mac OS X编写语言：C++，Python接口：Python，C/C++是否支持 CUDA：是自动微分：是是否有预训练模型：否循环网络：是卷积网络：是随机储存器/动态贝叶斯网络：是MXNET软件：MXNET开发者：分布式（深度）机器学习社区软件证书：Apache 2.0是否开源：是平台：Ubuntu, OS X, Windows, AWS, Android, iOS, JavaScript编写语言：C++, Python, Julia, Matlab, R, Scala接口：C++, Python, Julia, Matlab, JavaScript, R, Scala是否支持 CUDA：是自动微分：是是否有预训练模型：是循环网络：是卷积网络：是随机储存器/动态贝叶斯网络：是优缺点非符号构架优点：像 torch，caffe 这样的非符号（命令式）神经网络构架的计算部分的设计非常相似。根据可表达性，设计良好的命令构架也能揭露类图接口（例如 torch/nngraph）。非符号架构缺点：命令构架主要的缺点实际上在于人工优化。例如，就地操作必须要人工实现。大多命令构架设计得不够好，比不上符号构架的可表达性。符号构架优点：符号构架可能可以从依赖图中自动推导优化。一个符号构架可以利用更多内存复用机会，这点 MXNET 做得很好。符号构架能自动计算最佳进度表。详情请参照 TensorFlow 白皮书：http://download.tensorflow.org/paper/whitepaper2015.pdf符号构架缺点：现存可用开源符号构架的表现仍逊色于命令构架。符号构架缺点：现存可用开源符号构架的表现仍逊色于命令构架。增加新运算符在这些构架中，增加一个表现理想的运算符并不容易。Theano / MXNETTensorFlow在内联 C 支持的 Python 下，可以增加运算符。在 C++ 中推进，在 Python 中符号梯度。代码复用性训练深度网络非常耗时。所以，Caffe 发布了一些预训练模型/权重（model zoo），它们能作为初始权重被用于特殊领域或自定义图像的迁移学习或微调深度网络。TheanoLasagne：是构建在顶尖 Theano 上的高级构架。在 Lasagne 中使用 Caffe 预训练模型权重非常容TensorFlow：不支持预训练模型。MXNET：有一个 caffe 转换工具，能够转换基于 caffe 的预训练模型权重，使其可以适应 MXNET。低级 Tensor 操作符理想而高效的低级运算符实现能充当新模型的原料，节省了写新运算符的工作量。TheanoTensorFlowMXNET许多基础运算符相当好非常少控制流运算符控制流运算符增加符号引擎的表达性和通用性。TheanoTensorFlowMXNET支持试验阶段不支持高级支持Theano：纯净的符号计算构架。高级构架，加以改造，可以适用于各种所需的使用方式。成功案例包括 Keras、Lasagne、blocks。TensorFlow：设计良好，不仅考虑到了神经网络的训练，同时避免彻底成为神经网络构架，是非常出色的成果。图像、队列、图像增加器等能成为更高级包装的有用构造块。MXNET：除了符号部分，MXNET 也支持图像分类——从数据加载到构建模型，该模型有可以开始训练的方法。性能单 GPU 下的基准测试我使用单 GPU （NVIDIA Quadro K1200 GPU）在 MNIST 数据集上对 LeNet 模型进行了基准测试。TheanoTensorFlowMXNET好不太好极佳内存显存有限可能是大型模型的常见问题。TheanoTensorFlowMXNET好不太好极佳单 GPU 速度Theano 花了很长的时间编译图像，特别是模型复杂的时候。TensorFlow 有点慢。Theano / MXNETTensorFlow比得上 CuDNNv4慢一倍并行/分布式支持TheanoTensorFlowMXNET试验多 GPU多 GPU分布式总结Theano（高级的 Lasagne 和 Keras）是深度学习模型的极佳选择。很容易用 Lasagne/Keras 实现新网络或者编辑现存网络。我更喜欢用 python 语言，并且因为 Lasagne/Keras 有非常成熟的 python 接口而更喜欢使用它们。然而，它们不支持 R。我已经尝试在 Lasagne/Keras 中使用迁移学习和微调，编辑一个现存网络并自定义特定域的自定义数据是非常容易的。不同构架之间的比较显示了 MXNET 是最好的选择（更好的表现/记忆）。此外，它对 R 的支持很出色。事实上，它是唯一支持所有 R 函数的构架。在 MXNET 中，迁移学习和微调网络是可能实现的，但是不太容易（和 Lasagne/Keras 相比）。这使得编辑现存训练好的网络更困难，因此使用特定域的自定义数据也有点难。?本文由机器之心编译，转载请联系本公众号获得授权。?------------------------------------------------加入机器之心（全职记者/实习生）：投稿或寻求报道：广告&商务合作：
发表评论：
馆藏&33333
TA的最新馆藏Copyright (C) 2015&&
&&Powered by&Read Eval Print Loop (REPL)
REPL在Scala里面指的是直接运行scala.exe进入的交互式命令行模式。广义上讲，也泛指那些在线编程工具。
核心规则1：请使用REPL来熟悉Scala语言。
Scala的REPL有个好处是能够将我们输入的每行代码的内部表示反馈出来。比如：
scala& def add(a:Int, b:Int):Int = a + b
add: (a: Int, b: Int)Int
我们定义一个函数，完成两个数的加法。Scala回显给我们的内容可以帮助我们写代码。
表达式与语句
表达式与语句的区别是：语句是用来执行的，而表达式是用来求值的。在程序员的世界里，表达式就是返回值，语言就是没有返回值执行程序。
Scala是表达式导向的编程语言。但并不是100%成立，Scala代码中还是有控制语块，毕竟我们写程序就是为了控制各种实体为我们服务的。
核心规则2：使用表达式，而不是语句。
这条规则主要是帮助我们简化代码，就像前面加法的例子，a+b就是一个表达式。相比于我们C语言写的相同实现，简单不好。代码里面，像这样的例子肯定还是存在很多的。
不要使用Return
当我们使用表达式的时候，就不需要Return了。因为表达式本身就是用来求值的，我们必要再去显式地说我现在要返回什么。Scala编译器自动使用最后一个表达式的返回值作为函数的返回值。
我们应该记得一个编程指导意见就是函数在同一个地方返回。如果我们现在没有Return语句了，像在Scala中，有没有类似的编程指导呢？看个例子：
object&NoReturn&extends&scala.App&{
&&def&createErrorMessage1(errorCode&:&Int)&:&String&=&{
&&&&val&result&=&errorCode&match&{
&&&&&&case&1&=&&"Network&Failure"
&&&&&&case&2&=&&"I/O&Failure"
&&&&&&case&3&=&&"Unknown&Error"
&&&&return&result
&&def&createErrorMessage2(errorCode:&Int)&:&String&=&{
&&&&var&result&:&String&=&null&&&&&&&&&&&&//&not&val
&&&&errorCode&match&{
&&&&&&case&1&=&
&&&&&&&&result&=&"Network&Failure"
&&&&&&case&2&=&
&&&&&&&&result&=&"I/O&Failure"
&&&&&&case&_&=&
&&&&&&&&result&=&"Unknown&Error"
&&&&return&
&&def&createErrorMessage3(errorCode&:&Int)&:&String&=&{
&&&&errorCode&match&{
&&&&&&case&1&=&&"Network&Failure"
&&&&&&case&2&=&&"I/O&Failure"
&&&&&&case&3&=&&"Unknown&Error"
&&println(createErrorMessage1(1))
&&println(createErrorMessage2(2))
&&println(createErrorMessage3(3))
&&println(1&match{case&1&=&&"Network&Failure"&case&2&=&&3})
&&println(2&match{case&1&=&&"Network&Failure"&case&2&=&&3})
createErrorMessage2应该是我们以往的写法。定义一个局部变量，然后匹配errorCode，对其进行赋值。createErrorMessage1是Scala推荐的写法（虽然还不够简洁），它使用的是val而不是var，来声明临时变量。val表示值，赋值后就不允许再更改；var是变量，可以重复赋值。createErrorMessage1的的result之后是一个表达式。求值之后直接就赋值了。createErrorMessage3就更加简洁了，差不多到了终极形态了。函数直接就返回一个表达式，少了临时对象。
注：match case支持每个分支返回的类型不同。这个特性在函数式编程中非常有用。
Scala虽然支持所有的3中写法，但是推荐最后一种。因为它帮助简化了代码的复杂度，增加了程序的不可变性。不可变指的是程序在执行过程中，所有的状态（变量）都是常量。不可变的代码比可变代码更加容易理解、调试和维护。
表达式导向的语言倾向与使用不可变的对象，能减少程序中的可变对象。
使用不可变对象
核心规则3：使用不可变对象可以大幅减少运行时故障。当面对可变与不可变的选择时，选择不可变对象无疑是最安全的。
对象等价性
Scala提供了##和==来判断对象是不是等价，它们可以作用于AnyRef（引用）和AnyVal（值）。
对象的哈希值和equal应该成对出现。因为等价性经常使用到了hash值。
import&collection.immutable.HashMap
class&Point2(var&x:&Int,&var&y:&Int)&extends&Equals&{
&&def&move(mx:&Int,&my:&Int)&:&Unit&=&{
&&&&x&=&x&+&mx
&&&&y&=&y&+&my
&&override&def&hashCode():&Int&=&y&+&(31*x)
&&def&canEqual(that:&Any):&Boolean&=&that&match&{
&&&&case&p:&Point2&=&&true
&&&&case&_&=&&false
&&override&def&equals(that:&Any):&Boolean&=&{
&&&&def&strictEquals(other:&Point2)&=
&&&&&&this.x&==&other.x&&&&this.y&==&other.y
&&&&that&match&{
&&&&&&case&a:&AnyRef&if&this&eq&a&=&&true
&&&&&&case&p:&Point2&=&&(p&canEqual&this)&&&&strictEquals(p)
&&&&&&case&_&=&&false
object&ObjecteEquality&extends&scala.App
&&val&x&=&new&Point2(1,1)
&&val&y&=&new&Point2(1,2)
&&val&z&=&new&Point2(1,1)
&&println(x&==&y)&//&false
&&println(x&==&z)&//&true
&&val&map&=&HashMap(x&-&&"HAI",&y&-&&"ZOMG")
&&println(map(x))&//&HAI
&&println(map(y))&//&ZOMG
&&println(map(z))&//&HAI,&if&we&remove&hashCode,&there&will&be&an&exception
&&x.move(1,1)
//&println(map(x))&//Exception&in&thread&"main"&java.util.NoSuchElementException:&key&not&found:&Point2@40
&&println(map.find(_._1&==&x))
3-22行定义了一个Point2类，它继承自Equals。
trait Equals extends Any {
& def canEqual(that: Any): Boolean
& def equals(that: Any): Boolean
定义了自己的move方法和hashCode方法。canEqual用来判断是否可以在对象上应用equal方法，这里只是检查是否类型匹配。equal包含一个内部函数strictEquals用来判断对象的成员是否相等。equal首先检查是不是引用了同一个Point2对象，如果是，直接返回true。否则，检查类型是不是匹配，如果是，用strictEquals用来判断对象的成员是否相等。
第36行：println(map(z))，它的正确执行依赖于hashCode是否定义。Map在寻找指定key的值的时候，会调用key.##。
第38行，由于move改变了x的内部状态，hashCode计算出来的新值当做key去Map里面查找，找不到对应的值，就会报NoSuchElementException异常。
第40行，比较奇特。看下find的定义：
trait IterableLike： &
override /*TraversableLike*/ def find(p: A =& Boolean): Option[A] = iterator.find(p)
object Iterator：
& def find(p: A =& Boolean): Option[A] = {
& & var res: Option[A] = None
& & while (res.isEmpty && hasNext) {
& & & val e = next()
& & & if (p(e)) res = Some(e)
传给find的是一个predicate。迭代器遍历集合中的每个元素，并将该元素作为参数传给predicate。所有我们这里传给predicate的参数是一个键值对[A,B]。_就是传给predicate的参数。_1指的是键值对中的第一个元素（实际上是元组中的第一个元素），即A，也就是作为key的Point2。现在很容易明白这句的意思了，就是与x的hashCode一样的元素。_1的定义位于：
trait Product2：
& /** A projection of element 1 of this Product.
A projection of element 1.
& def _1: T1
在我们实现对象的等价判断的时候，请遵循：
如果两个对象相等，那它们应该有相同的hashCode。
对象的hashCode在其生命周期内不会改变。
如果将一个对象发送给其他的JVM，应该保证等价判断依赖于对象在两个JVM都可用的属性。主要用于序列化。
如果我们的对象是不可变的，那么上面的条件2自行就满足了，这会简化等价判断。另外，不可变性不仅仅简化等价判断，也会简化并行数据的访问，因为不存在同步互斥。
使用None而不是null
null的使用还是很受大家诟病的。null迫使大家添加了额外的处理代码。Scala使用Option来包装了null的处理，我们不在需要去判断变量是否为空。我们可以将Option看成一个通用的容器，包含了一些对象的容器（Some），或者是空容器（None）。这两周容器都需要对象的类型。
类似地，Scala还有空的列表Nil。
核心规则4：使用None而不是null
Java中，我们经常会碰到空异常。如果我们学会了正确使用Option，完全可以避免空异常的发生。
Scala的Option伴生对象（companion object）包含一个工厂方法，将Java的null自动转换为None：var x : Option[String] = Option(null)。等价于var x : Option[String] = None。
Scala更加高级的用法是把它当作一个集合。这意味着，你可以在Option上使用map、flatMap、foreach，甚至是for表达式。
使用Null的一些高级实例：
class&HttpSession
class&Connection
object&DriverManager&{
&&def&getConnection(url:&String,&user:&String,&pw:&String):&Connection&=&{
&&&&println("getConnection")
&&&&new&Connection
object&AdvancedNull&extends&scala.App&{
&&//CREATE&AN&OBJECT&OR&RETURN&A&DEFAULT
&&def&getTemporaryDirectory(tmpArg:&Option[String]):&java.io.File&=&{
&&&&tmpArg.map(name&=&&new&java.io.File(name)).
&&&&&&filter(_.isDirectory).
&&&&&&getOrElse(new&java.io.File(
&&&&&&System.getProperty("java.io.tmpdir")))
&&//EXECUTE&BLOCK&OF&CODE&IF&VARIABLE&IS&INITIALIZED
&&val&username1:&Option[String]&=&Option("Sulliy")
&&for&(uname&&-&username1)&{
&&&&println("User:&"&+&uname)
&&val&username2:&Option[String]&=&None
&&for&(uname&&-&username2)&{
&&&&println("User:&"&+&uname)
&&def&canAuthenticate(username:&String,&password:&Array[Char]):&Boolean&=&{
&&&&println("canAuthenticate")
&&def&privilegesFor(username:&String):&Int&=&{
&&&&println("privilegesFor")
&&def&injectPrivilegesIntoSession(session:&HttpSession,&privileges:&Int):&Unit&=&{
&&&&println("injectPrivilegesIntoSession")
&&def&authenticateSession(session:&HttpSession,
&&&&&&&&&&&&&&&&&&&&&&&&&&username:&Option[String],
&&&&&&&&&&&&&&&&&&&&&&&&&&password:&Option[Array[Char]])&=&{
&&&&for&(u&&-&
&&&&&&&&&p&&-&
&&&&&&&&&if&canAuthenticate(u,&p))&{
&&&&&&val&privileges&=&privilegesFor(u)
&&&&&&injectPrivilegesIntoSession(session,&privileges)
&&authenticateSession(new&HttpSession,&None,&None)
&&//USING&POTENTIAL&UNINITIALIZED&VARIABLES&TO&CONSTRUCT&ANOTHER&VARIABLE
&&def&createConnection(conn_url:&Option[String],
&&&&&&&&&&&&&&&&&&&&&&&conn_user:&Option[String],
&&&&&&&&&&&&&&&&&&&&&&&conn_pw:&Option[String]):&Option[Connection]&=
&&&&&&url&&-&conn_url
&&&&&&user&&-&conn_user
&&&&&&pw&&-&conn_pw
&&&&}&yield&DriverManager.getConnection(url,&user,&pw)
&&createConnection(None,&Option("sully"),&None)
&&def&lift3[A,&B,&C,&D](f:&Function3[A,&B,&C,&D]):&Function3[Option[A],&Option[B],&Option[C],&Option[D]]&=&{
&&&&(oa:&Option[A],&ob:&Option[B],&oc:&Option[C])&=&
&&&&&&for&(a&&-&&b&&-&&c&&-&oc)&yield&f(a,&b,&c)
&&lift3(DriverManager.getConnection)(Option("127.0.0.1"),&Option("sulliy"),&Option("sulliy"))
11行-16行，示例了通过一个文件名获取File对象。由于输入参数是Option[String]，该函数可以接受None，既null。map、filter、getOrElse都是Option的成员函数：
final def map[B](f: A =& B): Option[B] =
& & if (isEmpty) None else Some(f(this.get))
final def filter(p: A =& Boolean): Option[A] =
& & if (isEmpty || p(this.get)) this else None
final def getOrElse[B &: A](default: =& B): B =
& & if (isEmpty) default else this.get
前两个函数都又返回了Option[]，所以我们可以进行级联的书写。map返回None（Option的子类），None的filter返回None，None的getOrElse返回default，即new java.io.File( System.getProperty("java.io.tmpdir")。
我们在需要创建一个对象或者返回一个缺省对象的时候，可以使用这种方法。
18行-21行，示例了将Option放在for循环里面。由于username1赋值了，username2为空，因此20行会被执行，24行不会被执行。37行-47行，给了一个更加复杂的例子。
49行-56行，示例了通过一个可能未初始化的对象来创建新对象。用到了yield。
58行-62行，提供了一个通用方法，将普通的Java方法封装为支持Option的新的Scala方法。这样，我们就不需要自己去处理所有参数的null检查。
多态环境下的等价判断
核心规则5：在使用多态情况下，使用scala.Equals提供的模板。
前面已经提到了scala.Equals，需要注意的是：请同时重写canEqual和equal。
& 开源中国(OSChina.NET) |
开源中国社区(OSChina.net)是工信部
指定的官方社区Deep Learning继续学习（37）
-12日，由中国计算机学会（CCF）主办，CCF大数据专家委员会承办，中国科学院计算技术研究所、北京中科天玑科技有限公司与CSDN共同协办，以“数据安全、深度分析、行业应用”为主题的 2015中国大数据技术大会（Big Data Technology Conference 2015，BDTC 2015）在北京新云南皇冠假日酒店盛大开幕。
11日下午的深度学习分论坛，地平线机器人科技高级工程师余轶南，阿里巴巴iDST语音组高级专家鄢志杰，厦门大学教授纪荣嵘，华中科技大学教授、国家防伪工程中心副主任白翔，以及微软亚洲研究院研究员洪春涛分享了深度学习在图像识别、语音识别、视觉搜索、文字识别等方面的应用，以及开源深度学习框架的演进。
余轶南：基于深度学习的图像识别进度
地平线机器人科技高级工程师余轶南分享了题为《基于深度学习的图像识别进度》的演讲。
从2012年底开始，深度学习从图象识别出发，很快席卷了所有图像里大部分的任务，包括后来的目标检测、图像分割，以及各种图像的应用，以及最近图像超分辨率和跟踪，都被深度学习所颠覆。神经网络系统自由度和它的灵活性非常强，可以用这样一套统一的东西做很多过去需要用不同处理架构做的事情。
算法方面已经做了非常多的工作，将来会在以下几个方面有所突破：第一，理论方面Deep Learning的分析是现在所获取的，需要进行Network的理论分析。第二，无论是谷歌，还是微软今天公布的150多层的网络，都是人工精心做的，这对design非常重要。第三，遇到的真实问题远是很困难的任务，所以很多时候是Structured Data Processing。第四，Logistic、Counting、Reasonino。第五，over-Reliance ON HP-Data And HP-Communication
很多数据的获得都是非常容易的，但是有一些数据不是这样，有一些数据获得成本非常高昂，而且出现频率非常低。需要把原来云端计算模型搬到前端，之所以能搬到前端，就要在价格、功耗、成本各方面进行考量。其实相当于云端来说，前端这样的使用场景，身边的每一样设备都需要智能东西对它进行全新的革命。就要有所选择，用一款通用芯片计算单元，还是专门构建这样一款针对DATA Network或者是不同硬件做计算。把计算适用性和指标放在这里。核数比较少的情况下，但是精度运算能力非常强，非常适合逻辑计算，现在大多数电脑和手机都在这个领域做工作。第二个方面是DSP，最大的好处是低功耗和低成本，在身边用得最多的是这个。随着核数越来越多，能耗比是越来越好。
无论是谷歌网络，还是MSR ImageNet网络，都离不开三件事情：第一，迭代。第二是转机。最后是Multiplication。如果你把计算机迭代再加上门，你就可以做Recurrence，这三个基础上非常繁杂，各种各样的Network，使Network服务于不同的奇奇怪怪的需求。可以发现，人脑其实也是这样的架构。人脑要回答几千乘几千问题很困难，但是可以对面前的情况做出反应。电脑可以非常快算出几十亿乘几十亿的数据，但是要处理以上的问题非常难。所以需要深度学习来进行综合。
阿里iDST鄢志杰：Deep Learning在客服中心的应用
阿里巴巴iDST语音组高级专家鄢志杰分享了题为《Deep Learning助力客服小二：数据技术及机器学习在客服中心的应用》的演讲。他主要从传统客服中心的现状与挑战、沉淀客服数据、全量客服质检、自助客服四个方面进行了分享。
传统客服中心面临的挑战包括：效率不高，用户体验欠佳；缺乏有效反馈，难以保证服务质量；随业务发展可扩展性差。以阿里巴巴和蚂蚁金融为例，传统客服具有话务量大和用工量大的特点。这种规模膨胀带来了三个问题：面对客户，如何提升服务体验？针对小二，如何提升服务质量？放眼未来，如何通过数据技术及机器学习升级传统客服？
面对以上问题，iDST进行了以下尝试：
语音识别沉淀客服数据，自动语音识别，将对话转写为文本，为后续应用提供前提。全量自动质量控制，扫描每通电话，监测基本服务质量，并且进行问题定位质检，提升问题解答一致性。自动识别问题，提高自助渠道解决率。存储语音数据不等于沉淀，高准确率的自动语音识别是后续诸多应用的前提。
客服电话语音识别的难点在于电话对话语音识别是语音识别领域最困难的任务之一，所以需要训练声学模型来识别语音。声学模型是决定语音识别准确率的核心模型之一。快速周转训练声学模型是第一要素，第二是Deep Learning。可以利用更多数据、覆盖更多实际使用场景来提升识别准确率，但更多数据意味着更长的训练周期，所以缩短训练周期是工业界声学模型训练的核心问题之一。
他通过分析GPU多机多卡Machine Learning Middleware、基于DBLSTM的语音识别声学模型、基于DLSTM的问题定位质检、我的客服“因子+行为”自动问题识别对机器学习在语音方面的应用做了进一步分享。其中，问题定位模型需要确定问题类目、收集训练数据。问题类目是定位和质检的目标。
关于未来总结云展望，他提到未来是否有自动问题生成模型，用户说完一句话，或者是说完几句话你还向访问一些东西，澄清一些问题，这时候需要自动问题生成模块回到IVR系统，问出这句话，使得帮助你做判断。于此之外要配响应语音合成技术，还有说话人识别、验证、情绪检测等等，这些合在一起就是智能机器人。
厦门大学纪荣嵘：大规模特征哈希与深度网络压缩
厦门大学教授纪荣嵘分享了题为《视觉大数据系统紧凑性初探——大规模特征哈希与深度网络压缩》的演讲。他主要从面向大规模视觉搜索的特征哈希和深度神经网络压缩这两个切入点介绍了视觉大数据搜索与识别系统。
视觉数据近年来呈爆炸性增长，大规模视觉搜索技术具有紧迫需求。实际应用问题经常面临百千万/亿级视觉（图片、视频）数据库；计算资源受到限制，具有有限的内存容量与时间效率容忍性；传统的视觉特征表示维度过高；倒排索引表内容开销过大；移动与嵌入式系统的场景限制，无法容忍高维实值特征的时空开销，最小化数据通信量的需求。面向大规模视觉搜索的特征哈希具有一定的优势：哈希函数为特征投影快，搜索时间为汉明查表，复杂度低，百万量级图像搜索系统可以存储在内存中。代表性的特征哈希技术包括数据独立哈希和数据非独立哈希。
最早的想法跟数据库里做哈希不一样，数据库生成哈希码，哈希码本身是唯一，如果两个有差别生成哈希码差别很大，汉明距离不能区别你的相似性。通过随机切分平面可以一定保障原始特征空间里两个点足够近，有一定的概率落在同一个哈希码里，所以有一套严格的数据证明。这个性能并没有大家想象的强，所以这个性能并不是非常满意。如果原始特征空间并不完美，一个想法是在原始空间里构造Graph，用Graph Hashing表示两个点的相似性，把Graph Hashing引到一起。计算哈希码优化过程中，只需要对两个小矩阵做低级矩阵分解，通过这种方式大大节约矩阵分解时带来的时间消耗。
对于深度神经网络压缩，主要做CNN压缩，也可以做乘法量化压缩，还可以做参差编码压缩等。之前大家做的工作大多是网络减枝、权值的共享、矩阵压缩、哈希、组合式。他提出应该直接优化模型和判决力，重构线购线性分类误差，中小化线性分类的误差。他介绍了深度神经网络压缩的常用模型AlexNet、SPPNet、VGGNet、GoogleNet。他主要介绍了全局误差最小化压缩，即跨全连接层间，联合最小化非基于线性响应的分类（或特征表示）判决面距离重构误差。
华中科技大学白翔：场景文字识别的深度表示方法
华中科技大学教授、国家防伪工程中心副主任白翔分享了题为《场景文字识别的深度表示方法》的演讲。他主要从问题定义、意义和挑战、算法等方面进行了分享。
场景文字识别是指将场景文字转换为计算机可读可编程的过程。场景文字识别对图像理解会有很大的帮助，可以应用于产品搜索、人机交互等方面，其面临的挑战有颜色、尺度、方向、字体、语种、背景等。这些问题在实际情况里都要考虑进去。正是因为要考虑的因素太多了，所以导致这个问题相当的困难。
文字识别过程分成三个部分：第一，文字进行检测。给你一张照片，你将照片里或者是视频里属于文字的区域找到，以单词的形式，或者是以句子形式抓举出来；第二，识别过程，这些区域依然是图片的格式，需要转换成计算机可以理解的符号；第三，将前面两个步骤统一到同一个框架之下，从检测到识别，都是用一个系统完成，如果是深度学习可以用深度网络全部完成这件事情。他介绍了文字识别的方法。首先是基于MSER，把来自同一个象素的进行分类，文字的笔划往往具有相同的特性，所以进行多尺度的积累，提供的结果是多尺度。同一个文字，文字间的间距有规律，或者是具有相同的颜色。结合规则对非区域进行规律或者删除，剩余就是干净的文字，这是检测最基本的描述值。
文字识别的传统方法是基于连通区域的，存在一定问题。他提出了三层结构来进行场景文字处理：底层卷积层计算文字特征，中层利用回归神经网络来对特征序列进行处理，上层把置信度转换为文字。对于扭曲的文字，他提出了一种处理思想：在卷基层之前加一个变换层进行处理。
基于文字检测的方法，比较直接的方法，对于每一个字符，做两个分类器，可以在两个分类器在图像里进行全局扫描，把响应比较高的地方反馈出来。
场景文字的核心问题还是表述，如何场景里表述文字，表述不是如何进行检测，包括识别都是要进行表述。一个核心的想法是在检测的过程中能不能提高识别，同时识别模型能不能帮你提升检测精度，需要列在一个框架下。并且如果你把这个特征共享，检测时你也用，识别时你也用，能统一起来的话，你会有意想不到的效果。
微软亚洲研究院洪春涛：开源深度学习框架MXNET解析
微软亚洲研究院研究员洪春涛分享了题为《MXNET: An Efficient and Flexible Programming Framework for Deep Learning》的演讲。他主要介绍了MXNet深度学习的工具，可以让大家比较快的写出Deep Learning的程序来。他从程序接口、系统架构、设计细节等方面进行了介绍。
主要的语言是C++，用C++保证了系统的效率。Python、R、Julia、Go这些语言可以直接拿来写程序调MXNet，这样保证非常好的编程接口，同时又有非常好的执行。既支持CPU也支持GPU，因为系统整个做的非常小巧，所以在手机上也可以跑。支持分布式，也支持命令式和声明式的接口。MXNet的特征包括：自动求导，这对写程序非常有用；占用内存少，可以用更大的model；灵活接口，一种是符号式编程，一种是命令式编程，两个各有优缺点，命令式的语言显然更容易懂一些，更直观一些，但是符号式的更利于做优化，以及更利于做自动求导，所以都保留；支持分布式、单机多CPU。命令式编程提供的接口类似Numpy，不同之处是多CPU支持和并行执行。符号借口类似于函数。MXNet将这两种接口结合了起来，这两种接口都可以使用。
MXNet的设计细节包括：符号执行和自动求导；运行依赖引擎；内存节省。Symbolic好处不是很直观，和一般的编成确实不一样。很难表达动态的东西，比如说SMT里面你要做，你事先不知道多少词，就很难写。第二个重点，是系统里所谓的运行时的依赖引擎，运行式依赖是什么，这是编辑里的概念。比如你要算B=A+1，C=A×2，这里有一个依赖，你必须等到A有值，B、C才能执行。或者是你要算C=A×B，或者是D=C+1，C=A×B算完，D=C+1才可以。同时用这样的依赖引擎多GPU都可以很好的实现。运行依赖引擎包括读依赖、删除依赖、写依赖和共享资源。
这是两层的最终依赖图，可以看到总共创建了八个矩阵，不同颜色三角形标的是他们用的内存，比如说粉色三角形表示三个矩阵可以供用同样的内存。最终，生成八个矩阵，计算当中用了八个矩阵，但是事实上只生成了三块内存
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：335977次
积分：4578
积分：4578
排名：第4450名
原创：45篇
转载：151篇
评论：555条
(1)(22)(17)(1)(2)(1)(1)(1)(5)(1)(1)(3)(1)(9)(3)(4)(2)(16)(2)(2)(1)(1)(1)(4)(41)(6)(8)(5)(1)(3)(3)(6)(1)(3)(3)(5)(3)(7)(1)(2)(1)(1)(10)(3)}