Hadoop-深度学习-全-

Hadoop 深度学习（全）

原文：Deep learning with Hadoop

协议：CC BY-NC-SA 4.0

零、前言

这本书将教你如何使用 Hadoop 在深度神经网络中部署大规模数据集，以获得最佳性能。

从了解什么是深度学习，以及与深度神经网络相关的各种模型开始，这本书将向您展示如何为深度学习设置 Hadoop 环境。

这本书涵盖了什么

第 1 章深度学习简介介绍了深度学习在过去十年中是如何普及的，并且由于其增强的功能，现在的发展速度甚至超过了机器学习。本章首先介绍人工智能的现实应用、相关挑战，以及深度学习如何有效地解决所有这些问题。本章通过解决一些主要的机器学习问题，如维数灾难、消失梯度问题等，对深度学习进行了深入的解释。为了开始后续章节的深度学习，本章的后半部分将讨论各种深度学习网络的分类。这一章主要适合读者，他们有兴趣了解深度学习的基础知识，但不太了解单个深度神经网络的细节。

第二章大规模数据分布式深度学习解释了大数据和深度学习无疑是近几天最热门的两大技术趋势。这两者密切相关，并在过去几年中显示出巨大的增长。本章从深度学习技术如何能够被提供大量的非结构化数据来促进从其中提取有价值的隐藏信息开始。著名的科技公司，如谷歌、脸书、苹果等，正在他们的深度学习项目中使用这些大规模数据，以更智能的方式训练一些激进的深度神经网络。然而，深度神经网络在处理大数据时显示出某些挑战。本章详细解释了所有这些挑战。本章的后半部分介绍了 Hadoop，讨论如何使用 Hadoop 的 part 及其迭代的 Map-reduce 范式来实现深度学习模型。本章进一步介绍了 Deeplearning4j，这是一个流行的用于深度学习的开源分布式框架，并解释了它的各种组件。

第三章 、卷积神经网络、介绍了卷积神经网络(CNN)，这是一种深度神经网络，被顶尖科技行业广泛应用于其各种深度学习项目中。CNN 在图像识别、视频识别、自然语言处理等各个领域都有着广泛的应用。卷积是一种特殊的数学运算，是 CNN 的一个组成部分。首先，本章首先用一个实际例子讨论卷积的概念。此外，通过描述网络的每个组件，提供了对卷积神经网络的深入解释。为了提高网络的性能，有线电视新闻网提供了三个最重要的参数，即稀疏连通性、参数共享和等变表示。这一章解释了所有这些，以便更好地了解美国有线电视新闻网。此外，有线电视新闻网还拥有很少的关键超参数，这有助于决定网络的输出容量的维度。本章详细讨论了这些超参数之间的数学关系。本章的后半部分重点介绍了分布式卷积神经网络，并展示了它使用 Hadoop 和 Deeplearning4j 的实现。

第四章、循环神经网络解释了它是一种特殊类型的神经网络，可以对长序列的向量进行运算，产生不同序列的向量。最近，它们已经成为建模可变长度序列的非常流行的选择。RNN 已经成功地实现了各种应用，例如语音识别、在线手写识别、语言建模等。这一章通过提供基本的数学关系和视觉表现，详细解释了 RNN 的各种概念。RNN 拥有自己的存储器来存储中间隐藏层的输出。记忆是循环神经网络的核心组成部分，本章已经用适当的框图进行了讨论。此外，还提出了单向循环神经网络的局限性，为了克服这些局限性，引入了双向循环神经网络(BRNN)的概念。后来，为了解决消失梯度的问题，在第一章中介绍了的一个特殊单位，叫做长短期记忆(简称)。最后，用 Deeplearning4j 展示了用 Hadoop 实现分布式深度循环神经网络的过程。

第 5 章 【受限玻尔兹曼机】**涵盖了第 3 章和第 4 章中讨论的两种模型，并解释了它们是区分模型。第五章讨论了一个称为受限玻尔兹曼机(RBM)的生成模型。当向 RBM 提供隐藏参数时，它能够随机产生可见数据值。本章首先介绍了基于能量的模型的概念，并解释了受限玻尔兹曼机是如何与之相关的。此外，讨论朝着被称为卷积受限玻尔兹曼机的特殊类型的 RBM 前进，卷积受限玻尔兹曼机是卷积和受限玻尔兹曼机的组合，并且有助于高维图像特征的提取。

*深度信念网络(DBN)，一个广泛使用的多层网络由几个受限制的玻尔兹曼机在本章的后半部分介绍。这一部分还讨论了如何使用 Hadoop 在分布式环境中实现 DBN。本章末尾讨论了使用深度学习 4j 实现 RBM 以及分布式 DBN。

第 6 章、自编码器介绍了另一种称为自编码器的生成模型，通常用于降维、特征学习或提取。本章首先解释自编码器的基本概念及其一般框图。自编码器的核心结构基本上分为编码器和解码器两部分。编码器将输入映射到隐藏层，而解码器将隐藏层映射到输出层。基本自编码器的主要关注点是将输入层的某些方面复制到输出层。本章的下一部分讨论一种称为稀疏自编码器的自编码器，它基于隐藏层的分布式稀疏表示。更进一步，包含多个编码器和解码器的深度自编码器的概念将通过适当的示例和框图进行深入解释。随着我们的继续，去噪自编码器和堆叠去噪自编码器将在本章的后半部分进行解释。最后，第六章还展示了在 Hadoop 中使用 Deeplearning4j 实现堆叠去噪自编码器和深度自编码器。

第 7 章 【使用 Hadoop 的杂类深度学习操作】**主要关注分布式环境下三种最常用的机器学习应用的设计。本章讨论了用 Hadoop 实现大规模视频处理、大规模图像处理和自然语言处理。它解释了如何在 Hadoop 分布式文件系统(HDFS)中部署大规模视频和图像数据集，并使用 Map-reduce 算法进行处理。对于 NLP，本章末尾提供了对设计和实现的深入解释。

*# 这本书你需要什么

我们希望这本书的所有读者都有一些计算机科学的背景。这本书主要讲述了不同的深度神经网络，它们的设计以及与 Deeplearning4j 的应用。为了从书中获得最大的收获，读者应该了解机器学习、线性代数、概率论、分布式系统和 Hadoop 的概念。为了用 Hadoop 实现深度神经网络，深度学习 4j 在本书中被广泛使用。以下是运行深度学习 4j 所需的所有内容的链接:

https://deeplearning4j.org/quickstart

这本书是给谁的

如果你是一个数据科学家，想学习如何在 Hadoop 上进行深度学习，这本书就是为你准备的。充分利用这本书需要基本的机器学习概念的知识和对 Hadoop 的一些理解。

惯例

在这本书里，你会发现许多区分不同种类信息的文本样式。以下是这些风格的一些例子和对它们的意义的解释。

文本中的码字、数据库表名、文件夹名、文件名、文件扩展名、路径名、伪 URL、用户输入和 Twitter 句柄如下所示:“使用.build()函数构建图层。”

代码块设置如下:

public static final String DATA_URL =     
  "http://ai.stanford.edu/~amaas/data/sentiment/*";

当我们希望将您的注意力吸引到代码块的特定部分时，相关的行或项目以粗体显示:

MultiLayerNetwork model = new MultiLayerNetwork(getConfiguration());
Model.init();

新名词和重要词语以粗体显示。你在屏幕上看到的单词，比如在菜单或对话框中看到的单词，出现在文本中是这样的:“简单来说，任何具有两层或更多层(隐藏)的神经网络都被定义为深度前馈网络或前馈神经网络。”

注

警告或重要提示会出现在这样的框中。

类型

提示和技巧是这样出现的。

读者反馈

我们随时欢迎读者的反馈。让我们知道你对这本书的看法——你喜欢或不喜欢什么。读者反馈对我们来说很重要，因为它有助于我们开发出你真正能从中获益的标题。要给我们发送一般反馈，只需发送电子邮件feedback@packtpub.com，并在您的邮件主题中提及书名。如果您对某个主题有专业知识，并且对写作或投稿感兴趣，请参见我们位于www.packtpub.com/authors的作者指南。

客户支持

现在，您已经自豪地拥有了一本书，我们有许多东西可以帮助您从购买中获得最大收益。

下载示例代码

你可以从你在http://www.packtpub.com的账户下载这本书的示例代码文件。如果您在其他地方购买了这本书，您可以访问http://www.packtpub.com/support并注册，以便将文件直接通过电子邮件发送给您。

您可以按照以下步骤下载代码文件:

1. 使用您的电子邮件地址和密码登录或注册我们的网站。
2. 将鼠标指针悬停在顶部的 SUPPORT 选项卡上。
3. 点击代码下载&勘误表。
4. 在搜索框中输入图书名称。
5. 选择要下载代码文件的书籍。
6. 从您购买这本书的下拉菜单中选择。
7. 点击代码下载。

下载文件后，请确保使用最新版本的解压缩文件夹:

• 视窗系统的 WinRAR / 7-Zip
• zipeg/izp/un ARX for MAC
• 适用于 Linux 的 7-Zip / PeaZip

这本书的代码包也托管在 GitHub 上，网址为https://GitHub . com/PacktPublishing/Deep-Learning-with-Hadoop。我们还有来自丰富的图书和视频目录的其他代码包，可在https://github.com/PacktPublishing/获得。看看他们！

下载本书的彩色图片

我们还为您提供了一个 PDF 文件，其中包含本书中使用的截图/图表的彩色图像。彩色图像将帮助您更好地理解输出中的变化。您可以从https://www . packtpub . com/sites/default/files/downloads/deep learning with adoop _ color images . pdf下载此文件。

勘误表

尽管我们尽了最大努力来确保我们内容的准确性，但错误还是会发生。如果你在我们的某本书里发现一个错误，也许是文本或代码中的错误，如果你能向我们报告，我们将不胜感激。通过这样做，你可以让其他读者免受挫折，并帮助我们改进这本书的后续版本。如果您发现任何勘误表，请访问http://www.packtpub.com/submit-errata，选择您的书籍，点击勘误表提交表链接，并输入您的勘误表的详细信息。一旦您的勘误表得到验证，您的提交将被接受，勘误表将上传到我们的网站或添加到该标题勘误表部分下的任何现有勘误表列表中。

要查看之前提交的勘误表，请前往https://www.packtpub.com/books/content/support并在搜索栏中输入图书名称。所需信息将出现在勘误表部分。

盗版

互联网上版权材料的盗版是所有媒体的一个持续问题。在 Packt，我们非常重视版权和许可证的保护。如果您在互联网上遇到任何形式的我们作品的非法拷贝，请立即向我们提供位置地址或网站名称，以便我们寻求补救。

请通过copyright@packtpub.com联系我们，获取疑似盗版资料的链接。

我们感谢您在保护我们的作者方面的帮助，以及我们为您带来有价值内容的能力。

问题

如果您对本书的任何方面有问题，可以在questions@packtpub.com联系我们，我们将尽最大努力解决问题。**

一、深度学习导论

|   | “到目前为止，人工智能最大的危险是，人们过早地得出结论，认为自己理解了它。” |   |
|   | -Eliezer yukowsky |

有没有想过，为什么下棋经常很难打败电脑，即使是对最好的棋手来说？脸书是如何在数亿张照片中认出你的脸的？您的手机如何识别您的声音，并将呼叫从列出的数百个联系人中重定向到正确的人？

这本书的主要目标是处理这些查询，并为读者提供详细的解决方案。这本书可以被各种各样的读者用于各种各样的原因，然而，我们写这本书时考虑了两个主要的目标受众。主要目标受众之一是学习深度学习和人工智能的本科生或研究生；第二类读者是已经具备大数据、深度学习和统计建模知识的软件工程师，但希望快速获得深度学习如何用于大数据的知识，反之亦然。

本章将主要通过提供基本概念、术语、特征和深度学习的主要挑战来为读者奠定基础。本章还将提出不同深度网络算法的分类，这些算法在过去十年中被研究者广泛使用。以下是本章将涵盖的主要主题:

• 开始深度学习
• 深入学习术语
• 深度学习:人工智能的一场革命
• 深度学习网络的分类

自从文明出现以来，人们就一直梦想着制造出行为和工作完全像人类的人造机器或机器人。从希腊神话人物到古代印度教史诗，这样的例子数不胜数，清楚地表明了人们对创造和拥有人工生命的兴趣和倾向。

在最初的计算机时代，人们一直想知道计算机是否能变得像人类一样聪明！展望未来，即使在医学领域，对自动化机器的需求也变得不可或缺，几乎不可避免。有了这种需求和同一领域不断的研究，人工智能 ( 人工智能)已经成为一项蓬勃发展的技术，在多个领域有各种应用，如图像处理、视频处理以及医学中的许多其他诊断工具。

虽然人工智能系统每天都会解决很多问题，但是没有人知道人工智能系统是如何编程的具体规则！一些直观的问题如下:

• 谷歌搜索，它能很好地理解你输入或说出的内容
• 如前所述，脸书也有点擅长识别你的脸，从而理解你的兴趣

而且，随着其他各个领域的融合，例如概率、线性代数、统计学、机器学习、深度学习等等，随着时间的推移，人工智能已经在研究领域获得了巨大的普及。

人工智能早期成功的关键原因之一可能是它基本上处理了计算机不需要大量知识的基本问题。例如，在 1997 年，IBM 的深蓝下棋系统能够击败世界冠军加里·卡斯帕罗夫[1]。虽然这种成就在当时可以认为意义重大，但仅仅用象棋中涉及的有限规则训练计算机，绝对不是一项繁重的任务！用固定且有限数量的规则训练一个系统被称为计算机的硬编码知识。许多人工智能项目已经用许多传统语言经历了这种关于世界各个方面的硬编码知识。随着时间的推移，这种硬编码的知识似乎不适用于处理大量数据的系统。此外，数据遵循的规则数量也在频繁变化。因此，遵循该系统的大多数项目都没有达到预期的高度。

这种硬编码知识面临的挫折意味着，这些人工智能系统需要某种方式从提供的原始数据中归纳出模式和规则，而不需要外部的填鸭式喂养。系统做到这一点的熟练程度被称为机器学习。我们在日常生活中使用各种成功的机器学习实现。一些最常见和最重要的实现如下:

• 垃圾邮件检测:给定收件箱中的一封电子邮件，模型可以检测是将该邮件放入垃圾邮件还是收件箱文件夹中。常见的朴素贝叶斯模型可以区分这类电子邮件。
• 信用卡诈骗检测:可以检测特定时间间隔内进行的多笔交易是否由原客户进行的模型。
• Mor-Yosef 等人在 1990 年给出的最流行的机器学习模型之一使用了逻辑回归，它可以建议患者是否需要剖腹产！

在机器学习技术的帮助下，已经实现了许多这样的模型。

图 1.1:该图显示了不同类型表示的示例。假设我们想训练机器来检测果冻豆之间的一些空白空间。在右边的图像中，我们有稀疏的果冻豆，人工智能系统更容易确定空的部分。然而，在左侧的图像中，我们有非常紧凑的果冻豆，因此，对于机器来说，找到空白空间将是一项极其困难的任务。图片来源于南加州大学 SIPI 图像数据库

机器学习系统的很大一部分性能取决于输入系统的数据。这被称为数据的表示。与该表示相关的所有信息被称为数据的特征。例如，如果用逻辑回归来检测患者的脑瘤，AI 系统将不会尝试直接诊断患者！相反，相关医生将根据患者的常见症状向系统提供必要的输入。然后，人工智能系统将这些输入与已经接收到的用于训练系统的过去输入进行匹配。

基于系统的预测分析，它将提供关于疾病的决策。虽然逻辑回归可以根据给定的特征进行学习和决定，但它不能影响或修改特征的定义方式。与线性回归不同，逻辑回归是一种回归模型，其中因变量基于自变量具有有限数量的可能值。因此，例如，如果该模型提供了剖腹产患者的报告，而不是脑肿瘤患者的报告，它肯定无法预测正确的结果，因为给定的特征永远不会与训练数据相匹配。

机器学习系统对数据表示的这些依赖性对我们来说并不是不知道的！事实上，基于数据的表现方式，我们的大多数计算机理论都表现得更好。例如，数据库的质量是根据模式的设计来考虑的。如果对表进行了适当的索引，那么任何数据库查询的执行，即使是在一千或一百万行数据上，都会变得非常快。因此，人工智能系统数据表示的依赖性不应该让我们感到惊讶。

日常生活中也有很多这样的例子，数据的表示决定了我们的效率。在 20 个人中找到一个人显然比在 500 人的人群中找到同一个人容易。前面的图 1.1 中显示了两种不同类型数据表示的可视化表示。

因此，如果人工智能系统被输入适当的特征数据，即使是最困难的问题也能得到解决。然而，对计算机程序员来说，以正确的方式收集并向系统提供所需的数据是一个严重的障碍。

可能有许多实时场景，其中提取特征可能是一项繁琐的任务。因此，数据的表示方式决定了系统智能的主要因素。

注

如果特征不合适，在一群人和猫中找到猫可能会非常复杂。我们知道猫有尾巴；因此，我们可能希望检测尾巴的存在作为一个突出的特征。然而，给定不同的尾部形状和大小，通常很难准确描述尾部在像素值方面的样子！此外，尾巴有时会与人类的手混淆。此外，一些物体的重叠可能会忽略猫尾巴的存在，使图像更加复杂。

从以上所有讨论可以得出结论，人工智能系统的成功主要取决于数据是如何表示的。此外，各种表示可以捕捉和缓存数据背后所有差异的不同解释因素。

表征学习是用于处理这些特定问题的最流行和最广泛实践的学习方法之一。从现有的数据表示中学习下一层的表示可以被定义为表示学习。理想情况下，所有的表示学习算法都具有学习表示的优势，它可以捕获潜在的因素，一个可能适用于每个特定子任务的子集。下面图 1.2 给出了一个简单的说明:

图 1.2:该图说明了表征学习。中间层能够发现解释因素(隐藏层，在蓝色矩形框中)。有些因素解释了每项任务的目标，而有些因素解释了输入

然而，在处理从大量原始数据中提取一些高级数据和特征时，需要某种程度的人类理解，这已经显示出它的局限性。这样的例子可以有很多:

• 区分两个相似年龄婴儿的哭声。
• 识别猫眼在白天和晚上的图像。这变得很笨拙，因为猫的眼睛在晚上发光，而不是在白天。

在所有这些前面的边缘情况下，表征学习似乎没有异常表现，并且表现出威慑行为。

深度学习是机器学习的一个子领域，它可以通过构建多层次的表示或从一系列其他简单的表示和特征中学习特征的层次结构来纠正表示学习的这个主要问题[2] [8]。

图 1.3:该图显示了深度学习系统如何通过识别角和轮廓等各种组合来表示人类图像，这些组合可以用边缘来定义。图片经伊恩·古德费勒、约舒·本吉奥和亚伦·库维尔许可转载，深度学习，麻省理工学院出版社出版

前面的图 1.3 显示了深度学习模型的图示。对于计算机来说，将原始非结构化输入数据(如这张图像所示)解码为不同像素值的集合通常是一项麻烦的任务。理想情况下，将转换像素组以识别图像的映射函数很难实现。此外，直接训练计算机进行这种映射几乎是不可逾越的。对于这些类型的任务，深度学习通过创建一系列映射子集来达到期望的输出，从而解决了这个难题。映射的每个子集对应于模型的一组不同的层。输入包含可以观察到的变量，因此在可见图层中表示。从给定的输入中，我们可以逐步提取数据的抽象特征。由于这些值在给定数据中不可用或不可见，因此这些图层被称为隐藏图层。

在图像中，从第一层数据，仅仅通过相邻像素的比较研究就可以容易地识别边缘。第二个隐藏层可以从第一个隐藏层对边缘的描述中区分拐角和轮廓。从描述角和轮廓的第二个隐藏层，第三个隐藏层可以识别特定对象的不同部分。最终，可以从第三层清楚地检测到图像中存在的不同对象。

深度学习于 2006 年独家开启征程， Hinton et al. 于 2006 年[2]；同样 Bengio 等人在 2007 年【3】最初关注的是 MNIST 数字分类问题。在过去的几年里，深度学习经历了从数字到自然图像中对象识别的重大转变。除此之外，克里哲夫斯基等人在 2012 年【4】使用 ImageNet 数据集实现了一项重大突破。

这本书的范围主要限于深度学习，所以在直接深入之前，应该讨论深度学习的必要定义。

许多研究人员以多种方式定义了深度学习，因此，在过去的 10 年里，它也经历了许多定义！以下是一些广为接受的定义:

• 正如 GitHub 所指出的，深度学习是机器学习研究的一个新领域，它的引入是为了让机器学习更接近其最初的目标之一:人工智能。深度学习是指学习多层次的表示和抽象，这有助于理解图像、声音和文本等数据。
• 正如维基百科最近更新的那样，深度学习是基于一组算法的机器学习的一个分支，这些算法试图通过使用具有多个处理层的深度图来建模数据中的高级抽象，该深度图由多个线性和非线性变换组成。

正如定义所暗示的，深度学习也可以被认为是一种特殊类型的机器学习。深度学习凭借其从各种简单特征中学习复杂表示的能力，在数据科学领域获得了巨大的普及。为了深入掌握深度学习，我们列出了几个术语，这些术语将在接下来的章节中频繁使用。本章的下一个主题将通过提供用于深度学习的各种术语和重要网络来帮助您为深度学习奠定基础。

开始深度学习

要理解本书的深度学习之旅，必须了解机器学习的所有术语和基本概念。但是，如果您已经对机器学习和相关术语有了足够的了解，您应该可以忽略这一部分，跳到本章的下一个主题。对数据科学充满热情，想要彻底学习机器学习的读者，可以关注汤姆·米契尔(1997) [5]和的机器学习【机器学习:一个概率的视角】 (2012) [6]。

注

神经网络不会创造奇迹。但是，如果使用得当，它们可以产生一些惊人的结果。

深度前馈网络

神经网络可以是递归的，也可以是前馈的。前馈网络在它们的图中没有任何相关联的环路，而是排列在一组层中。多层网络被称为深度网络。简单来说，任何具有两层或更多层(隐藏)的神经网络都被定义为深度前馈网络或前馈神经网络。图 1.4 显示了深度前馈神经网络的一般表示。

深度前馈网络的工作原理是，随着深度的增加，网络也可以执行更多的顺序指令。顺序指令可以提供强大的功能，因为这些指令可以指向较早的指令。

前馈网络的目的是推广某些函数。例如，分类器 y=f(x) 从输入 x 映射到类别 y 。深度前馈网络修改了映射，y = f(x；α) ，学习参数 α 的值，给出函数最合适的值。下面的图 1.4 显示了深度前向网络的简单表示，以提供与传统神经网络的架构差异。

注

深度神经网络是具有许多隐藏层的前馈网络。

图 1.4:图中显示了浅层和深层前馈网络

各种学习算法

数据集被认为是学习过程的构建模块。数据集可以被定义为相互关联的数据集的集合，它由独立的实体组成，但是可以根据用例作为单个实体使用。数据集的单个数据元素称为数据点。

下面的图 1.5 给出了从社交网络分析中收集的各种数据点的可视化表示:

图 1.5:图片展示了社交网络分析的零散数据点。图片来源于维基百科

• 未标注数据:这部分数据由人为生成的物体组成，可以很容易的从周围获取。一些例子是 x 光片、日志文件数据、新闻文章、演讲、视频、推文等等。
• 标记数据:标记数据是来自一组未标记数据的标准化数据。这些类型的数据通常被很好地格式化、分类、标记，并且容易被人类理解以便进一步处理。

从顶层理解来看，机器学习技术根据其学习过程是如何进行的，可以分为监督学习和非监督学习。

无监督学习

在无监督学习算法中，给定的输入数据集没有期望的输出。在分析数据集的过程中，系统从其经验中学习有意义的属性和特征。在深度学习中，系统通常试图从数据点的整体概率分布中学习。有各种类型的无监督学习算法，它们执行聚类。用简单的话来解释，聚类意味着在相似类型数据的聚类中分离数据点。但是，这种类型的学习，没有基于最终输出的反馈，也就是不会有老师来纠正你！图 1.6 展示了无监督聚类的基本概况:

图 1.6:图显示了无监督聚类的简单表示

无监督聚类算法的一个真实例子是谷歌新闻。当我们在谷歌新闻下打开一个主题时，它会显示一些重定向到几个页面的超链接。这些主题中的每一个都可以被认为是指向独立链接的一组超级链接。

监督学习

在监督学习中，与无监督学习不同，体验的每一步都有一个预期的输出。系统被赋予一个数据集，它已经知道期望的输出是什么样子，以及每个关联层的输入和输出之间的正确关系。这种类型的学习通常用于分类问题。

图 1.7 给出了如下可视化表示:

图 1.7:图中显示了基于监督学习的数据分类

监督学习的现实例子包括人脸检测、人脸识别等等。

尽管监督学习和非监督学习看起来像是不同的身份，但它们往往通过各种方式相互联系。因此，这两种学习之间的细微差别对于学生团体来说往往是模糊的。

前面的陈述可以用下面的数学表达式来表述:

概率的一般乘积规则指出，对于数据集 n ε ℝ ^t 的 n 个数量，联合分布可以被分割如下:

该分布表示出现的无监督问题可以通过 t 个有监督问题来解决。除此之外， p (k | n) 的条件概率是一个有监督的问题，可以使用无监督学习算法来体验 p (n，k) 的联合分布来解决。

虽然这两种类型不是完全独立的身份，但它们通常有助于根据执行的操作对机器学习和深度学习算法进行分类。一般来说，聚类形成、基于相似性识别种群密度等被称为无监督学习，而结构化格式化输出、回归、分类等被认为是有监督学习。

半监督学习

顾名思义，在这种类型的学习中，在训练过程中既使用有标签的数据，也使用无标签的数据。这是一类在训练过程中使用大量未标记数据的监督学习。

例如，半监督学习用于深度信念网络(稍后解释)，这是一种深度网络，其中一些层学习数据的结构(无监督)，而一层学习如何对数据进行分类(监督学习)。

在半监督学习中，给定 n 或 p (k | n】的概率，使用来自 p (n) 的未标记数据和来自 p (n，k) 的标记数据来预测 k 的概率。

图 1.8:图中显示了半监督学习技术中大量未标记数据的影响。图来自维基百科

在前面的图 1.8 中，顶部显示了模型在区分白圈和黑圈后使用的决策边界。底部的图显示了模型包含的另一个决策边界。在该数据集中，除了两个不同类别的圆之外，还附有一组未标记的数据(灰色圆)。这种类型的训练可以被视为创建聚类，然后用标记数据标记这些聚类，这将决策边界从高密度数据区域移开。

前面的图 1.8 描绘了半监督学习的图解。你可以参考查佩尔等人的书【7】来了解更多关于半监督学习方法的知识。

因此，由于您已经对人工智能、机器学习和表示学习有了基础，我们现在可以将整个重点转移到进一步描述的深度学习上。

从前面提到的深度学习的定义中，可以指出深度学习的两个主要特征，如下:

• 通过来自后续抽象层的连续知识，体验特征表示的无监督和有监督学习的方式
• 由非线性信息处理的多个抽象阶段组成的模型

深度学习术语

• 深度神经网络 ( DNN ):这可以定义为一个有很多隐藏层的多层感知器。所有层的权重完全相互连接，并接收来自前一层的连接。通过监督学习或无监督学习来初始化权重。
• 循环神经网络 ( RNN ): RNN 是一种深度学习网络，专门用于从时间序列或序列数据中学习，如语音、视频等。RNN 的主要概念是，来自前一个州的观察结果需要为下一个州保留。最近跟 RNN 深度学习的热门话题是长短期记忆 ( LSTM )。
• 深度信念网络 ( DBN ):这种类型的网络【9】【10】【11】可以定义为具有可见和多层潜在变量(隐藏)的概率生成模型。每个隐藏层通过学习拥有下层单元之间的统计关系。网络越趋向于向更高层移动，关系就变得越复杂。这种类型的网络可以使用贪婪的逐层训练来有效地训练，其中所有的隐藏层以自下而上的方式一次训练一个。
• 玻尔兹曼机 ( BM ):这可以定义为一个网络，它是一个对称连接的神经元状单元，能够随机决定是保持开启还是关闭。BMs 通常有一个简单的学习算法，这使得它们能够发现许多有趣的特征，这些特征代表了训练数据集中的复杂规律。
• 受限玻尔兹曼机 ( RBM ):生成式随机人工神经网络 RBM 是玻尔兹曼机的一种特殊类型。这些类型的网络能够学习数据集集合上的概率分布。RBM 由一层可见和隐藏的单元组成，但没有可见-可见或隐藏-隐藏的联系。
• 卷积神经网络:卷积神经网络是神经网络的一部分；这些层彼此稀疏地连接，并且连接到输入层。后续层的每个神经元只负责输入的一部分。深度卷积神经网络在位置识别、图像分类、人脸识别等领域取得了无可匹敌的性能。
• 深度自编码器:深度自编码器是一种具有多个隐藏层的自编码器。这种类型的网络可以预先训练为单层自编码器的堆栈。训练过程通常比较困难:首先，我们需要训练第一个隐藏层重构输入数据，然后用它训练下一个隐藏层重构前一个隐藏层的状态，以此类推。
• 梯度下降 ( GD ):这是机器学习中广泛使用的确定函数系数的优化算法( f )，降低了函数的整体代价。梯度下降主要用于无法解析计算所需参数的情况(例如线性代数)，必须通过某种优化算法才能找到。

在梯度下降中，模型的权重随着训练数据集(历元)的每次迭代而递增更新。

具有平方误差之和的成本函数 J (w) 可以写成如下:

权重更新的幅度方向通过在成本梯度的相反方向上采取一个步骤来计算，如下所示:

在上式中， η 是网络的学习速率。权重在每个时期后按照以下规则递增更新:

                         for one or more epochs, 
                           for each weight i, 
                             wi:= w + ∆wi 
                           end  
                         end 

可以使用梯度下降进行优化的流行示例是逻辑回归和线性回归。

• 随机梯度下降 ( SGD ):各种深度学习算法在大量数据集上运行，基于一种称为随机梯度下降的优化算法。梯度下降仅在小数据集的情况下表现良好。然而，在非常大规模的数据集的情况下，这种方法变得极其昂贵。在梯度下降中，在整个训练数据集上一次通过只需要一个单独的步骤；因此，随着数据集的大小趋于增加，整个算法最终会变慢。权重的更新速度非常慢；因此，收敛到全局最小成本所需的时间变得很长。

因此，为了处理这样的大规模数据集，使用了称为随机梯度下降的梯度下降变体。与梯度下降不同，权重在训练数据集的每次迭代后更新，而不是在整个数据集的末尾更新。

                     until cost minimum is reached 
                       for each training sample j: 
                         for each weight i 
                           wi:= w + ∆wi 
                         end 
                       end 
                     end 

在过去的几年里，深度学习获得了巨大的普及，因为它已经成为许多广泛实践的学科的研究领域的结合点，例如模式识别、神经网络、图形建模、机器学习和信号处理。

这种流行的其他重要原因可以总结为以下几点:

• 近年来， GPU ( 图形处理单元)的能力大幅提升
• 用于训练目的的数据集的数据大小显著增加
• 最近在机器学习、数据科学和信息处理方面的研究已经显示出一些重大进展

所有这些要点的详细描述将在本章的下一个主题中提供。

深度学习:人工智能的一场革命

深度学习的广泛历史超出了本书的范围。然而，要对这门学科产生兴趣和认知，一些基本的背景知识是必不可少的。

在介绍中，我们已经稍微谈到了深度学习在人工智能领域占据的空间。本节将详细介绍机器学习和深度学习是如何相互关联或相互不同的。我们还将讨论在过去十年左右的时间里，这两个主题的趋势是如何变化的。

|   | “数年来，深度学习的浪潮一直拍打着计算语言学的海岸，但 2015 年似乎是海啸席卷主要自然语言处理(NLP)会议的一年。” |   |
|   | - 克里斯托弗·曼宁博士，2015 年 12 月 |

图 1.9:该图描绘了大约 10 年前深度学习处于初始阶段。然而，机器学习在研究者群体中是一个趋势性的话题。

深度学习正在人工智能领域迅速扩展其领域，并以其惊人的实证结果不断让许多研究人员感到惊讶。机器学习和深度学习都代表了两种不同的思想流派。机器学习可以被视为人工智能最基本的方法，深度学习可以被认为是一个新的、巨大的时代，增加了这门学科的一些功能。

图 1.10:图中描绘了深度学习如今是如何越来越受欢迎，并试图达到机器学习的水平

然而，机器学习往往不能完全解决人工智能的许多关键问题，主要是语音识别、对象识别等。

随着随机变量数量的不断增加，传统算法在处理高维数据时的性能似乎更具挑战性。此外，传统机器学习方法中用于获得泛化能力的过程不足以学习高维空间中的复杂任务，这通常会增加整个模型的计算成本。深度学习的发展主要是由机器学习的基本算法在这些函数上的崩溃所推动的，也是为了克服上述障碍。

很大比例的研究者和数据科学家认为，随着时间的推移，深度学习将占据人工智能的主要部分，并最终使机器学习算法过时。为了清楚地了解这一点，我们查看了这两个领域的当前谷歌趋势，并得出以下结论:

• 机器学习的曲线一直是过去十年的成长阶段。深度学习是新的，但比机器学习发展得更快。当趋势被密切观察时，人们会发现与机器学习相比，深度学习的增长速度更快。

前面的图 1.9 和图 1.10 都描绘了谷歌趋势的可视化。

深度学习的动机

机器学习算法面临的最大问题之一是维度的诅咒【12】【13】【14】。这是指当数据集中的维数较高时，某些学习算法可能表现不佳。在下一节中，我们将讨论深度学习如何通过引入新的特性给这个问题带来了足够的希望。与传统体系结构相比，深度体系结构在许多其他相关问题上表现出了明显的优势。在本章的这一部分，我们将把更明显的挑战作为一个单独的主题进行介绍。

维度的诅咒

维数灾难可以定义为在高维空间(在数千甚至更高维的范围内)中分析和组织数据时出现的现象。当数据集的维数很高时，机器学习问题面临着极大的困难。高维数据很难处理，原因如下:

• 随着维数的增加，特征的数量将趋于指数增长，最终导致噪声的增加。
• 在标准实践中，我们不会得到足够多的观测值来概括数据集。

维度诅咒的一个直接解释可能是组合爆炸。根据组合爆炸，通过收集大量的变量，可以建立一个巨大的组合。例如，对于 n 二进制变量，可能组合的数量为 O (2 ⁿ ) 。因此，在高维空间中，配置的总数几乎是不可数的，比我们可用的示例数量要多得多——大多数配置都没有相关的训练示例。图 1.11 为了更好地理解，显示了类似现象的图示。

因此，由于训练的困难，这种情况对于任何机器学习模型来说都是麻烦的。休斯效应【15】声明如下:

“对于固定数量的训练样本，预测能力随着维数的增加而降低。”

因此，随着解释变量数量的增加，模型的可实现精度几乎崩溃。

为了应对这种情况，我们需要增加提供给系统的样本数据集的大小，使其能够与该情况竞争。但是随着数据复杂度的也增加，维度的数量几乎达到了一千。对于这种情况，即使是拥有数亿张图像的数据集也是不够的。

深度学习以其更深的网络配置，在部分解决这个问题方面显示出一些成功。这一贡献主要归因于以下原因:

• 现在，研究人员能够在输入样本进行训练之前，通过重新定义网络结构来管理模型的复杂性
• 深度卷积网络关注的是数据的高层特征，而不是基本层信息，这大大降低了特征的维数

尽管深度学习网络已经给出了一些应对维度诅咒的见解，但它们还不能完全征服挑战。在微软最近对超深度神经网络的研究中，他们提出了 150 层；因此，参数空间变得更大。该团队已经探索了研究，甚至深度网络几乎达到 1000 层；但是由于模型过拟合，结果不达标！

注

机器学习中的过拟合:当一个模型被过度训练到对其性能产生负面影响的程度时，这种现象被称为模型的过拟合。当模型学习到训练数据集的随机波动和不想要的噪声时，就会出现这种情况。这些现象的后果并不令人满意——模型不能很好地处理新的数据集，这对模型的泛化能力产生了负面影响。

机器学习中的欠拟合:这是指模型既不能用当前数据集执行，也不能用新数据集执行的情况。这种类型的模型不适合数据集，并且表现出较差的性能。

图 1.11:图中显示，随着维度数量从一个增加到三个，从上到下，随机变量的数量可能呈指数级增加。图片转载自尼古拉斯·查帕多斯的文章《精算估值的数据挖掘算法》。

在上图的 1D 示例(上)中，由于只有 10 个感兴趣的区域，因此学习算法正确地进行归纳应该不是一项艰巨的任务。然而，对于更高维度的 3D 示例(底部)，模型需要跟踪所有的 101010=1000 个感兴趣区域，这要麻烦得多(或者几乎将是模型无法完成的任务)。这可以作为维度诅咒最简单的例子。

消失梯度问题

消失梯度问题[16]是在训练人工神经网络时发现的障碍，它与一些基于梯度的方法相关联，例如反向传播。理想情况下，这个困难使得学习和训练前几层变得非常困难。当深层神经网络的层数急剧增加时，情况会变得更糟。

梯度下降算法特别通过梯度的负值乘以小比例值(位于0和1之间)来更新权重。

如前面的等式所示，我们将重复梯度，直到它达到零。然而，理想情况下，我们通常为最大迭代次数设置一些超参数。如果迭代次数太高，训练的持续时间也会更长。另一方面，如果迭代的次数对于某些深度神经网络来说变得难以察觉，我们最终肯定会得到不准确的结果。

在消失梯度问题中，相对于先前层的参数，网络输出的梯度变得非常小。因此，结果权重不会随着每次迭代而出现任何显著变化。因此，即使早期层的参数值发生较大变化，也不会对整体输出产生显著影响。作为这个问题的结果，深度神经网络的训练变得不可行，并且模型的预测变得不令人满意。这种现象被称为消失梯度问题。这将导致一些拉长的成本函数，如下图图 1.12 :

图 1.12:平坦梯度和拉长成本函数的图像

下面图 1.13 中也展示了一个梯度较大的例子，梯度下降可以快速收敛:

图 1.13:较大梯度成本函数的图像；因此，梯度下降可以更快地收敛

这对于深度学习的成功来说是一个实质性的挑战，但是现在，由于各种不同的技术，这个问题已经在一定程度上被克服了。长短期记忆(【LSTM】)网络是 1997 年使这个问题无效的重大突破之一。第四章、循环神经网络给出了详细描述。此外，一些研究人员试图用不同的技术来解决这个问题，包括功能准备、激活功能等。

分布式表示

所有的深度网络大多基于分布式表示的概念，这是深度学习算法成功背后的理论优势。在深度学习的背景下，分布式表示是多尺度表示，与理论化学和物理的多尺度建模密切相关。分布式表示背后的基本思想是，感知的特征是多个因素的结果，这些因素作为一个组合来产生期望的结果。日常生活中的一个例子可能是人脑，它使用分布式表示来伪装周围的物体。

在这种表示中，人工神经网络将以这样一种方式构建，即它将具有表示我们必要模型所需的大量特征和层。该模型将使用多个相互依赖的层来描述数据，例如语音、视频或图像，其中每个层将负责在不同的尺度级别上描述数据。这样，表示将分布在许多层上，涉及许多尺度。因此，这种表示被称为分布式表示。

注

分布式表示本质上是密集的。它遵循两种表示形式之间的多对多关系。一个概念可以用多个神经元来表示。另一方面，一个神经元描绘了不止一个概念。

使用非分布式表示的传统聚类算法，如最近邻算法、决策树或高斯混合，都需要 O(N) 参数来区分 O(N) 输入区域。在某个时候，人们很难相信有任何其他算法能表现得比这更好！然而，深度网络，如稀疏编码、RBM、多层神经网络等，都可以仅用 O(N) 参数来区分多达 O(2 ^k ) 个输入区域(其中 k 表示稀疏表示中非零元素的总数， k=N 表示其他非稀疏 RBM 和密集表示)。

在这些类型的操作中，要么对输入的不同部分应用相同的聚类，要么并行进行几个聚类。将聚类推广到分布式表示被称为多重聚类。

使用分布式表示的指数优势是由于在多个示例中重用了每个参数，这些示例不一定彼此靠近。例如，在这种情况下，受限玻尔兹曼机可能是一个合适的例子。然而，在局部泛化的情况下，输入空间中不相同的区域只关心它们自己的私有参数集。

主要优势如下:

• 数据内部结构的表示在抗损坏性和适度降级方面是稳健的
• 它们有助于概括数据之间的概念和关系，从而增强推理能力。

以下图 1.14 表示分布式表示的实时示例:

图 1.14:图显示了分布式表示如何帮助模型区分图像中的各种类型的表达式

深度学习网络的分类

机器学习中的人工神经网络常被许多研究者称为新一代神经网络。我们听到的大多数学习算法本质上都是为了让系统像生物大脑一样学习而构建的。这就是人工神经网络这个名字的由来！历史上，深度学习的概念源自人工神经网络 ( ANN )。深度学习的实践可以追溯到 20 世纪 60 年代，甚至可能更早。随着深度学习的兴起，人工神经网络在研究领域越来越受欢迎。

多层感知器 ( MLP )或具有许多隐藏中间层的前馈神经网络，被称为深度神经网络 ( DNN )，是深度架构模型的一些很好的例子。第一个流行的深度架构模型是由 Ivakhnenko 和帕拉在 1965 年使用有监督的深度前馈多层感知器发布的[17]。

图 1.15:GMDH 网络有四个输入(输入向量 x 的分量)和一个输出 y，这是对真实函数 y= f(x) = y 的估计

Alexey Ivakhnenko 在 1971 年的另一篇论文中使用了数据处理算法 ( GMDH )的分组方法，该方法试图解释一种具有八个训练层的深度网络。它仍然被认为是当前千年最受欢迎的论文之一[18]。前面的图 1.15 显示了四个输入的 GMDH 网络。

向前看，反向传播 ( BP )是一种众所周知的学习相似类型网络参数的算法，在 20 世纪 80 年代流行起来。然而，由于许多原因，具有许多隐藏层的网络难以处理，因此，BP 未能达到预期水平[8] [19]。此外，反向传播学习使用基于局部梯度信息的梯度下降算法，这些操作从一些随机的初始数据点开始。当通过不断增加的网络深度传播时，这些信息通常会被收集到一些不需要的局部最优值中；因此，结果通常会陷入糟糕的解决方案中。

在两篇论文[8] [20]中建立了一种高效的无监督学习算法后，与深度架构模型相关的优化约束被务实地减少了。这两篇论文介绍了一类被称为深度信念网络 ( DBN )的深度生成模型。

2006 年，又发表了两个具有非生成性、非概率特征的无监督深度模型，这在研究界非常受欢迎。一种是基于能量的无监督模型[21]，另一种是带有后续层训练的自编码器变体，很像之前的 DBN 训练[3]。这两种算法都可以有效地用来训练深度神经网络，几乎完全像 DBN。

自 2006 年以来，世界范围内深度学习的研究出现了巨大的爆发。除了传统的浅层机器学习技术之外，该学科已经经历了持续的指数级增长。

基于本章前面主题中提到的学习技术，并根据所使用的技术和架构的用例，深度学习网络可以大致分为两个不同的组。

深度生成模型或无监督模型

许多深度学习网络都属于这一类，如受限玻尔兹曼机、深度信念网络、深度玻尔兹曼机、去噪自编码器等。这些网络中的大多数都可以通过在网络中采样来产生样本。然而，一些其他网络，例如稀疏编码网络等，难以采样，因此本质上不具有生成性。

一个流行的深度无监督模型是深度玻尔兹曼机(DBM)【22】【23】【24】【25】。一个传统的 DBM 包含许多层隐藏的变量；但是，同一层中的变量之间没有联系。传统的玻尔兹曼机 ( BM )虽然算法比较简单，但是学习起来太复杂，训练起来非常慢。在 DBM 中，每一层都获得前一层的潜在特征的响应之间的高阶复杂相关性。许多现实生活中的问题，如对象和语音识别，需要学习复杂的内部表示，用数据库管理系统更容易解决。

具有一个隐藏层的 DBM 被称为受限玻尔兹曼机 ( RBM )。类似于 DBM，RBM 没有任何隐藏到隐藏和可见到可见的联系。RBM 的关键特性体现在它建立了许多成果管理制。随着大量潜在层的形成，先前 RBM 的特征激活充当下一个的输入训练数据。这种架构产生了一种不同的网络，名为深度信仰网络 ( DBN )。在第 5 章、受限玻尔兹曼机中详细讨论了受限玻尔兹曼机和深度信念网络的各种应用。

DBN 的一个主要组成部分是一组层，这降低了其时间复杂度，与网络的大小和深度成线性关系。除了 DBN 特性可以通过从一些期望的初始化数据点开始训练来克服 BP 的主要缺点之外，它还具有其他吸引人的捕捉特性。其中一些列举如下:

• DBN 可以被认为是一个概率生成模型。
• 由于有数亿个参数，数据库网络普遍存在过拟合问题。此外，深度体系结构由于其庞大的数据集，经常遇到不合适的问题。这两个问题都可以在预训练步骤中有效地减少。
• DBN 对未标记数据进行了有效利用。

可以用于无监督(以及有监督)学习的另一个深度生成网络是和积网络 ( SPN ) [26]，[27]。SPN 是深度网络，可以看作有向无环图，其中图的叶子是观察变量，内部节点是和与积运算。“总和”节点代表混合模型，“产品”节点构成特征层次结构。使用期望最大化算法和反向传播来训练 SPN。学习 SPN 的主要障碍是当向深层移动时，梯度迅速减小。具体地说，从条件似然的导数生成的规则深度神经网络的标准梯度下降经历了磨难。减少这个问题的一个解决方案是用潜变量的最可能状态代替边际推断，然后通过它传播梯度。多明戈和金斯在[28]中提出了一个关于小规模图像识别的杰出成果。以下图 1.16 为便于理解，展示了一个 SPN 网络示例。它显示了和积网络的框图:

图 1.16:和积网络框图

另一种流行的深度生成网络，可以用作无监督(以及监督)学习，是循环神经网络 ( RNN )。这种网络的深度直接取决于输入数据序列的长度。在无监督的 RNN 模型中，来自先前数据样本的经验被用来预测未来的数据序列。rnn 已经被用作对文本或语音进行数据排序的一个优秀的强大模型，然而，由于消失梯度问题的出现，它们的受欢迎程度最近有所下降[29] [16]。使用随机曲率估计，无黑森优化[30]在一定程度上克服了局限性。最近，Bengio 等人[31]和 Sutskever [32]提出了不同的变体来训练生成的 RNNs，其性能优于无黑森优化模型。RNN 在本书第四章、循环神经网络中得到进一步阐述。

在无监督深度网络的其他子类中，基于能量的深度模型大多是已知的体系结构[33] [34]。深度网络的无监督模型类别的一个典型例子是深度自编码器。深度自编码器的大多数变体本质上都是生成性的；然而，属性和实现通常彼此不同。流行的例子有预测稀疏编码器、变换自编码器、去噪自编码器及其堆叠版本等。自编码器在第 6 章、自编码器中有详细说明。

深度判别模型

监督学习中使用的大多数鉴别技术都是浅层体系结构，如隐藏的马可夫模型[35]，[36]，[37]，[38]，[39]，[40]，[41]或条件随机场。然而，最近，通过将每一个较低层的输出作为较高层的输入，一种深层结构的条件随机场模型已经发展起来。对于自然语言处理、电话识别、语言识别等，已经成功地实现了多种版本的深度结构条件随机场。尽管有区别的方法对于深度架构来说是成功的，但是它们还没有达到预期的结果。

如前一节所述，RNNs 已经被用于无监督学习。然而，神经网络也可以作为一个判别模型，用监督学习进行训练。在这种情况下，输出成为与输入数据序列相关的标签序列。语音识别技术在很久以前就已经看到了这种有区别的神经网络，但是收效甚微。论文[42]表明，一个隐藏的马科夫模型被用来将 RNN 分类结果变异成一个标签序列。但不幸的是，出于所有这些原因使用隐藏马科夫模型并没有充分利用无线网络的全部功能。

最近为神经网络开发了一些其他的方法和模型，其基本思想是将 RNN 输出视为一些条件分布，并分布在所有可能的输入序列上[43]，[44]，[45]，[46]。这有助于 RNNs 进行序列分类，同时将长短期记忆嵌入其模型中。主要的好处是它既不需要训练数据集的预分割，也不需要输出的后处理。基本上，数据集的分割是由算法自动执行的，并且可以导出一个可微分的目标函数来优化标签序列上的条件分布。这种算法的有效性广泛适用于手写识别操作。

一种更流行的深度鉴别体系结构是卷积神经网络 ( CNN )。在美国有线电视新闻网中，每个模块由一个卷积层和一个汇集层组成。为了形成深度模型，模块通常一个堆叠在另一个之上，或者在它的顶部具有深度神经网络。卷积层有助于共享许多权重，池层稍后分离卷积的输出，最小化来自前一层的数据速率。美国有线电视新闻网被认为是一个高效的模型，尤其是对于图像识别、计算机视觉等任务。最近，在美国有线电视新闻网设计的具体修改下，也发现它在语音识别方面同样有效。时延神经网络(TDNN)【47】【48】，起源于早期的语音识别，是卷积神经网络的特例，也可以认为是它的前身。

在这种类型的模型中，权重分配仅限于时间维度，不存在池层。第三章、卷积神经网络深入讨论了中枢神经系统的概念和应用。

深度学习有许多模式，也有广泛的应用。许多顶尖的科技公司，如脸书、微软、谷歌、Adobe、IBM 等，都在广泛使用深度学习。除了计算机科学，深度学习也为其他科学领域做出了宝贵的贡献。

用于物体识别的现代中枢神经系统已经对视觉处理有了很大的了解，甚至神经科学家也可以进一步探索。深度学习还为处理大规模数据和在科学领域进行预测提供了必要的功能工具。该领域在预测分子行为以促进药物研究方面也非常成功。

总而言之，深度学习是机器学习的一个子领域，由于其更广泛的适用性，它在实用性和普及性方面有了非凡的增长。然而，未来几年应该充满挑战和机遇，以进一步改善深度学习，并为新的数据爱好者探索这一主题。

注

为了帮助读者更深入地了解深度学习，以下是其他一些优秀且经常更新的在线阅读列表:http://deeplearning.net/tutorial/http://ufldl.stanford.edu/wiki/index.php/UFLDL_Tutorialhttp://deeplearning.net/reading-list/

总结

在过去的十年里，我们有幸从许多从事人工智能工作的伟大科学家和公司那里听到了深度学习的最伟大发明。深度学习是机器学习的一种方法，在过去的几年里，它的实用性和普及性有了巨大的发展。这主要是因为它能够处理涉及高维数据的大型数据集，解决诸如消失梯度问题等主要问题，以及训练更深层次网络的技术。在本章中，我们已经详细解释了这些概念中的大部分，并且还对深度学习的各种算法进行了分类，这些将在后续章节中详细阐述。

本书下一章将介绍大数据与深度学习的关联。本章将主要关注深度学习如何在从大规模数据中提取有价值的信息方面发挥主要作用。

二、大规模数据的分布式深度学习

|   | “在我们信任的上帝中，所有其他人都必须带来数据” |   |
|   | - W .爱德华兹·德明 |

在这个指数级增长的数字世界中，大数据和深度学习是两个最热门的技术趋势。深度学习和大数据是数据科学世界中两个相互关联的主题，就技术增长而言，两者相互关联且同等重要。

数字数据和云存储遵循一个被称为摩尔定律的一般定律[50]，该定律大致指出世界数据每两年翻一番；然而，存储该数据的成本以大致相同的速度下降。这种丰富的数据产生了更多的特征和验证，因此，为了从中提取所有有价值的信息，应该建立更好的深度学习模型。

海量的数据有助于为多个行业带来巨大的机遇。此外，大数据及其分析部分在数据挖掘领域产生了许多挑战，如利用数据和从中检索隐藏信息。在人工智能领域，深度学习算法在学习过程中以大规模数据提供最佳输出。因此，随着数据以前所未有的速度增长，深度学习在提供所有大数据分析解决方案方面也发挥着至关重要的作用。

本章将深入探讨深度学习模型如何处理大数据，并揭示相关挑战。本章的后半部分将介绍 Deeplearning4j，这是一个开源的分布式框架，提供了与 Hadoop 和 Spark 的集成，用于部署大规模数据的深度学习。本章将提供示例来展示如何使用 Deeplearning4j 实现基本的深度神经网络，以及它与 Apache Spark 和 Hadoop YARN 的集成。

以下是本章将涉及的重要主题:

• 海量数据的深度学习
• 大数据深度学习的挑战
• 分布式深度学习和 Hadoop
• 深度学习 4j:一个用于深度学习的开源分布式框架
• 在 Hadoop Yarn 上设置深度学习 4j

对海量数据的深度学习

在这个 Exa-Byte 规模的时代，数据正以指数级的速度增长。数据的增长被许多组织和研究人员以各种方式分析，也有许多不同的目的。根据国际数据公司 ( IDC 的调查，互联网每天处理大约 2pb 的数据[51]。2006 年，数字数据的规模约为 0.18 ZB，而 2011 年这一数字已增至 1.8 ZB。到 2015 年，预计其规模将达到 10 个 ZB，到 2020 年，其在世界上的数量将达到约 30 个 ZB 至 35 个 ZB。这个数据山的时间线见图 2.1 。数字世界中的这些海量数据被正式称为大数据。

|   | “大数据世界火了” |   |
|   | - 《经济学人》，2011 年 9 月 |

图 2.1:图中显示了大约 20 年时间跨度内数据的增长趋势

在 200 米物体中，脸书几乎有 21pb[52]，而捷豹 ORNL 有超过 5 PB 的数据。这些存储的数据增长如此之快，以至于到 2018 年至 2020 年可能会使用 Exa-Byte 规模的存储系统。

这种数据爆炸无疑对传统的数据密集型计算构成了直接威胁，并指出需要一些分布式和可扩展的存储体系结构来查询和分析大规模数据。大数据的一般思路是，原始数据极其复杂、各式各样且日益增长。理想的大数据集由大量无监督的原始数据和一些可忽略的结构化/分类数据组成。因此，在处理这些非平稳结构化数据时，传统的数据密集型计算往往会失败。因此，多样性不受限制的大数据需要复杂的方法和工具，这些方法和工具可以用来提取模式和分析大规模数据。大数据的增长主要是由于计算处理能力的提高和现代系统以较低成本存储数据的能力。

考虑到大数据的所有这些特征，它可以分为四个不同的维度，通常被称为四个 Vs: 卷、品种、速度和准确性。下图图 2.2 通过提供所有 4V 的数据展示了大数据的不同特征:

图 2.2:图中描绘了 4Vs 大数据的可视化表示

在当前这个数据密集型技术时代，数据的速度、数据收集和获取的不断升级的速度与大数据的其他参数一样重要，即卷和品种。按照生成这些数据的给定速度，如果不明智地收集和分析这些数据，就有丢失重要数据的巨大风险。尽管可以选择将这种快速移动的数据保留到大容量存储中，以便在以后进行批处理，但处理这种高速数据的真正重要性在于组织可以多快地将原始数据转换为结构化和可用的格式。具体来说，如果不立即保留数据并以系统的方式进行处理，对时间敏感的信息(如机票、酒店费用或某些电子商务产品的价格等)将变得过时。大数据中参数的准确性关系到数据分析后所得结果的准确性。随着数据日益复杂，保持对大数据隐藏信息的信任面临重大挑战。

为了提取和分析这些极其复杂的数据，需要一个更好的、计划良好的模型。在理想情况下，模型在处理大数据时应该比处理小数据时表现得更好。然而，情况并非总是如此。在这里，我们将展示一个例子来详细讨论这一点。

如图图 2.3 所示，在数据集较小的情况下，最佳算法的性能要比最差算法好 n% 。但是，随着数据集(大数据)大小的增加，性能也会成倍提高到一些 k % > > n % 。从[53]中可以很好地找到这种痕迹，这清楚地表明了大规模训练数据集对模型性能的影响。然而，如果使用任何最简单的模型，只使用大数据集就能获得最佳性能，这将是完全误导的。

从[53]我们可以看出，算法 1 基本上是一个朴素贝叶斯模型，算法 2 属于基于记忆的模型，算法 3 对应的是 Winnow。下图显示了一个小数据集，Winnow 的性能低于基于内存的性能。而在处理大数据集时，朴素贝叶斯和 Winnow 都显示出比基于内存的模型更好的性能。所以，看一下图 2.3 ，真的很难推断这些简单模型中的任何一个在大数据集的环境下在什么基础上工作得更好。对于基于内存的方法在大数据集上相对较差的性能，一个直观的解释是，该算法由于将大量数据加载到内存中的延迟而遭受损失。因此，这纯粹是一个与内存相关的问题，仅使用大数据无法解决这个问题。因此，性能的主要原因应该是模型有多复杂。因此，深度学习模式的重要性开始发挥作用。

注

大数据。心胸狭窄。没有进步！大数据。大脑瓜。突破！[54]

深度学习与大数据形成鲜明对比。深度学习已经成功地在各种行业产品中实现，并被各种研究人员利用这种大规模的数字数据广泛实践。脸书、苹果和谷歌等著名科技公司每天都在收集和分析这些海量数据，并在过去几年中积极推进各种深度学习相关项目。

谷歌对从各种来源收集的海量非结构化数据部署深度学习算法，这些来源包括谷歌街景、图像搜索引擎、谷歌翻译和安卓语音识别。

图 2.3:不同类型算法的准确率随数据集大小的增加而变化

苹果的 Siri 是苹果手机的虚拟个人助理，提供大量不同的服务，如体育新闻、天气报告、用户问题的答案等。Siri 的整个应用都是基于深度学习，从不同的苹果服务中收集数据，获得其智能。其他行业，主要是微软和 IBM，也在使用深度学习作为他们的主要领域来处理这些海量的非结构化数据。IBM 的类脑计算机、沃森和微软的必应搜索引擎主要使用深度学习技术来利用大数据。

当前的深度学习架构由数百万甚至数十亿个数据点组成。此外，数据增长的规模防止了模型过度拟合的风险。计算能力的快速增长也使得高级模型的训练变得更加容易。

表 2.1 展示了在最近的研究中，如何使用流行的深度学习模型来实践大数据，以从数据中获取最大信息:

| **车型** | **计算能力** | **数据集** | **平均运行时间** | | 卷积神经网络[55] | 两个英伟达 GTX 580 3 GB 图形处理器。 | 在 120 万张高分辨率图像的训练集中，大约有 90 个周期。 | 五到六天。 | | 深度信念网络[41] | NVIDIA GTX 280 1 GB GPU。 | 一百万张图片。 | 大约一天。 | | 稀疏自编码器[ 66] | 1000 个 CPU，每个 CPU 有 16000 个内核。 | 1000 万张 200*200 像素图像。 | 大约三天。 |

表 2.1:大规模深度学习模型的最新研究进展。部分信息取自[55]

深度学习算法在分层学习方法的帮助下，基本上用于从输入原始数据中提取有意义的通用表示。基本上，在更高的层次上，数据的更复杂和抽象的表示从先前的层和多层次学习模型的不太抽象的数据中学习。尽管深度学习也可以从大量已标记(已分类)的数据中学习，但当模型可以从未标记/未分类的数据中学习时，它们通常看起来很有吸引力[56]，因此有助于生成一些有意义的模式和大的非结构化数据的表示。

在处理大规模无监督数据时，深度学习算法可以比浅层学习架构更好地提取数据点之间的一般模式和关系。以下是深度学习算法在使用大规模未标记数据进行训练时的一些主要特征:

• 从更高层次的抽象和表示中，可以从深度学习模型中获得大数据的语义和关系知识
• 即使是一个简单的线性模型也可以有效地处理从庞大数据集的过于复杂和抽象的表示中获得的知识
• 这种来自无监督数据的大量数据表示为学习其他数据类型(如文本、音频、视频、图像等)打开了大门

因此，可以肯定地得出结论，深度学习将成为提供大数据情感分析、预测分析等的重要组成部分，特别是随着图形处理单元 ( GPU )容量的增强处理能力和进步。本章的目的不是广泛涵盖大数据，而是阐述大数据和深度学习之间的关系。后续章节将介绍深度学习的关键概念、应用和挑战，同时处理大规模未分类的数据。

大数据深度学习的挑战

大数据的潜力当然值得关注。然而，为了在这个规模上充分提取有价值的信息，我们需要新的创新和有前途的算法来解决许多相关的技术问题。例如，为了训练模型，大多数传统的机器学习算法将数据加载到内存中。但是在有大量数据的情况下，这种方法肯定是不可行的，因为系统可能会耗尽内存。为了克服所有这些棘手的问题，并利用深度学习技术充分利用大数据，我们将需要头脑 Storm。

尽管如前一节所述，大规模深度学习在过去十年中取得了许多成就，但该领域仍处于发展阶段。大数据不断提高其 4V 的局限性。因此，为了解决所有这些问题，需要对模型进行更多的改进。

海量数据带来的深度学习挑战(前五)

大规模数据量对深度学习提出了巨大挑战。大数据具有非常高的维度(属性)、大量的示例(输入)和种类繁多的分类(输出)，通常会增加模型的复杂性，以及算法的运行时间复杂性。堆积如山的数据使得深度学习算法的训练几乎不可能使用集中存储及其有限的处理能力。为了缓冲巨大数据量带来的挑战，应该使用具有并行服务器的分布式框架。升级后的深度网络模型已经开始使用 CPU 和 GPU 集群来提高训练速度，而不会影响算法的准确性。各种新的模型并行和数据并行策略已经发展出来。

在这些类型中，模型或数据被分割成块，这些块可以适合内存中的数据，然后通过向前和向后传播被分发到各个节点[57]。Deeplearning4j 是一个基于 Java 的用于深度学习的分布式工具，它为此使用了数据并行，下一节将对此进行解释。

大量数据总是与嘈杂的标签和数据不完整相关联。这在大规模深度学习的培训过程中构成了重大挑战。大数据的很大一部分包含在未标记或非结构化数据中，其中主要存在有噪声的标签。为了克服这个问题，在很大程度上需要对数据集进行一些手动管理。例如，所有的搜索引擎都用来收集过去一年的数据。对于这些数据，我们需要某种过滤，特别是去除冗余和低值数据。先进的深度学习方法对于处理这种嘈杂、冗余的数据至关重要。此外，相关算法应该能够容忍这些混乱的数据集。还可以实现一些更有效的代价函数和更新的训练策略，以充分克服噪声标签的影响。此外，使用半监督学习[58] [59]有助于增强与这种噪声数据相关的解决方案。

从多种多样的数据中深度学习的挑战(第二个 V)

这是大数据的第二个维度，它代表了所有类型的格式，具有不同的分布和众多的来源。呈指数级增长的数据来自不同的来源，包括来自各种日志文件的大量音频流、图像、视频、动画、图形和非结构化文本。这些不同的数据具有不同的特征和行为。数据集成可能是处理这种情况的唯一方法。正如第 1 章、深度学习简介所述，深度学习具有表示从结构化/非结构化数据中学习的能力。深度学习可以以分层的方式执行无监督学习，即每次执行一个级别的训练，较高级别的特征由直接较低的级别定义。深度学习的这一特性可以用来解决数据集成问题。自然的解决方案是从每个单独的数据源中学习数据表示，然后在后续的层次上集成所学的特性。

已经有一些实验[60] [61]成功地证明了深度学习可以很容易地用于异构数据源，因为它在系统性能方面有显著的提高。然而，在接下来的几年里，深度学习仍有许多未解的问题需要解决。目前，大多数深度学习模型主要在双模态(仅来自两个来源的数据)上进行测试，但是在处理多模态时，系统性能会得到提高吗？可能会出现多个数据源提供冲突信息的情况；在这些情况下，该模型将如何消除此类冲突，并以建设性和富有成效的方式整合数据？由于深度学习能够学习中间表示和与各种数据相关的潜在因素，因此它似乎非常适合于将各种数据源与多种模式相集成。

从高速数据中深度学习的挑战(第三个五)

数据增长的极快速度对深度学习技术提出了巨大挑战。对于数据分析，以这种速度创建的数据也应该得到及时处理。在线学习是从这种高速数据中学习的解决方案之一[62-65]。然而，在线学习使用顺序学习策略，整个数据集应该保存在内存中，这对传统机器来说变得极其困难。虽然传统的神经网络已经被修改为在线学习[67-71]，但是在这个领域，深度学习仍然有很大的进步空间。作为在线学习的替代方法，随机梯度下降方法[72]，[73]也应用于深度学习。在这种类型中，具有已知标签的一个训练示例被馈送到下一个标签以更新模型参数。此外，为了加速学习，更新也可以在小批量的基础上进行[74]。这个小批量可以在运行时间和计算机内存之间提供良好的平衡。在下一节中，我们将解释为什么小批量数据对于分布式深度学习最重要。

与这种高速数据相关的一个更大的挑战是，这种数据在本质上是极其多变的。随着时间的推移，数据的分发过于频繁。理想情况下，随时间变化的数据被分成小块，从小时间段中获取。基本思想是，数据在一段时间内保持稳定，并且还具有某种主要的相关性[75] [76]。因此，大数据的深度学习算法应该具有以流的形式学习数据的特性。能够从这些非平稳数据中学习的算法对于深度学习来说确实至关重要。

深度学习保持数据准确性的挑战(四五)

数据准确性，不精确或不确定的数据，有时会被忽视，尽管它与大数据的其他 3v 同样重要。随着大数据的巨大多样性和速度，组织不能再依赖传统模型来衡量数据的准确性。根据定义，非结构化数据包含大量不精确和不确定的数据。例如，社交媒体数据在本质上是过度不确定的。尽管有一些工具可以自动化数据的规范化和清理，但它们大多处于工业化前阶段。

分布式深度学习和 Hadoop

从本章前面的部分，我们已经对深度学习和大数据之间的关系为什么以及如何给研究界带来重大变化有了足够的了解。此外，随着时间的推移，一个集中的系统不会对这种关系有实质性的帮助。因此，将深度学习网络分布在多个服务器上已经成为当前深度学习实践者的主要目标。然而，在分布式环境中处理大数据总是伴随着一些挑战。其中大部分在上一节中有深入的解释。这些包括处理高维数据、具有太多特征的数据、可用于存储的内存量、处理海量大数据集等等。此外，大数据集对 CPU 和内存时间的计算资源要求很高。因此，处理时间的减少已经成为一个极其重要的标准。以下是分布式深度学习的主要挑战:

• 我们如何在节点的主内存中保存数据集块？
• 我们如何保持数据块之间的协调，以便以后可以将它们移动到一起，从而产生最终结果？
• 如何才能让分布式并行处理变得极具调度性和协调性？
• 我们如何实现跨数据集的管弦乐搜索过程以实现高性能？

在大数据集上使用分布式深度学习有多种方式。然而，当我们谈论大数据时，在防御过去五年的大部分挑战方面表现非常出色的框架是 Hadoop 框架[77-80]。Hadoop 允许并行和分布式处理。它无疑是最受欢迎和使用最广泛的框架，与其他传统框架相比，它可以更高效地存储和处理数据山。几乎所有的主要技术公司，如谷歌、脸书等，都使用 Hadoop 以复杂的方式部署和处理他们的数据。谷歌设计的大多数软件都使用 Hadoop，这需要使用数据海洋。Hadoop 的主要优势是它在数千个商品服务器上存储和处理大量数据的方式，带来了一些组织良好的结果[81]。从我们对深度学习的一般理解中，我们可以得出这样的结论:深度学习确实需要那种分布式计算能力，才能从输入数据中产生一些奇妙的结果。大数据集可以分割成块，分布在多个商品硬件上进行并行训练。此外，深度神经网络的完整阶段可以分成子任务，然后这些子任务可以并行处理。

注

Hadoop 已经成为所有数据湖的汇聚点。对已经存在于 Hadoop 中的数据进行深度学习的需求已经变得非常重要。

Hadoop 的运作理念是移动计算比移动数据【86】【87】更便宜。Hadoop 允许跨商品服务器集群对大规模数据集进行分布式处理。它还提供了高效的负载平衡，具有非常高的容错度，并且可以通过最少的努力实现高度的横向扩展。它可以检测和容忍应用层的故障，因此适合在商用硬件上运行。为了实现数据的高可用性，默认情况下，Hadoop 保持三倍的复制因子，每个数据块的副本放在另外两台独立的机器上。因此，如果一个节点出现故障，可以立即从其他两个节点进行恢复。Hadoop 的复制因子可以根据数据的价值和对数据的其他相关要求轻松增加。

Hadoop 最初主要是为了处理批处理任务而构建的，因此它最适合深度学习网络，在深度学习网络中，主要任务是找到大规模数据的分类。学习如何对数据进行分类的特征选择主要是在大批量数据集上完成的。

Hadoop 具有极强的可配置性，可以根据用户需求轻松优化。例如，如果用户希望保留更多的数据副本以获得更好的可靠性，他可以增加复制因子。但是，副本数量的增加最终会增加存储需求。在这里，我们将不再解释数据的特性和配置，而是主要讨论 Hadoop 的一部分，它将被广泛用于分布式深度神经网络。

在新版本的 Hadoop 中，我们在本书中主要使用的部分是 HDFS、地图缩减和另一个资源协商者 ( Yarn)。Yarn 已经在很大程度上主导了 Hadoop 的地图缩减(在下一部分中解释)。目前，Yarn 负责将作品分配给 Hadoop 的数据节点(数据服务器)。 Hadoop 分布式文件系统 ( HDFS )则是一个分布式文件系统，它分布在名为 NameNode 的集中式元数据服务器下的所有数据节点上。为了实现高可用性，在更高的版本中，一个辅助名称节点被集成到 Hadoop 框架中，其目的是在特定检查点之后拥有主名称节点的元数据副本。

地图-缩小

Map-Reduce 范式[83]是谷歌在 2004 年开发的分布式编程模型，它与在一群机器上用并行和分布式算法处理巨大数据集相关联。整个地图缩减应用对于大规模数据集非常有用。基本上，它有两个主要组成部分，一个叫做 Map，另一个叫做 Reduce，还有一些中间阶段，比如洗牌、排序和分区。在映射阶段，大的输入作业被分解成小的，每个作业被分配到不同的内核。然后在这些机器上的每个小作业上执行操作。缩减阶段将所有分散和转换的输出放入一个单独的数据集。

详细解释 Map-Reduce 的概念超出了本章的范围；感兴趣的读者可以通过“Map-Reduce:大型集群上的简化数据处理”【83】来深入了解这一点。

迭代地图-缩小

深度学习算法本质上是迭代的——模型从优化算法中学习，优化算法经历多个步骤，从而导致最小误差点。对于这些类型的模型，Map-Reduce 应用的工作效率似乎不如其他用例。

迭代 Map-Reduce，一个下一代的 Yarn 框架(不同于传统的 Map-Reduce)对数据进行多次迭代，数据只通过一次。尽管迭代地图缩减和地图缩减的体系结构在设计上是不同的，但是对这两种体系结构的高级理解是简单的。迭代地图缩减只是一系列地图缩减操作，其中第一个地图缩减操作的输出成为下一个操作的输入，以此类推。在深度学习模型的情况下，映射阶段将特定迭代的所有操作放在分布式系统的每个节点上。然后，它将该海量输入数据集分发到集群中的所有机器。模型的训练在集群的每个节点上执行。

在将聚合的新模型发送回每台机器之前，缩减阶段会获取从映射阶段收集的所有输出，并计算参数的平均值。同样的操作被迭代归约算法反复迭代，直到学习过程完成，误差最小化到几乎为零。

图 2.4 比较了两种方法的高级功能。左图是地图缩减的框图，右边是迭代地图缩减的特写。每个“处理器”都是一个工作的深层网络，它在较大数据集的小块上学习。在“超级步骤”阶段，在将整个模型重新分配到整个集群之前，对参数进行平均，如下图所示:

图 2.4:地图缩减和并行迭代缩减中的功能差异

又一个资源协商者(Yarn)

Yarn 的主要思想是将作业调度和资源管理从数据处理中分离出来。因此，数据可以继续在系统中与 Map-Reduce 批处理作业并行处理。Yarn 拥有一个中央资源管理器，主要根据需要管理 Hadoop 系统资源。节点管理器(特定于节点)负责管理和监控集群中各个节点的处理。该处理由 ApplicationMaster 专门控制，它从中央资源管理器监视资源，并与节点管理器一起监视和执行任务。下图概述了 Yarn 的体系结构:

图 2.5:Yarn 的高级体系结构概述

Hadoop 的所有这些组件主要用于分布式深度学习，以克服前面提到的所有挑战。下面的小节展示了分布式深度学习的更好性能需要满足的标准。

分布式深度学习设计的重要特征

以下是分布式深度学习设计的重要特征:

1. Small batch processing: In distributed deep learning, the network must intake and process data quickly in parallel. To process and provide results more accurately, every node of the cluster should receive small chunks of data of approximately 10 elements at a time.

   例如，假设 Yarn 的主节点正在为 200 GB 的大数据集协调 20 个工作节点。主节点会将数据集拆分为 20 个小批量数据的 10 GB，为每个工作人员分配一个小批量。工作人员将并行处理数据，并在主机完成计算后立即将结果发送回主机。所有这些结果将由主节点汇总，结果的平均值将最终重新分配给各个工作人员。

   深度学习网络在处理近 10 个小批量数据时表现良好，而不是处理 100 或 200 个大批量数据。小批量的数据使网络能够从不同方向的数据中深入学习，随后会重新编译，为模型提供更广泛的知识。

   另一方面，如果批量太大，网络会试图快速学习，从而使错误最大化。相反，更小的批量会降低学习速度，并导致当网络接近最小错误率时出现分歧的可能性。

2. Parameter Averaging: Parameter averaging is a crucial operation for the training of distributed deep network. In a network, parameters are generally the weight and biases of the node layers. As mentioned in the small batch processing section, once training is completed for several workers, they will pass different sets of parameters back to the master. With every iteration, the parameters are averaged, updated, and sent back to the master for further operations.

   参数平均的顺序过程可以概括如下:

   • 主机配置初始网络并设置不同的超参数
   • 基于训练主数据的配置，大数据集被分成几个较小数据集的块
   • 对于训练数据集的每个分割，直到错误率接近零，执行以下操作:
     • 主设备将参数从主设备分配给每个工人
     • 每个工作人员用其专用的数据集块开始模型的训练
     • 计算参数的平均值并返回给主机。
   • 培训结束，主人将拥有一份培训网络

3. 在分布式训练的情况下，参数平均具有以下两个重要优势:

   • 它通过同时生成结果来实现并行性。
   • 通过将给定数据集分布到多个较小的数据集，有助于防止过度拟合。网络然后学习平均结果，而不仅仅是从不同的小批量中汇总结果。

图 2.6 显示了小批量处理和参数平均操作的组合示意图:

图 2.6:图中显示了分布式深度学习架构的高层架构

深度学习 4j——一个用于深度学习的开源分布式框架

深度学习 4j(DL4J)【82】是为 JVM 编写的开源深度学习框架，主要用于商业级。该框架完全是用 Java 编写的，因此包含了名称“4j”。由于与 Java 一起使用，Deeplearning4j 开始受到更广泛的受众和从业者的欢迎。

这个框架基本上是由一个与 Hadoop 和 Spark 集成的分布式深度学习库组成的。借助 Hadoop 和 Spark，我们可以非常容易地分发模型和大数据集，并运行多个图形处理器和中央处理器来执行并行操作。Deeplearning4j 在执行图像、声音、文本、时间序列数据等模式识别方面取得了巨大成功。除此之外，它还可以应用于各种客户使用案例，例如面部识别、欺诈检测、业务分析、推荐引擎、图像和语音搜索以及传感器数据的预测性维护。

下图图 2.7 显示了 Deeplearning4j 的通用高级架构框图:

图 2.7:深度学习的高级架构框图 4j [82]

深度学习的主要特征 4j

Deeplearning4j 自带各种吸引人的功能，这使其完全区别于现有的其他 Deeplearning 工具，如 antano、Torch 等。

• 分布式架构:deep learning 4j 中的训练可以通过两种方式进行——使用分布式多线程深度学习，或者使用传统的普通单线程深度学习技术。培训在商品节点集群中进行。因此，深度学习 4j 能够快速处理任意数量的数据。使用迭代约简方法并行训练神经网络，该方法适用于 Hadoop YARN 和 Spark。它还与 Cuda 内核集成进行纯 GPU 操作，并与分布式 GPU 协同工作。

Deeplearning4j 操作可以作为作业在 Hadoop Yarn 或 Spark 上运行。在 Hadoop 中，迭代缩减工作人员在 HDFS 的每个块上工作，并同步并行处理数据。当处理完成时，它们将转换后的参数推回到它们的主节点，在那里获取参数的平均值，并更新每个工作节点的模型。

在 Deeplearning4j 中，分布式运行时是可以互换的，它们就像一个巨大的模块化架构中的目录，可以换入或换出。

• 数据并行:神经网络的分布式训练有两种方式:一种是数据并行，一种是模型并行。深度学习 4j 遵循数据并行性进行训练。在数据并行中，我们可以将大数据集分割成小数据集的块，并将其分布到运行在不同服务器上的并行模型中进行并行训练。

• JVM 的科学计算能力:对于 Java 和 Scala 中的科学计算，Deeplearning4j 包括一个 N 维数组类，使用了Java 的 N 维数组 ( ND4J )。ND4J 的功能比 Numpy 提供给 Python 的要快得多，而且大部分是用 C++编写的。它有效地基于生产环境中的矩阵操作和线性代数库。ND4J 的大部分例程都是为了以最小的内存需求快速运行而设计的。

• 机器学习的矢量化工具:对于各种文件格式和数据类型的矢量化，Canova 已经和 Deeplearning4j 合并。Canova 使用输入/输出系统执行矢量化，类似于 Hadoop 如何使用 Map-Reduce。Canova 主要设计用于从命令行界面 ( CLI )对文本、CSV、图像、声音、视频等进行矢量化。

深度学习 4j 功能概述

以下是深度学习 4j 的功能概述:

• Deeplearning4j 可以说是有史以来构建的最完整、生产就绪、开源的 Deeplearning 库
• 与基于网络的工具相比，它有更多专为深度网络设计的功能
• Deeplearning4j 非常容易使用；即使是非专家也可以应用它的惯例来解决计算密集型问题
• 这些工具提供了广泛的适用性，因此，这些网络同样适用于图像、声音、文本和时间序列
• 它是完全分布式的，可以并行运行多个 GPU，不像 antao[84]是不分布式的，Torch7 [85]也没有像 DL4J 那样自动化它的分发

在 Hadoop Yarn 上设置深度学习 4j

Deeplearning4j 主要用于具有多层的网络。要开始使用 Deeplearning4j，需要熟悉先决条件，以及如何安装所有相关软件。大部分文档可以在https://deeplearning4j.org/【88】deep learning 4j 官网轻松找到。

在本章的这一部分，我们将帮助您熟悉 Deeplearning4j 的代码。首先，我们将展示用 Deeplearning4j 实现多层神经网络的简单操作。本节的后半部分将讨论使用 Deeplearning4j 库进行分布式深度学习。Deeplearning4j 使用 Apache Spark 在多个分布式 GPU 上训练分布式深度神经网络。本节的后半部分还将介绍针对深度学习 4j 的 Apache Spark 的设置。

熟悉深度学习 4j

这一部分将主要介绍深度学习的“你好世界”项目。我们将借助两个简单的深度学习问题来解释图书馆的基本功能。

在 Deeplearning4j，MultiLayerConfiguration中，库的一个类可以被认为是构建块的基础，它负责组织神经网络的层和相应的超参数。这门课可以被认为是神经网络深度学习 4j 的核心组成部分。在整本书中，我们将使用这个类来配置不同的多层神经网络。

注

超参数是决定神经网络学习过程的主要支柱。它们主要包括如何初始化模型的权重，应该更新多少次，模型的学习速率，使用哪些优化算法等等。

在第一个例子中，我们将展示如何在 Deeplearning4j 的帮助下为多层感知器分类器分类数据模式。

以下是将在此程序中使用的示例训练数据集:

  0, -0.500568579838,  0.687106471955 
  1,  0.190067977988, -0.341116711905 
  0,  0.995019651532,  0.663292952846 
  0, -1.03053733564,   0.342392729177 
  1,  0.0376749555484,-0.836548188848 
  0, -0.113745482508,  0.740204108847 
  1,  0.56769119889,  -0.375810486522 

首先，我们需要初始化网络的各种超参数。下面这段代码将为程序设置 ND4J 环境:

Nd4j.ENFORCE_NUMERICAL_STABILITY = true; 
int batchSize = 50; 
int seed = 123; 
double learningRate = 0.005; 

纪元数设置为30:

int nEpochs = 30;  
int numInputs = 2; 
int numOutputs = 2; 
int numHiddenNodes = 20; 

以下代码将把训练数据加载到网络中:

RecordReader rr = new CSVRecordReader(); 
rr.initialize(new FileSplit(new File("saturn_data_train.csv"))); 
DataSetIterator trainIter = new RecordReaderDataSetIterator      
                            (rr,batchSize,0,2); 

随着训练数据的加载，我们用下面的代码将测试数据加载到模型中:

RecordReader rrTest = new CSVRecordReader(); 
rrTest.initialize(new FileSplit(new File("saturn_data_eval.csv"))); 
DataSetIterator trainIter = new RecordReaderDataSetIterator
                            (rrTest,batchSize,0,2); 

网络模型的所有层的组织以及超参数的设置可以通过以下代码来完成:

MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder() 
.seed(seed)
.iterations(1)                          
.optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT) 
.learningRate(learningRate) 
.updater(Updater.NESTEROVS).momentum(0.9)
.list() 
.layer(0, new DenseLayer.Builder().nIn(numInputs).nOut(numHiddenNodes) 
   .weightInit(WeightInit.XAVIER) 
   .activation("relu")
   .build()) 
 .layer(1, new OutputLayer.Builder(LossFunction.NEGATIVELOGLIKELIHOOD) 
   .weightInit(WeightInit.XAVIER)                         
   .activation("softmax")
   .nIn(numHiddenNodes).nOut(numOutputs).build())
 .pretrain(false)
 .backprop(true)
 .build(); 

现在，我们已经加载了训练和测试数据集，模型的初始化可以通过调用init()方法来完成。这也将从给定的输入开始模型的训练:

MultiLayerNetwork model = new MultiLayerNetwork(conf); 
model.init(); 

为了检查某个内部之后的输出，让我们在每次5参数更新时打印分数:

model.setListeners(new ScoreIterationListener(5));      
for ( int n = 0; n < nEpochs; n++) 
{ 

最后，通过调用.fit()方法训练网络:

 model.fit( trainIter ); 
}  
System.out.println("Evaluating the model....");  
Evaluation eval = new Evaluation(numOutputs); 
while(testIter.hasNext())
  { 
    DataSet t = testIter.next(); 
    INDArray features = t.getFeatureMatrix(); 
    INDArray lables = t.getLabels(); 
    INDArray predicted = model.output(features,false); 
    eval.eval(lables, predicted); 
  } 
System.out.println(eval.stats()); 

这样模型的训练就完成了。在下一部分中，将绘制数据点，并计算相应的数据精度，如以下代码所示:

double xMin = -15;
double xMax = 15; 
double yMin = -15; 
double yMax = 15; 

int nPointsPerAxis = 100; 
double[][] evalPoints = new double[nPointsPerAxis*nPointsPerAxis][2]; 
int count = 0; 
for( int i=0; i<nPointsPerAxis; i++ )
{ 
 for( int j=0; j<nPointsPerAxis; j++ )
 { 
   double x = i * (xMax-xMin)/(nPointsPerAxis-1) + xMin; 
   double y = j * (yMax-yMin)/(nPointsPerAxis-1) + yMin; 

   evalPoints[count][0] = x; 
   evalPoints[count][1] = y; 

   count++; 
 } 
} 

INDArray allXYPoints = Nd4j.create(evalPoints); 

INDArray predictionsAtXYPoints = model.output(allXYPoints); 

以下代码将在将所有训练数据绘制到图形中之前，将这些数据存储在一个数组中:

rr.initialize(new FileSplit(new File("saturn_data_train.csv"))); 
rr.reset(); 
int nTrainPoints = 500; 
trainIter = new RecordReaderDataSetIterator(rr,nTrainPoints,0,2); 
DataSet ds = trainIter.next(); 
PlotUtil.plotTrainingData(ds.getFeatures(), ds.getLabels(),allXYPoints, predictionsAtXYPoints, nPointsPerAxis); 

通过网络运行测试数据并生成预测可以通过以下代码来完成:

rrTest.initialize(new FileSplit(new File("saturn_data_eval.csv"))); 
rrTest.reset(); 
int nTestPoints = 100; 
testIter = new RecordReaderDataSetIterator(rrTest,nTestPoints,0,2); 
ds = testIter.next(); 
INDArray testPredicted = model.output(ds.getFeatures()); 
PlotUtil.plotTestData(ds.getFeatures(), ds.getLabels(), testPredicted, allXYPoints, predictionsAtXYPoints, nPointsPerAxis); 

当执行前面的代码时，它将运行大约 5-10 秒，这取决于您的系统配置。在此期间，您可以查看控制台，它将显示您的模型的最新训练分数。

一项评估显示如下:

o.d.o.l.ScoreIterationListener - Score at iteration 0 is    
                                 0.6313823699951172 
o.d.o.l.ScoreIterationListener - Score at iteration 5 is 
                                 0.6154170989990234 
o.d.o.l.ScoreIterationListener - Score at iteration 10 is     
                                 0.4763660430908203 
o.d.o.l.ScoreIterationListener - Score at iteration 15 is 
                                 0.52469970703125 
o.d.o.l.ScoreIterationListener - Score at iteration 20 is    
                                 0.4296367645263672 
o.d.o.l.ScoreIterationListener - Score at iteration 25 is 
                                 0.4755714416503906 
o.d.o.l.ScoreIterationListener - Score at iteration 30 is 
                                 0.3985047912597656 
o.d.o.l.ScoreIterationListener - Score at iteration 35 is 
                                 0.4304619598388672 
o.d.o.l.ScoreIterationListener - Score at iteration 40 is   
                                 0.3672477722167969 
o.d.o.l.ScoreIterationListener - Score at iteration 45 is 
                                 0.39150180816650393 
o.d.o.l.ScoreIterationListener - Score at iteration 50 is 
                                 0.3353725051879883 
o.d.o.l.ScoreIterationListener - Score at iteration 55 is 
                                 0.3596681213378906 

最后，程序将使用 Deeplearning4j 为模型输出不同的训练统计信息，如下所示:

Evaluating the model.... 
Examples labeled as 0 classified by model as 0: 48 times 
Examples labeled as 1 classified by model as 1: 52 times 

在背景中，我们可以可视化数据的绘图，这将给出土星看起来像什么的印象。在下一部分中，我们将展示如何将 Hadoop Yarn 和 Spark 与深度学习 4j 集成。下图图 2.8 用图形表示程序的输出:

图 2.8:执行前面的程序时，绘制了分散的数据点。数据点给出了土星的印象

集成 Hadoop YARN 和 Spark 进行分布式深度学习

要在 Hadoop 上使用 Deeplearning4j，我们需要包含deeplearning-hadoop依赖项，如以下代码所示:

<!-- https://mvnrepository.com/artifact/org.Deeplearning4j/Deeplearning4j-hadoop --> 
<dependency> 
    <groupId>org.Deeplearning4j</groupId> 
    <artifactId>Deeplearning4j-hadoop</artifactId> 
    <version>0.0.3.2.7</version> 
</dependency> 

同样，对于 Spark，我们必须包含deeplearning-spark依赖项，如以下代码所示:

<!-- https://mvnrepository.com/artifact/org.Deeplearning4j/dl4j-spark-nlp_2.11 --> 
<dependency> 
    <groupId>org.Deeplearning4j</groupId> 
    <artifactId>dl4j-spark-nlp_2.11</artifactId> 
    <version>0.5.0</version> 
</dependency> 

解释 Apache Spark 的详细功能超出了本书的范围。感兴趣的读者可以在http://spark.apache.org/了解同样的内容。

为 Hadoop Yarn 上的 Spark 配置内存分配的规则

如前一节所述，Apache Hadoop Yarn 是一个集群资源管理器。当 Deeplearning4j 通过 Spark 向 Yarn 簇提交培训作业时，Yarn 簇负责管理资源的分配，例如中央处理器内核、每个执行器消耗的内存量等。然而，为了从 Deeplearning4j on YARN 中获得最佳性能，需要进行一些仔细的内存配置。具体如下:

• 需要使用spark.executor.memory指定执行器 JVM 内存量。
• 需要使用spark.yarn.executor.memoryOverhead指定 Yarn 容器内存开销。
• spark.executor.memory和spark.yarn.executor.memoryOverhead的总和必须始终小于 Yarn 分配给容器的内存量。
• ND4j 和 JavaCPP 应该知道堆外内存的分配；这可以使用org.bytedeco.javacpp.maxbytes系统属性来完成。
• org.bytedeco.javacpp.maxbytes必须小于spark.yarn.executor.memoryOverhead。

深度学习 4j 的当前版本使用参数平均来执行神经网络的分布式训练。以下操作的执行方式与前一节参数平均部分所述的方式完全相同:

SparkDl4jMultiLayer sparkNet = new SparkDl4jMultiLayer(sc,conf, 
                               new ParameterAveragingTrainingMaster
                              .Builder(numExecutors(),dataSetObjSize 
                              .batchSizePerWorker(batchSizePerExecutor) 
                              .averagingFrequency(1) 
                              .repartionData(Repartition.Always) 
                              .build()); 
sparkNet.setCollectTrainingStats(true); 

要列出来自 HDFS 的所有文件以便在不同的节点上运行代码，请运行以下代码:

Configuration config = new Configuration(); 
FileSystem hdfs = FileSystem.get(tempDir.toUri(), config); 
RemoteIterator<LocatedFileStatus> fileIter = hdfs.listFiles
  (new org.apache.hadoop.fs.Path(tempDir.toString()),false); 

List<String> paths = new ArrayList<>(); 
while(fileIter.hasNext())
  { 
   String path = fileIter.next().getPath().toString(); 
   paths.add(path); 
  } 

代码包中将提供一个完整的代码，说明如何使用 Yarn 和 HDFS 设置 Spark。为了简单起见，为了便于理解，这里只显示了部分代码。

现在，我们将展示一个示例来演示如何使用 Spark，并使用 Deeplearning4j 将数据加载到内存中。我们将使用一个基本的数据向量示例来展示对一些 CSV 数据的一些预处理操作。

示例数据集如下所示:

2016-01-01 17:00:00.000,830a7u3,u323fy8902,1,USA,100.00,Legit 
2016-01-01 18:03:01.256,830a7u3,9732498oeu,3,FR,73.20,Legit 
2016-01-03 02:53:32.231,78ueoau32,w234e989,1,USA,1621.00,Fraud 
2016-01-03 09:30:16.832,t842uocd,9732498oeu,4,USA,43.19,Legit 
2016-01-04 23:01:52.920,t842uocd,cza8873bm,10,MX,159.65,Legit 
2016-01-05 02:28:10.648,t842uocd,fgcq9803,6,CAN,26.33,Fraud 
2016-01-05 10:15:36.483,rgc707ke3,tn342v7,2,USA,-0.90,Legit 

该计划的问题陈述如下:

• 删除一些不必要的列
• 过滤掉数据，只保留数值为MerchantCountryCode列的USA和MX的例子
• 替换TransactionAmountUSD列中的无效条目
• 解析数据字符串，并从中收集一天中的小时，以创建新的HourOfDay列

Schema inputDataSchema = new Schema.Builder() 
     .addColumnString("DateTimeString") 
     .addColumnsString("CustomerID", "MerchantID")  
     .addColumnInteger("NumItemsInTransaction") 
     .addColumnCategorical("MerchantCountryCode",  
      Arrays.asList("USA","CAN","FR","MX")) 
     .addColumnDouble("TransactionAmountUSD",0.0,null,false,false)  
     .addColumnCategorical("FraudLabel",Arrays.asList("Fraud","Legit"))
     .build(); 

System.out.println("\n\nOther information obtainable from schema:"); 
System.out.println("Number of columns: " + 
                   inputDataSchema.numColumns()); 
System.out.println("Column names: " +              
                   inputDataSchema.getColumnNames()); 
System.out.println("Column types: " +  
                   inputDataSchema.getColumnTypes()); 

以下部分将定义我们要对数据集执行的操作:

TransformProcess tp = new TransformProcess.Builder(inputDataSchema) 
.removeColumns("CustomerID","MerchantID") 
.filter(new ConditionFilter(
 new CategoricalColumnCondition("MerchantCountryCode", 
 ConditionOp.NotInSet, new HashSet<>(Arrays.asList("USA","MX"))))) 

在非结构化数据中，数据集通常是有噪声的，因此我们需要处理一些无效数据。如果美元值为负，程序会将其替换为0.0。我们将保持正美元数额不变。

.conditionalReplaceValueTransform( 
  "TransactionAmountUSD",       
  new DoubleWritable(0.0),      
  new DoubleColumnCondition("TransactionAmountUSD",ConditionOp.LessThan
  , 0.0))   

现在，根据问题陈述格式化DateTime格式，使用以下代码:

.stringToTimeTransform("DateTimeString","YYYY-MM-DD HH:mm:ss.SSS",            
 DateTimeZone.UTC) 
.renameColumn("DateTimeString", "DateTime") 
.transform(new DeriveColumnsFromTimeTransform.Builder("DateTime") 
   .addIntegerDerivedColumn("HourOfDay", DateTimeFieldType.hourOfDay()) 
   .build())
.removeColumns("DateTime")
.build(); 

执行所有这些操作后，会创建一个不同的模式，如下所示:

Schema outputSchema = tp.getFinalSchema(); 

System.out.println("\nSchema after transforming data:"); 
System.out.println(outputSchema); 

下面这段代码将设置 Spark 执行所有操作:

SparkConf conf = new SparkConf(); 
conf.setMaster("local[*]"); 
conf.setAppName("DataVec Example"); 

JavaSparkContext sc = new JavaSparkContext(conf); 

String directory = new  ClassPathResource("exampledata.csv").getFile()
.getParent(); 

要直接从 HDFS 获取数据，必须通过hdfs://{the filepath name}:

JavaRDD<String> stringData = sc.textFile(directory); 

输入数据使用CSVRecordReader()方法解析如下:

RecordReader rr = new CSVRecordReader(); 
JavaRDD<List<Writable>> parsedInputData = stringData.map(new  StringToWritablesFunction(rr)); 

Spark 的预定义转换执行如下:

SparkTransformExecutor exec = new SparkTransformExecutor(); 
JavaRDD<List<Writable>> processedData = exec.execute(parsedInputData, 
tp); 

JavaRDD<String> processedAsString = processedData.map(new 
WritablesToStringFunction(","));  

如前所述，要将数据保存回 HDFS，只需将文件路径放在hdfs://之后即可:

processedAsString.saveAsTextFile("hdfs://your/hdfs/save/path/here") 

List<String> processedCollected = processedAsString.collect(); 
List<String> inputDataCollected = stringData.collect(); 

System.out.println("\n ---- Original Data ----"); 
for(String s : inputDataCollected) System.out.println(s); 

System.out.println("\n ---- Processed Data ----"); 
for(String s : processedCollected) System.out.println(s); 

当使用深度学习 4j 使用 Spark 执行该程序时，我们将获得以下输出:

14:20:12 INFO MemoryStore: Block broadcast_0 stored as values in memory (estimated size 104.0 KB, free 1390.9 MB) 
16/08/27 14:20:12 INFO MemoryStore: ensureFreeSpace(10065) called with curMem=106480, maxMem=1458611159 
16/08/27 14:20:12 INFO MemoryStore: Block broadcast_0_piece0 stored as bytes in memory (estimated size 9.8 KB, free 1390.9 MB) 
16/08/27 14:20:12 INFO BlockManagerInfo: Added broadcast_0_piece0 in memory on localhost:46336 (size: 9.8 KB, free: 1391.0 MB) 
16/08/27 14:20:12 INFO SparkContext: Created broadcast 0 from textFile at BasicDataVecExample.java:144 
16/08/27 14:20:13 INFO SparkTransformExecutor: Starting execution of stage 1 of 7 
16/08/27 14:20:13 INFO SparkTransformExecutor: Starting execution of stage 2 of 7 
16/08/27 14:20:13 INFO SparkTransformExecutor: Starting execution of stage 3 of 7 
16/08/27 14:20:13 INFO SparkTransformExecutor: Starting execution of stage 4 of 7 
16/08/27 14:20:13 INFO SparkTransformExecutor: Starting execution of stage 5 of 7 

以下是输出:

---- Processed Data ---- 
17,1,USA,100.00,Legit 
2,1,USA,1621.00,Fraud 
9,4,USA,43.19,Legit 
23,10,MX,159.65,Legit 
10,2,USA,0.0,Legit 

与此示例类似，在 Spark 中，许多其他数据集可以以定制的方式进行处理。从下一章开始，我们将展示针对特定深度神经网络的深度学习 4j 代码。Apache Spark 和 Hadoop YARN 的实现是一个通用的过程，不会根据神经网络而改变。读者可以根据自己的需求，使用该代码在集群或本地部署深层网络代码。

总结

与传统的机器学习算法相比，深度学习模型有能力解决大量输入数据带来的挑战。深度学习网络旨在从非结构化数据中自动提取复杂的数据表示。这一特性使得深度学习成为从大数据中学习隐藏信息的宝贵工具。然而，由于数据量和种类日益增加的速度，深度学习网络需要以分布式方式存储和处理。Hadoop 作为针对此类需求使用最广泛的大数据框架，在这种情况下极为方便。我们解释了对分布式深度学习架构至关重要的 Hadoop 的主要组件。深入阐述了分布式深度学习网络的关键特征。Deeplearning4j 是一个开源的分布式深度学习框架，它与 Hadoop 集成实现了上述不可或缺的需求。Deeplearning4j 完全用 Java 编写，可以通过迭代 Map-Reduce 以分布式方式更快地处理数据，并且可以解决大规模数据带来的许多问题。我们提供了两个示例，让您了解基本的 Deeplearning4j 代码和语法。我们还提供了一些与 Hadoop YARN 和 Hadoop 分布式文件系统集成的 Spark 配置的代码片段。

本书的下一章将介绍卷积神经网络，一种流行的深度学习网络。本章将讨论卷积方法，以及如何将其用于构建主要用于图像处理和图像识别的高级神经网络。本章将提供如何使用深度学习实现卷积神经网络的信息。

三、卷积神经网络

|   | “电脑会不会思考的问题，并不比潜艇会不会游泳的问题更有趣。” |   |
|   | Edsger 中的一个。Dijkstra 字首 |

卷积神经网络(CNN) -加入了一些可以忽略不计的计算机科学，难道没有给人一种数学和生物学结合的诡异感觉吗？然而，这些类型的网络已经成为计算机视觉领域中一些最主要和最强大的体系结构。CNN 在 2012 年之后开始获得知名度，当时分类的精度有了巨大的提高，这要归功于深度学习领域的一些先驱。从那以后，一堆高科技公司一直在使用深度 CNN 进行各种服务。亚马逊使用美国有线电视新闻网进行产品推荐，谷歌使用它进行照片搜索，脸书主要使用它进行自动标记算法。

美国有线电视新闻网[89]是一种前馈神经网络，由神经元组成，具有可学习的权重和偏差。这些类型的网络基本上用于处理数据，具有网格状的拓扑形式。顾名思义，中枢神经系统是一种神经网络，与一般的矩阵乘法不同，它是一种特殊类型的线性数学运算，即卷积，用于至少一个后续层。美国有线电视新闻网的架构旨在利用多维结构的输入。这些包括输入图像、语音信号甚至一维时间序列数据的 2D 结构。有了这些优势，美国有线电视新闻网在许多实际应用中取得了真正的成功。因此，美国有线电视新闻网非常成功，特别是在自然语言处理、推荐系统、图像识别和视频识别等领域。

注

偏置单元是一个额外的神经元，其值为 1，并被添加到每个预输出层。这些单元没有连接到上一层，因此不代表任何真正意义上的活动。

*在这一章中，我们将深入讨论 CNN 的构建模块。我们将首先讨论什么是卷积，以及卷积运算在神经网络中的必要性。在这个主题下，我们还将讨论池操作，这是美国有线电视新闻网最重要的组成部分。本章的下一个主题将指出 CNN 在处理大规模数据时面临的主要挑战。本章的最后一部分将帮助读者学习如何使用 Deeplearning4j 设计 CNN。

本章的主要主题如下:

• 理解卷积
• 美国有线电视新闻网的背景
• 美国有线电视新闻网的基本层
• 分布式深层 CNN
• 深度学习的美国有线电视新闻网 4j

理解卷积

为了理解卷积的概念，让我们举一个例子，借助激光传感器来确定丢失手机的位置。假设手机在 t 时刻的当前位置可以由激光给出为 f (t) 。激光对 t 的所有数值给出不同的位置读数。激光传感器本质上通常是有噪声的，这对于这种情况是不希望的。因此，为了获得噪音较小的手机位置测量值，我们需要计算各种测量值的平均值。理想情况下，测量值越多，定位的精度就越高。因此，我们应该进行加权平均，为测量提供更多的权重。

加权函数可以由函数 w (b) 给出，其中 b 表示测量的年龄。为了推导出一个新的函数来更好地估计手机的位置，我们需要取每时每刻重量的平均值。

新函数可以如下给出:

前面的操作称为卷积。表示卷积的传统方法用星号或星号表示。

形式上，卷积可以定义为两个函数乘积的积分，其中一个函数被反转和移位。此外，取加权平均值，也可以用于其他目的。

就卷积网络术语而言，我们示例中的函数 f 被称为输入，函数 w 第二个参数被称为运算的内核。内核由多个过滤器组成，这些过滤器将用于输入以获得输出，称为特征图。以一种更方便的方式，内核可以被视为一个膜，它将只允许输入的期望特征通过它。图 3.1 显示了操作的示意图:

图 3.1:该图显示了卷积网络的简单表示，其中输入必须通过内核来提供特征图。

在实际场景中，如我们的示例所示，激光传感器无法真正提供每个给定时刻的测量值。理想情况下，当计算机处理数据时，它只在一些有规律的时间间隔内工作；因此，时间将是离散的。因此，传感器通常会在某个规定的时间间隔内提供结果。如果我们假设仪器每秒提供一次输出，那么参数 t 将只取整数值。有了这些假设，函数 f 和 w 将只为 t 的整数值定义。离散卷积的修正方程现在可以写成如下:

在机器学习或深度学习应用的情况下，输入通常是数据的多维数组，内核使用算法获取的不同参数的多维数组。基本假设是，函数的值仅在我们存储值的有限点集上非零，在其他地方为零。因此，无限求和可以表示为有限个数组元素范围的求和。例如，对于作为输入的 2D 图像 I 和对应的 2D 核 K ，卷积函数可以写成如下:

所以，有了这个，你已经有了卷积的一些背景。在本章的下一节，我们将讨论卷积在神经网络中的应用以及美国有线电视新闻网的组成部分。

美国有线电视新闻网的背景

CNN 作为深度学习模型的一种特殊形式，并不是一个新概念，长期以来被视觉社区广泛采用。该模型在 1998 年由 LeCun 等人提出的手写数字识别中运行良好[90]。但不幸的是，由于有线电视新闻网无法处理更高分辨率的图像，它的受欢迎程度随着时间的推移而下降。原因主要是硬件和内存限制，以及缺乏大规模训练数据集。随着计算能力随着时间的增加，主要是由于 CPU 和 GPU 的广泛可用性以及大数据的产生，各种大规模数据集，如 MIT Places 数据集(见周等，2014)，ImageNet [91]等。训练更大更复杂的模型成为可能。这最初由 Krizhevsky 等人[4]在他们的论文中显示，使用深度卷积神经网络进行 Imagenet 分类。在那篇论文中，他们用比传统方法低一半的方法降低了错误率。在接下来的几年里，他们的论文成为计算机视觉领域最具实质性的论文之一。这个由亚历克斯·克里哲夫斯基(Alex Krizhevsky)训练的流行网络，被称为 AlexNet，很可能是在计算机视觉领域使用深度网络的起点。

架构概述

我们假设读者已经熟悉了传统的神经网络。在这一部分，我们将看看美国有线电视新闻网的一般组成部分。

传统的神经网络接收单个向量作为输入，并通过一系列潜(隐)层达到中间状态。每个隐藏层由几个神经元组成，其中每个神经元都与前一层的所有其他神经元完全连接。最后一层称为“输出层”，是全连接的，负责班级成绩。由三层组成的规则神经网络如图图 3.2 :

图 3.2:该图显示了三层规则神经网络的框图。每一层的神经元都与前一层的每一层完全相连。

常规神经网络在处理大规模图像时面临巨大挑战。例如，在 CIFAR-10 RGB 数据库中，图像的维数为 32x32x3 ，因此，传统神经网络的第一隐藏层中的单个全连接神经元将具有 32323= 3072 数量的权重。权重的数量，虽然在一开始看起来是合理的，但是随着维度数量的增加，这将是一个非常麻烦的任务。对于另一幅 RGB 图像，如果维数变为( 300x300x3 )，神经元的总权重数将产生 3003003 = 270000 权重。此外，随着层数的增加，这个数字也将急剧增加，并将很快导致过度拟合。此外，图像的可视化完全忽略了图像的复杂 2D 空间结构。因此，从初始阶段开始，神经网络的全连接概念似乎不适用于更大维度的数据集。因此，我们需要建立一个模型来克服这两个限制:

图 3.3:CNN 在 3D 中的排列(宽度、高度和深度)如图所示。每层将神经元激活的 3D 输入体积转换为相应的 3D 输出体积。红色输入层保留图像，因此，它的宽度和高度是图像的尺寸，深度是三(红色、绿色和蓝色)。图片来源于维基百科。

解决这个问题的一种方法是用卷积代替矩阵乘法。从一组卷积滤波器(核)中学习要比从整个矩阵( 300x300x3 )中学习容易得多。与传统的神经网络不同，美国有线电视新闻网的各层神经元排列在三个维度上:宽度、高度和深度。图 3.3 显示了这种情况的表现。例如，在前面的 CIFAR-10 示例中，图像的尺寸为 32x32x3 ，分别为宽度、深度和高度。在美国有线电视新闻网中，一层中的神经元将只连接到前一层神经元的子集，而不是完全连接的神经元。这方面的细节将在本节的后续部分解释。此外，最终的输出层 CIFAR-10 图像将具有维度1x 10，因为 CNN 将把完整的图像缩小为类分数的单个向量，与深度维度一起放置。

CNN 的基本层

有线电视新闻网由一系列层组成，网络的每一层都通过一个可微分的函数将自己从一个激活体转换到另一个激活体。四种主要类型的层用于构建有线电视新闻网:卷积层、校正线性单元层、汇集层和全连接层。所有这些层堆叠在一起，形成一个完整的 CNN。

一个普通的美国有线电视新闻网可以有以下架构:

[输入- CONV - RELU 池- FC]

但是，在深度 CNN 中，这五个基本层之间一般会穿插更多的层。

经典的深度神经网络将具有以下结构:

输入-> conv-> rel-> conv-> rel->池-> rel-> conv-> rel->池->完全连接

前面提到的 AlexNet 可以作为这种结构的完美例子。AlexNet 的架构如图图 3.4 所示。在每一层之后，都添加了一个隐式的 ReLU 非线性。我们将在下一节详细解释这一点。

有人可能会想，为什么我们需要在一个 CNN 中有多层？本章的下一节也将对此进行解释:

图 3.4:图中显示了 AlexNet 的深度和重量。大括号内的数字表示上面写有尺寸的过滤器的数量。

深度在美国有线电视新闻网的重要性

在论文[96]中，作者提出了一些统计数据，以显示深度网络如何帮助获得更高的输出精度。如前所述，克里哲夫斯基等人的架构模型使用八层，在 ImageNet 上进行训练。当完全连接的顶层(第 7 层)被移除时，它会丢弃大约 1600 万个参数，性能下降 1.1%。此外，当移除最上面的两层(第 6 层和第 7 层)时，近 5000 万个参数会随着性能下降 5.7%而减少。同样，当移除上部要素提取器图层(第 3 层和第 4 层)时，会导致约 100 万个参数下降，性能下降 3.0%。为了更好地了解场景，当移除上层要素提取器图层和完全连接的(第 3、第 4、第 6 和第 7)图层时，模型只剩下四个图层。在这种情况下，性能会下降 33.5%。

因此，很容易得出结论，我们需要深度卷积网络来提高模型的性能。然而，如前所述，由于内存和性能管理的限制，深度网络在集中式系统中极难管理。因此，需要一种分布式的方式来实现深度 CNN。在本章的后续章节中，我们将解释如何在 Deeplearning4j 的帮助下实现这一点，并将该处理与 Hadoop 的 SHARE 相集成。

卷积层

如架构概述所示，卷积的主要目的是允许模型在特定时间使用有限数量的输入。此外，卷积支持三个最重要的特征，这大大有助于提高深度学习模型的性能。功能如下:

• 稀疏连通性
• 参数共享
• 等变表示

我们现在将依次描述这些特性。

稀疏连通性

如已经解释的，传统网络层使用矩阵乘以参数矩阵，不同的参数描述每个输出单元和输入单元之间的交互。另一方面，中枢神经系统为此使用稀疏连接，有时称为稀疏交互或稀疏权重。这个想法是通过保持内核的大小小于输入来实现的，这有助于降低算法的时间复杂度。例如，对于大型图像数据集，图像可能有数千或数百万像素；然而，我们可以从核中识别图像的小而重要的特征，例如边缘和轮廓，这些特征只有数百或数十个完整的像素。因此，我们只需要保留少量参数，这反过来有助于降低模型和数据集的内存需求。这个想法还减少了操作的数量，这可以提高整体计算能力。这反过来又极大地降低了计算的运行时间复杂度，最终提高了效率。图 3.5 示意性地显示了如何使用稀疏连接方法，我们可以减少每个神经元的感受野数量。

注

卷积层中的每个神经元呈现前一层中应用的滤波器的响应。这些神经元的主要目的是通过一些非线性传递响应。应用该滤波器的前几层的总面积称为该神经元的感受野。所以，感受野总是相当于过滤器的大小。

图 3.5:该图显示了 M 的输入单位如何影响具有稀疏连通性的输出单位 N3。与矩阵乘法不同，稀疏连接方法中的感受野数量从五个减少到三个(M2、M3 和 M4)。箭头也表示参数共享方法。模型中一个神经元的连接被两个神经元共享

因此，利用稀疏连接方法，每一层的感受野比使用矩阵乘法方法的感受野小。然而，需要注意的是，对于深层中枢神经系统，单位的感受野实际上大于相应浅层网络的感受野。原因是深层网络中的所有单元都间接连接到网络的几乎所有神经元。图 3.6 展示了这样一个场景的可视化表示:

图 3.6:卷积神经网络深层稀疏连通性的表示。与图 3.5 不同，在图 3.5 中，单位 N3 有三个感受野，而在这里，N3 的感受野数量增加到了五个。

时间复杂度提高

类似于上一节给出的例子，如果一层中有 p 输入和 q 输出，那么矩阵乘法将需要 (pq)* 个数的参数。算法的运行时间复杂度将变为 O (pq)* 。在稀疏连接方式下，如果我们将每个输出关联的上限连接数限制为 n ，那么它将只需要 nq* 个参数，运行时复杂度将降低到 O (nq)* 。对于许多实际应用，稀疏连接方法为深度学习任务提供了良好的性能，同时保持了 n < < p 的大小。

参数共享

参数共享可以定义为一个函数的相同参数可以用于模型中多个函数的过程。在常规神经网络中，当计算层的输出时，权重矩阵的每个元素仅应用一次。权重乘以输入的一个元素，但永远不会被重新访问。参数共享也可以称为绑定权重，因为用于一个输入的权重值与用于其他输入的权重值绑定在一起。图 3.5 也可以看做参数共享的例子。例如，来自 M2 的特定参数与 N1 和 N3 一起使用。

该操作的主要目的是控制卷积层中自由参数的数量。在有线电视新闻网中，内核的每个元素几乎都用在输入的每个位置。对此的一个逻辑假设是，如果其中一个特征在某个空间位置是所期望的，那么也应该有必要计算其他位置。

由于单个深度切片的所有元素共享相同类型的参数化，卷积层的每个深度切片中的前向通过可以被测量为具有神经元权重的输入体积的卷积。这种卷积的结果是激活图。这些激活图的集合与深度维度的关联堆叠在一起，以产生输出体积。尽管参数共享方法赋予了 CNN 体系结构的平移不变性，但它并没有增强前向传播的运行时间。

提高空间复杂度

在参数共享中，模型的运行时间仍然保持 O (nq)* 。然而，它有助于显著降低整体空间复杂性，因为模型的存储需求减少到 n 个参数。由于 p 和 q 一般大小相似，因此 n 的值与 pq* 相比几乎可以忽略不计。

注

就时间复杂度和空间复杂度而言，卷积比传统的密集矩阵乘法要高效得多。

等变表示

在卷积层中，由于参数共享，层具有称为平移等方差的特性。等变函数被定义为其输出与输入变化方式相同的函数。

从数学上讲，如果 X 和 Y 都属于同一个组 G，那么如果中的 f (g.x) = g.f(x)表示所有的GT7】T8】G和所有的 x 在 X 中，那么函数f:XY就是等变的。

在卷积的情况下，如果我们取 g 为任意函数，该函数将输入移位相等的幅度，那么卷积函数与 g 等变。例如，让 I 成为给任意偶数坐标赋予图像颜色的函数。设 h 为另一个函数，将一个图像函数映射为另一个图像函数，由下式给出:

I^/T3】是将 I 的每个像素向右移动 5 个单位的图像功能。因此，我们有以下几点:

现在，如果我们将此翻译应用于 I ，然后是卷积，当我们将卷积应用于 I ^/ ，然后是变换函数 h 到输出时，结果将完全相同。

在图像的情况下，卷积运算生成输入中存在的所有确定特征的二维图。因此，类似于前面的例子，如果我们将输出中的对象移动某个固定的比例，输出表示也将以相同的比例移动。这个概念在某些情况下是有用的；例如，考虑两个不同队的板球运动员的合影。我们可以在图像中找到球衣的一些共同特征来检测一些球员。现在，类似的特征显然也会出现在其他人的 t 恤上。因此，在整个图像中共享参数是非常实用的。

卷积还有助于处理一些特殊类型的数据，用传统的固定形状矩阵乘法很难，甚至不可能。

选择卷积层的超参数

到目前为止，我们已经解释了卷积层中的每个神经元是如何连接到输入体积的。在本节中，我们将讨论控制输出音量大小的方法。换句话说，控制输出音量中神经元的数量，以及它们是如何排列的。

基本上，有三个超参数控制卷积层的输出体积的大小。它们是:深度、步幅和零填充。

我们如何知道我们应该使用多少卷积层，滤波器的大小应该是多少，或者步幅和填充的值是多少？这些都是非常主观的问题，它们的解决方案本质上一点也不琐碎。没有研究人员设置任何标准参数来选择这些超参数。神经网络通常在很大程度上取决于用于训练的数据类型。这些数据的大小、输入原始图像的复杂性、图像处理任务的类型以及许多其他标准都可能不同。通过查看大数据集，一个总的思路是，必须考虑如何选择超参数来推导正确的组合，从而以适当的比例创建图像的抽象。我们将在这一小节中讨论所有这些。

深度

在输出音量中，深度被认为是一个重要参数。深度对应于我们希望对输入中的一些变化的每次学习迭代应用的过滤器的数量。如果第一卷积层将原始图像作为输入，那么在存在各种颜色斑点或不同方向边缘的情况下，沿着深度维度的多个神经元可能会激活。同一输入区域中的神经元集合被称为深度列。

跨步

Stride 指定围绕空间维度(宽度和高度)分配深度列的策略。它基本上控制滤波器如何围绕输入音量进行卷积。步幅可以正式定义为卷积过程中滤波器移动的量。理想情况下，stride 的值应该是整数，而不是分数。从概念上来说，这个量有助于决定在进入下一层之前想要保留多少输入图像信息。步幅越大，为下一层保留的信息就越多。

例如，当步幅为 1 时，新的深度列被分配给空间位置，相隔一个空间单位。由于两列之间的感受野高度重叠，这就产生了大量的输出。另一方面，如果步幅值增加，感受野之间的重叠将减少，这导致空间上更小的维度输出体积。

我们将举一个例子来进一步简化这个概念。让我们想象一个 77* 的输入音量和一个 33* 的滤波器(为了简单起见，我们将忽略第三维度)，步幅为 1 。这种情况下的输出音量为尺寸 55* ，如图 3.7 所示。然而，这看起来有些简单。现在，在步幅 2 的情况下，保持其他参数不变，输出音量将具有较少的顺序维度 33* 。在这种情况下，感受野将移动 2 个单位，因此，体积将缩小到 33* 的尺寸:

图 3.7:说明滤波器如何将 7x7 的输入音量与步幅 1 卷积，从而产生 5x5 的输出音量。

这在图 3.8 中有说明。所有这些计算都基于本节下一个主题中提到的一些公式。现在，如果我们想将步幅进一步增加到 3 ，我们将很难确定间距并确保感受野适合输入音量。理想情况下，只有当需要较少的感受野重叠，并且需要较小的空间维度时，程序员才会提高步幅值:

图 3.8:说明滤波器如何将 7x7 的输入音量与步幅 2 卷积，从而产生 3×3 的输出音量。

零填充

我们已经获得了足够的信息来推断，随着我们不断对输入音量应用更多的卷积层，输出音量的大小会进一步减小。然而，在某些情况下，我们可能希望保留关于原始输入体积的几乎所有信息，以便我们也可以提取低级特征。在这种情况下，我们在输入体积的边界周围用零填充输入体积。

这种大小的零填充被认为是一个超参数。它可以定义为一个超参数，在我们希望精确保留输入体积的空间大小的场景中，它直接用于控制输出体积的空间大小。

例如，如果我们将 553 滤波器应用于 32323 输入音量，输出音量将降低到 28283 。但是，假设我们想要使用相同的卷积层，但是需要将输出音量保持在 32323 。我们将使用尺寸为 2 的零填充来填充该层。这将给出 36363 的输出音量，如下图所示。现在，如果我们用 553 滤波器应用三个卷积层，它将产生 32323 的输出体积，从而保持输入体积的精确空间大小。图 3.9 为场景示意图:

图 3.9:输入体积的尺寸为 32323。零的两个边框将生成 36363 的输入体积。卷积层的进一步应用，具有三个尺寸为 553 的滤波器，步长为 1，将产生 32323 的输出音量。

超参数的数学表达式

本章的这一部分将介绍一个公式，用于根据我们到目前为止讨论的超参数来计算输出体积的空间大小。这个方程对于为美国有线电视新闻网选择超参数非常有用，因为这些是“适合”网络中神经元的决定因素。输出音量的空间大小可以写成输入音量大小( W )、感受野大小或卷积层神经元的滤波器大小( K )、施加的步幅值( S )和边界上使用的零填充量( P )的函数。

计算输出体积空间大小的公式可以写成如下:

考虑到图 3.7 和图 3.8 中给出的例子，其中 W=7 ， K=3 ，无填充， P =0 。对于跨步 1 ，我们有 S=1 ，这将给出以下内容:

类似地，对于步幅 2 ，等式将给出 2 的值:

因此，如图 3.7 中的所示，我们将得到一个空间大小为 3 的输出。然而，在这种配置下，当应用 3 的步幅时，它将不适用于整个输入音量，因为该等式将为输出音量返回一个小数值 2.333 :

*

这也意味着超参数的值具有相互约束。前面的示例返回一个小数值，因此，超参数将被认为是无效的。但是，我们可以通过在边框周围添加一些零填充来解决这个问题。

注

超参数的空间排列相互制约。

补零效果

如零填充部分所述，它的主要目的是将输入音量的信息保留到下一层。为了确保输入和输出音量的空间大小相同，传统的零填充公式为:跨步 S=1 :

以图 3.9 给出的例子，可以验证公式的真实性。在示例中， W = 32 ， K=5 ，以及 S=1 。因此，为了确保空间输出音量等于 32，我们选择零填充的数量如下:

因此，当 P=2 时，输出音量的空间大小如下:

因此，这个等式很好地保持了输入体积和输出体积的相同空间维度。

ReLU(校正线性单位)层

在卷积层，系统基本上通过逐元素乘法和求和来计算线性运算。深度卷积通常执行卷积运算，然后在每一层之后进行非线性运算。这是必不可少的，因为级联线性运算会产生另一个线性系统。在层与层之间添加非线性证实了模型比线性模型更具表达性。

因此，在每个卷积层之后，激活层被应用于当前输出。因此，这个激活层的主要目的是给系统引入一些非线性。现代中枢神经系统使用整流线性单元 ( ReLu )作为激活功能。

在人工神经网络中，激活函数整流器定义如下:

其中 x 是神经元的输入。

操作整流器的单元称为 ReLU。此前，网络中使用了许多非线性函数，如 tan h 、sigmoid 等，但在最近几年，研究人员发现 ReLU 层工作得更好，因为它们有助于网络更快地训练，而不会影响结果的准确性。计算效率的显著提高是一个主要因素。

此外，该层增强了模型和其他整体网络的非线性特性，而不会对卷积层的感受野产生任何影响。

最近，在 2013 年，Mass 等人[94]引入了非线性的一个新版本，称为泄漏-ReLU。泄漏-ReLU 可以定义如下:

其中是预定参数。后来，在 2015 年，何等人[95]更新了这个方程，提出参数μ也可以训练，这导致了一个大大改进的模型。

*### ReLU 相对于乙状结肠功能的优势

ReLU 有助于缓解消失梯度问题，在第 1 章、深度学习入门中有详细说明。ReLU 将上述功能 f(x) 应用于输入音量的所有值，并将所有负激活转换为 0 。对于最大函数，梯度定义如下:

然而，对于 Sigmoid 函数，当我们增加或减少 x 的值时，梯度趋于消失。

Sigmoid 函数如下所示:

Sigmoid 函数的范围为[ 0，1 ，而 ReLU 函数的范围为[ 0，﹍T4】。因此，应用 Sigmoid 函数对概率进行建模，而 ReLU 可以对所有正数进行建模。

汇集层

这一层是 CNN 的第三阶段。稍后应用一些校正线性单元后，程序员可能会选择应用池层。该层也可以称为下采样层。

池功能基本上用于进一步修改图层的输出。该层的主要功能是用相邻输出的汇总统计数据替换某个位置的网络输出。这一层有多种选择，最大池是最受欢迎的一种。最大池操作[93]在矩形邻域内操作，并报告其最大输出。最大池基本上取一个过滤器(一般大小为 2x2 )和相同长度的步幅，即 2 。然后将滤波器应用于输入音量，并在滤波器卷积的每个区域输出最大值。图 3.10 显示了同一事物的表现。汇集图层的其他流行选项包括矩形邻域的 L2 法线的平均值、矩形邻域的平均值或基于距中心像素距离的加权平均值:

图 3.10:具有 2*2 过滤器和跨距 2 的最大池示例。图片来源于维基百科。

注

如果我们感兴趣的是邻近的特征，而不是特征的确切位置，那么对局部平移的不变性是非常有益的。

哪里有用，哪里没有？

池层背后的直观原因是，一旦知道了原始输入卷的某个特定特征，与它相对于其他特征的位置相比，它的确切位置就变得微不足道了。在池的帮助下，对于输入的小翻译，表示变得几乎不变。对翻译的不变性意味着，对于输入端的少量翻译，大部分合并输出的值没有显著变化。

如果我们感兴趣的是邻近的特征而不是特征的确切位置，那么对于局部平移的不变性是非常有益的。但是，在处理计算机视觉任务时，需要谨慎使用 Pooling 层。尽管集中有助于降低模型的复杂性，但最终可能会失去模型的位置敏感性。

让我们举一个图像处理的例子，它包括识别图像中的一个框。在这种情况下，如果我们简单地以确定图像中框的存在为目标，池层将有所帮助。但是，如果问题陈述更关心定位盒子的确切位置，那么在使用 Pooling 层时，我们必须足够小心。作为另一个例子，假设我们正在研究一个语言模型，并且对识别两个单词之间的上下文相似性感兴趣。在这种情况下，使用池层是不可取的，因为它会损失一些有价值的特征信息。

因此可以得出结论，Pooling 层基本上是用来降低模型的计算复杂度的。池层更像是一个平均过程，我们对一组相邻要素更感兴趣。该层可以应用于我们可以放弃一些本地化信息的场景。

全连接层

全连接层是 CNN 的最后一层。该层的输入量来自前面的卷积层、ReLU 或池层的输出。完全连接的图层接受该输入并输出一个 N 维向量，其中 N 是初始输入数据集中存在的不同类别的数量。全连接层的基本思想是，它处理从前面一层接收到的输出，并识别与特定类最相关的特定特征。例如，如果模型正在预测图像是否包含猫或鸟，它将在激活图中具有高值，这将分别表示一些高级特征，例如四条腿或翅膀。

分布于美国有线电视新闻网深部

本章的这一部分将介绍一些极具侵略性的深度 CNN 架构，这些网络面临的相关挑战，以及需要更大规模的分布式计算来克服这些挑战。本节将解释 Hadoop 及其 Yarn 如何为这个问题提供足够的解决方案。

最流行的攻击性深度神经网络及其配置

近年来，中枢神经系统在图像识别方面取得了惊人的成果。然而，不幸的是，它们的训练成本极高。在顺序训练过程的情况下，卷积运算占用了总运行时间的大约 95%。对于大数据集，即使是小规模的分布式训练，训练过程也需要很多天才能完成。获奖的美国有线电视新闻网，2012 年的 AlexNet 和 ImageNet，用了将近一整周的时间来训练两个 GTX 580 3 GB 的图形处理器。下表显示了几个最流行的分布式深层中枢神经系统及其配置，以及完成培训过程所需的相应时间:

| **车型** | **计算能力** | **数据集** | **深度数** | **训练过程所用时间** | | 阿勒克斯网 | 两个英伟达 GTX 580 3 GB 图形处理器 | 对网络进行 ImageNet 数据培训，其中包含来自 22，000 多个类别的 1，500 多万张高分辨率图像。 | 八层 | 五到六天。 | | ZFNet [97] | GTX 580 GPU | 130 万张图片，分布在 1000 个不同的班级。 | 八层 | 十二天。 | | VGG Net [98] | 4 个英伟达泰坦黑色图形处理器 | 该数据集包括 1000 个类别的图像，并分为三个集合:训练(1.3 M 图像)、验证(50 K 图像)和测试(100 K 图像，带有伸出的类别标签)。 | 19 层 | 两到三周。 | | GoogLeNet [99] | 一些高端图形处理器 | 一百二十万训练用图像。 | 当只计算带参数的层时，网络有 22 层深(如果我们也计算池，则为 27 层)。用于构建网络的总层数(独立构建模块)约为 100 层。 | 一周内。 | | 微软 ResNet [100] | 8 GPU 机器 | 在 128 万张训练图像上进行训练，在 50k 张验证图像上进行评估。 | 152 层。 | 两到三周。 |

训练时间-与深度神经网络相关的主要挑战

从上表中，可以肯定地推断，研究人员已经做了大量的努力来提高结果的准确性。从表中得出的一个关键点是，层数已经成为提高精度的主要标准之一。微软的 Resnet 使用了一个深度达 152 层的神经网络，结果是一个极具攻击性的深度神经网络。这种架构在 2015 年通过深度 CNN 在分类、本地化和检测方面创造了许多新记录。除此之外，ResNet 还以令人难以置信的改进赢得了 ILSVRC 2015，错误率仅为 3.6%。

尽管深度卷积网络几乎即将达到预期的准确性，但几乎所有这些深度中枢神经系统中的主要问题是表中最右边的一列。因此，它表明，当前训练深度中枢神经系统的挑战是建立一个大规模的分布式框架，以在快速互联的网络上并行化多个中央处理器和图形处理器的训练。

深度中枢神经系统的 Hadoop

在本节中，我们将解释如何使用 Hadoop 来大规模分发深度模型，以加快处理速度。

氯化萘的运行时间可分为两大类:

• 网络中存在的所有卷积层消耗大约 90-95%的计算。它们使用大约 5%的参数，并且具有大的表示。[101]
• 其余的计算，大约 5-10%，由完全连接的层进行。它们使用了几乎 95%的参数，并且具有小的表示。

Alex Krizhevsky 在[101]中提出了一种使用分布式架构训练 CNN 的算法。在传统的 CNN 中，卷积运算本身消耗了整个过程几乎全部的运行时间；因此，数据并行应该用于更快的训练。但是，对于完全连接的层，建议使用模型并行方法。我们将在本章的这一部分解释使用 Hadoop 及其 Yarn 的算法。

在 Hadoop 中，分布式系统工作人员坐在 HDFS 的每个区块上，并行同步处理数据。我们将从原始输入图像中使用 1024 个示例的小批量大小，这些示例将被分成 N 个多个块 Hadoop 分布式文件系统 ( HDFS )。所以，总的来说 N 工人将为每一小批数据工作。HDFS 的区块大小将保持为大小 K 。现在 K 应该多大？虽然小尺寸的 K 会增加块的数量，有助于使训练更快，但大量的 N 最终也会增加驻留在名称节点中的元数据的数量。这种情况下的一个主要缺点是 Hadoop [81]的单点故障 ( SPOF )，这更容易导致 NameNode 的主内存变小。但是 K 值越大，我们得到的 HDFS 街区数量就越少，因此并行工作的工人数量就越少。这将再次使训练过程变慢。因此，选择 K 尺寸的更好方法主要取决于以下三个因素:

• 名称节点的主内存大小的可用性。
• 输入批处理的大小和对每个数据块执行的操作的复杂性。
• 数据的中间结果有多重要或有价值。基于这些标准，我们可以设置复制因子。但是，复制因子越高，名称节点的负载就越高。

HDFS 的数据块分布在 Hadoop 的所有数据节点上，Yarn 将直接在这些数据节点上并行操作。

卷积层的分布式训练步骤如下:

1. 每个 N 块从原始输入图像中被给予不同的 1024 个例子的小数据批次。
2. 对 N 个块中的每一个应用相同大小的滤波器和步长，这导致基于输入值的单独空间输出。
3. ReLU 被同步地、并行地应用于所有这些，以在结果中获得一些非线性。
4. 如果需要，最大池或任何其他下采样算法将根据结果的必要性应用于这些单独的数据块。
5. N 块的每次迭代的输出(变换参数)被发送回称为资源管理器的主节点，在那里它们的参数被平均。新更新的参数被发送回每个 N 块以再次执行动作。
6. 对预定数量的时期重复步骤 2 至 5。

对于完全连接的层，在小批量输入图像的任何一个 N 数据块上工作的一个 N 数量的工人将把最后阶段的卷积活动发送给所有其他( N-1 )数量的工人。然后，工作人员将对这批 1024 个示例执行完全连接操作，然后开始反向传播这 1024 个示例的梯度。与此操作并行的下一个工作器将把它的最后一级卷积层活动发送给其他工作器，类似于前面的情况。工人们将再次进行第二批 1024 个例子的全连接活动。这个过程将反复进行，直到我们以期望的最小误差得到结果。

在这种方法中，工人将他们最后一级卷积层的信息广播给所有其他工人。这种方法的主要好处是可以抑制很大比例( (N-1)/N )的通信，并且可以与全连接层的计算并行运行。该方法在网络通信方面非常有利。

因此，很明显，借助 HDFS 和 Hadoop Yarn，Hadoop 可以为美国有线电视新闻网提供一个分布式环境。

现在，我们已经熟悉了用 Hadoop 并行分发模型的方法，下一部分将讨论每个工人在 HDFS 的每个区块上操作的编码部分。

使用深度学习的卷积层 4j

本章的这一部分将提供如何使用 Deeplearning4j 为 CNN 编写代码的基本思路。您将能够学习使用本章中提到的各种超参数的语法。

为了使用 Deeplearning4j 实现 CNN，整个想法可以分为三个核心阶段:加载数据或准备数据、网络配置以及模型的训练和评估。

加载数据

对于中枢神经系统，通常我们只处理图像数据来训练模型。在深度学习 4j 中，可以使用ImageRecordReader读取图像。以下代码片段显示了如何为模型加载16° 16彩色图像:

RecordReader imageReader = new ImageRecordReader(16, 16, false);
imageReader.initialize(new FileSplit(new      
File(System.getProperty("user.home"), "image_location")));

之后，使用CSVRecordReader，我们可以从输入的 CSV 文件中加载所有的图像标签，如下所示:

int numLinesToSkip = 0;
String delimiter = ",";
RecordReader labelsReader = new    
CSVRecordReader((numLinesToSkip,delimiter);
labelsReader.initialize(new FileSplit(new   
File(System.getProperty("user.home"),"labels.csv_file_location"))

为了组合图像和标签数据，我们可以使用ComposableRecordReader。ComposableRecordReader在我们需要合并来自多个来源的数据的情况下也是有益的:

ComposableRecordReader(imageReader,labelsReader);

类似地，在某些情况下，如果有人需要将 MNIST 数据集加载到模型中，而不是 imageset 为此，我们可以使用以下部分。本例使用12345的随机数种子:

DataSetIterator mnistTrain = new      
MnistDataSetIterator(batchSize,true,12345);
DataSetIterator mnistTest = new     
MnistDataSetIterator(batchSize,false,12345);

车型配置

操作的下一部分是配置 CNN。Deeplearning4j 提供了一个简单的构建器来逐层定义深度神经网络，设置不同的所需超参数:

MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder() MultiLayerConfiguration.Builder builder = new  
NeuralNetConfiguration.Builder() 
.seed(seed) 
.iterations(iterations)
.regularization(true)
.l2(0.0005) 
.learningRate(0.01)

第一层，卷积层，可以使用ConvolutionLayer.Builder方法调用。.build()功能用于构建图层。.stride()用于设置卷积层的步距:

.layer(0, new ConvolutionLayer.Builder(5, 5)

nIn和nOut表示深度。nIn这里是nChannels，nOut是卷积要应用的滤波器数量:

.nIn(nChannels)
.stride(1, 1)
.nOut(20)

要将身份函数添加为激活函数，我们将以这种方式定义它:

.activation("identity")
.build())

要添加最大池类型的池层，我们将在第一层之后调用SubsamplingLayer.Builder()方法:

.layer(1, new SubsamplingLayer.Builder(SubsamplingLayer.PoolingType
.MAX)
.kernelSize(2,2)
.stride(2,2)
.build())

通过调用新的DenseLayer.Builder().activation("relu")可以添加整流器线性单元 ( ReLU )层:

.layer(4, new DenseLayer.Builder().activation("relu")
.nOut(500).build())

模型可以通过调用init()方法进行初始化，如下所示:

MultiLayerNetwork model = new MultiLayerNetwork(getConfiguration());
model.init();

培训和评估

如前一节所述，对于训练部分，我们需要将整个大数据集分成多个批次。然后，该模型将在 Hadoop 中逐个处理这些批次。假设我们将数据集分成 5，000 个批次，每个批次的大小为 1024 个示例。然后，这 1024 个例子将被分成多个区块，工人们将在这些区块中并行工作。大数据集的拆分操作使用RecordReaderDataSetIterator()方法完成。让我们首先初始化调用方法所需的参数，如下所示:

int batchSize = 1024; 
int seed = 123;
int labelIndex = 4; 
int iterations = 1

让图像中的类总数为10:

int numClasses = 10;

现在，由于我们已经设置了RecordReaderDataSetIterator()的参数数量，我们可以调用方法来设置训练平台:

DataSetIterator iterator = new RecordReaderDataSetIterator(recordReader,batchSize,labelIndex,numClasses);
DataSet batchData= iterator.next();
batchData.shuffle();

在训练阶段，我们可以将批次随机分成训练和测试数据集。如果我们想要 70 个样本用于训练集，其余 30 个样本用于测试集，我们可以使用以下方法设置此配置:

SplitTestAndTrain testAndTrain = batchData.splitTestAndTrain(0.70); 
DataSet trainingData = testAndTrain.getTrain();
DataSet testData = testAndTrain.getTest();

trainAndTest =batchData.splitTestAndTrain(0.70);
trainInput = trainAndTest.getTrain();                

testInput.add(trainAndTest.getTest().getFeatureMatrix());

当模型被完全训练后，对于每个批次，可以保存测试数据，以便验证模型。因此，通过只定义Evaluation类的一个对象，我们将能够收集整个数据集的统计数据:

Evaluation eval = new Evaluation(numOfClasses);
for (int i = 0; i < testInput.size(); i++) 
{
 INDArray output = model.output(testInput.get(i));
 eval.eval(testLabels.get(i), output);
}

这个模型现在已经完全可以训练了。这可以通过调用fit()方法来完成，如下所示:

model.fit(trainInput);

总结

有线电视新闻网虽然不是一个新概念，但在过去五年里获得了巨大的普及。该网络主要应用于视觉领域。在过去的几年里，谷歌、微软、苹果等各种科技公司以及各种知名研究人员对美国有线电视新闻网进行了一些重大研究。本章从一开始就讲了卷积的概念，卷积是这类网络的主干。接下来，本章将介绍该网络的各个层。然后它为深层 CNN 的每一个相关层提供了深入的解释。然后，从理论和数学上解释了各种超参数及其与网络的关系。随后，本章讲述了如何借助 Hadoop 及其 Yarn 在各种机器上分发深度有线电视新闻网的方法。最后一部分讨论了如何使用 Deeplearning4j 为每个工作在 Hadoop 每个块上的工作人员实现这个网络。

在下一章中，我们将讨论另一种流行的深度神经网络，称为循环神经网络。循环神经网络最近获得了巨大的普及，主要是因为它能够对可变长度的序列进行建模。到目前为止，该网络已成功应用于语言建模、手写识别、语音识别等不同领域。***

四、循环神经网络

|   | 我认为大脑本质上是一台计算机，意识就像一个计算机程序。当计算机关闭时，它将停止运行。理论上，它可以在神经网络上重建，但这将非常困难，因为它需要一个人的所有记忆。 |   |
|   | - 斯蒂芬·霍金 |

为了解决每一个问题，人们不会从头开始思考。我们的思想是非易失性的，它就像电脑的只读存储器 ( ROM )一样持久。当我们阅读一篇文章时，我们从对句子中较早单词的理解中理解每个单词的意思。

让我们用一个真实的例子来解释一下这个背景。假设我们想根据视频中每一点发生的事件进行分类。由于我们没有视频早期事件的信息，对于传统的深度神经网络来说，找到一些有区别的原因来对这些事件进行分类将是一项麻烦的任务。传统的深度神经网络不能执行这种操作，因此，它一直是它们的主要限制之一。

循环神经网络(RNN)【103】是一种特殊类型的神经网络，它为这些困难的机器学习和深度学习问题提供了许多谜一样的解决方案。在最后一章中，我们讨论了卷积神经网络，它专门处理一组值 X (例如，图像)。同样，rnn 在处理一系列值时也很神奇， x (0) 、 x (1) 、 x(2) 、...， x(τ-1) 。在本章中，首先让我们将这个网络放在卷积神经网络旁边，这样您就可以了解它的基本功能，并基本了解这个网络。

卷积神经网络可以很容易地缩放到具有大宽度、高度和深度的图像。此外，一些卷积神经网络也可以处理不同大小的图像。

相比之下，递归网络可以很容易地扩展到长序列；此外，其中大多数也可以处理可变长度序列。为了处理这些任意的输入序列，RNN 使用了它们的内部记忆。

rnn 通常对小批量序列进行操作，并且包含向量 x (t) ，时间步长指数 t 的范围从 0 到 (τ-1) 。序列长度 τ 对于小批量的每个成员也可以变化。这个时间步长索引不应该总是指现实世界中的时间间隔，也可以指序列内部的位置。

一个 RNN，当及时展开时，可以被看作是一个具有无限层数的深层神经网络。然而，与普通的深度神经网络相比，神经网络的基本功能和体系结构有些不同。对于 RNNs，层的主要功能是引入内存，而不是分层处理。对于其他深度神经网络，输入仅在第一层提供，输出在最后一层产生。然而，在无线网络中，输入通常在每个时间步长接收，相应的输出在这些时间间隔计算。随着每一次网络迭代，新的信息被集成到每一层中，网络可以随着这些信息进行无限次数的网络更新。然而，在训练阶段，反复出现的权重需要学习他们应该向前传递哪些信息，以及他们必须拒绝什么。这个特征产生了一种特殊形式的 RNN 的主要动机，叫做长短期记忆 ( LSTM )。

RNNs 在几十年前就开始了它的旅程[104]，但是最近，它已经明显成为建模可变长度序列的流行选择。截至目前，RNN 已经成功实现在各种问题中，如学习单词嵌入[105]、语言建模[106] [107] [108]、语音识别[109]和在线手写识别[110]。

在本章中，我们将讨论您需要了解的关于 RNN 和相关核心组件的一切。我们将在本章后面介绍龙的短时记忆，它是的一种特殊类型。

本章的主题组织如下:

• 是什么让循环网络与众不同？
• 循环神经网络
• 穿越时间的反向传播(BPTT)
• 长短期记忆(LSTM)
• 双向无线网络
• 分布式深层 RNNs
• 深度学习的无线网络 4j

是什么让递归网络与众不同？

你可能很想知道 RNNs 的专业。本章的这一节将讨论这些事情，从下一节开始，我们将讨论这种网络的构建模块。

从第三章、卷积神经网络中，你大概已经感受到了卷积网络的苛刻限制，以及它们的 API 过于受限；网络只能接受固定大小向量的输入，并且还会生成固定大小的输出。此外，这些操作通过预定数量的中间层来执行。RNNs 区别于其他 RNNs 的主要原因是它们能够操作长序列的向量，并产生不同序列的向量作为输出。

|   | “如果训练普通神经网络是对函数的优化，那么训练递归网络就是对程序的优化” |   |
|   | - 亚历克斯·勒布朗 |

我们在图 4.1 中展示了不同类型的神经网络的输入输出关系，以描述差异。我们展示了如下五种类型的投入产出关系:

• 一对一:这种输入输出关系是针对传统的神经网络处理，没有 RNN 的参与。主要用于图像分类，其中映射是从固定大小的输入到固定大小的输出。
• 一对多:在这种关系中，输入和输出保持一对多的关系。该模型用一个固定大小的输入生成一系列输出。经常观察模型拍摄图像(图像标题)，并产生一句话。
• 多对一:在这种类型的关系中，模型取一个输入序列，输出一个单一的观测值。例如，在情感分析的情况下，向模型提供一个句子或评论；它将句子分为积极情绪或消极情绪。
• 多对多(可变中间状态):模型接收一系列输入，生成相应的一系列输出。在这种类型中，RNN 读一个英语句子，然后翻译并输出一个德语句子。用于机器翻译的情况。
• 多对多(中间状态的固定数量):模型接收同步的输入序列，并生成输出序列。例如，在视频分类中，我们可能希望对电影的每个事件进行分类。

图 4.1:图中的矩形表示序列向量的每个元素，箭头表示函数。输入向量以红色显示，输出向量以蓝色显示。绿色代表中间的 RNN 状态。图片取自[111]。

涉及序列的操作通常比具有固定大小的输入和输出的网络更强大和更有吸引力。这些模型用于构建更智能的系统。在接下来的部分中，我们将看到 RNNs 是如何构建的，以及网络如何将输入向量及其状态向量与定义的函数结合起来，以生成新的状态向量。

循环神经网络

在这一节中，我们将讨论 RNN 的建筑。我们将讨论递归关系的时间是如何展开的，并用于在 RNNs 中执行计算。

展开循环计算

本节将解释展开递归关系如何导致在深层网络结构中共享参数，并将其转换为计算模型。

让我们考虑一个简单的动力系统的循环形式:

在上式中， s ^(t) 代表系统在时间 t 的状态， θ 是所有迭代中共享的相同参数。

这个方程叫做递归方程，因为 s ^(t) 的计算需要 s ^(t-1) 返回的值， s ^(t-1) 的值将需要 s ^(t-2) 的值，以此类推。

出于理解的目的，这是动态系统的简单表示。再举一个例子，动力系统由外部信号 x ^(t) 驱动，产生输出 y ^(t) :

理想情况下，RNNs 遵循第二类方程，其中中间状态保留了整个过去序列的信息。然而，任何涉及递归的方程都可以用来模拟 RNN。

因此，类似于前馈神经网络，可以使用变量 h 在时间 t 定义 RNNs 的隐藏(中间)层的状态，如下所示:

在本节的下一部分，我们将在 RNN 中解释前面这个等式的功能。到目前为止，为了说明这个隐藏层的功能，图 4.2 显示了一个没有输出的简单递归网络。图的左侧显示了当前状态影响下一个状态的网络。循环中间的方框表示两个连续时间步长之间的延迟。

如前面的循环方程所示，我们可以及时展开或展开隐藏的状态。图像的右侧显示了循环网络的展开结构。在那里，随着时间的推移，网络可以被转换成前馈网络。

在展开的网络中，每个时间步长的每个变量都可以显示为网络的一个独立节点。

图 4.2:图的左半部分显示了信息通过隐藏层以每个时间步长多次传递的循环网络。右边是同一个网络的展开结构。该网络的每个节点都与一个时间戳相关联。

因此，从图 4.2 中，展开操作可以定义为执行左侧电路到右侧分割成多个状态的计算模型的映射的操作。

模型的优势及时展现

及时展开网络有以下几个主要优势:

• 一个没有参数的模型将需要许多用于学习目的的训练例子。然而，学习一个共享的单一模型有助于概括序列长度，甚至是那些不在训练集中的序列长度。这允许模型用较少的训练例子来估计即将到来的序列数据。
• 不管序列的长度如何，模型的输入大小将始终保持不变。展开模型中的输入大小是根据从隐藏状态到其他状态的转换来指定的。然而，对于其他情况，它是根据未定义的国家历史长度来规定的。
• 由于参数共享，每个时间步长都可以使用相同的过渡函数 f ，参数相同。

RNNs 的记忆

到目前为止，你可能已经知道前馈神经网络和递归网络之间的主要区别是反馈回路。反馈回路被吸收到它自己的中间结果中，作为下一个状态的输入。对输入序列的每个元素执行相同的任务。因此，每个隐藏状态的输出取决于之前的计算。在实际情况中，每个隐藏状态不仅关心当前正在运行的输入序列，还关心他们在时间上感知到的后退一步。因此，理想情况下，每个隐藏状态都必须包含上一步结果的所有信息。

由于这种对持久信息的要求，据说 rnn 有自己的内存。在循环网络的隐藏状态下，顺序信息被保存为内存。这有助于在网络向前级联时处理即将到来的时间步骤，以便用每个新序列更新处理。

图 4.3 展示了 Elman 早在 1990 年提出的简单循环神经网络的概念[112]；它展示了 RNN 的持久记忆。

在下图中，底部单词序列 AYSXWQF 的一部分表示当前正在考虑的输入示例。这个输入示例的每个框代表一个单元池。向前箭头显示了下一时间步从每个发送输入单元到每个输出单元的整套可训练映射。上下文单元可以被认为是持久存储单元，它保存前面步骤的输出。从隐藏层指向上下文单元的向后箭头显示了输出的复制操作，用于评估下一个时间步骤的结果。

RNN 在时间步长 t 到达的决定主要取决于其在时间步长 (t-1) 的最后决定。因此，可以推断，与传统的神经网络不同，神经网络有两个输入源。

一个是当前正在考虑的输入单元，如下图中的 X ，另一个是从最近的过去接收的信息，取自图中的上下文单元。这两个源组合起来决定了当前时间步长的输出。关于这一点的更多内容将在下一节中讨论。

图 4.3:一个简单的具有 RNN 记忆概念的循环神经网络如图所示。

建筑

因此，我们已经知道，神经网络有自己的记忆，可以收集到目前为止计算出的信息。在本节中，我们将讨论无线网络的一般架构及其功能。

在正向计算中涉及的计算时，典型的 RNN 展开(或展开)如图 4.4 所示。

展开或展开网络意味着写出完整输入序列的网络。在开始解释架构之前，让我们举个例子。如果我们有一个 10 个单词的序列，那么 RNN 将被展开成一个 10 层的深度神经网络，每个单词一层，如下图所示:

图 4.4:该图显示了展开或展开成完整网络的 RNN。

从输入 x 到输出 o 的时间段被分成由 (t-1) 、 t 、 (t+1) 等给出的多个时间戳。

RNN 的计算步骤和公式如下:

• 在上图中， x _t 是时间步长 t 的输入。图为三个时间戳 (t-1) 、 t 、 (t+1) 的计算，其中输入分别为 x _(t-1) 、 x _t 、 x _(t+1) 、。例如 x ₁ 和 x ₂ 是对应于序列第二个和第三个字的向量。
• s_tT3】代表时间步 t 的隐藏状态。从概念上讲，这种状态定义了神经网络的记忆。数学上 s _t 的公式或携带记忆的过程可以写成如下:

所以，隐藏状态是时间步长 x _t 的输入，乘以权重 U ，加上最后时间步长 s _t-1 的隐藏状态，再乘以自身的隐藏状态到隐藏状态矩阵 W 的函数。这种隐藏状态到隐藏状态的转换通常被称为转移矩阵，类似于马尔可夫链。权重矩阵表现为过滤器，主要决定过去的隐藏状态和当前输入的重要性。为当前状态生成的误差将通过反向传播被发送回来，以更新这些权重，直到误差被最小化到期望值。

注

为了计算第一个隐藏状态，我们需要确定值 s-1 ，它通常被初始化为全零。

与传统的深度神经网络不同，在传统的深度神经网络中，不同的参数用于每一层的计算，RNN 在所有的时间步长中共享相同的参数(这里， U 、 V 和 W )来计算隐藏层的值。这使得神经网络的生命变得更加容易，因为我们需要学习的参数数量更少。

权重输入和隐藏状态的总和被函数 f 压缩，该函数通常是一个非线性函数，如逻辑 sigmoid 函数， tan h ，或 ReLU:

• 在最后一个图中， o _t 被表示为时间步长 t 的输出。步骤 o _t 的输出完全是基于时间步长 t 时网络可用的内存来计算的。理论上，虽然 RNNs 可以为任意长的序列保留内存，但实际上，这有点复杂，并且它们仅限于回顾几个时间步长。从数学上讲，这可以表示如下:

下一节将讨论如何通过反向传播训练 RNN。

穿越时间的反向传播(BPTT)

您已经了解到，RNNs 的主要要求是对顺序输入进行清晰的分类。误差反向传播和梯度下降主要有助于执行这些任务。

在前馈神经网络的情况下，反向传播从每个隐藏层的最终误差输出、权重和输入向后移动。反向传播通过计算它们的偏导数来分配产生误差的权重:其中 E 表示误差， w 是各自的权重。对学习率应用导数，梯度减小以更新权重，从而最小化错误率。

然而，RNN 没有直接使用反向传播，而是使用了它的扩展，称为通过时间 ( BPTT )反向传播。在本节中，我们将讨论 BPTT，以解释培训如何为无线网络服务。

误差计算

穿越时间的反向传播 ( BPTT )学习算法是传统反向传播方法的自然延伸，传统反向传播方法在完全展开的神经网络上计算梯度下降。

图 4.5 显示了与展开的 RNN 的每个隐藏状态相关的错误。数学上，与每种状态相关的误差可以如下给出:

其中o_tT3】代表正确输出，o_tT7】代表时间步长 t 的预测词。整个网络的总误差(成本函数)计算为每个时间步长所有中间误差的总和。**

如果将 RNN 展开成多个时间步长，从t₀T3】到 t _n-1 开始，总误差可以写成:

图 4.5:该图显示了与 RNN 的每个时间步长相关的误差。

在时间反向传播方法中，不同于传统方法，梯度下降权值在每个时间步长内更新。

让w_ijT3】表示从神经元 i 到神经元 j 的权重连接。 η 表示网络的学习速率。因此，在数学上，每个时间步长的梯度下降权重更新由以下等式给出:

长时间短时记忆

本节我们将讨论一个名为长短期记忆(【LSTM】)的特殊单位，它被整合到 RNN。LSTM 的主要目的是防止 RNN 的一个重大问题，称为消失梯度问题。

随时间深度反向传播的问题

与传统的前馈网络不同，由于 RNN 展开的时间步长很窄，以这种方式生成的前馈网络可能会非常深。这有时使得通过时间过程的反向传播进行训练变得极其困难。

在第一章中，我们讨论了消失梯度问题。展开的 RNN 遭受爆炸的消失梯度问题，同时执行穿越时间的反向传播。

RNN 的每个状态都依赖于它的输入和先前的输出乘以当前的隐藏状态向量。在时间反向传播期间，相同的操作发生在相反方向的梯度上。展开的 RNN 的层次和无数时间步长通过乘法相互关联，因此导数很容易随着每次通过而消失。

另一方面，小的梯度趋于变小，而大的梯度在通过每个时间步长时变得更大。这分别为 RNN 创建了消失或爆炸渐变问题。

长时间短时记忆

在 90 年代中期，德国研究人员 Sepp Hochreiter 和 Juergen Schmidhuber [116]提出了一个更新版本的 RNNs，它带有一个特殊的单位，称为长短期记忆(【LSTM】)单位，以防止爆炸或消失的梯度问题。

LSTM 有助于保持恒定的误差，该误差可以通过时间和网络的每一层传播。这种对恒定误差的保留允许展开的递归网络在一个激进的深度网络上学习，甚至以一千个时间步长展开。这最终打开了一个渠道，远程链接影响的原因。

LSTM 体系结构通过特殊存储单元的内部状态保持恒定的错误流。下图(图 4.6 )为了便于理解，显示了一个 LSTM 的基本框图:

图 4.6:该图显示了长期-短期记忆的基本模型

如上图所示，LSTM 单元由主要长时间存储信息的存储单元组成。三个专门的门神经元-写门、读门和忘记门-保护对这个存储单元的访问。与计算机的数字存储不同，这些门本质上是模拟的，范围从 0 到 1。与数字器件相比，模拟器件还有一个额外的优势，因为它们是可微分的，因此可以用于反向传播方法。LSTM 的门单元不是将信息作为输入转发给下一个神经元，而是设置将神经网络的其余部分连接到存储单元的相关权重。记忆细胞基本上是一个自连接的线性神经元。当遗忘单元复位(变为 0 )时，存储单元将其内容写入自身，并记住存储器的最后内容。但是对于存储器写操作，应该设置忘记门和写获取(关闭 1 )。此外，当遗忘门输出接近于 1 的东西时，存储单元实际上忘记了它已经存储的所有先前的内容。现在，当写门被设置时，它允许任何信息写入其存储单元。类似地，当读取门输出 1 时，它将允许网络的其余部分从其存储单元读取。

如前所述，计算传统无线网络的梯度下降的问题是，误差梯度在展开的网络中通过时间步长传播时迅速消失。加上 LSTM 单元，从输出反向传播时的误差值被收集在 LSTM 单元的存储单元中。这种现象也被称为错误转盘。我们将使用以下示例来描述 LSTM 如何克服神经网络的消失梯度问题:

图 4.7:该图显示了长短期记忆在时间上的展开。它还描述了如何借助三个门来保护存储单元的内容。

图 4.7 显示了随着时间展开的长短期记忆单元。我们首先将忘记门的值初始化为 1 并将门写入 1 。如上图所示，这将把信息 K 写入存储单元。写入后，通过将遗忘门的值设置为 0 ，该值被保留在存储单元中。然后，我们将读取门的值设置为 1 ，它从存储单元读取并输出值 K 。从将 K 加载到存储单元中到从存储单元中读取该存储单元，随后是时间的反向传播。

从读取点接收的误差导数通过网络反向传播，并有一些名义变化，直到写入点。这是因为记忆神经元的线性特性。因此，通过这种操作，我们可以在数百步内保持误差导数，而不会陷入消失梯度问题的陷阱。

所以为什么 Long 短时记忆优于标准 RNNs 有很多原因。LSTM 能够在非分段连接手写识别中获得最著名的结果[117]；此外，它同样成功地应用于自动语音识别。截至目前，苹果、微软、谷歌、百度等主要科技公司已开始广泛使用 LSTM 网络作为其最新产品的主要组件[118]。

双向 rnn

本章的这一节将讨论无线网络的主要限制，以及双向 RNN(一种特殊的 RNN)如何帮助克服这些不足。双向神经网络除了从过去获取输入外，还从未来环境中获取所需预测的信息。

rnn 的不足

标准或单向无线网络的计算能力受到限制，因为当前状态无法到达其未来的输入信息。在许多情况下，以后出现的未来输入信息对序列预测非常有用。例如，在语音识别中，由于语言的依赖性，语音作为音素的适当解释可能取决于接下来的几个口语单词。手写识别也可能出现同样的情况。

在 RNN 的一些修改版本中，通过在输出中插入一定量( N )时间步长的延迟来部分实现该特征。这种延迟有助于捕获未来信息以预测数据。虽然理论上，为了捕捉大部分可用的未来信息， N 的值可以设置为非常大，但是在实际场景中，模型的预测能力实际上随着 N 的大值而降低。论文[113]对这一推论提出了一些合乎逻辑的解释。随着 N 值的增加，RNN 的大部分计算能力只集中在记住(来自图 4.8 )的输入信息来预测结果， y _tc 。(图中 t _c 表示所考虑的当前时间步长)。因此，该模型将具有较少的处理能力来组合从不同输入向量接收的预测知识。下图图 4.8 显示了不同类型的无线网络所需的输入信息量:

图 4.8:该图显示了不同类型的网络节点使用的输入信息的可视化。[113]

需要克服的解决方案

为了克服上一节解释的单向 RNN 的局限性，1997 年发明了双向递归网络 ( BRNN )。

双向 RNN 背后的基本思想是将普通 RNN 的隐藏状态分成两部分。一部分负责正向状态(正时间方向)，另一部分负责反向状态(负时间方向)。前向状态产生的输出不连接到后向状态的输入，反之亦然。双向 RNN 的一个简单版本，在三个时间步骤中展开，如图 4.9 所示。

利用这种结构，由于时间方向都被考虑，当前评估的时间框架可以容易地使用来自过去和未来的输入信息。因此，当前输出的目标函数最终将最小化，因为我们不需要再增加延迟来包含未来的信息。正如上一节所述，这对于常规 rnn 是必要的。

图 4.9:该图显示了在三个时间步骤中展开的双向神经网络的传统结构。

到目前为止，已经发现双向 RNNs 在语音识别[114]、手写识别、生物信息学[115]等应用中极其有用。

分布式深层神经网络

现在，您已经了解了 RNN、它的应用、特性和体系结构，我们可以继续讨论如何将这个网络用作分布式体系结构。分发 RNN 不是一项容易的任务，因此，过去只有少数研究人员从事过这项工作。虽然所有网络的数据并行性的主要概念是相似的，但是在多台服务器之间分配无线网络需要一些头脑 Storm 和一些繁琐的工作。

最近，谷歌[119]的一项工作试图在语音识别任务中在许多服务器中分发循环网络。在本节中，我们将借助 Hadoop 在分布式 RNNs 上讨论这项工作。

异步随机梯度下降 ( ASGD )可用于一个 RNN 的大规模训练。ASGD 在深度神经网络的序列鉴别训练中特别成功。

一个两层深的长短期记忆被用来建立长短期记忆网络。每个长短期记忆由 800 个记忆单元组成。该论文使用了 1300 万个 LSTM 网络参数。对于单元输入和输出单元，使用 tan h(双曲正切激活)，对于写、读和遗忘门，使用逻辑 sigmoid 函数。

出于训练目的，输入语音训练数据可以在 Hadoop 框架的多个数据节点上被分割和随机混合。长短期内存放在所有这些数据节点上，并在这些数据集上并行执行分布式训练。异步随机梯度下降用于这种分布式训练。使用一个参数服务器，专用于维护所有模型参数的当前状态。

为了在 Hadoop 上实现这个过程，每个数据节点必须对分区数据执行异步随机梯度下降操作。运行在每个数据块上的每个工作人员都在分区上工作，一次一句话。对于语音的每一次发声，模型参数 P 从前面提到的参数服务器中获取。工人计算每一帧的当前状态；破译语音话语以计算最终的外部梯度。然后，更新后的参数被发送回参数服务器。然后，工作人员反复请求参数服务器提供最新的参数。然后执行时间反向传播，以计算下一组帧的更新参数梯度，该梯度再次被发送回参数服务器。

深度学习的神经网络 4j

训练一个 RNN 不是一个简单的任务，它有时会非常需要计算。由于长序列的训练数据涉及许多时间步骤，训练有时变得极其困难。到目前为止，你已经从理论上更好地理解了穿越时间的反向传播是如何以及为什么主要用于训练 RNN 的。在本节中，我们将考虑一个使用 RNN 及其使用深度学习 4j 实现的实际例子。

我们现在举一个例子来说明如何使用 RNN 对电影评论数据集进行情感分析。该网络的主要问题陈述是将电影评论的一些原始文本作为输入，并基于呈现的内容将电影评论分类为正面或负面。原始评论文本中的每个单词都使用 Word2Vec 模型转换成向量，然后输入 RNN。该示例使用了取自 http://ai.stanford.edu/~amaas/data/sentiment/的原始电影评论的大规模数据集。

使用 DL4J 实现该模型的整个过程可以分为以下几个步骤:

1. 下载并提取原始电影评论数据。

2. 配置培训所需的网络配置，并评估性能。

3. 加载每篇评论，并使用 Word2Vec 模型将单词转换为向量。

4. 为多个预定义的时期执行培训。对于每个时期，在测试集上评估性能。

5. 要下载和提取电影评论的数据，我们需要首先设置下载配置。下面的代码片段设置了这样做所需的所有内容:

           public static final String DATA_URL = 
           "http://ai.stanford.edu/~amaas/data/sentiment/*"; 
   
   

6. 本地文件路径中保存和提取训练和测试数据的位置设置如下:

           public static final String DATA_PATH = FilenameUtils.concat
           (System.getProperty("java.io.tmpdir"),local_file_path); 
   
   

7. 谷歌新闻向量的本地文件系统的位置如下所示:

           public static final String WORD_VECTORS_PATH =    
           "/PATH_TO_YOUR_VECTORS/GoogleNews-vectors-negative300.bin"; 
   
   

8. 以下代码有助于将数据从网址下载到本地文件路径:

           if( !archiveFile.exists() )
           { 
            System.out.println("Starting data download (80MB)..."); 
            FileUtils.copyURLToFile(new URL(DATA_URL), archiveFile); 
            System.out.println("Data (.tar.gz file) downloaded to " +  
            archiveFile.getAbsolutePath()); 
   
            extractTarGz(archizePath, DATA_PATH); 
           }
           else 
           {       
            System.out.println("Data (.tar.gz file) already exists at " +  
            archiveFile.getAbsolutePath()); 
            if( !extractedFile.exists())
              { 
               extractTarGz(archizePath, DATA_PATH); 
              } 
            else 
              { 
               System.out.println("Data (extracted) already exists at " +   
               extractedFile.getAbsolutePath()); 
              } 
            } 
            } 
   
   

9. 现在，由于我们已经下载了原始电影评论的数据，我们现在可以开始设置我们的 RNN 来执行这些数据的训练。下载的数据被分割成多个示例，用于每个小批量中，在每个 Hadoop 工作人员上进行分布式训练。为此，我们需要声明一个变量batchSize。这里，作为一个示例，我们使用每批 50 个示例，这些示例将被分割到 Hadoop 的多个块中，工作人员将在这些块中并行运行:

         int batchSize = 50;      
         int vectorSize = 300; 
         int nEpochs = 5;  
         int truncateReviewsToLength = 300; 
    MultiLayerConfiguration conf = new             
         NeuralNetConfiguration.Builder()
    .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_
            DESCENT)
    .iterations(1)
           .updater(Updater.RMSPROP) 
           .regularization(true).l2(1e-5) 
           .weightInit(WeightInit.XAVIER) 
           .gradientNormalization(GradientNormalization
           .ClipElementWiseAbsoluteValue).gradientNormalizationThreshold
           (1.0) 
           .learningRate(0.0018) 
           .list() 
           .layer(0, new GravesLSTM.Builder()
                 .nIn(vectorSize)
                 .nOut(200) 
                 .activation("softsign")
                 .build()) 
           .layer(1, new RnnOutputLayer.Builder()
                 .activation("softmax") 
                 .lossFunction(LossFunctions.LossFunction.MCXENT)
                 .nIn(200)
                 .nOut(2)
                 .build()) 
           .pretrain(false)
           .backprop(true)
           .build(); 
   
         MultiLayerNetwork net = new MultiLayerNetwork(conf); 
         net.init(); 
         net.setListeners(new ScoreIterationListener(1)); 
   
   

10. As we set the network configuration for a RNN, we can now move on to the training operation as follows:

```scala
      DataSetIterator train = new AsyncDataSetIterator(new    
      SentimentExampleIterator(DATA_PATH,wordVectors,
      batchSize,truncateReviewsToLength,true),1);
      DataSetIterator test = new AsyncDataSetIterator(new          
      SentimentExampleIterator(DATA_PATH,wordVectors,100,
      truncateReviewsToLength,false),1); 
      for( int i=0; i<nEpochs; i++ )
      { 
        net.fit(train); 
        train.reset(); 
        System.out.println("Epoch " + i + " complete. Starting    
        evaluation:"); 

```

网络测试通过创建`Evaluation`类的对象来执行，如下所示:

```scala
        Evaluation evaluation = new Evaluation(); 
        while(test.hasNext())
        { 
          DataSet t = test.next(); 
          INDArray features = t.getFeatureMatrix(); 
          INDArray lables = t.getLabels(); 
          INDArray inMask = t.getFeaturesMaskArray(); 
          INDArray outMask = t.getLabelsMaskArray(); 
          INDArray predicted =  
          net.output(features,false,inMask,outMask); 
          evaluation.evalTimeSeries(lables,predicted,outMask); 
        } 
      test.reset(); 

      System.out.println(evaluation.stats()); 
      } 

```

总结

与其他传统的深度神经网络相比，神经网络是特殊的，因为它们能够处理长序列的向量，并输出不同序列的向量。神经网络随着时间的推移而展开，像前馈神经网络一样工作。神经网络的训练是在时间反向传播的基础上进行的，是传统反向传播算法的扩展。RNNs 的一个特殊单位，称为长短期记忆，有助于克服时间算法反向传播的局限性。

我们还谈到了双向 RNN，这是单向 RNN 的更新版本。由于缺乏未来的输入信息，单向神经网络有时无法正确预测。稍后，我们讨论了深度神经网络的分布以及它们在深度学习 4j 中的实现。异步随机梯度下降可用于分布式 RNN 的训练。在下一章中，我们将讨论另一种深度神经网络模型，称为受限玻尔兹曼机。

五、受限玻尔兹曼机

|   | “我不能创造的，我不明白。” |   |
|   | - 理查德·费曼 |

到目前为止，在这本书里，我们只讨论了区分模型。这些在深度学习中的用途是模拟未观察变量 y 对观察变量 x 的依赖关系。数学上表述为 P(y|x) 。在本章中，我们将讨论深度学习中使用的深度生成模型。

生成模型是这样的模型，当给定一些隐藏参数时，它可以从这些参数中随机生成一些可观察的数据值。该模型在标签序列和观察上的联合概率分布上工作。

生成模型用于机器和深度学习，或者作为生成条件概率密度函数的中间步骤，或者直接从概率密度函数中建模观察值。

受限玻尔兹曼机 ( RBMs )是一种流行的生成模型，将在本章中讨论。RBM 基本上是概率图形模型，也可以解释为随机神经网络。

注

随机神经网络可以定义为一种通过向网络中提供随机变量而生成的人工神经网络。随机变化可以以各种方式提供，例如提供随机权重或通过给定网络的神经元随机传递函数。

在这一章中，我们将讨论一种叫做 RBM 的特殊类型的玻尔兹曼机，这是这一章的主题。我们将讨论基于能源的模型 ( 电子商务管理系统)如何与 RBM 相关，以及它们的功能。本章后面我们将介绍深信网 ( DBN )，它是 RBM 的延伸。本章将讨论这些在分布式环境中的大规模实现。这一章将以 RBM 和 DBN 的深度学习 4j 为例来结束。

本章的组织如下:

• 基于能源的模型
• 玻尔兹曼机
• 受限玻尔兹曼机
• 卷积受限玻尔兹曼机
• 深度信念网络
• 分布式深度信念网络
• 深度学习在 RBM 和 DBN 的实施 4j

基于能量的模型

深度学习和统计建模的主要目标是编码变量之间的依赖关系。通过从已知变量的值中了解这些依赖关系，模型可以回答关于未知变量的问题。

基于能量的模型(EBMs)【120】通过识别定标器能量来收集依赖关系，定标器能量通常是对变量的每个配置的兼容性的度量。在循证医学中，预测是通过设定观察变量的值和寻找未观察变量的值来进行的，这使得总能量最小化。循证医学中的学习包括制定一个能量函数，该函数将低能量赋给未观测变量的正确值，将高能量赋给不正确的值。基于能量的学习可以被视为分类、决策或预测任务的概率估计的替代方法。

为了清楚地了解循证医学是如何工作的，让我们看一个简单的例子。

如图 F 图 5.1 所示，我们来考虑两组变量，观察到的和未观察到的，分别是 X 和 Y 。图中的变量 X 代表图像中像素的集合。变量 Y 是离散的，包含分类所需对象的可能类别。变量 Y 在这种情况下，由六个可能的值组成，即:飞机、动物、人、汽车、卡车，以上都不是。该模型用作能量函数，将测量 X 和 Y 之间映射的正确性。

该模型使用了一个惯例，即小的能量值意味着变量的高度相关的配置。另一方面，随着能量值的增加，变量的不相容性也同样增加。与 X 和 Y 变量相关的函数称为能量函数，表示如下:

在能量模型的情况下，输入 X 是从周围环境中收集的，并且模型生成输出 Y，该输出更可能回答关于观测变量 X 的问题。模型需要产生值 Y ^/ ，从一组 Y* 中选择，这将使能量函数 E(Y，X) 的值最小。数学上，这表示如下:

下面的图 5.1 描述了上一节提到的整体示例的框图:

图 5.1:图中显示了一个能量模型，该模型计算观察到的变量 X 和未观察到的变量 Y 之间的兼容性。图像中的 X 是一组像素，Y 是用于对 X 进行分类的级别集。该模型发现选择“动物”会使能量函数值最小。图片取自[121]

深度学习中的循证医学与概率有关。概率与 e 的负能量成正比:

EBMs 通过公式函数 E(x) 间接定义概率。指数函数确保概率总是大于零。这也意味着，在基于能量的模型中，人们总是可以根据观察到的和未观察到的变量自由选择能量函数。尽管基于能量的模型中的分类概率可以任意接近零，但它永远不会达到零。

前面方程形式的分布是玻尔兹曼分布的一种形式。因此，电子制动系统通常被称为玻尔兹曼机。我们将在本章的后续章节中解释玻尔兹曼机及其各种形式。

玻尔兹曼机

玻尔兹曼机[122]是对称连接的神经元单元网络，用于给定数据集上的随机决策。最初，他们被引入学习二进制向量的概率分布。玻尔兹曼机具有简单的学习算法，这有助于它们推断和得出关于包含二进制向量的输入数据集的有趣结论。在具有多层特征检测器的网络中，学习算法变得非常慢；但是，每次使用一层特征检测器，学习速度会快得多。

为了解决学习问题，玻尔兹曼机由一组二进制数据向量组成，并更新相应连接上的权重，以便数据向量成为权重所奠定的优化问题的良好解决方案。为了解决学习问题，玻尔兹曼机对这些权重进行了大量的小更新。

二维二进制向量上的玻尔兹曼机可以定义为x ^d 。如前一节所述，玻尔兹曼机是一种基于能量的函数，其联合概率函数可以使用下面给出的能量函数来定义:

这里， E(x) 为能量函数， Z 为确定_xP(x)= 1的配分函数。玻尔兹曼机的能量函数如下:

这里， W 是模型参数的权重矩阵， b 是偏差参数的向量。

玻尔兹曼机，如 EBMs，对观察到的和未观察到的变量进行工作。当观察到的变量不是更高的数时，玻尔兹曼机工作得更有效。在这些情况下，未观察到的或隐藏的变量表现得像多层感知器的隐藏单元，并显示出可见单元之间的高阶相互作用。

玻尔兹曼机在隐藏层之间以及可见单元之间都有层间连接。图 5.2 显示了玻尔兹曼机的图示:

图 5.2:图 5 显示了一个简单的玻尔兹曼机的图形表示。图中的无向边表示节点之间的依赖关系，w _i，j 表示节点 I 和 j 之间关联的权重。图中显示了 3 个隐藏节点和 4 个可见节点

玻尔兹曼机的一个有趣的特性是，学习规则不会随着隐藏单元的增加而改变。这最终有助于学习二进制特征，以捕获输入数据中的高阶结构。

玻尔兹曼机表现为离散变量上概率质量函数的通用逼近器。

注

在统计学习中，最大似然估计 ( 最大似然估计)是通过找到一个或多个参数的值来找到给定观测值的统计模型的参数的过程，这最大化了用参数进行观测的可能性。

玻尔兹曼机是如何学习的

玻尔兹曼机的学习算法一般基于最大似然估计方法。当用基于最大似然估计的学习规则训练玻尔兹曼机时，连接模型两个单元的特定权重的更新将仅依赖于这两个相关单元。网络的其他单元参与修改生成的统计数据。因此，可以在不让网络其他人知道的情况下更新权重。换句话说，网络的其余部分只能知道最终的统计数据，但不知道统计数据是如何计算的。

短缺

在玻尔兹曼机中，由于有许多隐藏层，网络变得极其庞大。这使得模型通常很慢。玻尔兹曼机停止对大规模数据的学习，因为机器的规模也同时呈指数级增长。对于大型网络，权重通常非常大，平衡分布也变得非常高。不幸的是，这给玻尔兹曼机带来了一个重大问题，最终导致达到分布平衡状态的时间更长。

这种限制可以通过限制两层之间的连通性来克服，从而通过一次学习一个潜在层来简化学习算法。

受限玻尔兹曼机

受限玻尔兹曼机 ( RBM )是用于深度学习的深度概率模型构建块的经典示例。RBM 本身不是深度模型，但可以作为构建其他深度模型的基础。事实上，径向基函数是由一层观察变量和一层隐藏变量组成的无向概率图形模型，可以用来学习输入的表示。在本节中，我们将解释如何使用 RBM 来构建许多更深层次的模型。

让我们考虑两个例子来看看 RBM 的用例。RBM 主要采用二元因素分析。假设我们有一家餐馆，想让顾客给食物打分，从 0 到 5。在传统的方法中，我们将尝试根据变量的隐藏因素来解释每个食品和顾客。例如，像意大利面和千层面这样的食物会与意大利因素有很强的联系。另一方面，RBM 采用了不同的方法。他们没有要求每个顾客对食物进行连续评分，而是简单地提到他们是否喜欢，然后 RBM 会试图推断各种潜在因素，这有助于解释每个顾客食物选择的激活。

另一个例子是根据某人喜欢的电影类型来猜测他的电影选择。假设 X 先生在给定的电影集上提供了他的五个二进制偏好。RBM 的工作是根据隐藏的单位激活他的偏好。所以，在这种情况下，这五部电影会向所有隐藏单元发送消息，要求它们更新自己。然后，RBM 会根据之前给这个人的一些偏好，以很高的概率激活隐藏单元。

基本架构

RBM 是一个浅层的两层神经网络，用作构建深层模型的基础。RBM 的第一层称为观察层或可见层，第二层称为潜层或隐层。它是一个二分图，在观察层的任何变量之间，或者在潜在层的任何单元之间，都不允许有相互联系。如图图 5.3 所示，各层之间没有层内通信。由于这种限制，该模型被称为受限玻尔兹曼机。每个节点都用于处理输入的计算，并通过随机(随机确定)决定是否传递输入来参与输出。

注

二部图是这样一种图，其中顶点可以分成两个不相交的集合，这样每条边都将一个集合的顶点连接到另一个集合。但是，同一集合的顶点之间没有任何联系。顶点集通常被称为图的一部分。

RBM 的两层背后的主要直觉是，有一些可见的随机变量(例如，来自不同顾客的食物评论)和一些潜在的变量(例如菜系、顾客的国籍或其他内部因素)，训练 RBM 的任务是找到这两组变量如何相互关联的概率。

为了从数学上表述 RBM 的能量函数，让我们用向量 v 来表示由一组n_vT3】二元变量组成的观测层。 n _h 二进制随机变量的隐藏或潜在层表示为 h 。

类似于玻尔兹曼机，RBM 也是一个基于能量的模型，其中联合概率分布由其能量函数决定:

图 5.3:图中显示了一个简单的 RBM。该模型是一个对称的二部图，其中每个隐藏节点连接到每个可见节点。隐藏单位表示为 h _i ，可见单位表示为 v _i

具有二进制可见和潜在单位的 RBM 的能量函数如下:

这里， a 、 b 和 W 是不受约束的、可学习的实值参数。从前面的图 5.3 我们可以看到模型被拆分成两组变量， v 和 h 。单元之间的相互作用由矩阵 W 描述。

成果预算制如何运作

因此，我们现在已经了解了 RBM 的基本架构，在本节中，我们将讨论该模型的基本工作过程。RBM 得到了一个它应该从中学习的数据集。模型的每个可见节点从数据集的一个项目接收一个低级特征。例如，对于灰度图像，最低级别项目是图像的一个像素值，可见节点将接收到该像素值。因此，如果图像数据集有 n 个像素，处理它们的神经网络也必须在可见层上拥有 n 个输入节点:

图 5.4:图中显示了一条输入路径的 RBM 计算

现在，让我们通过两层网络传播一个单像素值 p 。在隐藏层的第一个节点，将 p 乘以权重 w ，并添加到偏差中。最后的结果被输入到激活函数，激活函数产生节点的输出。给定输入像素 p ，该操作产生的结果可以被称为通过该节点的信号强度。图 5.4 显示了单输入 RBM 涉及的计算的可视化表示。

RBM 的每个可见节点都与一个单独的权重相关联。来自不同单元的输入在一个隐藏的节点上合并。输入的每个 p (像素)乘以与之相关的单独权重。产品被总结并添加到一个偏见。该结果通过激活函数传递，以生成节点的输出。下面的图 5.5 显示了 RBMs 可视层的多个输入所涉及的计算的可视化表示:

图 5.5:图中显示了具有多个输入和一个隐藏单元的 RBM 的计算

前面的图 5.5 显示了如何使用与每个可见节点相关联的权重来计算隐藏节点的最终结果。

图 5.6:图中显示了一个 RBM 涉及多个可见单元和隐藏单元的计算

如前所述，径向基函数类似于二部图。此外，该机器的结构基本上类似于对称二分图，因为从所有可见节点接收的输入被传递到 RBM 的所有潜在节点。

对于每个隐藏节点，每个输入 p 乘以其各自的权重 w 。因此，对于单个输入 p 和 m 数量的隐藏单元，该输入将具有与之相关联的 m 权重。在图 5.6 中，输入 p 将有三个权重，总共 12 个权重:可见层的四个输入节点和下一层的三个隐藏节点。两层之间关联的所有权重形成一个矩阵，其中行等于可见节点，列等于隐藏单元。在上图中，第二层的每个隐藏节点接受四个输入乘以它们各自的权重。乘积的最终和再加到一个偏差上。然后，这个结果通过激活算法，为每个隐藏层产生一个输出。图 5.6 表示在这种情况下发生的整体计算。

有了堆叠的 RBM，它将形成更深层的神经网络，其中第一个隐藏层的输出将作为输入传递给下一个隐藏层。这将通过尽可能多的隐藏层传播，以达到所需的分类层。在接下来的部分，我们将解释如何使用 RBM 作为深度神经网络。

卷积受限玻尔兹曼机

非常高维的输入，如图像或视频，给传统机器学习模型的内存、计算和操作要求带来巨大压力。在第三章、卷积神经网络中，我们已经展示了用小核的离散卷积运算代替矩阵乘法是如何解决这些问题的。展望未来，Desjardins 和 Bengio [123]已经表明，当应用于成果管理制时，这种方法也能很好地工作。在本节中，我们将讨论这个模型的功能。

图 5.7:图中显示了观察到的变量或 RBM 的可见单位可以与图像的小批量相关联来计算最终结果。权重连接代表一组过滤器

此外，在正常的径向基函数中，可见单元通过不同的参数和权重与所有隐藏变量直接相关。根据空间局部特征来描述图像理想地需要较少的参数，这可以被更好地概括。这有助于从高维图像中检测和提取相同的局部特征。因此，使用 RBM 从图像中检索所有全局特征用于对象检测并不那么令人鼓舞，尤其是对于高维图像。一种简单的方法是在从输入图像中采样的小批量上训练 RBM，将其放在 Hadoop 的数据节点上的块中以生成本地特征。这种被称为基于面片的 RBM 的方法的表示如图 5.7 所示。然而，这有一些潜在的局限性。Hadoop 分布式环境中使用的基于补丁的 RBM 不遵循小批量的空间关系，而是将每个映像的小批量视为附近补丁中的独立补丁。这使得从相邻面片中提取的特征是独立的，并且有些明显冗余。

为了处理这种情况，使用了卷积受限玻尔兹曼机 ( CRBM )，这是传统 RBM 模型的扩展。CRBM 在结构上几乎类似于 RBM，这是一个两层模型，其中可见和隐藏的随机变量被构造成矩阵。因此，在 CRBM，可以为可见单元和隐藏单元定义位置和邻域。在 CRBM，可见矩阵代表图像，矩阵的小窗口定义图像的小批量。CRBM 的隐藏单元被划分成不同的特征地图，以在可见单元的多个位置定位多个特征的存在。要素地图中的单位在可见单位的不同位置表示相同的要素。CRBM 的隐藏-可见连接完全是局部的，权重通常在隐藏单元的集群中分割。

CRBM 的隐藏单元用于从重叠的小型可见单元批次中提取特征。此外，相邻迷你批次的特征相互补充，并协作来对输入图像进行建模。

图 5.8 为 CRBM，可见单元矩阵 V 和隐藏单元矩阵 H ，与 K 33* 滤波器连接，即 W ₁ 、 W ₂ 、 W ₃ ，... W _K 。图中隐藏单元拆分为 K 称为特征图的子矩阵，H₁T29】H₂T33】，... H _K 。每个隐藏单元 H _i 表示在可见单元的 33* 邻域存在特定特征。****

与基于补丁的 RBM 不同，CRBM 在整个输入图像或图像的大区域上进行训练，以学习局部特征并利用重叠的小批次的空间关系，在 Hadoop 上以分布式方式进行处理。重叠小批量的隐藏单元在 CRBM 中相互依赖和合作。因此，一个隐藏的单元，一旦被解释，就不需要在邻域重叠的小批量中被再次解释。这反过来有助于减少功能的冗余。

图 5.8:CRBM 涉及的计算如图所示

堆叠卷积受限玻尔兹曼机

CRBMs 可以堆叠在一起，形成深度神经网络。堆叠卷积受限玻尔兹曼机 ( 堆叠 CRBMs )可以采用自下而上的方法逐层训练，类似于全连接神经网络的逐层训练。在每个 CRBM 滤波层之后，在堆叠网络中，实现确定性子采样方法。对于特征的二次采样，在非重叠图像区域中执行最大池化。汇集层，如第 3 章、卷积神经网络所述，有助于最小化特征的维度。除此之外，它还使特征对小的移动具有鲁棒性，并有助于传播更高级的特征以在输入图像的区域上生长。

深层 CRBMs 需要池化操作，因此每个连续层的空间大小都会减小。尽管大多数传统卷积模型对各种空间大小的输入都能很好地工作，但对于玻尔兹曼机来说，改变输入大小变得有些困难，这主要有几个原因。首先，能量函数的配分函数随着输入的大小而变化。其次，卷积网络通过增加与输入大小成比例的汇集函数的大小来获得大小不变性。然而，扩大玻尔兹曼机的汇集区域是非常困难的。

对于 CRBMs 来说，位于图像边界的像素也带来了困难，而玻尔兹曼机本质上是对称的这一事实又加剧了困难。这可以通过对输入进行隐式零填充来消除。请记住，零填充输入通常由较小的输入像素驱动，这些像素在需要时可能不会被激活。

深度信念网络

深度信念网络 ( 数据库网络)是最受欢迎的非卷积模型之一，可以在 2006-07 年成功部署为深度神经网络[124] [125]。深度学习的复兴可能始于 2006 年 DBNs 的发明。在引入数据库网络之前，深度模型的优化非常困难。通过超越支持向量机 ( 支持向量机，数据库网络已经表明深度模型可以真正成功；虽然，与其他生成式或无监督学习算法相比，DBNs 的受欢迎程度有所下降，目前很少使用。然而，它们在深度学习的历史中仍然发挥着非常重要的作用。

注

只有一个隐藏层的 DBN 只是一个 RBM。

数据库网络是由一层以上的隐藏变量组成的生成模型。隐藏变量本质上一般是二元的；然而，可见单位可能由二进制或实数组成。在分布式数据库网络中，每一层的每一个单元都与其相邻层的每一个单元相连接，尽管可能存在具有稀疏连接单元的 DBN。中间层之间没有连接。如图图 5.9 所示，数据库网络基本上是由若干个 RBM 组成的多层网络。上面两层之间的连接是无方向的。但是，所有其他层之间的连接是定向的，箭头指向最接近数据的层。

除了堆栈的第一层和最后一层，DBN 的每一层都有两个用途。首先，它作为其前一层的隐藏层，并作为其下一层的可见层或输入。DBNs 主要用于视频序列和图像的聚类、识别和生成。

图 5.9:由三个成果管理制组成的 DBN 如图所示

贪婪分层训练

2006 年提出了一种贪婪的分层训练算法来训练数据库网络[126]。这个算法一次训练 DBN 一层。在这种方法中，首先训练 RBM，它将实际数据作为输入并对其建模。

一级 DBN 就是 RBM。贪婪分层方法的核心思想是，在训练了一个 m 级 DBN 的顶级 RBM 之后，在一个( m+1 )级 DBN 中添加参数的同时，参数的解释发生了变化。在 RBM，在层( m-1 )和 m 之间，层 m 的概率分布是根据那个 RBM 的参数定义的。然而，在 DBN 的情况下，层 m 的概率分布是根据上层的参数来定义的。这个过程可以无限地重复，以连接任意多层的数据库网络。

分布式深度信念网络

到目前为止，DBNs 在语音和电话识别[127]、信息检索[128]、人体运动建模[129]等众多应用中取得了很大成就。然而，RBM 和 DBNs 的顺序实现都有各种限制。在大规模数据集上，由于所涉及的长时间、耗时的计算、算法的内存需求等，模型在应用中表现出各种缺点。为了处理大数据，成果管理制和数据库网络需要分布式计算来提供可扩展、一致和高效的学习。

为了使数据库网络默认存储在计算机集群上的大规模数据集，数据库网络应该获得一种基于 Hadoop 和 Map-Reduce 的分布式学习方法。[130]中的论文展示了一种针对 RBM 每一级的键值对方法，其中预训练是在 Map-Reduce 框架中的分布式环境中分层完成的。学习是在 Hadoop 上通过迭代计算方法对训练 RBM 进行的。因此，分布式数据库网络的分布式训练是通过堆叠多个径向基函数实现的。

受限玻尔兹曼机的分布式训练

如前所述，RBM 的能量函数由下式给出:

让一个输入数据集 I = {x _i = i= 1，2，...N} 用于 RBM 的分布式学习。如前一节所述，对于 DBN 的学习，首先通过使用贪婪的分层无监督训练来初始化 RBM 的每个级别中的权重和偏差。分布式训练的目的是学习重量和相关偏差 b 和 c 。对于使用地图缩减的分布式 RBM，一个地图缩减作业在每个时代都是必不可少的。

对于矩阵-矩阵乘法，使用 Gibbs 抽样，并且对于 RBMs 的训练，花费大部分计算时间。因此，为了缩短计算时间，吉布斯采样可以在地图阶段分布在运行 Hadoop 框架上不同数据节点的多个数据集之间。

注

Gibbs 抽样是一种马尔可夫链蒙特卡罗 ( MCMC )算法，用于在传统的直接抽样变得困难时，确定根据指定的多元概率分布估计的观测序列。

最初，初始化训练所需的不同参数，例如可见层和隐藏层的神经元数量、输入层偏差 a 、隐藏层偏差 b 、权重 W 、时期数量(比如说 N )、学习速率等等。时代的数量表示地图和缩减阶段将重复 N 次。对于每个时期，映射器针对数据节点的每个块运行，并执行吉布斯采样以计算 W 、 a 和 b 的近似梯度。然后，减速器用下一个时期所需的计算增量更新这些参数。因此，从第二个时期开始，映射阶段的输入值，即 W 、 a 和 b 的更新值，是根据前一个时期减速器的输出来计算的。

输入数据集 I 被分成许多块，并存储在不同的块中，在每个数据节点上运行。运行在块上的每个映射器将计算存储在该块上的特定块的权重和偏差的近似梯度。然后，减速器计算相应参数的增量，并相应地更新它们。该过程将结果参数和更新值视为该特定时期的地图缩减阶段的最终结果。在每个时期之后，如果是最终时期，缩减器决定是否存储学习的权重，或者是否增加时期索引并将键值对值传播到下一个映射器。

深度信念网络的分布式训练

对于隐藏层数为 L 的分布式数据库神经网络的分布式训练，采用预训练 L 径向基函数神经网络进行学习。底层 RBM 按照讨论的那样进行训练，但是，对于其余的( L-1 )径向基函数，输入数据集会针对每个级别进行更改。

m _第T3】级( L m > 1 ) RBM 的输入数据将是( m-1 ) _第级 RBMs 的隐藏节点的条件概率:

分布式反向传播算法

这是反向传播算法的分布式训练的第二阶段，以调整全局网络。在此过程中，在计算权重梯度时，前馈和反向传播方法占据了大部分计算时间。因此，对于每个时期，为了更快地执行，这个过程应该在输入数据集的每个小批量上并行运行。

在程序的第一步，学习到的重量为一个 L 级 DBN，即 W1 、 W2 、...WL 被载入内存，其他超参数被初始化。在这个微调阶段，map 和 reduce 阶段的主要工作类似于 RBMs 分布式训练。映射器将确定权重的梯度，并最终更新权重增量。缩减器从一个或多个权重更新权重增量，并将输出传递给映射器以执行下一次迭代。

该过程的主要目的是通过将标签层放置在全局网络的顶部并迭代地调整整个层的权重来获得模型的一些辨别能力。

成果管理制和数据库管理系统的性能评价

论文[130]在 Hadoop 集群上进行了分布式 RBM 和 DBN 的实验，以提供与传统顺序方法的比较研究。在 MNIST 数据集上进行了手写数字识别实验。训练集有 60，000 个图像，测试集有 10，000 个图像。HDFS 的数据块大小设置为 64 MB，复制因子为 4。所有节点都设置为最多运行 26 个映射器和 4 个缩减器。感兴趣的读者可以修改块大小和复制因子，以查看使用这些参数的实验的最终结果。

训练时间大幅提升

本实验的目的是在训练时间方面比较分布式径向基函数和数据库网络与传统的训练策略(顺序的)。顺序程序在一个中央处理器上执行，而分布式程序在一个节点的 16 个中央处理器上执行。这两个实验都是在前面提到的 MNIST 数据集上进行的。获得的结果汇总在表 5.1 和表 5.2: 中

表 5.1:该表显示了完成分布式和顺序式成果管理制培训所需的时间

表 5.2:该表表示完成分布式和顺序数据库网络的训练所需的时间

表中显示的数据清楚地描述了使用 Hadoop 的分布式成果管理制和数据库网络相对于传统的顺序方法的优势。模型的分布式方法的训练时间比顺序方法有了显著的改进。此外，使用 Hadoop 框架进行分发的一个关键优势是，它可以根据训练数据集的大小以及用于分发它的机器数量进行非常好的扩展。

本章的下一节将演示使用 Deeplearning4j 的两种模型的编程方法。

使用深度学习实现 4j

本章的这一部分将提供如何使用 Deeplearning4j 编写成果管理制和数据库网络代码的基本思路。读者将能够学习使用本章中提到的各种超参数的语法。

要使用 Deeplearning4j 实现成果管理制和数据库网络，整个想法非常简单。整个实现可以分为三个核心阶段:加载数据或准备数据、网络配置以及模型的训练和评估。

在本节中，我们将首先讨论基于虹膜数据集的径向基函数，然后讨论数据库网络的实现。

受限玻尔兹曼机

对于 RBMs 的构建和训练，首先我们需要定义和初始化模型所需的超参数:

Nd4j.MAX_SLICES_TO_PRINT = -1; 
Nd4j.MAX_ELEMENTS_PER_SLICE = -1; 
Nd4j.ENFORCE_NUMERICAL_STABILITY = true; 
final int numRows = 4; 
final int numColumns = 1; 
int outputNum = 10; 
int numSamples = 150; 

这里的 batchsize 可以初始化为150，也就是说数据集的150个样本一次提交给 Hadoop 框架。请放心，所有其他参数都已初始化，就像我们在前面几章中所做的那样。

int batchSize = 150; 
int iterations = 100; 
int seed = 123; 
int listenerFreq = iterations/2; 

在下一阶段，基于定义的batchsize和每批样本数量，将虹膜数据集加载到系统中:

log.info("Load data....");
DataSetIterator iter = new IrisDataSetIterator(batchSize, numSamples); 
DataSet iris = iter.next();

这里，使用NeuralNetConfiguration.Builder()将 RBM 创建为图层。类似地，受限玻尔兹曼的对象用于存储属性，例如分别应用于观察层和隐藏层的变换-高斯和校正线性变换:

NeuralNetConfiguration conf = new NeuralNetConfiguration.Builder()
.regularization(true)       
 .miniBatch(true) 
.layer(new RBM.Builder().l2(1e-1).l1(1e-3) 
    .nIn(numRows * numColumns)       
    .nOut(outputNum)

ReLU用于激活功能:

.activation("relu") 

weightInit()函数用于权重的初始化，表示放大进入每个节点的输入信号所需的系数的起始值:

.weightInit(WeightInit.RELU) 
 .lossFunction(LossFunctions.LossFunction.RECONSTRUCTION
     _CROSSENTROPY.k(3) 

可见单元使用高斯变换，隐藏层使用校正线性变换。这在深度学习 4j 中非常简单。我们需要通过参数VisibleUnit。GAUSSIAN和HiddenUnit.RECTIFIED里面的.visibleUnit和.hiddenUnit方法:

.hiddenUnit(HiddenUnit.RECTIFIED).visibleUnit(VisibleUnit.GAUSSIAN) 
 .updater(Updater.ADAGRAD).gradientNormalization(Gradient
     Normalization.ClipL2PerLayer) 
    .build())       
  .seed(seed)    
  .iterations(iterations) 

反向传播步长在此定义:

.learningRate(1e-3)
  .optimizationAlgo(OptimizationAlgorithm.LBFGS)       
  .build();       

Layer model = LayerFactories.getFactory(conf.getLayer()).create(conf);       
model.setListeners(new ScoreIterationListener(listenerFreq));

log.info("Evaluate weights....");       
INDArray w = model.getParam(DefaultParamInitializer.WEIGHT_KEY);       
log.info("Weights: " + w);

要缩放到数据集，可以使用数据集类的对象调用scale():

iris.scale(); 

在早期过程中完成评估后，模型现在已经完全准备好接受训练。可以使用fit()方法以类似的方式对其进行训练，就像对早期模型所做的那样，并将getFeatureMatrix作为参数:

log.info("Train model....");       
for(int i = 0; i < 20; i++)
  {       
   log.info("Epoch "+i+":");model.fit(iris.getFeatureMatrix()); }

深度信念网络

正如本章所解释的，DBN 是限制性商业惯例数量的叠加版本。在这一部分中，我们将展示如何使用 Deeplearning4j 以编程方式部署数据库网络。程序的流程将遵循其他模型的标准程序。使用 Deeplearning4j 实现简单的数据库网络非常简单。该示例将展示如何使用数据库网络训练和遍历输入 MNIST 数据。

对于 MNIST 数据集，下面一行指定 batchsize 和示例数，用户将指定这些示例一次在 HDFS 加载数据:

log.info("Load data....");
DataSetIterator iter = new MnistDataSetIterator(batchSize,numSamples,
true);

在下一阶段，将通过将 10 个成果管理制堆叠在一起来构建模型。下面这段代码将指定使用 Deeplearning4j 执行此操作的方式:

log.info("Build model....");
MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
  .seed(seed)
  .iterations(iterations)
  .optimizationAlgo(OptimizationAlgorithm.LINE_GRADIENT_DESCENT)
  .list()
  .layer(0, new RBM.Builder().nIn(numRows * numColumns).nOut(1000)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
  .layer(1, new RBM.Builder().nIn(1000).nOut(500)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
  .layer(2, new RBM.Builder().nIn(500).nOut(250)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
  .layer(3, new RBM.Builder().nIn(250).nOut(100)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
  .layer(4, new RBM.Builder().nIn(100).nOut(30)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())  
  .layer(5, new RBM.Builder().nIn(30).nOut(100)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())  
  .layer(6, new RBM.Builder().nIn(100).nOut(250)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
  .layer(7, new RBM.Builder().nIn(250).nOut(500)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
  .layer(8, new  RBM.Builder().nIn(500).nOut(1000)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
  .layer(9, new OutputLayer.Builder(LossFunctions.LossFunction.
   RMSE_XENT).nIn(1000).nOut(numRows*numColumns).build())
  .pretrain(true)
  .backprop(true)
  .build();

MultiLayerNetwork model = new MultiLayerNetwork(conf);
model.init();

在最后一部分，将使用加载的 MNIST 数据集通过调用fit()方法来训练代码:

log.info("Train model....");
while(iter.hasNext())
  {
   DataSet next = iter.next();
   model.fit(new DataSet(next.getFeatureMatrix(),next.
   getFeatureMatrix()));
  }

执行代码后，该过程将给出以下输出:

Load data.... 
Build model.... 
Train model.... 

o.d.e.u.d.DeepAutoEncoderExample - Train model.... 
o.d.n.m.MultiLayerNetwork - Training on layer 1 with 1000 examples 
o.d.o.l.ScoreIterationListener - Score at iteration 0 is 394.462 
o.d.n.m.MultiLayerNetwork - Training on layer 2 with 1000 examples 
o.d.o.l.ScoreIterationListener - Score at iteration 1 is 506.785 
o.d.n.m.MultiLayerNetwork - Training on layer 3 with 1000 examples 
o.d.o.l.ScoreIterationListener - Score at iteration 2 is 255.582 
o.d.n.m.MultiLayerNetwork - Training on layer 4 with 1000 examples 
o.d.o.l.ScoreIterationListener - Score at iteration 3 is 128.227 

......................................... 

o.d.n.m.MultiLayerNetwork - Finetune phase 
o.d.o.l.ScoreIterationListener - Score at iteration 9 is 132.45428125 

........................... 

o.d.n.m.MultiLayerNetwork - Finetune phase 
o.d.o.l.ScoreIterationListener - Score at iteration 31 is 135.949859375 
o.d.o.l.ScoreIterationListener - Score at iteration 32 is 135.9501875 
o.d.n.m.MultiLayerNetwork - Training on layer 1 with 1000 examples 
o.d.o.l.ScoreIterationListener - Score at iteration 33 is 394.182 
o.d.n.m.MultiLayerNetwork - Training on layer 2 with 1000 examples 
o.d.o.l.ScoreIterationListener - Score at iteration 34 is 508.769 
o.d.n.m.MultiLayerNetwork - Training on layer 3 with 1000 examples 

............................ 

o.d.n.m.MultiLayerNetwork - Finetune phase 
o.d.o.l.ScoreIterationListener - Score at iteration 658 is 142.4304375 
o.d.o.l.ScoreIterationListener - Score at iteration 659 is 142.4311875 

总结

RBM 是一个生成模型，当一些潜在或隐藏的参数被提供给它时，它可以随机产生可见的数据值。在本章中，我们讨论了玻尔兹曼机的概念和数学模型，玻尔兹曼机是一种基于能量的模型。这一章接着讨论并给出了 RBM 的视觉表现。此外，本章还讨论了 CRBM 算法，它是卷积和径向基函数的结合，用于提取高维图像的特征。然后，我们转向流行的数据库网络，这些网络只不过是基于结果的管理系统的堆叠实现。本章进一步讨论了在 Hadoop 框架中分发成果管理制和数据库网络培训的方法。

我们通过为这两个模型提供代码示例来结束这一章。本书的下一章将介绍另一种称为自编码器的生成模型及其各种形式，如去噪自编码器、深度自编码器等。

六、自编码器

|   | “人们担心计算机会变得太聪明，接管世界，但真正的问题是它们太愚蠢，它们已经接管了世界。” |   |
|   | -- 佩德罗·多明戈斯 |

在最后一章中，我们讨论了一个称为受限玻尔兹曼机的生成模型。在本章中，我们将介绍另一种称为自编码器的生成模型。自编码器是一种人工神经网络，通常用于降维、特征学习或提取。

随着本章的继续，我们将详细讨论自编码器的概念及其各种形式。我们还将解释术语正则化自编码器和稀疏自编码器。将讨论稀疏编码的概念以及稀疏自编码器中稀疏因子的选择标准。稍后，我们将讨论深度学习模型 deep autoencoder，以及它使用 Deeplearning4j 的实现。去噪自编码器是传统自编码器的另一种形式，这将在本章的结尾部分讨论。

总的来说，本章分为以下几个小节:

• 自编码器
• 稀疏自编码器
• 深度自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编自编
• 去噪自编码器
• 自编码器的应用

自锚

自编码器是具有一个隐藏层的神经网络，它被训练来学习试图将其输入重构为其输出的恒等式函数。换句话说，自编码器试图通过投影到由隐藏节点定义的低维子空间来复制输入数据。隐藏层 h 描述了一个代码，用于表示输入数据及其结构。因此，该隐藏层被迫从其输入训练数据集学习结构，以便它可以在输出层复制输入。

自编码器的网络可以分为两部分:编码器和解码器。编码器由函数 h=f (k) 描述，试图重构或复制的解码器由 r = g (h) 定义。autoencoder 的基本思想应该是只复制优先输入的那些方面，而不是创建输入的精确副本。它们被设计成这样一种方式，即限制隐藏层仅大致复制，而不是来自输入数据的所有内容。因此，如果自编码器学会为所有的 k 值完全设置 g(f(k) = k ，它就不会被称为有用的。图 6.1 表示自编码器的总体结构，通过代码的内部隐藏层 h 将输入 k 映射到输出 r :

图 6.1:自编码器的一般框图。这里，输入 k 通过隐藏状态或内部表示 h 映射到输出 r。编码器 f 将输入 k 映射到隐藏状态 h，解码器 g 执行 h 到输出 r 的映射

再举一个例子，让我们考虑一下图 6.2 。该图显示了一个用于输入图像块的自编码器的实际表示 k ，它学习隐藏层 h 以输出 r 。输入层 k 是来自图像块的强度值的组合。隐藏层节点帮助将高维输入层投影到隐藏节点的低维激活值中。隐藏节点的这些激活值被合并在一起以生成输出层 r ，其是输入像素的近似。在理想情况下，与输入层节点相比，隐藏层的节点数量通常较少。出于这个原因，他们被迫以仍然可以生成输出层的方式减少信息。

图 6.2:图 6 显示了自编码器如何从输入像素的近似值中学习输出结构的一个实际例子。

将输入的结构复制到输出可能听起来效率不高，但实际上，自编码器的最终结果并不完全取决于解码器的输出。相反，训练自编码器背后的主要思想是复制输入任务的有用属性，这将反映在隐藏层中。

从自编码器中提取所需特征或信息的常见方法之一是将隐藏层 h 限制为具有比输入 k 更小的尺寸 (d ^/ ) ，尺寸 d、即 d ^/ < d 。由此产生的较小维度层可以称为输入 k 的损失压缩表示。隐藏层尺寸小于输入尺寸的自编码器称为欠采样。

所描述的学习过程可以数学地表示为最小化损失函数 L ，其给出如下:

简单来说， L 可以定义为一个损失函数，它惩罚 g (f (k)) 与输入 k 不同。

利用线性解码器功能，自编码器学习形成空间基础，类似于主成分分析 ( 主成分分析)程序。收敛后，隐藏层将形成训练数据集的主子空间作为输入所跨越的空间的基础。然而，与主成分分析不同，这些过程不一定需要生成正交向量。因此，具有非线性编码器功能 f 和非线性解码器功能 g 的自编码器可以学习更强大的主成分分析非线性泛化能力。这将最终在很大程度上增加编码器和解码器的容量。然而，随着容量的增加，自编码器开始显示不需要的行为。

然后，它可以学习在不注意提取所需信息的情况下复制整个输入。从理论上讲，自编码器可能是一维代码，但实际上，一个非常强大的非线性编码器可以学习用代码 i 表示每个训练示例 k(i) 。解码器然后将这些整数 (i) 映射到特定训练示例的值。因此，使用容量更大的自编码器时，仅复制输入数据集中的有用要素会完全失败。

注

主成分分析是一种统计方法，它应用正交变换将一组可能相关的观测变量转换成一组称为主成分的线性相关变量。主成分分析法的主成分数小于或等于原始输入变量数。

类似于提到的欠采样自编码器的边缘情况问题，其中隐藏层的尺寸小于输入的尺寸，自编码器，其中隐藏层或代码被允许具有相等的输入尺寸，经常面临相同的问题。

隐藏代码的维数大于输入维数的自编码器称为过完备自编码器。这种类型的自编码器更容易出现上述问题。即使是线性编码器和解码器也可以执行从输入到输出的学习，而无需学习输入数据集的任何期望属性。

正则化自编码器

通过为隐藏层选择合适的尺寸，以及根据模型分布的复杂性选择编码器和解码器的容量，可以成功地构建任何类型架构的自编码器。能够提供相同功能的自编码器称为正则化自编码器。

除了将输入复制到输出的能力之外，正则化自编码器还具有损失函数，这有助于模型拥有其他属性。这些包括对缺失输入的鲁棒性、数据表示的稀疏性、表示导数的小性等。即使是非线性且过完备的正则化自编码器也能够至少了解一些关于数据分布的信息，而不管模型的容量如何。正则化自编码器[131]能够借助重构误差和正则化器之间的有效对立来捕获训练分布的结构。

稀疏自编码器

分布式稀疏表示是深度学习算法中学习有用特征的关键之一。它不仅是一种连贯的数据表示模式，而且有助于捕捉大多数真实世界数据集的生成过程。在本节中，我们将解释自编码器如何促进数据的稀疏性。我们将从介绍稀疏编码开始。当一个输入触发神经网络中相对少量节点的激活时，代码被称为稀疏的，这些节点组合起来以稀疏的方式表示它。在深度学习技术中，使用类似的约束来生成稀疏代码模型，以实现常规的自编码器，这些自编码器用稀疏常数训练，称为稀疏自编码器。

稀疏编码

稀疏编码是一种无监督方法，用于学习多组过完备的基，以便以连贯有效的方式表示数据。稀疏编码的主要目标是确定一组向量 (n) v _i ，使得输入向量 k 可以表示为这些向量的线性组合。

从数学上讲，这可以表示如下:

这里a_IT3】是与每个向量相关的系数 v _{i 。}

借助 PCA，我们可以连贯地学习一整套基向量；然而，我们想要学习一组过完备的基向量来表示输入向量 k ，其中 n > m 。使过完备基的原因是基向量通常能够捕捉输入数据固有的模式和结构。然而，过完备有时会引起退化，以此为基础，系数 a _i 不能唯一地识别输入向量 k 。为此，在稀疏编码中引入了一个称为稀疏性的附加标准。

简单地说，稀疏性可以被定义为具有很少的非零分量或者具有很少的不接近零的分量。如果对于给定的输入向量，非零系数的数量或者离零很远的系数的数量应该很少，则系数集合 a _i 被称为稀疏的。

有了对稀疏编码的基本理解，我们现在可以进入下一部分，了解稀疏编码概念如何用于自编码器来生成稀疏自编码器。

稀疏自编码器

当输入数据集保持某种结构时，如果输入特征是相关的，那么即使是简单的自编码器算法也可以发现这些相关性。此外，在这种情况下，一个简单的自编码器最终将学习一个低维表示，这类似于主成分分析。

这种看法是基于这样一个事实，即隐藏层的数量相对较少。然而，通过对网络施加其他约束，即使有大量的隐藏层，网络仍然可以从输入向量中发现期望的特征。

稀疏自编码器通常用于学习特征以执行其他任务，如分类。添加了稀疏性约束的自编码器必须响应其所训练的输入数据集的独特统计特征，而不是简单地充当身份函数。

图 6.3:图中显示了一个稀疏自编码器的典型例子

稀疏自编码器是一种带有稀疏执行器的自编码器，它有助于指导单层网络学习隐藏层代码。这种方法最大限度地减少了重构错误，同时限制了重构输出所需的码字数量。这种稀疏化算法可以看作是一个分类问题，它将输入限制在一个单一的类值，这有助于减少预测误差。

在这一部分，我们将用一个简单的架构来解释稀疏自编码器。图 6.3 显示了稀疏自编码器的最简单形式，由单个隐藏层 h 组成。隐藏层 h 通过权重矩阵 W 连接到输入向量 K ，形成编码步骤。在解码步骤中，隐藏层 h 借助于捆绑权重矩阵 W ^T 输出到重构向量 K` 。在网络中，激活函数表示为 f ，偏置项表示为 b 。激活函数可以是任何函数:线性函数、乙状线函数或 ReLU 函数。

计算隐藏代码 l 的稀疏表示的公式如下:

重构输出是隐藏表示，使用以下公式线性映射到输出:

通过重构误差的反向传播进行学习。所有参数均经过优化，以最小化均方误差，如下所示:

现在我们已经有了网络设置，我们可以添加稀疏化组件，它驱动向量 L 朝向稀疏表示。这里，我们将使用 k 稀疏自编码器来实现层的稀疏表示。(不要混淆 K-稀疏表示的 k 和输入向量的 K 。为了区分这两者，我们分别用小 k 和大写 K 来表示这两个。)

k-稀疏自编码器

k-Sparse 自编码器[132]是基于一个具有绑定权重和线性激活函数的自编码器。k 稀疏自编码器的基本思想非常简单。在自编码器的前馈阶段，一旦我们计算出隐藏代码 l = WK + b ，而不是从所有隐藏单元重建输入，该方法搜索 k 最大的隐藏单元，并将剩余隐藏单元的值设置为零。

确定 k 最大隐藏单位有替代方法。通过对隐藏单元的活动进行排序或使用 ReLU，调整具有阈值的隐藏单元，直到我们确定 k 最大的活动。这个寻找 k 最大活动的选择步骤是非线性的。选择步骤的行为类似于正则化，这有助于防止在通过重构输入来构建输出时使用大量隐藏单元。

如何选择稀疏度 k

如果我们实施低稀疏度，比如说 k=10 ，那么在 k 稀疏自编码器的训练过程中可能会出现问题。一个常见的问题是，在最初的几个时期，算法将积极地开始将单个隐藏单元分配给训练案例组。这些现象可以与 k-means 聚类方法进行比较。在连续的时代，这些隐藏的单位将被选择和重新实施，但其他隐藏的单位不会被调整。

这个问题可以通过以适当的方式调度稀疏级别来解决。让我们假设我们的目标是稀疏度为 10。在这种情况下，我们可以从较大的稀疏度开始，比如说 k=100 或 k=200 。因此，k 稀疏自编码器可以训练所有存在的隐藏单元。渐渐地，在半个历元内，我们可以将 k=100 的稀疏度线性降低到 k=10 。这大大增加了所有隐藏单位被选中的几率。然后，我们将在下半个纪元保持 k=10 。这样，这种调度将保证即使在低稀疏度的情况下，所有的过滤器都将被训练。

稀疏度的影响

在设计或实现 k 稀疏自编码器时， k 值的选择非常关键。 k 的值决定了理想的稀疏级别，这有助于使该算法非常适合各种数据集。例如，一个应用可以用于预训练深度辨别神经网络或浅层网络。

如果我们对 k 取一个较大的值(比如说在 MNIST 数据集上 k=200 ，算法将倾向于识别和学习数据集的非常局部的特征。这些特性有时表现得过于过早，不能用于浅层体系结构的分类。浅层架构通常有一个简单的线性分类器，它没有足够的架构强度来合并所有这些特性并获得相当高的分类率。然而，相似的局部特征对于预先训练深度神经网络是非常理想的。

对于稀疏级别的较小值(比如说 MNIST 数据集上的 k=10 ，使用较小的隐藏单元集从输入中重建输出。这最终导致从数据集中检测全局特征，而不是像前面的情况那样检测局部特征。这些局部性较小的特征适用于分类任务的浅层体系结构。相反，这些类型的情况对于深度神经网络来说并不理想。

深度自编码器

到目前为止，我们只讨论了简单自编码器的单层编码器和单层解码器。然而，具有多个编码器和解码器的深度自编码器带来更多优势。

前馈网络在深度时表现更好。自编码器基本上是前馈网络；因此，基本前馈网络的优点也可以应用于自编码器。编码器和解码器是自编码器，也像前馈网络一样工作。因此，我们也可以在这些组件中利用前馈网络的深度优势。

在这种情况下，我们还可以谈论通用逼近器定理，该定理确保具有至少一个隐藏层和足够隐藏单元的前馈神经网络可以以任何精度产生任何任意函数的逼近。遵循这个概念，具有至少一个隐藏层并包含足够的隐藏单元的深度自编码器可以很好地逼近从输入到代码的任何映射。

注

人们可以用两层网络以任何精度逼近任何连续函数。在人工神经网络的数学理论中，通用逼近函数指出，前馈网络可以逼近 R ⁿ 的紧致子集的任何连续函数，如果它至少有一个具有有限数量神经元的隐层。

与浅层架构相比，深层自编码器具有许多优势。自编码器不平凡的深度抑制了表示一些函数的计算。此外，自编码器的深度大大减少了学习功能所需的训练数据量。甚至在实验中，已经发现与浅自编码器相比，深自编码器提供更好的压缩。

为了训练深度自编码器，通常的做法是训练一堆浅自编码器。因此，为了训练深度自编码器，经常会遇到一系列浅自编码器。在接下来的小节中，我们将深入讨论深度自编码器的概念。

深度自编码器的训练

这里介绍的深度自编码器的设计是基于 MNIST 手写数字数据库的。在论文[133]中，解释了一个结构良好的深度自编码器的构建和训练过程。训练深度自编码器的基础是通过三个阶段，即:预训练、展开和微调。

1. Pre-training: The first phase of training a deep autoencoder is 'pre-training'. The main purpose of this phase is to work on binary data, generalize in to a real-valued data, and then to conclude that it works well for various datasets.

   我们已经有足够的见解，单层隐藏单元不是在一大组图像中建模结构的合适方式。深度自编码器由多层受限玻尔兹曼机组成。在第 5 章、受限玻尔兹曼机中，我们给出了关于受限玻尔兹曼机如何工作的足够信息。使用相同的概念，我们可以继续构建深度自编码器的结构:

   

   图 6.4:深度自编码器的预训练包括学习一堆受限玻尔兹曼机(RBMs)，其中每个 RBM 拥有一层特征检测器。一台受限玻尔兹曼机的学习特性被用作“输入数据”来训练堆栈的下一个 RBM。在预训练阶段之后，所有的 RBM 被展开或展开以构建深度自编码器。然后，使用误差导数的反向传播方法对这种深度自编码器进行微调。

   当 RBM 的第一层由数据流驱动时，该层开始学习特征检测器。这种学习可以被视为下一层学习的输入数据。这样，第一层的特征检测器成为学习受限玻尔兹曼机的下一层的可见单元。这个逐层学习的过程可以根据需要重复多次。这个过程在预先训练深度自编码器的权重方面确实非常有效。在每一层之后捕获的特征在下面隐藏单元的活动之间具有一串高阶相关性。第一部分图 6.4 给出了该程序的流程图。在处理基准数据集 MNIST 时，深度自编码器将在每个 RBM 之后使用二进制转换。为了处理实值数据，深度自编码器在每个受限玻尔兹曼机层之后使用高斯校正变换。

   

   图 6.5:编码器和解码器的数量或向量在各阶段如何变化的图示。

2. Unrolling: Once the multiple layers of feature detectors of the deep autoencoders are pre-trained, the whole model is unrolled to generate the encoder and decoder networks, which at first use the same weights. We will explain each of the designs of each part given in the second part of the image separately to have a better understanding of this phase.

   • 编码器:对于 28x28 像素图像的 MNIST 数据集，网络将获得 784 像素的输入。根据经验法则，深度自编码器第一层的参数数量应该稍大一些。如图 6.4 、 2000 参数取网络第一层。这听起来可能不合理，因为采用更多参数作为输入会增加网络过度拟合的机会。然而，在这种情况下，增加参数的数量将最终增加输入的特征，这又使得自编码器数据的解码成为可能。

   • As shown in Figure 6.4, the layers would be 2000, 1000, 500, and 30-nodes wide respectively. A snapshot of this phenomenon is depicted in Figure 6.5. In the end, the encoder will produce a vector 30 numbers long. This 30 number vector is the last layer of the encoder of the deep autoencoder. A rough outline for this encoder will be as follows:

     

   • Decoder: The 30 number vectors found at the end of the encoding phase are the encoded version of the 28x28 pixel images. The second part of the deep autoencoder is the decoder phase, where it basically learns how to decode the condensed vector. Hence, the output of the encoder phase (30-number vectors) becomes the input of the decoder phase. This half of the deep autoencoder is a feed-forward network, where the encoded condensed vector proceeds towards the reconstructed input after each layer. The layers shown in Figure 6.4 are 30, 500, 1000, and 2000. The layers initially possess the same weights as their counterparts in the pre-training network; it is just that the weights are transposed as shown in the figure. A rough outline for this encoder will be as follows:

     

     所以，解码半个深度自编码器的主要目的是学习如何重建图像。该操作在第二前馈网络中执行，第二前馈网络也执行反向传播，反向传播通过重构熵发生。

3. 微调:在微调阶段，随机活动被确定性的实值概率所取代。通过使用反向传播方法，与整个深度自编码器的每一层相关联的权重被微调用于最佳重建。

使用深度学习实现深度自编码器 4j

所以，你现在有足够的想法如何建立一个深度自编码器使用一些有限的玻尔兹曼机。在本节中，我们将解释如何借助 Deeplearning4j 设计深度自编码器。

我们将使用与上一节相同的 MNIST 数据集，并保持深度自编码器的设计与我们之前解释的相似。

正如在前面的示例中已经解释的那样，从原始 MNIST 数据集使用了 1024 个示例的小批量大小，该数据集可以划分为多个 Hadoop 块。每个工作人员将在 Hadoop 分布式文件系统上并行运行这些 N 多个数据块。实现深度自编码器的代码流程简单明了。

步骤如下所示:

1. 在 HDFS 批量加载 MNIST 数据集。每批将包含1024个实例。
2. 开始建立模型。
3. 执行编码操作。
4. 执行解码操作。
5. 通过调用fit()方法训练模型。

final int numRows = 28;

设置 Hadoop 环境所需的初始配置。batchsize设置为1024。

final int numColumns = 28; 
int seed = 123; 
int numSamples = MnistDataFetcher.NUM_EXAMPLES; 
int batchSize = 1024; 
int iterations = 1; 
int listenerFreq = iterations/5; 

将数据加载到 HDFS:

log.info("Load data...."); 
DataSetIterator iter = new  MnistDataSetIterator(batchSize,numSamples,true); 

我们现在都准备好构建模型，添加受限玻尔兹曼机的层数来构建深度自编码器:

log.info("Build model...."); 
MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder() 
  .seed(seed) 
  .iterations(iterations) 
  .optimizationAlgo(OptimizationAlgorithm.LINE_GRADIENT_DESCENT) 

为了用指定的层(这里是八层)创建一个列表生成器，我们调用。list()方法:

 .list(8) 

现在下一步是构建模型的编码阶段。这可以通过随后将受限玻尔兹曼机添加到模型中来实现。编码阶段有四层受限玻尔兹曼机，其中每一层分别有2000、1000、500和30节点:

  .layer(0, new RBM.Builder().nIn(numRows *    
  numColumns).nOut(2000).lossFunction(LossFunctions.LossFunction
  .RMSE_XENT).build()) 
  .layer(1, new RBM.Builder().nIn(2000).nOut(1000)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build()) 
  .layer(2, new RBM.Builder().nIn(1000).nOut(500)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build()) 
  .layer(3, new RBM.Builder().nIn(500).nOut(30)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build()) 

编码器之后的下一个阶段是解码器阶段，我们将以类似的方式再使用四个受限玻尔兹曼机:

  .layer(4, new RBM.Builder().nIn(30).nOut(500)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())  
  .layer(5, new RBM.Builder().nIn(500).nOut(1000)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build()) 
  .layer(6, new RBM.Builder().nIn(1000).nOut(2000)
  .lossFunction(LossFunctions.LossFunction.RMSE_XENT).build()) 
  .layer(7, new OutputLayer.Builder(LossFunctions.LossFunction.MSE)
  .activation("sigmoid").nIn(2000).nOut(numRows*numColumns).build()) 

由于现在已经构建了所有的中间层，我们可以通过调用build()方法来构建模型:

 .pretrain(true).backprop(true) 
  .build(); 

实现的最后一个阶段是训练深度自编码器。可以通过调用fit ()方法来完成:

MultiLayerNetwork model = new MultiLayerNetwork(conf); 
model.init(); 

model.setListeners(new ScoreIterationListener(listenerFreq)); 

log.info("Train model...."); 
while(iter.hasNext())
  { 
   DataSet next = iter.next(); 
   model.fit(new DataSet(next.getFeatureMatrix(),next
   .getFeatureMatrix())); 
  } 

去噪自编码器

从输入重建输出并不总是能保证期望的输出，有时会以简单地复制输入而告终。为了防止这种情况，在[134]中，提出了一种不同的策略。在该建议的体系结构中，不是在输入数据的表示中放置一些约束，而是基于清除部分损坏的输入来构建重建标准。

“一个好的表示是可以从一个被破坏的输入中稳健地获得的，并且对于恢复相应的干净输入是有用的。”

去噪自编码器是一种以损坏的数据作为输入的自编码器，模型被训练成预测原始的、干净的和未损坏的数据作为其输出。在本节中，我们将解释设计去噪自编码器背后的基本思想。

去噪自编码器的体系结构

去噪自编码器背后的主要思想是引入一个损坏过程，即 Q (k ^/ | k) ，并从损坏的输入 k ^/ 重建输出 r 。图 6.6 显示了去噪自编码器的整体表示。在去噪自编码器中，对于训练数据 k 的每一个小批次，应该使用 Q (k ^/ | k) 生成相应的损坏的k^//T17】。从那里，如果我们把初始输入看作是被破坏的输入 k ^/ ，那么整个模型可以看作是一个基本编码器的一种形式。被破坏的输入 k ^/ 被映射生成隐藏表示 h 。

因此，我们得到以下结果:

从这个隐藏的表示中，重构的输出 r 可以使用 r = g (h) 来导出。去噪自编码器重新组织数据，然后尝试了解数据以重建输出。这种数据重组或数据混洗产生噪声，模型从噪声中学习特征，这允许对输入进行分类。在网络训练期间，它产生一个模型，该模型通过损失函数计算该模型和基准之间的距离。其思想是最小化训练集的平均重建误差，以使输出 r 尽可能接近原始未被破坏的输入 k 。

图 6.6:设计去噪自编码器的步骤。原始输入为 k；从 k 导出的损坏输入表示为 k ^/ 。最终输出表示为 r。

堆叠去噪自编码器

构建堆叠去噪自编码器来初始化深度神经网络的基本概念类似于堆叠多个限制性玻尔兹曼机来构建 Deep credit 网络或传统的深度自编码器。仅在每个单独层的初始去噪训练中需要产生损坏的输入，以帮助学习有用的特征提取。

一旦我们知道编码函数 f 达到隐藏状态，它就被用在原始的、未被破坏的数据上，以达到下一个级别。一般来说，不会出现损坏或噪声来生成表示，这将作为训练下一层的未损坏输入。堆叠式去噪自编码器的一个关键功能是在输入通过时进行逐层无监督预训练。一旦一个层被预先训练以对来自前一层的输入执行特征选择和提取，就可以进行下一阶段的监督微调，就像传统的深度自编码器一样。

图 6.7 展示了设计堆叠式去噪自编码器的详细表示。学习和堆叠去噪自编码器的多个层的整个过程如下图所示:

图 6.7:堆叠去噪自编码器的表示

使用深度学习实现堆叠去噪自编码器 4j

通过创建一个拥有自编码器作为其隐藏层的MultiLayerNetwork，可以使用深度学习 4j 构建堆叠去噪自编码器。自编码器有一些corruptionLevel，称为噪声。

在这里，我们设置了建立模型所需的初始配置。出于说明的目的，采用了一组1024数量的例子。输入数和输出数分别取为1000和2。

int outputNum = 2;
int inputNum = 1000;
int iterations = 10;
int seed = 123;
int batchSize = 1024;

输入数据集的加载与深度自编码器部分所述相同。因此，我们将直接跳到如何构建堆栈去噪自编码器。我们采用了一个五隐藏层深度模型来说明该方法:

log.info ("Build model....");
MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder ()
.seed(seed)
.gradientNormalization(GradientNormalization
  .ClipElementWiseAbsoluteValue)
.gradientNormalizationThreshold (1.0)
.iterations(iterations)
.updater(Updater.NESTEROVS)
.momentum(0.5)
.momentumAfter(Collections.singletonMap(3, 0.9))
.optimizationAlgo(OptimizationAlgorithm.CONJUGATE_GRADIENT)
.list()
.layer(0, new AutoEncoder.Builder()
.nIn(inputNum)
.nOut(500)
.weightInit(WeightInit.XAVIER)
.lossFunction(LossFunction.RMSE_XENT)

以下代码表示有多少输入数据将被损坏:

.corruptionLevel (0.3)
    .build())
  .layer(1, new AutoEncoder.Builder()
    .nIn(500)
    .nOut(250)
    .weightInit(WeightInit.XAVIER).lossFunction
    (LossFunction.RMSE_XENT)
    .corruptionLevel(0.3)
    .build())
  .layer(2, new AutoEncoder.Builder()
    .nIn(250)
    .nOut(125)
    .weightInit(WeightInit.XAVIER).lossFunction         
    (LossFunction.RMSE_XENT)
    .corruptionLevel(0.3)
    .build())
  .layer(3, new AutoEncoder.Builder()
     .nIn(125)
     .nOut(50)
     .weightInit(WeightInit.XAVIER).lossFunction
     (LossFunction.RMSE_XENT)
     .corruptionLevel(0.3)
     .build())
   .layer(4, new OutputLayer.Builder   
   (LossFunction.NEGATIVELOGLIKELIHOOD)
     .activation("softmax")
     .nIn(75)
     .nOut(outputNum)
     .build())
   .pretrain(true)
.backprop(false)
.build();

模型建立后，通过调用fit()方法进行训练:

try {
     model.fit(iter);
    } 
catch(Exception ex)
   {
     ex.printStackTrace();
   }

自编码器的应用

自编码器可以成功地应用于许多用例中，因此在深度学习领域获得了广泛的应用。在本节中，我们将讨论自编码器的重要应用和用途:

• 降维:如果你还记得的话，在第一章、深度学习入门中，我们引入了‘维度诅咒’的概念。降维是深度学习最早的应用之一。最初研究自编码器是为了克服维数灾难的问题。从这一章中，我们已经对深度自编码器如何处理高维数据以降低最终输出的维数有了一个合理的想法。
• 信息检索:自编码器一个比较重要的应用是在信息检索方面。信息检索基本上意味着在数据库中搜索与输入的查询相匹配的一些条目。在高维数据中搜索通常是一项繁琐的任务；然而，随着数据集的降维，在某些类型的低维数据中，搜索会变得非常高效。从自编码器获得的降维可以生成低维和二进制性质的代码。这些可以存储在键值存储的数据结构中，其中键是二进制代码向量，值是相应的条目。这样的键值存储通过返回与查询匹配的所有数据库条目来帮助我们执行信息检索。这种通过降维和二进制编码来检索信息的方法被称为语义散列法[135]。
• 图像搜索:如深度自编码器部分所述，深度自编码器能够将更高维度的图像数据集压缩到非常少的向量，比如 30 个。因此，这使得高维图像的图像搜索更加容易。一旦图像被上传，搜索引擎会将其压缩成小向量，然后将该向量与其索引中的所有其他向量进行比较。对于搜索查询，包含相似数字的向量将被返回并转换成映射图像。

总结

自编码器是最流行和应用最广泛的生成模型之一，本章已经讨论过了。自编码器基本上帮助两个阶段:一个是编码器阶段，另一个是解码器阶段。在本章中，我们用适当的数学解释详细阐述了这两个阶段。接下来，我们解释了一种特殊的自编码器，称为稀疏自编码器。我们还通过解释深度自编码器讨论了如何在深度神经网络世界中使用自编码器。深度自编码器由多层受限玻尔兹曼机组成，这些机器参与网络的编码器和解码器阶段。我们解释了如何使用 Deeplearning4j 部署深度自编码器，方法是将输入数据集的块加载到 Hadoop 分布式文件系统中。在本章的后面，我们介绍了最流行的自编码器形式，称为去噪自编码器，以及其深度网络版本，称为堆叠去噪自编码器。还展示了使用 Deeplearning4j 的堆叠去噪自编码器的实现。我们通过概述自编码器的常见应用来结束本章。

在下一章中，我们将借助 Hadoop 讨论深度学习的一些常见有用应用。

七、使用 Hadoop 的其他深度学习操作

|   | “在拓荒者时代，他们用牛来拉重物，当一头牛拉不动一根木头时，他们不会试图长出更大的牛。我们不应该尝试更大的计算机，而应该尝试更多的计算机系统。” |   |
|   | - 格蕾丝·赫柏 |

到目前为止，在本书中，我们讨论了各种深度神经网络模型及其概念、应用以及分布式环境中模型的实现。我们还解释了为什么集中式计算机很难使用这些模型存储和处理大量数据并提取信息。Hadoop 已经被用来克服大规模数据带来的限制。

由于我们现在已经到了本书的最后一章，我们将主要讨论三个最常用的机器学习应用的设计。我们将使用 Hadoop 框架解释大规模视频处理、大规模图像处理和自然语言处理的一般概念。

本章的组织如下:

• 基于 Hadoop 的大规模分布式视频处理
• 基于 Hadoop 的大规模图像处理
• 使用 Hadoop 的自然语言处理

数字世界中大量可用的视频在最近几天生成的大数据中占据了很大份额。在第二章大规模数据分布式深度学习中，我们讨论了数百万视频是如何上传到 YouTube、脸书等各种社交媒体网站的。除此之外，出于安全目的安装在各种商场、机场或政府机构的监控摄像头每天都会生成大量视频。由于这些视频的巨大存储消耗，它们大多数通常存储为压缩视频文件。在这些企业中，大部分都是安全摄像头全天运行，后期存储重要视频，以备日后调查。

这些视频包含隐藏的“热点数据”或信息，需要快速处理和提取。因此，处理和分析这些大规模视频的需求已经成为数据爱好者的首要任务之一。此外，在许多不同的研究领域，如生物医学工程、地质学和教育研究，需要处理这些大规模的视频，并使它们在不同的位置可供详细分析。

在本节中，我们将研究使用 Hadoop 框架处理大规模视频数据集。大规模视频处理的主要挑战是将视频从压缩格式转码为非压缩格式。为此，我们需要一个分布式视频转码器，将视频写入 Hadoop 分布式文件系统 ( HDFS )中，并行解码比特流组块，生成序列文件。

当在 HDFS 处理一个输入数据块时，每个映射器进程分别访问每个拆分中的行。然而，在大规模视频数据集的情况下，当它被分割成多个预定义大小的块时，每个映射器进程应该分别解释比特流的块。然后，映射器过程将提供对解码视频帧的访问，用于后续分析。在下面的小节中，我们将讨论如何将包含视频比特流的 HDFS 的每个块转码为图像集，以进行进一步分析。

Hadoop 中的分布式视频解码

大多数流行的视频压缩格式，如 MPEG-2 和 MPEG-4，在比特流中遵循分层结构。在本小节中，我们将假设所使用的压缩格式的比特流具有分层结构。为简单起见，我们将解码任务分为两个不同的地图缩减作业:

1. Extraction of video sequence level information: From the outset, it can be easily predicted that the header information of all the video dataset can be found in the first block of the dataset. In this phase, the aim of the map-reduce job is to collect the sequence level information from the first block of the video dataset and output the result as a text file in the HDFS. The sequence header information is needed to set the format for the decoder object.

   对于视频文件，新的FileInputFormat应该用它自己的记录阅读器来实现。然后，每个记录阅读器将以这种格式向每个地图进程提供一对:<LongWritable, BytesWritable>。输入键表示文件中的字节偏移量；对应于BytesWritable的值是包含整个数据块的视频比特流的字节数组。

   对于每个映射过程，键值与0进行比较，以识别它是否是视频文件的第一个块。一旦第一块被识别，比特流被解析以确定序列级别信息。然后，这些信息被转储到一个.txt文件中，写入 HDFS。让我们将.txt文件的名称表示为input_filename_sequence_level_header_information.txt。由于只有 map 过程可以为我们提供所需的输出，因此该方法的 reducer count 被设置为0。

   注

   假设一个包含以下数据的文本文件:深度学习 配合 Hadoop 现在第一行的偏移量为0，Hadoop 作业的输入为<0,Deep Learning>，第二行的偏移量为<14,with Hadoop>。每当我们将文本文件传递给 Hadoop 作业时，它都会在内部计算字节偏移量。

2. Decode and convert the blocks of videos into sequence files: The aim of this Map-reduce job is to decode  each block  of the video datasets and generate a corresponding sequence file. The sequence file will contain the decoded video frames of each block of data in JPEG format. The InputFileFormat file and record reader should be kept same as the first Map-reduce job. Therefore, the <key, value> pairs of the mapper input is <LongWritable, BytesWritable>.

   

   图 7.1:使用 Hadoop 进行视频解码的整体表示

   • 在第二阶段，第一个作业的输出被视为第二个地图缩减作业的输入。因此，该作业的每个映射器将读取 HDFS 中的序列信息文件，并将该信息与作为BytesWritable输入的比特流缓冲区一起传递。
   • 映射过程基本上将解码后的视频帧转换为 JPEG 图像，并生成一个<key, value>对作为映射过程的输出。地图处理输出的键将输入的视频文件名和块号编码为video_filename_block_number。与该键对应的输出值是BytesWritable，它存储解码视频块的 JPEG 比特流。
   • 然后，缩减器会将数据块作为输入，并将解码后的帧简单地写入包含 JPEG 图像的序列文件，作为进一步处理的输出格式。整个过程的简单格式和概述见图 7.1 。出于说明目的，我们拍摄了一段输入视频sample.m2v。此外，在本章中，我们将讨论如何用 HDFS 处理大规模图像文件(来自序列文件)。

   注

   映射器输入<key,value>:<LongWritable, BytesWritable>

   例如:<17308965, BytesWritable> 从映射器输出<key,value>:<Text, BytesWritable> 例如:<sample.m2v_3, BytesWritable>

利用 Hadoop 进行大规模图像处理

我们在前面的章节中已经提到了图像的大小和体积是如何日益增大的；对于集中式计算机来说，存储和处理这些海量图像的需求是很困难的。让我们考虑一个例子来获得这种情况的实际想法。让我们拍一张 81025 像素乘 86273 像素的大规模图像。每个像素由三个值组成:红色、绿色和蓝色。考虑一下，要存储这些值，需要一个 32 位精度浮点数。因此，该图像的总内存消耗可以计算如下:

86273 * 8125 * 3 * 32 位元= 78.12 GB

抛开对这张图像的任何后期处理不谈，因为可以清楚地得出结论，传统计算机甚至不可能将这么多数据存储在其主存储器中。尽管一些先进的计算机配置更高，但考虑到投资回报，大多数公司不会选择这些计算机，因为它们太贵，无法购买和维护。因此，正确的解决方案应该是在商品硬件中运行图像，以便图像可以存储在它们的内存中。在本节中，我们将解释如何使用 Hadoop 以分布式方式处理这些海量图像。

地图缩减作业的应用

在本节中，我们将讨论如何使用 Hadoop 的地图缩减作业来处理大型图像文件。在作业开始之前，所有要处理的输入图像都被加载到 HDFS。在操作过程中，客户端发送一个作业请求，该请求通过名称节点。名称节点从客户端收集该请求，搜索其元数据映射，然后将文件系统的数据块信息以及数据块的位置发送回客户端。一旦客户端获得数据块的元数据，它就会自动访问所请求的数据块所在的数据节点，然后通过适用的命令处理这些数据。

用于大规模图像处理的地图缩减作业主要负责控制整个任务。基本上，这里我们解释了可执行 shell 脚本文件的概念，它负责从 HDFS 收集可执行文件的输入数据。

使用 Map-reduce 编程模型的最佳方式是设计我们自己的 Hadoop 数据类型，用于直接处理大量图像文件。该系统将使用 Hadoop Streaming 技术，帮助用户创建和运行特殊类型的地图缩减作业。这些特殊类型的作业可以通过前面提到的可执行文件来执行，该文件将充当映射器或缩减器。程序的映射器实现将使用 shell 脚本来执行必要的操作。shell 脚本负责调用图像处理的可执行文件。图像文件列表被作为这些可执行文件的输入，用于进一步处理。这种处理或输出的结果随后被写回到 HDFS。

因此，输入图像文件应该首先写入 HDFS，然后在 Hadoop Streaming 输入的特定目录中生成一个文件列表。该目录将存储文件列表的集合。文件列表的每一行都将包含要处理的图像文件的 HDFS 地址。映射器的输入将是Inputsplit类，这是一个文本文件。shell 脚本管理器逐行读取文件，并从元数据中检索图像。然后，它调用图像处理可执行文件来进一步处理图像，然后将结果写回 HDFS。因此，映射器的输出是最终期望的结果。因此，映射器完成所有工作，从 HDFS 检索图像文件，进行图像处理，然后将其写回 HDFS。该过程中的减压器数量可以设置为零。

这是一个如何利用 Hadoop 通过二值图像处理方法处理大量图像的简单设计。也可以部署其他复杂的图像处理方法来处理大规模图像数据集。

使用 Hadoop 的自然语言处理

网络中信息的指数级增长增加了大规模非结构化自然语言文本资源的扩散强度。因此，在过去的几年里，人们对提取、处理和共享这些信息的兴趣大大增加了。在规定的时间框架内处理这些知识来源已被证明是各种研究和商业行业的一项重大挑战。在本节中，我们将描述使用 Hadoop 以分布式方式抓取网络文档、发现信息和运行自然语言处理的过程。

要设计自然语言处理 ( NLP )的架构，首先要执行的任务是从大规模非结构化数据中提取带注释的关键词和关键短语。为了在分布式体系结构上执行自然语言处理，可以选择 Apache Hadoop 框架，因为它具有高效和可扩展的解决方案，并且还可以提高故障处理和数据完整性。大规模的网络爬虫可以设置为从网络中提取所有非结构化数据，并将其写入 Hadoop 分布式文件系统中进行进一步处理。为了执行特定的自然语言处理任务，我们可以使用开源的 GATE 应用，如论文[136]所示。图 7.2 中显示了分布式自然语言处理架构的初步设计概述。

为了分配网络爬虫的工作，可以使用 map-reduce 并在多个节点上运行。NLP 任务的执行以及最终输出的写入都是通过 Map-reduce 来执行的。整个体系结构将依赖于两个输入文件:I)为抓取存储在seed_urls.txt中的特定网页而给出的seedurls和 ii)NLP 应用的路径位置(例如安装 GATE 的位置)。网络爬虫将从.txt文件中获取seedurls，并为那些并行的文件运行爬虫。异步地，一个提取插件在被抓取的网页上搜索关键词和关键短语，并与被抓取的网页一起独立执行。最后一步，一个专门的程序根据需要将提取的关键词和关键短语存储在外部的 SQL 数据库或 NoSQL 数据库中，如Elasticsearch。架构中提到的所有这些模块将在以下小节中描述。

网络爬虫

为了解释这个阶段，我们不会深入解释，因为它几乎超出了本书的范围。网络爬行有几个不同的阶段。第一个阶段是 URL 发现阶段，该过程将每个种子 URL 作为seed_urls.txt文件的输入，并在分页 URL 中导航以发现相关 URL。这个阶段定义了将在下一阶段获取的一组 URL。

下一个阶段是获取网址的页面内容并保存在磁盘中。该操作是逐段完成的，其中每个段将包含一些预定义数量的网址。该操作将在不同的DataNodes上并行运行。这些阶段的最终结果存储在 Hadoop 分布式文件系统中。关键字提取器将在下一阶段处理这些保存的页面内容。

图 7.2:自然语言处理如何在 Hadoop 中执行的表示，将在下一阶段获取。下一个阶段是获取网址的页面内容并保存在磁盘中。操作是分段进行的，每个分段将包含一些预定义数量的网址。该操作将在不同的数据节点上并行运行。这些阶段的最终结果存储在 Hadoop 分布式文件系统中。关键字提取器将在下一阶段处理这些保存的页面内容。

用于自然语言处理的关键词和模块的提取

对于每个网址的页面内容，创建一个文档对象模型 ( DOM )并存储回 HDFS。在 DOM 中，文档有一个像树一样的逻辑结构。使用 DOM，可以编写xpath在自然语言处理阶段收集所需的关键词和短语。在本模块中，我们将为下一阶段执行自然语言处理应用定义 Map-reduce 作业。定义为<key, value>对键的映射函数是网址，值是该网址对应的 DOM。 reduce 功能将执行自然语言处理部分的配置和执行。在网络域级别对提取的关键词和短语的后续估计将在reduce方法中执行。为此，我们可以编写一个自定义插件来生成规则文件，以执行各种字符串操作，从提取的文本中过滤掉有噪声的、不需要的单词。规则文件可以是 JSON 文件，也可以是基于用例的任何其他易于加载和解释的文件。优选地，共同的名词和形容词被识别为来自文本的共同关键词。

对页面相关关键词的估计

论文[136]提出了一个非常重要的公式来从网络文档中找到相关的关键词和关键短语。他们提供了术语频率-反向文档频率 ( TF-IDF )度量来估计整个语料库的相关信息，该语料库由属于单个网络域的所有文档和页面组成。计算 TD-IDF 的值，并为其分配一个丢弃其他关键词的阈值，可以让我们从语料库中生成最相关的单词。换句话说，它丢弃了在文本中可能出现频率较高，但通常不具备任何有意义信息的常见冠词和连词。 TF-IDF 指标基本上是两个函数的乘积， TF 和 IDF 。

TF 提供语料库中每个词的出现频率，即一个词在语料库中出现的次数。而 IDF 表现为一个平衡项，表示在整个语料库中具有较低频率的项的较高值。

数学上，包含在文档 D 中的文档 d 中的关键词或关键短语 i 的度量 TF-IDF 由以下等式给出:

(TF-IDF)_【I】= TF_【I】。IDF _【我】

此处_TF【I】= f_【I】/n_【d】和【IDF】_【I】= log n_【d】

这里f_IT3】是文档 d 中候选关键词或关键短语 i 的出现频率，n_dT11】是文档 d 中术语的总数。在 IDF 中， N _D 表示语料库中存在的文档总数 D ，而 N _i 表示关键词或关键短语 i 存在的文档数。

基于用例，应该为 TF-IDF 定义一个通用的阈值频率。对于关键字或关键短语 i 如果 TF-IDF 的值变得高于阈值，则该关键字或关键短语作为最终结果被接受，并直接写入 HDFS。另一方面，如果相应的值小于阈值，则从最终集合中删除该关键字。这样，最后，所有想要的关键词都会被写到 HDFS。

总结

本章讨论了机器学习最广泛使用的应用，以及如何在 Hadoop 框架中设计它们。首先，我们从一个大型视频集开始，展示了如何在 HDFS 解码视频，然后将其转换为包含图像的序列文件，以供后续处理。本章接下来讨论大规模图像处理。用于此目的的映射器有一个执行所有必要任务的 shell 脚本。因此，不需要减速器来执行该操作。最后，我们讨论了如何在 Hadoop 中部署自然语言处理模型。

八、附录 1：参考文献

[1] Hsu, F.-H. (2002). Behind Deep Blue: Building the Computer That Defeated the World Chess Champion . Princeton University Press, Princeton, NJ, USA. 

[2] Geoffrey E. Hinton, Simon Osindero, and Yee-Whye Teh. 2006\. A fast learning algorithm for deep belief nets. Neural Comput. 18, 7 (July 2006), 1527-1554. 

[3] Bengio, Yoshua, et al. "Greedy layer-wise training of deep networks." Advances in neural information processing systems 19 (2007): 153. 

[4] Krizhevsky, Alex, Ilya Sutskever, and Geoffrey E. Hinton. "Imagenet classification with deep convolutional neural networks." Advances in neural information processing systems. 2012. 

[5] Machine Learning, Tom Mitchell, McGraw Hill, 1997. 

[6] Machine Learning: A Probabilistic Perspective (Adaptive Computation and Machine Learning series), Kevin P. Murphy 

[7] O. Chapelle, B. Scholkopf and A. Zien Eds., "Semi-Supervised Learning (Chapelle, O. et al., Eds.; 2006) [Book reviews]," in IEEE Transactions on Neural Networks, vol. 20, no. 3, pp. 542-542, March 2009. 

[8] Y. Bengio. Learning deep architectures for AI. in Foundations and Trends in Machine Learning, 2(1):1–127, 2009. 

[9] G. Dahl, D. Yu, L. Deng, and A. Acero. Context-dependent DBNHMMs in large vocabulary continuous speech recognition. In Proceedings of International Conference on Acoustics Speech and Signal Processing (ICASSP). 2011. 

[10] A. Mohamed, G. Dahl, and G. Hinton. Acoustic modeling using deep belief networks. IEEE Transactions on Audio, Speech, & Language Processing, 20(1), January 2012. 

[11] A. Mohamed, D. Yu, and L. Deng. Investigation of full-sequence training of deep belief networks for speech recognition. In Proceedings of Inter speech. 2010. 

[12] Indyk, Piotr, and Rajeev Motwani. "Approximate nearest neighbors: towards removing the curse of dimensionality." Proceedings of the thirtieth annual ACM symposium on Theory of computing. ACM, 1998. 

[13] Friedman, Jerome H. "On bias, variance, 0/1—loss, and the curse-of-dimensionality." Data mining and knowledge discovery 1.1 (1997): 55-77. 

[14] Keogh, Eamonn, and Abdullah Mueen. "Curse of dimensionality." Encyclopedia of Machine Learning. Springer US, 2011\. 257-258. 

[15] Hughes, G.F. (January 1968). "On the mean accuracy of statistical pattern recognizers". IEEE Transactions on Information Theory. 14 (1): 55–63. 

[16] Bengio, Yoshua, Patrice Simard, and Paolo Frasconi. "Learning long-term dependencies with gradient descent is difficult." IEEE transactions on neural networks 5.2 (1994): 157-166.



[17] Ivakhnenko, Alexey (1965). Cybernetic Predicting Devices. Kiev: Naukova Dumka. 

[18] Ivakhnenko, Alexey (1971). "Polynomial theory of complex systems". IEEE Transactions on Systems, Man and Cybernetics (4): 364–378. 

[19] X. Glorot and Y. Bengio. Understanding the difficulty of training deep feed-forward neural networks. In Proceedings of Artificial Intelligence and Statistics (AISTATS). 2010. 

[20] G. Hinton and R. Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786):504–507, July 2006 

[21] M. Ranzato, C. Poultney, S. Chopra, and Y. LeCun. Efficient learning of sparse representations with an energy-based model. In Proceedings of Neural Information Processing Systems (NIPS). 2006. 

[22] I. Goodfellow, M. Mirza, A. Courville, and Y. Bengio. Multi-prediction deep boltzmann machines. In Proceedings of Neural Information Processing Systems (NIPS). 2013. 

[23] R. Salakhutdinov and G. Hinton. Deep boltzmann machines. In Proceedings of Artificial Intelligence and Statistics (AISTATS). 2009. 

[24] R. Salakhutdinov and G. Hinton. A better way to pretrain deep boltzmann machines. In Proceedings of Neural Information Processing Systems (NIPS). 2012. 

[25] N. Srivastava and R. Salakhutdinov. Multimodal learning with deep boltzmann machines. In Proceedings of Neural Information Processing Systems (NIPS). 2012. 

[26] H. Poon and P. Domingos. Sum-product networks: A new deep architecture. In Proceedings of Uncertainty in Artificial Intelligence. 2011. 

[27] R. Gens and P. Domingo. Discriminative learning of sum-product networks. Neural Information Processing Systems (NIPS), 2012. 

[28] R. Gens and P. Domingo. Discriminative learning of sum-product networks. Neural Information Processing Systems (NIPS), 2012. 

[29] S. Hochreiter. Untersuchungen zu dynamischen neuronalen netzen. Diploma thesis, Institut fur Informatik, Technische Universitat Munchen, 1991. 

[30] J.Martens. Deep learning with hessian-free optimization. In Proceedings of international Conference on Machine Learning (ICML). 2010. 

[31] Y. Bengio. Deep learning of representations: Looking forward. In Statistical Language and Speech Processing, pages 1–37\. Springer, 2013. 

[32] I. Sutskever. Training recurrent neural networks. Ph.D. Thesis, University of Toronto, 2013. 

[33] J. Ngiam, Z. Chen, P. Koh, and A. Ng. Learning deep energy models. In Proceedings of International Conference on Machine Learning (ICML). 2011. 

[34] Y. LeCun, S. Chopra, M. Ranzato, and F. Huang. Energy-based models in document recognition and computer vision. In Proceedings of International Conference on Document Analysis and Recognition (ICDAR). 2007. 

[35] R. Chengalvarayan and L. Deng. Speech trajectory discrimination using the minimum classification error learning. IEEE Transactions on Speech and Audio Processing, 6(6):505–515, 1998.



[36] M. Gibson and T. Hain. Error approximation and minimum phone error acoustic model estimation. IEEE Transactions on Audio, Speech, and Language Processing, 18(6):1269–1279, August 2010 

[37] X. He, L. Deng, andW. Chou. Discriminative learning in sequential pattern recognition — a unifying review for optimization-oriented speech recognition. IEEE Signal Processing Magazine, 25:14–36, 2008. 

[38] H. Jiang and X. Li. Parameter estimation of statistical models using convex optimization: An advanced method of discriminative training for speech and language processing. IEEE Signal Processing Magazine, 27(3):115–127, 2010. 

[39] B.-H. Juang, W. Chou, and C.-H. Lee. Minimum classification error rate methods for speech recognition. IEEE Transactions On Speech and Audio Processing, 5:257–265, 1997. 

[40] D. Povey and P. Woodland. Minimum phone error and I-smoothing for improved discriminative training. In Proceedings of International Conference on Acoustics Speech and Signal Processing (ICASSP). 2002 

[41] D. Yu, L. Deng, X. He, and X. Acero. Large-margin minimum classification error training for large-scale speech recognition tasks. In Proceedings of International Conference on Acoustics Speech and Signal Processing (ICASSP). 2007. 

[42] A. Robinson. An application of recurrent nets to phone probability estimation. IEEE Transactions on Neural Networks, 5:298–305, 1994 

[43] A. Graves. Sequence transduction with recurrent neural networks. Representation Learning Workshop, International Conference on Machine Learning (ICML), 2012. 

[44] A. Graves, S. Fernandez, F. Gomez, and J. Schmidhuber. Connectionist temporal classification: Labeling unsegmented sequence data with recurrent neural networks. In Proceedings of International Conference on Machine Learning (ICML). 2006. 

[45] A. Graves, N. Jaitly, and A. Mohamed. Hybrid speech recognition with deep bidirectional LSTM. In Proceedings of the Automatic Speech Recognition and Understanding Workshop (ASRU). 2013. 

[46] A. Graves, A. Mohamed, and G. Hinton. Speech recognition with deep recurrent neural networks. In Proceedings of International Conference on Acoustics Speech and Signal Processing (ICASSP). 2013 

[47] K. Lang, A. Waibel, and G. Hinton. A time-delay neural network architecture for isolated word recognition. Neural Networks, 3(1):23–43, 1990. 

[48] A.Waibel, T. Hanazawa, G. Hinton, K. Shikano, and K. Lang. Phoneme recognition using time-delay neural networks. IEEE Transactions on Acoustical Speech, and Signal Processing, 37:328–339, 1989. 

[50] Moore, Gordon E. (1965-04-19). "Cramming more components onto integrated circuits". Electronics. Retrieved 2016-07-01. 

[51] [http://www.emc.com/collateral/analyst-reports/idc-the-digital-universe-in-2020.pdf](http://www.emc.com/collateral/analyst-reports/idc-the-digital-universe-in-2020.pdf) 

[52] D. Beaver, S. Kumar, H. C. Li, J. Sobel, and P. Vajgel, \Finding a needle in haystack: Facebooks photo storage," in OSDI, 2010, pp. 4760. 

[53] Michele Banko and Eric Brill. 2001\. Scaling to very very large corpora for natural language disambiguation. In Proceedings of the 39th Annual Meeting on Association for Computational Linguistics (ACL '01). Association for Computational Linguistics, Stroudsburg, PA, USA, 26-33. 

[54] [http://www.huffingtonpost.in/entry/big-data-and-deep-learnin_b_3325352](http://www.huffingtonpost.in/entry/big-data-and-deep-learnin_b_3325352) 

[55] X. W. Chen and X. Lin, "Big Data Deep Learning: Challenges and Perspectives," in IEEE Access, vol. 2, no. , pp. 514-525, 2014. 

[56] Bengio Y, LeCun Y (2007) Scaling learning algorithms towards, AI. In: Bottou L, Chapelle O, DeCoste D, Weston J (eds). Large Scale Kernel Machines. MIT Press, Cambridge, MA Vol. 34\. pp 321–360\. [http://www.iro.umontreal.ca/~lisa/pointeurs/bengio+lecun_chapter2007.pdf](http://www.iro.umontreal.ca/~lisa/pointeurs/bengio+lecun_chapter2007.pdf) 

[57] A. Coats, B. Huval, T. Wng, D. Wu, and A. Wu, ``Deep Learning with COTS HPS systems,'' J. Mach. Learn. Res., vol. 28, no. 3, pp. 1337-1345, 2013. 

[58] J.Wang and X. Shen, ``Large margin semi-supervised learning,'' J. Mach. Learn. Res., vol. 8, no. 8, pp. 1867-1891, 2007 

[59] R. Fergus, Y. Weiss, and A. Torralba, ``Semi-supervised learning in gigantic image collections,'' in Proc. Adv. NIPS, 2009, pp. 522-530. 

[60] J. Ngiam, A. Khosla, M. Kim, J. Nam, H. Lee, and A. Ng, ``Multimodal deep learning,'' in Proc. 28th Int. Conf. Mach. Learn., Bellevue, WA, USA, 2011 

[61] N. Srivastava and R. Salakhutdinov, ``Multimodal learning with deep Boltzmann machines,'' in Proc. Adv. NIPS, 2012 

[62] L. Bottou, ``Online algorithms and stochastic approximations,'' in On-Line Learning in Neural Networks, D. Saad, Ed. Cambridge, U.K.: Cambridge Univ. Press, 1998. 

[63] A. Blum and C. Burch, ``On-line learning and the metrical task system problem,'' in Proc. 10th Annu. Conf. Comput. Learn. Theory, 1997, pp. 45-53. 

[64] N. Cesa-Bianchi, Y. Freund, D. Helmbold, and M. Warmuth, ``On-line prediction and conversation strategies,'' in Proc. Conf. Comput. Learn. Theory Eurocolt, vol. 53\. Oxford, U.K., 1994, pp. 205-216. 

[65] Y. Freund and R. Schapire, ``Game theory, on-line prediction and boosting,'' in Proc. 9th Annu. Conf. Comput. Learn. Theory, 1996, pp. 325-332. 

[66] Q. Le et al., ‘‘Building high-level features using large scale unsupervised learning,’’ in Proc. Int. Conf. Mach. Learn., 2012. 

[67] C. P. Lim and R. F. Harrison, ``Online pattern classifcation with multiple neural network systems: An experimental study,'' IEEE Trans. Syst., Man, Cybern. C, Appl. Rev., vol. 33, no. 2, pp. 235-247, May 2003. 

[68] P. Riegler and M. Biehl, ``On-line backpropagation in two-layered neural networks,'' J. Phys. A, vol. 28, no. 20, pp. L507-L513, 1995 

[69] M. Rattray and D. Saad, ``Globally optimal on-line learning rules for multi-layer neural networks,'' J. Phys. A, Math. General, vol. 30, no. 22, pp. L771-776, 1997.



[70] P. Campolucci, A. Uncini, F. Piazza, and B. Rao, ``On-line learning algorithms for locally recurrent neural networks,'' IEEE Trans. Neural Netw., vol. 10, no. 2, pp. 253-271, Mar. 1999 

[71] N. Liang, G. Huang, P. Saratchandran, and N. Sundararajan, ``A fast and accurate online sequential learning algorithm for feedforward networks,'' IEEE Trans. Neural Netw., vol. 17, no. 6, pp. 1411-1423, Nov. 2006. 

[72] L. Bottou and O. Bousequet, ``Stochastic gradient learning in neural networks,'' in Proc. Neuro-Nimes, 1991. 

[73] S. Shalev-Shwartz, Y. Singer, and N. Srebro, ``Pegasos: Primal estimated sub-gradient solver for SVM,'' in Proc. Int. Conf. Mach. Learn., 2007. 

[74] D. Scherer, A. Müller, and S. Behnke, ``Evaluation of pooling operations in convolutional architectures for object recognition,'' in Proc. Int. Conf. Artif. Neural Netw., 2010, pp. 92-101. 

[75] J. Chien and H. Hsieh, ``Nonstationary source separation using sequential and variational Bayesian learning,'' IEEE Trans. Neural Netw. Learn. Syst., vol. 24, no. 5, pp. 681-694, May 2013. 

[76] W. de Oliveira, ``The Rosenblatt Bayesian algorithm learning in a nonstationary environment,'' IEEE Trans. Neural Netw., vol. 18, no. 2, pp. 584-588, Mar. 2007. 

[77] Hadoop Distributed File System,[http://hadoop.apache.org/2012](http://hadoop.apache.org). 

[78] T. White. 2009\. Hadoop: The Definitive Guide. OReilly Media, Inc. June 2009 

[79] Shvachko, K.; Hairong Kuang; Radia, S.; Chansler, R., May 2010\. The Hadoop Distributed File System,"2010 IEEE 26th Symposium on Mass Storage Systems and Technologies (MSST). vol., no., pp.1,10 

[80] Hadoop Distributed File System,[https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-hdfs/](https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-hdfs/). 

[81] Dev, Dipayan, and Ripon Patgiri. "Dr. Hadoop: an infinite scalable metadata management for Hadoop—How the baby elephant becomes immortal." Frontiers of Information Technology & Electronic Engineering 17 (2016): 15-31. 

[82] [http://deeplearning4j.org/](http://deeplearning4j.org/) 

[83] Dean, Jeffrey, and Sanjay Ghemawat. "MapReduce: simplified data processing on large clusters." Communications of the ACM 51.1 (2008): 107-113. 

[84] [http://deeplearning.net/software/theano/](http://deeplearning.net/software/theano/) 

[85] [http://torch.ch/](http://torch.ch/) 

[86] Borthakur, Dhruba. "The hadoop distributed file system: Architecture and design." Hadoop Project Website 11.2007 (2007): 21. 

[87] Borthakur, Dhruba. "HDFS architecture guide." HADOOP APACHE PROJECT [https://hadoop.apache.org/docs/r1.2.1/hdfs_design.pdf](https://hadoop.apache.org/docs/r1.2.1/hdfs_design.pdf) (2008): 39. 

[88] [http://deeplearning4j.org/quickstart](http://deeplearning4j.org/quickstart) 



[89] LeCun, Yann, and Yoshua Bengio. "Convolutional networks for images, speech, and time series." The handbook of brain theory and neural networks 3361.10 (1995): 1995. 

[90] LeCun, Y., Bottou, L., Bengio, Y., and Haffner, P. (1998). Gradient-based learning applied to document recognition. Proc. IEEE 86, 2278–2324\. doi:10.1109/5.726791 

[91] Gao, H., Mao, J., Zhou, J., Huang, Z., Wang, L., and Xu, W. (2015). Are you talking to a machine? Dataset and methods for multilingual image question answering. arXiv preprint arXiv:1505.05612. 

[92] Srinivas, Suraj, et al. "A Taxonomy of Deep Convolutional Neural Nets for Computer Vision." arXiv preprint arXiv:1601.06615 (2016). 

[93] Zhou, Y-T., et al. "Image restoration using a neural network." IEEE Transactions on Acoustics, Speech, and Signal Processing 36.7 (1988): 1141-1151. 

[94] Maas, Andrew L., Awni Y. Hannun, and Andrew Y. Ng. "Rectifier nonlinearities improve neural network acoustic models." Proc. ICML. Vol. 30\. No. 1\. 2013. 

[95] He, Kaiming, et al. "Delving deep into rectifiers: Surpassing human-level performance on imagenet classification." Proceedings of the IEEE International Conference on Computer Vision. 2015. 

[96] [http://web.engr.illinois.edu/~slazebni/spring14/lec24_cnn.pdf](http://web.engr.illinois.edu/~slazebni/spring14/lec24_cnn.pdf) 

[97] Zeiler, Matthew D., and Rob Fergus. "Visualizing and understanding convolutional networks." European Conference on Computer Vision. Springer International Publishing, 2014. 

[98] Simonyan, Karen, and Andrew Zisserman. "Very deep convolutional networks for large-scale image recognition." arXiv preprint arXiv:1409.1556 (2014). 

[99] Szegedy, Christian, et al. "Going deeper with convolutions." Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. 2015. 

[100] He, Kaiming, et al. "Deep residual learning for image recognition." arXiv preprint arXiv:1512.03385 (2015). 

[101] Krizhevsky, Alex. "One weird trick for parallelizing convolutional neural networks." arXiv preprint arXiv:1404.5997 (2014). 

[102] S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780, 1997. 

[103] Mikolov, Tomas, et al. "Recurrent neural network based language model." Interspeech. Vol. 2\. 2010. 

[104] Rumelhart, D. E., Hinton, G. E., and Williams, R. J. (1986). Learning representations by backpropagating errors. Nature, 323, 533–536. 

[105] Mikolov, T., Sutskever, I., Chen, K., Corrado, G., and Dean, J. (2013a). Distributed representations of words and phrases and their compositionality. In Advances in Neural Information Processing Systems 26, pages 3111–3119. 

[106]Graves, A. (2013). Generating sequences with recurrent neural networks. arXiv:1308.0850 [cs.NE]. 

[107] Pascanu, R., Mikolov, T., and Bengio, Y. (2013a). On the difficulty of training recurrent neural networks. In ICML’2013.



[108] Mikolov, T., Sutskever, I., Deoras, A., Le, H., Kombrink, S., and Cernocky, J. (2012a). Subword language modeling with neural networks. unpublished 

[109] Graves, A., Mohamed, A., and Hinton, G. (2013). Speech recognition with deep recurrent neural networks. ICASSP 

[110] Graves, A., Liwicki, M., Fernandez, S., Bertolami, R., Bunke, H., and Schmidhuber, J. (2009). A novel connectionist system for improved unconstrained handwriting recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence. 

[111] [http://karpathy.github.io/2015/05/21/rnn-effectiveness/](http://karpathy.github.io/2015/05/21/rnn-effectiveness/) 

[112] [https://web.stanford.edu/group/pdplab/pdphandbook/handbookch8.html](https://web.stanford.edu/group/pdplab/pdphandbook/handbookch8.html) 

[113] Schuster, Mike, and Kuldip K. Paliwal. "Bidirectional recurrent neural networks." IEEE Transactions on Signal Processing 45.11 (1997): 2673-2681. 

[114] Graves, Alan, Navdeep Jaitly, and Abdel-rahman Mohamed. "Hybrid speech recognition with deep bidirectional LSTM." Automatic Speech Recognition and Understanding (ASRU), 2013 IEEE Workshop on. IEEE, 2013 

[115] Baldi, Pierre, et al. "Exploiting the past and the future in protein secondary structure prediction." Bioinformatics 15.11 (1999): 937-946 

[116] Hochreiter, Sepp, and Jürgen Schmidhuber. "Long short-term memory." Neural computation 9.8 (1997): 1735-1780. 

[117] A. Graves, M. Liwicki, S. Fernandez, R. Bertolami, H. Bunke, J. Schmidhuber. A Novel Connectionist System for Improved Unconstrained Handwriting Recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 31, no. 5, 2009. 

[118] With QuickType, Apple wants to do more than guess your next text. It wants to give you an AI.". WIRED. Retrieved 2016-06-16 

[119] Sak, Hasim, Andrew W. Senior, and Françoise Beaufays. "Long short-term memory recurrent neural network architectures for large scale acoustic modeling." INTERSPEECH. 2014. 

[120] Poultney, Christopher, Sumit Chopra, and Yann L. Cun. "Efficient learning of sparse representations with an energy-based model." Advances in neural information processing systems. 2006. 

[121] LeCun, Yann, et al. "A tutorial on energy-based learning." Predicting structured data 1 (2006): 0. 

[122] Ackley, David H., Geoffrey E. Hinton, and Terrence J. Sejnowski. "A learning algorithm for Boltzmann machines." Cognitive science 9.1 (1985): 147-169. 

[123] Desjardins, G. and Bengio, Y. (2008). Empirical evaluation of convolutional RBMs for vision. Technical Report 1327, Département d’Informatique et de Recherche Opérationnelle, Université de Montréal. 

[124] Hinton, G. E., Osindero, S., and Teh, Y. (2006). A fast learning algorithm for deep belief nets. Neural Computation, 18, 1527–1554. 

[125] Hinton, G. E. (2007b). Learning multiple layers of representation. Trends in cognitive sciences , 11(10), 428–434.



[126] Bengio, Yoshua, et al. "Greedy layer-wise training of deep networks." Advances in neural information processing systems 19 (2007): 153. 

[127] A.-R. Mohamed, T. N. Sainath, G. Dahl, B. Ramabhadran, G. E. Hinton, and M. A. Picheny, ``Deep belief networks using discriminative features for phone recognition,'' in Proc. IEEE ICASSP, May 2011, pp. 5060-5063. 

[128] R. Salakhutdinov and G. Hinton, ``Semantic hashing,'' Int. J. Approx. Reasoning, vol. 50, no. 7, pp. 969-978, 2009. 

[129] G. W. Taylor, G. E. Hinton, and S. T. Roweis, ``Modeling human motion using binary latent variables,'' in Advances in Neural Information Processing Systems. Cambridge, MA, USA: MIT Press, 2006,pp. 1345-1352. 

[130] Zhang, Kunlei, and Xue-Wen Chen. "Large-scale deep belief nets with mapreduce." IEEE Access 2 (2014): 395-403.



[131] Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. Technical report, arXiv:1206.5538, 2012b. 

[132] Makhzani, Alireza, and Brendan Frey. "k-Sparse Autoencoders." arXiv preprint arXiv:1312.5663 (2013). 

[133] Hinton, Geoffrey E., and Ruslan R. Salakhutdinov. "Reducing the dimensionality of data with neural networks." Science 313.5786 (2006): 504-507. 

[134] Vincent, Pascal, et al. "Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion." Journal of Machine Learning Research 11.Dec (2010): 3371-3408. 

[135] Salakhutdinov, Ruslan, and Geoffrey Hinton. "Semantic hashing." RBM 500.3 (2007): 500. 

[136] Nesi, Paolo, Gianni Pantaleo, and Gianmarco Sanesi. "A hadoop based platform for natural language processing of web pages and documents." Journal of Visual Languages & Computing 31 (2015): 130-138.