提交 563ae41c 编写于 作者: W wizardforcel

2020-09-01 18:30:35

上级 93b3a6f6
......@@ -47,27 +47,27 @@
本书面向希望定期执行机器学习任务的数据科学家,机器学习从业人员和深度学习爱好者。 稍微熟悉深度神经网络并希望获得与 CNN 和 RNN 一起工作的专业知识的人会发现这本书很有用。
# 栏目
# 标题
在本书中,您会发现经常出现的几个标题(准备工作,如何做……,如何工作……,还有更多……以及另请参见)。 为了给出有关如何完成配方的明确说明,我们使用以下部分。
# 做好准备
# 准备
本节将告诉您配方中的预期内容,并介绍如何设置配方所需的任何软件或任何初步设置。
# 怎么做…
# 操作步骤
本节包含遵循食谱所需的步骤。
# 这个怎么运作…
# 工作原理
本节通常包括对上一节中发生的情况的详细说明。
# 还有更多…
# 更多
本节包含有关配方的其他信息,以使读者对配方有更多的了解。
# 也可以看看
# 另见
本节提供了指向该食谱其他有用信息的有用链接。
......
......@@ -57,7 +57,7 @@ TensorFlow 是 Google Brain 团队针对**深层神经网络**(**DNN**)开
* Windows 10,Anaconda 3,Python 3.5,TensorFlow GPU,CUDA 工具包 8.0,cuDNN v5.1,NVDIA®GTX 1070
* Windows 10 / Ubuntu 14.04 / Ubuntu 16.04 / macOS Sierra,Anaconda3,Python 3.5,TensorFlow(CPU)
# 做好准备
# 准备
TensorFlow 安装的前提条件是系统已安装 Python 2.5 或更高版本。 本书中的食谱是为 Python 3.5(Anaconda 3 发行版)设计的。 要准备安装 TensorFlow,请首先确保已安装 Anaconda。 您可以从[这里](https://www.continuum.io/downloads)下载并安装适用于 Windows/macOS 或 Linux 的 Anaconda。
......@@ -73,7 +73,7 @@ conda --version
对于 TensorFlow GPU,必须安装 CUDA 工具包 7.0 或更高版本,安装正确的 NVDIA®驱动程序,并安装 cuDNN v3 或更高版本。 在 Windows 上,此外,需要某些 DLL 文件。 您可以下载所需的 DLL 文件,也可以安装 Visual Studio C++ 。 要记住的另一件事是 cuDNN 文件安装在另一个目录中。 需要确保目录位于系统路径中。 也可以选择将相关文件复制到相应文件夹中的 CUDA 库中。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -139,7 +139,7 @@ with tf.Session() as sess:
8. 在 Windows 上使用命令`deactivate`在 MAC/Ubuntu 上使用`source deactivate`在命令行上禁用 conda 环境。
# 这个怎么运作...
# 工作原理
Google 使用 Wheels 标准分发 TensorFlow。 它是具有`.whl`扩展名的 ZIP 格式存档。 Anaconda 3 中的默认 Python 解释器 Python 3.6 没有安装轮子。 在撰写本书时,仅对 Linux/Ubuntu 支持 Python 3.6。 因此,在创建 TensorFlow 环境时,我们指定了 Python 3.5。 这将在名为`tensorflow`的 conda 环境中安装 PIP,python 和 wheel 以及其他一些软件包。
......@@ -153,7 +153,7 @@ Welcome to the exciting world of Deep Neural Networks!
恭喜您成功安装并执行了第一个 TensorFlow 代码! 在下一个食谱中,我们将更深入地研究代码。
# 还有更多...
# 更多
此外,您还可以安装 Jupyter 笔记本:
......@@ -194,7 +194,7 @@ message = tf.constant('Welcome to the exciting world of Deep Neural Networks!')
让我们深入研究这个简单的代码。
# 怎么做...
# 操作步骤
1. 导入`tensorflow`会导入 TensorFlow 库,并允许您使用其出色的功能。
......@@ -249,7 +249,7 @@ Creating TensorFlow device (/gpu:0) -> (device: 0, name: GeForce GTX 1070, pci b
Welcome to the exciting world of Deep Neural Networks
```
# 这个怎么运作...
# 工作原理
前面的代码分为三个主要部分。 **导入块**包含我们的代码将使用的所有库; 在当前代码中,我们仅使用 TensorFlow。 `import tensorflow as tf`语句使 Python 可以访问所有 TensorFlow 的类,方法和符号。 第二块包含图形定义部分; 在这里,我们建立了所需的计算图。 在当前情况下,我们的图仅由一个节点组成,张量常数消息由字节字符串`"Welcome to the exciting world of Deep Neural Networks"`组成。 我们代码的第三部分是**作为会话运行计算图**; 我们使用`with`关键字创建了一个会话。 最后,在会话中,我们运行上面创建的图。
......@@ -280,7 +280,7 @@ TensorFlow 与其他编程语言非常不同。 我们首先需要为要创建
**图形的执行**:使用会话对象执行图形的执行。 *会话对象封装了评估张量和操作对象的环境*。 这是实际计算和信息从一层传输到另一层的地方。 不同张量对象的值仅初始化,访问并保存在会话对象中。 到目前为止,张量对象仅仅是抽象的定义,在这里它们就变成了现实。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -319,7 +319,7 @@ sess.close()
请记住,每个会话都需要使用`close()`方法显式关闭,而`with`块在结束时会隐式关闭会话。
# 这个怎么运作...
# 工作原理
计算图的构建非常简单; 您将继续添加变量和运算,并按照您逐层构建神经网络的顺序将它们传递(使张量流动)。 TensorFlow 还允许您使用`with tf.device()`将特定设备(CPU/GPU)与计算图的不同对象一起使用。 在我们的示例中,计算图由三个节点组成,`v_1``v_2`代表两个向量,`Add`是对其执行的操作。
......@@ -343,7 +343,7 @@ run (fetches, feed_dict=None, options=None, run_metadata)
在同一程序代码中,我们可以有许多会话对象。
# 还有更多...
# 更多
您一定想知道为什么我们必须编写这么多行代码才能进行简单的矢量加法或打印一条小消息。 好吧,您可以很方便地以单线方式完成此工作:
......@@ -393,7 +393,7 @@ TensorFlow 支持三种类型的张量:
**占位符**:这些占位符用于将值输入 TensorFlow 图。 它们与`feed_dict`一起用于输入数据。 它们通常用于在训练神经网络时提供新的训练示例。 在会话中运行图形时,我们为占位符分配一个值。 它们使我们无需数据即可创建操作并构建计算图。 需要注意的重要一点是,占位符不包含任何数据,因此也无需初始化它们。
# 怎么做...
# 操作步骤
让我们从常量开始:
......@@ -584,7 +584,7 @@ with tf.Session() as sess:
```
# 这个怎么运作...
# 工作原理
所有常量,变量和占位符都将在代码的计算图部分中定义。 如果在定义部分中使用`print`语句,我们将仅获得有关张量类型的信息,而不是张量的值。
......@@ -595,7 +595,7 @@ print(sess.run(t_1))
# Will print the value of t_1 defined in step 1
```
# 还有更多...
# 更多
很多时候,我们将需要恒定的大尺寸张量对象。 在这种情况下,为了优化内存,最好将它们声明为具有可训练标志设置为`False`的变量:
......@@ -636,7 +636,7 @@ for i in tf.range(10)
本食谱将向您展示如何获取不同类型的矩阵以及如何对它们执行不同的矩阵操作。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -715,11 +715,11 @@ writer.close()
`tf.div` returns a tensor of the same type as the first argument.
# 这个怎么运作...
# 工作原理
矩阵的所有算术运算(例如加,乘,除,乘(元素乘),模和叉)都要求两个张量矩阵的数据类型相同。 如果不是这样,它们将产生错误。 我们可以使用`tf.cast()`将张量从一种数据类型转换为另一种数据类型。
# 还有更多...
# 更多
如果我们要在整数张量之间进行除法,最好使用`tf.truediv(a,b)`,因为它首先将整数张量强制转换为浮点,然后执行逐元素除法。
......@@ -727,7 +727,7 @@ writer.close()
TensorFlow 使用 TensorBoard 提供计算图的图形图像。 这使得理解,调试和优化复杂的神经网络程序变得很方便。 TensorBoard 还可以提供有关网络执行情况的定量指标。 它读取 TensorFlow 事件文件,其中包含您在运行 TensorFlow 会话时生成的摘要数据。
# 怎么做...
# 操作步骤
1. 使用 TensorBoard 的第一步是确定您想要的 OP 摘要。 对于 DNN,习惯上要知道损耗项(目标函数)如何随时间变化。 在自适应学习率的情况下,学习率本身随时间变化。 我们可以在`tf.summary.scalar` OP 的帮助下获得所需术语的摘要。 假设变量损失定义了误差项,并且我们想知道它是如何随时间变化的,那么我们可以这样做,如下所示:
......@@ -766,7 +766,7 @@ tensorboard --logdir=summary_dir
TensorFlow 1.x 不提供向后兼容性。 这意味着适用于 TensorFlow 0.x 的代码可能不适用于 TensorFlow 1.0。 因此,如果您有适用于 TensorFlow 0.x 的代码,则需要对其进行升级(旧的 GitHub 存储库或您自己的代码)。 本食谱将指出 TensorFlow 0.x 和 TensorFlow 1.0 之间的主要区别,并向您展示如何使用脚本`tf_upgrade.py`自动升级 TensorFlow 1.0 的代码。
# 怎么做...
# 操作步骤
这是我们进行食谱的方法:
......@@ -803,7 +803,7 @@ python tf_upgrade.py --intree /home/user/my_dir --outtree /home/user/my_dir_1p0
7. 在所有这些情况下,都会生成一个`report.txt`文件。 该文件包含转换的详细信息以及过程中的任何错误。
8. 读取`report.txt`文件,然后手动升级脚本无法更新的部分代码。
# 还有更多...
# 更多
`tf_upgrade.py`具有某些限制:
......@@ -819,7 +819,7 @@ with tf.variable_scope(tf.get_variable_scope(), resuse=True):
**加速线性代数****XLA**)是线性代数的特定领域编译器。 根据[这个页面](https://www.tensorflow.org/performance/xla/)的说法,它仍处于实验阶段,可用于优化 TensorFlow 计算。 它可以提高服务器和移动平台上的执行速度,内存使用率和可移植性。 它提供双向 **JIT****即时**)编译或 **AoT****预先**)编译。 使用 XLA,您可以生成平台相关的二进制文件(适用于 x64,ARM 等大量平台),可以针对内存和速度进行优化。
# 做好准备
# 准备
目前,XLA 不包含在 TensorFlow 的二进制发行版中。 需要从源代码构建它。 要从源代码构建 TensorFlow,需要具备 LLVM 和 Bazel 以及 TensorFlow 的知识。 [TensorFlow.org](http://TensorFlow.org) 仅在 MacOS 和 Ubuntu 中支持从源代码构建。 [从源代码构建 TensorFlow 所需的步骤如下](https://www.tensorflow.org/install/install_sources)
......@@ -871,7 +871,7 @@ sudo pip install /tmp/tensorflow_pkg/tensorflow-1.1.0-py2-none-any.whl
现在您可以开始了。
# 怎么做...
# 操作步骤
TensorFlow 生成 TensorFlow 图。 借助 XLA,可以在任何新型设备上运行 TensorFlow 图。
......@@ -916,7 +916,7 @@ TensorFlow 支持 CPU 和 GPU。 它还支持分布式计算。 我们可以在
如前所述,GPU 比 CPU 快得多,因为它们具有许多小型内核。 但是,就计算速度而言,将 GPU 用于所有类型的计算并不总是一个优势。 与 GPU 相关的开销有时可能比 GPU 提供的并行计算的优势在计算上更为昂贵。 为了解决这个问题,TensorFlow 规定将计算放在特定的设备上。 默认情况下,如果同时存在 CPU 和 GPU,则 TensorFlow 会优先考虑 GPU。
# 怎么做...
# 操作步骤
TensorFlow 将设备表示为字符串。 在这里,我们将向您展示如何在 TensorFlow 中手动分配用于矩阵乘法的设备。 为了验证 TensorFlow 确实在使用指定的设备(CPU 或 GPU),我们使用`log_device_placement`标志设置为`True`,即`config=tf.ConfigProto(log_device_placement=True)`创建会话:
......@@ -987,11 +987,11 @@ sess.close()
8. 在这种情况下,如果系统具有三个 GPU 设备,则第一组乘法将由`'/gpu:1'`进行,第二组乘法将由`'/gpu:2'`进行。
# 这个怎么运作...
# 工作原理
`tf.device()`参数选择设备(CPU 或 GPU)。 `with`块确保选择设备的操作。 `with`块中定义的所有变量,常量和操作都将使用`tf.device()`中选择的设备。 会话配置使用`tf.ConfigProto`控制。 通过设置`allow_soft_placement``log_device_placement`标志,我们告诉 TensorFlow 在指定设备不可用的情况下自动选择可用设备,并在执行会话时提供日志消息作为输出,描述设备的分配。
# TensorFlow 用于深度学习
# TensorFlow 用于深度学习
今天的 DNN 是 AI 社区的流行语。 使用 DNN 的候选人最近赢得了许多数据科学/凝视竞赛。 自 1962 年 Rosenblat 提出感知器以来,就一直使用 DNN 的概念,而 1986 年 Rumelhart,Hinton 和 Williams 发明了梯度下降算法后,DNN 就变得可行了。 直到最近,DNN 才成为 AI/ML 爱好者和全世界工程师的最爱。
......@@ -1012,7 +1012,7 @@ sess.close()
* TensorFlow 具有高级的机器学习 API(`tf.contrib.learn`),使配置,训练和评估大量机器学习模型变得更加容易。
* 在 TensorFlow 之上,可以使用高级深度学习库 Keras。 Keras 非常易于使用,可以轻松快速地制作原型。 它支持各种 DNN,例如 RNN,CNN,甚至是两者的组合。
# 怎么做...
# 操作步骤
任何深度学习网络都包含四个重要组成部分:数据集,定义模型(网络结构),训练/学习和预测/评估。 我们可以在 TensorFlow 中完成所有这些操作; 让我们看看如何:
......@@ -1112,7 +1112,7 @@ with tf.Session as sess:
TensorFlow 负责大多数神经网络的实现。 但是,这还不够。 对于预处理任务,序列化甚至是绘图,我们需要更多的 Python 软件包。
# 怎么做...
# 操作步骤
以下列出了一些常用的 Python 软件包:
......@@ -1134,7 +1134,7 @@ conda install -c conda-forge matplotlib
8. **TFlearn**:TFlearn 是建立在 TensorFlow 之上的模块化透明的深度学习库。 它为 TensorFlow 提供了更高级别的 API,以促进并加速实验。 它目前支持大多数最新的深度学习模型,例如卷积,LSTM,BatchNorm,BiRNN,PReLU,残差网络和生成网络。 它仅适用于 TensorFlow 1.0 或更高版本。 要安装,请使用`pip install tflearn`
9. **Keras**:Keras 也是神经网络的高级 API,它使用 TensorFlow 作为其后端。 它也可以在 Theano 和 CNTK 之上运行。 这是非常用户友好的,添加图层只是一项工作。 可以使用`pip install keras`安装。
# 也可以看看
# 另见
您可以在下面找到一些 Web 链接以获取有关 TensorFlow 安装的更多信息
......
......@@ -55,7 +55,7 @@ Logistic 回归用于分类问题,例如,给定医学数据,我们可以
如前所述,在回归中,我们定义`loss`函数或目标函数,目的是找到使损失最小的系数。 在本食谱中,您将学习如何在 TensorFlow 中定义`loss`函数,并根据眼前的问题选择合适的`loss`函数。
# 做好准备
# 准备
声明`loss`函数需要将系数定义为变量,将数据集定义为占位符。 一个人可以具有恒定的学习率或变化的学习率和正则化常数。 在以下代码中,令`m`为样本数,`n`为要素数,`P`为类数。 我们应该在代码之前定义以下全局参数:
......@@ -65,7 +65,7 @@ n = 15
P = 2
```
# 怎么做...
# 操作步骤
现在让我们看一下如何进行配方:
......@@ -135,11 +135,11 @@ regularization_param = lamda*tf.nn.l2_loss(W1)
loss += regularization_param
```
# 这个怎么运作...
# 工作原理
您学习了如何实现不同类型的`loss`功能。 根据手头的回归任务,您可以选择相应的`loss`函数或自行设计。 也可以在损耗项中组合 L1 和 L2 正则化。
# 还有更多...
# 更多
`loss`函数应为凸形以确保收敛。 平滑,可微凸的`loss`函数可提供更好的收敛性。 随着学习的进行,`loss`函数的值应减小并最终变得稳定。
......@@ -147,7 +147,7 @@ loss += regularization_param
从中学数学开始,您必须知道函数的一阶导数的最大值和最小值为零。 梯度下降算法基于相同的原理-调整系数(权重和偏差),以使`loss`函数的梯度减小。 在回归中,我们使用梯度下降来优化`loss`函数并获得系数。 在本食谱中,您将学习如何使用 TensorFlow 的梯度下降优化器及其某些变体。
# 做好准备
# 准备
系数(`W``b`)的更新与`loss`函数的梯度的负值成比例地完成。 根据训练样本的大小,梯度下降有三种变化:
......@@ -155,7 +155,7 @@ loss += regularization_param
* **随机梯度下降**:在随机梯度下降中,一次显示一个训练样本,权重和偏差得到更新,以使`loss`函数的梯度减小,然后我们移至下一个训练样本 。 重复整个过程许多时期。 由于它一次执行一次更新,因此它比普通更新要快,但是同时,由于频繁更新,`loss`功能可能会有很大差异。
* **小批量梯度下降**:结合了前两种产品的最佳质量; 在这里,为一批训练样本更新了参数。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -234,7 +234,7 @@ tf.train.ProximalGradientDescentOptimizer #Proximal GD optimizer
tf.train.ProximalAdagradOptimizer # Proximal Adagrad optimizer
```
# 还有更多...
# 更多
通常建议您从较高的学习率值入手,并随着学习的进行逐渐降低。 这有助于对训练进行微调。 我们可以使用 TensorFlow `tf.train.exponential_decay`方法来实现。 根据 TensorFlow 文档:
......@@ -262,7 +262,7 @@ learning_rate = tf.train.exponential_decay(initial_learning_rate, global_step, d
# Pass this learning rate to optimizer as before.
```
# 也可以看看
# 另见
以下是一些针对不同优化器的良好链接:
......@@ -274,7 +274,7 @@ learning_rate = tf.train.exponential_decay(initial_learning_rate, global_step, d
你们大多数人已经熟悉 Pandas 及其在处理大型数据集文件中的实用性。 TensorFlow 还提供了读取文件的方法。 在第一章中,我们介绍了从 TensorFlow 中读取文件的方法。 在本食谱中,我们将重点介绍如何在训练之前从 CSV 文件读取和预处理数据。
# 做好准备
# 准备
我们将考虑 Harrison 和 Rubinfield 在 1978 年收集的[波士顿住房价格数据集](http://lib.stat.cmu.edu/datasets/boston)。该数据集包含 506 个样本案例。 每个房屋都有 14 个属性:
......@@ -293,7 +293,7 @@ learning_rate = tf.train.exponential_decay(initial_learning_rate, global_step, d
* **`LSTAT`**:人口状况降低的百分比
* **`MEDV`**:自有住房的中位数价值,单位为 1,000 美元
# 怎么做…
# 操作步骤
我们按以下步骤进行:
......@@ -375,7 +375,7 @@ if __name__ =='__main__':
generate_data(feature_batch, label_batch)
```
# 还有更多...
# 更多
我们可以使用第一章中介绍的 TensorFlow 控件操作和张量操作来预处理数据。 例如,在波士顿房价的情况下,大约有 16 个数据行,其中`MEDV``50.0`。 这些数据点最有可能包含缺失或审查的值,建议不要在训练中考虑它们。 我们可以使用以下代码将它们从训练数据集中删除:
......@@ -390,11 +390,11 @@ data = tf.where(condition, tf.zeros(NUM_FEATURES), data[:])
在此配方中,我们将基于波士顿房价数据集上的房间数(`RM`)执行简单的线性回归。
# 做好准备
# 准备
我们的目标是预测最后一栏(`MEDV`)中给出的房价。 在此配方中,我们直接从 TensorFlow Contrib 数据集中加载数据集。 我们使用随机梯度下降优化器优化单个训练样本的系数。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -506,7 +506,7 @@ plt.plot(total)
plt.show()
```
# 这个怎么运作...
# 工作原理
从图中可以看出,我们的简单线性回归器试图将线性线拟合到给定的数据集:
......@@ -524,7 +524,7 @@ plt.show()
![](img/f9692463-d4f6-4776-b899-087b3dfbac21.png)
# 还有更多...
# 更多
好吧,我们执行了简单的线性回归,但是如何找出模型的性能呢? 有多种方法可以做到这一点。 从统计上讲,我们可以计算 R 方或将我们的数据分为训练和交叉验证集,并检查验证集的准确性(损失项)。
......@@ -532,7 +532,7 @@ plt.show()
我们可以通过对权重和占位符的声明进行一些修改来对同一数据进行多元线性回归。 在多重线性回归的情况下,由于每个要素都有不同的值范围,因此规范化必不可少。 这是使用所有 13 种输入功能对波士顿房价数据集进行多元线性回归的代码。
# 怎么做...
# 操作步骤
这是我们进行食谱的方法:
......@@ -647,13 +647,13 @@ plt.show()
![](img/5d071a85-6b69-4ce4-b92d-549d40b40356.png)
# 这个怎么运作...
# 工作原理
在此配方中,我们使用了所有 13 个功能来训练模型。 简单线性回归和多元线性回归之间的重要区别在于权重,系数的数量始终等于输入要素的数量。 以下是我们构建的多元线性回归模型的 TensorBoard 图:
![](img/226b5cad-ac63-44c7-b98f-1fc99b2f2fbd.png)
# 还有更多...
# 更多
我们现在可以使用从模型中学到的系数来预测房价:
......@@ -672,7 +672,7 @@ print('Predicted value: ${0} Actual value: / ${1}'.format(Y_pred[0]*1000, Y_tra
![](img/47ba5240-9d42-4475-866b-5ab156ecbdb0.png)
# 怎么做...
# 操作步骤
这是我们进行食谱的方法:
......@@ -769,7 +769,7 @@ with tf.Session() as sess:
12. 在 30 个周期后,我们的准确度为 86.5%,在 50 个周期后为 89.36%,在 100 个周期后,准确度提高到 90.91%。
# 这个怎么运作...
# 工作原理
我们使用张量`tensorboard --logdir=garphs`启动 TensorBoard。 在浏览器中,导航到网址`localhost:6006`,以查看 TensorBoard。 先前模型的图形如下:
......@@ -789,7 +789,7 @@ with tf.Session() as sess:
![](img/0c6737f6-7f74-4dee-8357-1a617c620e65.png)
# 也可以看看
# 另见
如果您有兴趣了解更多信息,这些是一些很好的资源:
......
......@@ -58,13 +58,13 @@ TensorFlow 借助不同的优化器自动计算这些梯度。 但是,需要
在此, `g`表示激活函数。 激活函数`∑(W[j]x[j]) + b`的参数称为神经元的**激活**
# 做好准备
# 准备
我们对给定输入刺激的反应受神经元激活函数的控制。 有时我们的回答是二进制的是或否。 例如,当开个玩笑时,我们要么笑要么不笑。 在其他时间,响应似乎是线性的,例如由于疼痛而哭泣。 有时,响应似乎在一定范围内。
模仿类似的行为,人工神经元使用了许多不同的激活函数。 在本食谱中,您将学习如何在 TensorFlow 中定义和使用一些常见的激活函数。
# 怎么做...
# 操作步骤
我们继续执行激活函数,如下所示:
......@@ -193,7 +193,7 @@ with tf.Session() as sess:
![](img/ae82089e-332d-4430-bbd1-86bf55c0acfb.png)
# 这个怎么运作...
# 工作原理
以下是功能的说明:
......@@ -204,11 +204,11 @@ with tf.Session() as sess:
* **ReLU 激活函数**是线性激活函数的整流版本,当在多层中使用时,此整流可以捕获非线性。 使用 ReLU 的主要优点之一是它导致稀疏激活。 在任何时候,所有具有负活动的神经元都不会放电。 这使网络在计算方面更轻便。 ReLU 神经元患有垂死的 ReLU 问题,也就是说,不激发的神经元的梯度将变为零,因此将无法进行任何训练并保持静止(死)。 尽管存在这个问题,如今的 ReLU 还是隐藏层最常用的激活函数之一。
* **Softmax 激活函数**通常用作输出层的激活函数。 该函数的范围为`[0, 1]`。 它用于表示多类分类问题中某类的概率。 所有单位的输出总和将始终为 1。
# 还有更多...
# 更多
神经网络已用于各种任务。 这些任务可以大致分为两类:函数逼近(回归)和分类。 根据手头的任务,一个激活函数可能会优于另一个。 通常,最好将 ReLU 神经元用于隐藏层。 对于分类任务,softmax 通常是更好的选择,对于回归问题,最好使用 S 形或双曲正切。
# 也可以看看
# 另见
* [该链接提供了 TensorFlow 中定义的激活函数及其使用方法的详细信息](https://www.tensorflow.org/versions/r0.12/api_docs/python/nn/activation_functions_)
* [关于激活函数的不错总结](https://en.wikipedia.org/wiki/Activation_function)
......@@ -217,7 +217,7 @@ with tf.Session() as sess:
简单的感知器是单层神经网络。 它使用阈值激活函数,并且正如 Marvin Minsky 论文所证明的那样,只能解决线性可分离的问题。 尽管这将单层感知器的应用限制为仅是线性可分离的问题,但看到它学习仍然总是令人惊奇。
# 做好准备
# 准备
由于感知器使用阈值激活函数,因此我们无法使用 TensorFlow 优化器来更新权重。 我们将不得不使用权重更新规则:
......@@ -225,7 +225,7 @@ with tf.Session() as sess:
这是学习率。 为了简化编程,可以将偏置作为附加权重添加,输入固定为 +1。 然后,前面的等式可用于同时更新权重和偏差。
# 怎么做...
# 操作步骤
这是我们处理单层感知器的方法:
......@@ -312,7 +312,7 @@ with tf.Session() as sess:
![](img/c027d4cd-11a8-45f8-bf0d-f57b4f405ef5.png)
# 还有更多...
# 更多
如果我们使用 S 形激活函数代替阈值激活函数,您会怎么办?
......@@ -328,7 +328,7 @@ BPN 算法是神经网络中研究最多的算法之一。 它用于将错误从
重复两次遍历,直到达到收敛为止。
# 做好准备
# 准备
首先为网络呈现`M`个训练对`(X, Y)`,并以`X`作为输入, `Y`为所需的输出。 输入通过激活函数`g(h)`从输入传播到隐藏层,直到输出层。 输出`Y_hat`是网络的输出,误差为`Y - Y_hat`
......@@ -346,7 +346,7 @@ BPN 算法是神经网络中研究最多的算法之一。 它用于将错误从
现在方程式就位了,让我们看看如何在 TensorFlow 中做到这一点。 在本食谱中,我们使用相同的[旧 MNIST 数据集](http://yann.lecun.com/exdb/mnist/)
# 怎么做...
# 操作步骤
现在让我们开始学习反向传播算法:
......@@ -482,15 +482,15 @@ with tf.Session() as sess:
![](img/89dcc2e8-9f73-4c7d-9bc0-40327d477b2a.png)
# 这个怎么运作...
# 工作原理
在这里,我们正在以 10 的批量大小训练网络。如果增加它,网络性能就会下降。 同样,在测试数据上检查训练网络的准确性; 对其进行测试的测试数据的大小为 1,000。
# 还有更多...
# 更多
我们的一个隐藏层多层感知器在训练数据上的准确度为 84.45,在测试数据上的准确度为 92.1。 很好,但还不够好。 MNIST 数据库用作机器学习中分类问题的基准。 接下来,我们了解使用 TensorFlow 的内置优化器如何影响网络性能。
# 也可以看看
# 另见
* [MNIST 数据库](http://yann.lecun.com/exdb/mnist/)
* [反向传播算法的简化解释](http://neuralnetworksanddeeplearning.com/chap2.html)
......@@ -501,7 +501,7 @@ with tf.Session() as sess:
TensorFlow 支持自动分化; 我们可以使用 TensorFlow 优化器来计算和应用梯度。 它使用梯度自动更新定义为变量的张量。 在此配方中,我们将使用 TensorFlow 优化器来训练网络。
# 做好准备
# 准备
在反向传播算法配方中,我们定义了层,权重,损耗,梯度,并手动通过梯度进行更新。 为了更好地理解,手动使用方程式进行操作是一个好主意,但是随着网络中层数的增加,这可能会非常麻烦。
......@@ -530,7 +530,7 @@ fully_connected(
`fully_connected` creates a variable called weights, representing a fully connected weight matrix, which is multiplied by the inputs to produce a tensor of hidden units. If a `normalizer_fn` is provided (such as `batch_norm`), it is then applied. Otherwise, if `normalizer_fn` is None and a `biases_initializer` is provided then a biases variable would be created and added to the hidden units. Finally, if `activation_fn` is not None, it is applied to the hidden units as well.
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -603,7 +603,7 @@ import tensorflow as tf
print ("Accuracy%:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))
```
# 这个怎么运作...
# 工作原理
改进的 MNIST MLP 分类器在测试数据集上的准确性达到了 96%,只有一个隐藏层并且在 10 个周期内。 仅在几行代码中我们就获得了约 96% 的准确度,这就是 TensorFlow 的强大功能:
......@@ -617,11 +617,11 @@ import tensorflow as tf
在本食谱中,我们将向您展示如何使用 MLP 进行函数逼近; 具体来说,我们将预测波士顿的房价。 我们已经熟悉了数据集; 在第 2 章,“回归”中,我们使用回归技术进行房价预测,现在我们将使用 MLP 进行相同的操作。
# 做好准备
# 准备
对于函数逼近,`loss`函数应为 MSE。 输入应该标准化,而隐藏层可以是 ReLU,而输出层则最好是 Sigmoid 。
# 怎么做...
# 操作步骤
这是我们从使用 MLP 进行函数逼近开始的方法:
......@@ -740,13 +740,13 @@ print(" Mean Error:", accuracy.eval({x: X_train, y: y_train})) plt.scatter(y_tra
writer.close()
```
# 这个怎么运作...
# 工作原理
该模型只有一个隐藏层,因此可以预测训练数据集的价格,平均误差为 0.0071。 下图显示了房屋的估计价格与实际价格之间的关系:
![](img/0d714534-3a0b-4373-9664-f29c8925d628.png)
# 还有更多...
# 更多
在这里,我们使用 TensorFlow ops Layers(Contrib)来构建神经网络层。 由于避免了分别声明每一层的权重和偏差,因此使我们的工作稍微容易一些。 如果我们使用像 Keras 这样的 API,可以进一步简化工作。 这是在 Keras 中使用 TensorFlow 作为后端的相同代码:
......@@ -786,7 +786,7 @@ print( "Performance Metrics R2 : {0:f}, RMSE : {1:f}".format( r2, rmse ) )
正如您现在必须已经观察到的那样,神经网络的性能在很大程度上取决于超参数。 因此,重要的是要了解这些参数如何影响网络。 超参数的常见示例是学习率,正则化器,正则化系数,隐藏层的尺寸,初始权重值,甚至是为优化权重和偏差而选择的优化器。
# 怎么做...
# 操作步骤
这是我们进行食谱的方法:
......@@ -843,11 +843,11 @@ for epoch in epochs:
print("Saved model to disk")
```
# 还有更多...
# 更多
还有另一种称为**贝叶斯优化**的方法,该方法也可以用于调整超参数。 在其中,我们定义了一个采集函数以及一个高斯过程。 高斯过程使用一组先前评估的参数以及由此产生的精度来假设大约未观测到的参数。 使用此信息的采集功能建议使用下一组参数。 有一个包装程序甚至可用于[基于梯度的超参数优化](https://github.com/lucfra/RFHO)
# 也可以看看
# 另见
* [两个用于超级参数优化的出色开源软件包的很好介绍:Hyperopt 和 scikit-optimize](https://roamanalytics.com/2016/09/15/optimizing-the-hyperparameter-of-which-hyperparameter-optimizer-to-use/)
* [另一个有关 Hyperopt 的内容](http://fastml.com/optimizing-hyperparams-with-hyperopt/)
......@@ -857,7 +857,7 @@ for epoch in epochs:
Keras 是将 TensorFlow 作为后端使用的高级 API。 向其添加层就像添加一行代码一样容易。 在建立模型架构之后,您可以使用一行代码来编译和拟合模型。 以后,它可以用于预测。 变量,占位符甚至会话的声明均由 API 管理。
# 怎么做...
# 操作步骤
我们对 Keras 进行如下操作:
......@@ -903,11 +903,11 @@ model.fit(data, labels, epochs=10, batch_size=32)
model.predict(test_data, batch_size=10)
```
# 还有更多...
# 更多
Keras 提供了添加卷积层,池化层,循环层甚至本地连接层的选项。 [Keras 文档](https://keras.io/models/sequential/)中提供了每种方法的详细说明。
# 也可以看看
# 另见
```py
McCulloch, Warren S., and Walter Pitts. A logical calculus of the ideas immanent in nervous activity The bulletin of mathematical biophysics 5.4 (1943): 115-133. http://vordenker.de/ggphilosophy/mcculloch_a-logical-calculus.pdf
......
......@@ -113,11 +113,11 @@ CNN 基本上是卷积的几层,具有非线性激活函数,并且池化层
在本食谱中,您将学习如何创建一个简单的三层卷积网络来预测 MNIST 数字。 深度网络由具有 ReLU 和最大池化的两个卷积层以及两个完全连接的最终层组成。
# 做好准备
# 准备
MNIST 是一组 60,000 张代表手写数字的图像。 本食谱的目的是高精度地识别这些数字。
# 怎么做...
# 操作步骤
让我们从食谱开始:
......@@ -345,7 +345,7 @@ plt.show()
训练和测试准确性提高的示例
# 这个怎么运作...
# 工作原理
使用卷积网络,我们将 MNIST 数据集的性能提高了近 95%。 我们的卷积网络由两层组成,分别是卷积,ReLU 和最大池化,然后是两个完全连接的带有丢弃的层。 训练以 Adam 为优化器,以 128 的大小批量进行,学习率为 0.001,最大迭代次数为 500。
......@@ -357,11 +357,11 @@ plt.show()
CIFAR 图像示例
# 做好准备
# 准备
在本食谱中,我们使用`tflearn`-一个更高级别的框架-抽象了一些 TensorFlow 内部结构,使我们可以专注于深度网络的定义。 TFLearn 可从[这里](http://tflearn.org/)获得,[该代码是标准发行版的一部分](https://github.com/tflearn/tflearn/tree/master/examples)
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -436,7 +436,7 @@ model.fit(X, Y, n_epoch=50, shuffle=True, validation_set=(X_test, Y_test),
show_metric=True, batch_size=96, run_id='cifar10_cnn')
```
# 这个怎么运作...
# 工作原理
TFLearn 隐藏了 TensorFlow 公开的许多实现细节,并且在许多情况下,它使我们可以专注于具有更高抽象级别的卷积网络的定义。 我们的管道在 50 次迭代中达到了 88% 的精度。 下图是 Jupyter 笔记本中执行的快照:
......@@ -444,7 +444,7 @@ TFLearn 隐藏了 TensorFlow 公开的许多实现细节,并且在许多情况
Jupyter 执行 CIFAR10 分类的示例
# 还有更多...
# 更多
要安装 TFLearn,请参阅[《安装指南》](http://tflearn.org/installation),如果您想查看更多示例,可以在线获取[一长串久经考验的解决方案](http://tflearn.org/examples/)
......@@ -452,11 +452,11 @@ Jupyter 执行 CIFAR10 分类的示例
在本食谱中,您将教计算机如何绘画。 关键思想是拥有绘画模型图像,神经网络可以从该图像推断绘画风格。 然后,此样式将转移到另一张图片,并相应地重新粉刷。 该食谱是对`log0`开发的代码的修改,[可以在线获取](https://github.com/log0/neural-style-painting/blob/master/TensorFlow%20Implementation%20of%20A%20Neural%20Algorithm%20of%20Artistic%20Style.ipynb)
# 做好准备
# 准备
我们将实现在论文[《一种艺术风格的神经算法》](https://arxiv.org/abs/1508.06576)中描述的算法,作者是 Leon A. Gatys,亚历山大 S. Ecker 和 Matthias Bethge。 因此,最好先阅读[该论文](https://arxiv.org/abs/1508.06576)。 此食谱将重复使用在线提供的预训练模型 [VGG19](http://www.vlfeat.org/matconvnet/models/beta16/imagenet-vgg-verydeep-19.mat),该模型应在本地下载。 我们的风格图片将是一幅可在线获得的[梵高著名画作](https://commons.wikimedia.org/wiki/File:VanGogh-starry_night.jpg),而我们的内容图片则是[从维基百科下载的玛丽莲梦露的照片](https://commons.wikimedia.org/wiki/File:Marilyn_Monroe_in_1952.jpg)。 内容图像将根据梵高的样式重新绘制。
# 怎么做...
# 操作步骤
让我们从食谱开始:
......@@ -857,11 +857,11 @@ sess.run(tf.reduce_sum(mixed_image)))
风格迁移的例子
# 这个怎么运作...
# 工作原理
在本食谱中,我们已经看到了如何使用样式转换来重绘内容图像。 样式图像已作为神经网络的输入提供,该网络学习了定义画家采用的样式的关键方面。 这些方面已用于将样式转移到内容图像。
# 还有更多...
# 更多
自 2015 年提出原始建议以来,样式转换一直是活跃的研究领域。已经提出了许多新想法来加速计算并将样式转换扩展到视频分析。 其中有两个结果值得一提
......@@ -875,7 +875,7 @@ sess.run(tf.reduce_sum(mixed_image)))
按照这种思路,计算机视觉研究人员现在通常使用经过预训练的 CNN 来生成新颖任务的表示形式,其中数据集可能不足以从头训练整个 CNN。 另一个常见的策略是采用经过预先训练的 ImageNet 网络,然后将整个网络微调到新颖的任务。 此处提出的示例的灵感来自 [Francois Chollet 在 Keras 的著名博客文章](https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html)
# 做好准备
# 准备
想法是使用在大型数据集(如 ImageNet)上预训练的 VGG16 网络。 请注意,训练在计算上可能会相当昂贵,因此可以重用已经预先训练的网络:
......@@ -885,7 +885,7 @@ A VGG16 Network
那么,如何使用 VGG16? Keras 使该库变得容易,因为该库具有可作为库使用的标准 VGG16 应用程序,并且自动下载了预先计算的权重。 请注意,我们明确省略了最后一层,并用我们的自定义层替换了它,这将在预构建的 VGG16 的顶部进行微调。 在此示例中,您将学习如何对 Kaggle 提供的猫狗图像进行分类。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -986,13 +986,13 @@ score = model.evaluate_generator(validation_generator, nb_validation_samples/bat
scores = model.predict_generator(validation_generator, nb_validation_samples/batch_size)
```
# 这个怎么运作...
# 工作原理
标准的 VGG16 网络已经在整个 ImageNet 上进行了预训练,并具有从互联网下载的预先计算的权重。 然后,将该网络与也已单独训练的自定义网络并置。 然后,并列的网络作为一个整体进行了重新训练,使 VGG16 的 15 个较低层保持冻结。
这种组合非常有效。 通过对网络在 ImageNet 上学到的知识进行转移学习,将其应用于我们的新特定领域,从而执行微调分类任务,它可以节省大量的计算能力,并重复使用已为 VGG16 执行的工作。
# 还有更多...
# 更多
根据特定的分类任务,需要考虑一些经验法则:
......@@ -1014,11 +1014,11 @@ Google 于 2014 年训练了神经网络以应对 **ImageNet 大规模视觉识
[如以下所示的 Google DeepDreams 示例](https://commons.wikimedia.org/wiki/File:Aurelia-aurita-3-0009.jpg)
# 做好准备
# 准备
从网上下载预训练的 [Inception 模型](https://github.com/martinwicke/tensorflow-tutorial/blob/master/tensorflow_inception_graph.pb)
# 怎么做...
# 操作步骤
我们按以下步骤进行操作:
......@@ -1152,15 +1152,15 @@ np.int32(np.float32(hw)/octave_scale))
DeepDream 转换的示例。 其中一位作家变成了狼
# 这个怎么运作...
# 工作原理
神经网络存储训练图像的抽象:较低的层存储诸如线条和边缘之类的特征,而较高的层则存储诸如眼睛,面部和鼻子之类的更复杂的图像特征。 通过应用梯度上升过程,我们最大化了`loss`函数,并有助于发现类似于高层存储的图案的内容图像。 这导致了网络看到虚幻图像的梦想。
# 还有更多...
# 更多
许多网站都允许您直接玩 DeepDream。 我特别喜欢[`DeepArt.io`](https://deepart.io/),它允许您上传内容图像和样式图像并在云上进行学习。
# 也可以看看
# 另见
在 2015 年发布初步结果之后,还发布了许多有关 DeepDream 的新论文和博客文章:
......
......@@ -27,11 +27,11 @@
在本食谱中,我们将使用 TFLearn 创建基于 CNN 的情感分析深度学习网络。 如上一节所述,我们的 CNN 将是一维的。 我们将使用 IMDb 数据集,用于训练的 45,000 个高度受欢迎的电影评论和用于测试的 5,000 个集合。
# 做好准备
# 准备
TFLearn 具有用于自动从网络下载数据集并促进卷积网络创建的库,因此让我们直接看一下代码。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -119,7 +119,7 @@ Training Step: 3519 | total loss: 0.09738 | time: 85.043s
--
```
# 这个怎么运作...
# 工作原理
[用于句子分类的卷积神经网络,Yoon Kim,EMNLP 2014](https://arxiv.org/abs/1408.5882)。 请注意,由于筛选器窗口对连续单词进行操作,因此本文提出的模型保留了一些有关位置的信息。 从论文中提取的以下图像以图形方式表示了网络之外的主要直觉。 最初,文本被表示为基于标准嵌入的向量,从而为我们提供了一维密集空间中的紧凑表示。 然后,使用多个标准一维卷积层处理矩阵。
......@@ -130,7 +130,7 @@ Training Step: 3519 | total loss: 0.09738 | time: 85.043s
* 过滤器通常在连续空间上卷积。 对于图像,此空间是像素矩阵表示形式,在高度和宽度上在空间上是连续的。 对于文本而言,连续空间无非是连续单词自然产生的连续尺寸。 如果仅使用单次编码表示的单词,则空间稀疏;如果使用嵌入,则由于聚集了相似的单词,因此生成的空间密集。
* 图像通常具有三个通道(RGB),而文本自然只有一个通道,因为我们无需表示颜色。
# 还有更多...
# 更多
论文[《用于句子分类的卷积神经网络》](https://arxiv.org/abs/1408.5882)(Yoon Kim,EMNLP 2014)进行了广泛的实验。 尽管对超参数的调整很少,但具有一层卷积的简单 CNN 在句子分类方面的表现却非常出色。 该论文表明,采用一组静态嵌入(将在我们谈论 RNN 时进行讨论),并在其之上构建一个非常简单的卷积网络,实际上可以显着提高情感分析的性能:
......@@ -146,7 +146,7 @@ Training Step: 3519 | total loss: 0.09738 | time: 85.043s
在本食谱中,我们将使用 [keras-vis](https://raghakot.github.io/keras-vis/),这是一个外部 Keras 软件包,用于直观检查预建的 VGG16 网络从中学到了什么不同的过滤器。 这个想法是选择一个特定的 ImageNet 类别,并了解 VGG16 网络如何学会代表它。
# 做好准备
# 准备
第一步是选择用于在 ImageNet 上训练 VGG16 的特定类别。 假设我们采用类别 20,它对应于下图中显示的*美国北斗星*鸟:
......@@ -156,7 +156,7 @@ Training Step: 3519 | total loss: 0.09738 | time: 85.043s
可以在网上找到 [ImageNet 映射](https://gist.github.com/yrevar/6135f1bd8dcf2e0cc683)作为 python 泡菜字典,其中 ImageNet 1000 类 ID 映射到了人类可读的标签。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -285,13 +285,13 @@ plt.show()
不出所料,该特定层正在学习非常基本的功能,例如曲线。 但是,卷积网络的真正力量在于,随着我们对模型的深入研究,网络会推断出越来越复杂的功能。
# 这个怎么运作...
# 工作原理
密集层的 keras-vis 可视化的关键思想是生成一个输入图像,该图像最大化与鸟类类相对应的最终密集层输出。 因此,实际上该模块的作用是解决问题。 给定具有权重的特定训练密集层,将生成一个新的合成图像,它最适合该层本身。
每个转换滤波器都使用类似的想法。 在这种情况下,请注意,由于卷积网络层在原始像素上运行,因此可以通过简单地可视化其权重来解释它。 后续的卷积过滤器对先前的卷积过滤器的输出进行操作,因此直接可视化它们不一定很有解释性。 但是,如果我们独立地考虑每一层,我们可以专注于仅生成可最大化滤波器输出的合成输入图像。
# 还有更多...
# 更多
GitHub 上的 [keras-vis 存储库](https://github.com/raghakot/keras-vis)提供了一组很好的可视化示例,这些示例说明了如何内部检查网络,包括最近的显着性地图,其目的是在图像经常包含其他元素(例如草)时检测图像的哪个部分对特定类别(例如老虎)的训练贡献最大。 种子文章是[《深度卷积网络:可视化图像分类模型和显着性图》](https://arxiv.org/abs/1312.6034)(Karen Simonyan,Andrea Vedaldi,Andrew Zisserman),并在下面报告了从 Git 存储库中提取的示例,在该示例中,网络可以自行了解*定义为*老虎的图像中最突出的部分是:
......@@ -333,11 +333,11 @@ ResNet 已在[《用于图像识别的深度残差学习》](https://arxiv.org/a
Xception 是 Inception 的扩展,在[《Xception:具有深度可分离卷积的深度学习》](https://arxiv.org/abs/1610.02357)(FrançoisChollet,2016 年)中引入。 Xception 使用一种称为深度可分离卷积运算的新概念,该概念使其在包含 3.5 亿张图像和 17,000 个类别的大型图像分类数据集上的表现优于 Inception-v3。 由于 Xception 体系结构具有与 Inception-v3 相同数量的参数,因此性能的提高并不是由于容量的增加,而是由于模型参数的更有效使用。
# 做好准备
# 准备
此食谱使用 Keras,因为该框架已预先完成了上述模块的实现。 Keras 首次使用时会自动下载每个网络的权重,并将这些权重存储在本地磁盘上。 换句话说,您不需要重新训练网络,而是可以利用互联网上已经可用的训练。 在您希望将网络分类为 1000 个预定义类别的假设下,这是正确的。 在下一个食谱中,我们将了解如何从这 1,000 个类别开始,并通过称为转移学习的过程将它们扩展到自定义集合。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -634,11 +634,11 @@ print_model('vgg19')
Non-trainable params: 0
```
# 这个怎么运作...
# 工作原理
我们使用了 Keras 应用程序,预训练的 Keras 学习模型,该模型随预训练的权重一起提供。 这些模型可用于预测,特征提取和微调。 在这种情况下,我们将模型用于预测。 我们将在下一个食谱中看到如何使用模型进行微调,以及如何在最初训练模型时最初不可用的数据集上构建自定义分类器。
# 还有更多...
# 更多
截至 2017 年 7 月,Inception-v4 尚未在 Keras 中直接提供,但可以作为单独的模块[在线下载](https://github.com/kentsommer/keras-inceptionV4)。 安装后,该模块将在首次使用时自动下载砝码。
......@@ -654,11 +654,11 @@ AlexNet 是最早的堆叠式深层网络之一,它仅包含八层,前五层
在本食谱中,我们将看到如何使用深度学习来提取相关功能
# 做好准备
# 准备
一个非常简单的想法是通常使用 VGG16 和 DCNN 进行特征提取。 该代码通过从特定层提取要素来实现该想法。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -696,7 +696,7 @@ x = preprocess_input(x)
features = model.predict(x)
```
# 这个怎么运作...
# 工作原理
现在,您可能想知道为什么我们要从 CNN 的中间层提取要素。 关键的直觉是:随着网络学会将图像分类,各层学会识别进行最终分类所必需的特征。
......@@ -716,11 +716,11 @@ InceptionV3 Net 是 Google 开发的非常深入的卷积网络。 Keras 实现
ImageNet v3 的示例
# 做好准备
# 准备
此框架示例受到 [Keras 网站上在线提供的方案](https://keras.io/applications/)的启发。 我们假设在与 ImageNet 不同的域中具有训练数据集 D。 D 在输入中具有 1,024 个特征,在输出中具有 200 个类别。
# 怎么做...
# 操作步骤
我们可以按照以下步骤进行操作:
......@@ -800,11 +800,11 @@ layer.trainable = False
model.fit_generator(...)
```
# 这个怎么运作...
# 工作原理
现在,我们有了一个新的深度网络,该网络可以重用标准的 Inception-v3 网络,但可以通过迁移学习在新的域 D 上进行训练。 当然,有许多参数需要微调以获得良好的精度。 但是,我们现在正在通过迁移学习重新使用非常庞大的预训练网络作为起点。 这样,我们可以通过重复使用 Keras 中已经可用的内容来节省对机器进行训练的需求。
# 还有更多...
# 更多
截至 2017 年,“计算机视觉”问题意味着在图像中查找图案的问题可以视为已解决,并且此问题影响了我们的生活。 例如:
......@@ -848,11 +848,11 @@ WaveNet 之外的主要直觉是所谓的因果因果卷积(有时称为原子
[如下所示的 NSynth 架构示例](https://magenta.tensorflow.org/nsynth)
# 做好准备
# 准备
对于本食谱,我们不会编写代码,而是向您展示如何使用[一些在线可用的代码](https://github.com/tensorflow/magenta/tree/master/magenta/models/nsynth)和一些不错的演示,您可以从 [Google Brain 找到](https://aiexperiments.withgoogle.com/sound-maker)。 有兴趣的读者还可以阅读以下文章:[《使用 WaveNet 自编码器的音符的神经音频合成》](https://arxiv.org/abs/1704.01279)(杰西·恩格尔,辛琼·雷斯尼克,亚当·罗伯茨,桑德·迪勒曼,道格拉斯·埃克,卡伦·西蒙扬,穆罕默德·诺鲁兹,4 月 5 日 2017)。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -926,11 +926,11 @@ axs[1].set_title('NSynth Encoding')
%time fastgen.synthesize(encoding, save_paths=['gen_' + fname], samples_per_save=sample_length)
```
# 这个怎么运作...
# 工作原理
WaveNet 是一种卷积网络,其中卷积层具有各种扩张因子,从而使接收场随深度呈指数增长,因此有效覆盖了数千个音频时间步长。 NSynth 是 WaveNet 的演进,其中原始音频使用类似 WaveNet 的处理进行编码,以学习紧凑的表示形式。 然后,使用这种紧凑的表示来再现原始音频。
# 还有更多...
# 更多
一旦我们学习了如何通过膨胀卷积创建音频的紧凑表示形式,我们就可以玩这些学习并从中获得乐趣。 您会在互联网上找到非常酷的演示:
......@@ -963,7 +963,7 @@ WaveNet 是一种卷积网络,其中卷积层具有各种扩张因子,从而
我们这种情况的唯一区别是,我们将图像层产生的特征与语言层产生的特征连接起来。
# 怎么做...
# 操作步骤
我们可以按照以下步骤进行操作:
......@@ -1223,11 +1223,11 @@ for label in reversed(np.argsort(y_output)[0,-5:]):
print str(round(y_output[0,label]*100,2)).zfill(5), "% ", labelencoder.inverse_transform(label)
```
# 这个怎么运作...
# 工作原理
视觉问题解答的任务是通过结合使用不同的深度神经网络来解决的。 预训练的 VGG16 已用于从图像中提取特征,而 LSTM 序列已用于从先前映射到嵌入空间的问题中提取特征。 VGG16 是用于图像特征提取的 CNN,而 LSTM 是用于提取表示序列的时间特征的 RNN。 目前,这两种方法的结合是处理此类网络的最新技术。 然后,在组合模型的顶部添加一个具有辍学功能的多层感知器,以形成我们的深度网络。
# 还有更多...
# 更多
在互联网上,您可以找到 [Avi Singh](https://avisingh599.github.io/deeplearning/visual-qa/) 进行的更多实验,其中比较了不同的模型,包括简单的“袋装”语言的“单词”与图像的 CNN,仅 LSTM 模型以及 LSTM + CNN 模型-类似于本食谱中讨论的模型。 博客文章还讨论了每种模型的不同训练策略。
......@@ -1264,7 +1264,7 @@ print str(round(y_output[0,label]*100,2)).zfill(5), "% ", labelencoder.inverse_t
[C3D + RNN 的示例](https://imatge-upc.github.io/activitynet-2016-cvprw/)
# 怎么做...
# 操作步骤
对于此食谱,我们仅汇总[在线呈现的结果](https://github.com/imatge-upc/activitynet-2016-cvprw/blob/master/misc/step_by_step_guide.md)
......@@ -1298,12 +1298,12 @@ cd data/models
python scripts/run_all_pipeline.py -i path/to/test/video.mp4
```
# 这个怎么运作...
# 工作原理
如果您有兴趣在计算机上训练 CNN3D 和 RNN,则可以在互联网上找到此计算机管道使用的特定命令。
目的是介绍可用于视频分类的不同方法的高级视图。 同样,不仅有一个单一的配方,而且有多个选项,应根据您的特定需求仔细选择。
# 还有更多...
# 更多
CNN-LSTM 体系结构是新的 RNN 层,其中输入转换和递归转换的输入都是卷积。 尽管名称非常相似,但如上所述,CNN-LSTM 层与 CNN 和 LSTM 的组合不同。 该模型在论文[《卷积 LSTM 网络:降水临近预报的机器学习方法》](https://arxiv.org/abs/1506.04214)(史兴建,陈周荣,王浩,杨天彦,黄伟坚,胡旺春,2015 年)中进行了描述,并且在 2017 年,有些人开始尝试使用此模块进行视频实验,但这仍然是一个活跃的研究领域。
\ No newline at end of file
......@@ -156,11 +156,11 @@ LSTM 单元的一个例子
在本食谱中,我们使用 NMT(神经机器翻译),这是一个可在 TensorFlow 顶部在线获得的翻译演示包。
# 做好准备
# 准备
NMT 可在[这个页面](https://github.com/tensorflow/nmt/)上找到,并且代码在 GitHub 上。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -287,7 +287,7 @@ saving hparams to /tmp/nmt_model/hparams
global step 9700 lr 1 step-time 1.52s wps 3.71K ppl 38.01 bleu 4.89
```
# 这个怎么运作...
# 工作原理
所有上述代码已在[这个页面](https://github.com/tensorflow/nmt/blob/master/nmt/model.py)中定义。 关键思想是将两个 RNN *打包在一起*。 第一个是编码器,它在嵌入空间中工作,非常紧密地映射相似的单词。 编码器*理解*训练示例的含义,并产生张量作为输出。 然后只需将编码器的最后一个隐藏层连接到解码器的初始层,即可将该张量传递给解码器。 注意学习是由于我们基于基于与`labels=decoder_outputs`的交叉熵的损失函数而发生的。
......@@ -311,7 +311,7 @@ Tensorboard 中的 BLEU 指标示例
* **采样**:通过对对率产生的对率进行采样来产生单词
* **集束搜索**:一个以上的预测,因此创建了可能的扩展树
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -343,7 +343,7 @@ python -m nmt.nmt \
--inference_output_file=/tmp/nmt_model/output_infer
```
# 这个怎么运作...
# 工作原理
将两个 RNN *打包在一起*,以形成编码器-解码器 RNN 网络。 解码器产生对率,然后将其贪婪地转换为目标语言的单词。 例如,此处显示了从越南语到英语的自动翻译:
......@@ -364,7 +364,7 @@ python -m nmt.nmt \
* 其次,创建上下文向量以汇总注意权重的结果
* 第三,将上下文向量与当前目标隐藏状态组合以获得注意力向量
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -423,7 +423,7 @@ nmt: But what do you know ?
# Best bleu, step 12000 step-time 1.67 wps 3.37K, dev ppl 14.01, dev bleu 15.9, test ppl 12.58, test bleu 17.5, Sat Sep 23 04:36:35 2017
```
# 这个怎么运作...
# 工作原理
注意是一种机制,该机制使用由编码器 RNN 的内部状态获取的信息,并将该信息与解码器的最终状态进行组合。 关键思想是,通过这种方式,有可能或多或少地关注源序列中的某些标记。 下图显示了 BLEU 得分,引起了关注。
......@@ -433,7 +433,7 @@ nmt: But what do you know ?
Tensorboard 中注意力的 BLEU 指标示例
# 还有更多...
# 更多
值得记住的是 seq2seq 不仅可以用于机器翻译。 让我们看一些例子:
......@@ -452,7 +452,7 @@ Tensorboard 中注意力的 BLEU 指标示例
为了简单起见,我们将使用框架 [TFLearn](http://tflearn.org/),它在 TensorFlow 上运行。 此示例是标准分发版的一部分,[可从以下位置获得](https://github.com/tflearn/tflearn/blob/master/examples/nlp/lstm_generator_shakespeare.py)。开发的模型是 RNN 字符级语言模型,其中考虑的序列是字符序列而不是单词序列。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -527,7 +527,7 @@ print("-- Test with temperature of 0.5 --")
print(m.generate(600, temperature=0.5, seq_seed=seed))
```
# 这个怎么运作...
# 工作原理
当新的未知或被遗忘的艺术品要归功于作者时,有著名的学者将其与作者的其他作品进行比较。 学者们要做的是在著名作品的文本序列中找到共同的模式,希望在未知作品中找到相似的模式。
......@@ -616,7 +616,7 @@ This made a called grace to hear him and an ass,
And the provest and stand,
```
# 还有更多...
# 更多
博客文章[循环神经网络的不合理有效性](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)描述了一组引人入胜的示例 RNN 字符级语言模型,包括以下内容:
......@@ -634,7 +634,7 @@ And the provest and stand,
We offer historical data from our Bitcoin Price Index through the following endpoint: https://api.coindesk.com/v1/bpi/historical/close.json By default, this will return the previous 31 days' worth of data. This endpoint accepts the following optional parameters: ?index=[USD/CNY]The index to return data for. Defaults to USD. ?currency=<VALUE>The currency to return the data in, specified in ISO 4217 format. Defaults to USD. ?start=<VALUE>&end=<VALUE> Allows data to be returned for a specific date range. Must be listed as a pair of start and end parameters, with dates supplied in the YYYY-MM-DD format, e.g. 2013-09-01 for September 1st, 2013. ?for=yesterday Specifying this will return a single value for the previous day. Overrides the start/end parameter. Sample Request: https://api.coindesk.com/v1/bpi/historical/close.json?start=2013-09-01&end=2013-09-05 Sample JSON Response: {"bpi":{"2013-09-01":128.2597,"2013-09-02":127.3648,"2013-09-03":127.5915,"2013-09-04":120.5738,"2013-09-05":120.5333},"disclaimer":"This data was produced from the CoinDesk Bitcoin Price Index. BPI value data returned as USD.","time":{"updated":"Sep 6, 2013 00:03:00 UTC","updatedISO":"2013-09-06T00:03:00+00:00"}}
```
# 怎么做...
# 操作步骤
这是我们进行食谱的方法:
......@@ -954,11 +954,11 @@ for j in range(nb_predictions):
比特币价值预测的一个例子
# 这个怎么运作...
# 工作原理
带有 GRU 基本单元的编码器-解码器层堆叠 RNN 用于预测比特币值。 RNN 非常擅长学习序列,即使使用基于 2 层和 12 个 GRU 单元的简单模型,比特币的预测确实相当准确。 当然,此预测代码并非鼓励您投资比特币,而只是讨论深度学习方法。 而且,需要更多的实验来验证我们是否存在数据过度拟合的情况。
# 还有更多...
# 更多
预测股市价值是一个不错的 RNN 应用程序,并且有许多方便的软件包,例如:
......@@ -974,7 +974,7 @@ for j in range(nb_predictions):
[RNN 序列的一个例子](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -1007,6 +1007,6 @@ model = Sequential()
model.add(LSTM(1, input_shape=(timesteps, data_dim), return_sequences=True))
```
# 这个怎么运作...
# 工作原理
Keras 使您可以轻松编写各种形状的 RNN,包括一对一,一对多,多对一和多对多映射。 上面的示例说明了用 Keras 实施它们有多么容易。
\ No newline at end of file
......@@ -23,7 +23,7 @@
**主成分分析****PCA**)是用于降维的最流行的多元统计技术。 它分析了由几个因变量组成的训练数据,这些因变量通常是相互关联的,并以一组称为**主成分**的新正交变量的形式从训练数据中提取重要信息。 我们可以使用两种方法执行 PCA -- **特征值分解****奇异值分解****SVD**)。
# 做好准备
# 准备
PCA 将`n`维输入数据还原为`r`维输入数据,其中`r < n`。 简单来说,PCA 涉及平移原点并执行轴的旋转,以使其中一个轴(主轴)与数据点的差异最小。 通过执行此变换,然后以高方差落下(删除)正交轴,可以从原始数据集中获得降维数据集。 在这里,我们采用 SVD 方法降低 PCA 尺寸。 考虑`X``n`维数据,具有`p`个点`X[p,n]`。 任何实数(`p × n`)矩阵都可以分解为:
......@@ -35,7 +35,7 @@ PCA 将`n`维输入数据还原为`r`维输入数据,其中`r < n`。 简单
[此处提供的代码已从以下 GitHub 链接进行改编](https://github.com/eliorc/Medium/blob/master/PCA-tSNE-AE.ipynb)
# 怎么做...
# 操作步骤
我们按以下步骤进行操作:
......@@ -132,11 +132,11 @@ ax.scatter(pca[:, 0], pca[:, 1],pca[:, 2], c=colors)
![](img/846880ef-99be-40b7-a3ac-85db002f80dd.png)
# 这个怎么运作...
# 工作原理
前面的代码对 MNIST 图像执行降维。 每个原始图像的尺寸为`28 x 28`; 使用 PCA 方法,我们可以将其减小到较小的尺寸。 通常,对于图像数据,降维是必要的。 之所以如此,是因为图像很大,并且包含大量的冗余数据。
# 还有更多...
# 更多
TensorFlow 提供了一种称为**嵌入**的技术,该技术是将对象映射到向量中。 TensorBoard 的嵌入式投影仪允许我们以交互方式可视化模型中的嵌入。 嵌入式投影仪提供了三种降低尺寸的方法:PCA,t-SNE 和自定义。 我们可以使用 TensorBoard 的嵌入投影器实现与上一个类似的结果。 我们需要从`tensorflow.contrib.tensorboard.plugins`导入`projector`类,以从`tensorflow.contrib.tensorboard.plugins`导入`projector`进行相同的操作。 我们可以通过三个简单的步骤来做到这一点:
......@@ -178,7 +178,7 @@ with tf.Session() as sess:
![](img/0138c6e3-6c07-415d-a74c-f080e9d27718.png)
# 也可以看看
# 另见
* <https://arxiv.org/abs/1404.1100>
* <http://www.cs.otago.ac.nz/cosc453/student_tutorials/principal_components.pdf>
......@@ -198,7 +198,7 @@ K 均值算法以以下方式工作:
3. 使用当前簇成员资格重新计算质心,以使平方和的距离减小
4. 重复最后两个步骤,直到达到收敛
# 做好准备
# 准备
我们将使用 TensorFlow `KmeansClustering`估计器类来实现 K 均值。 它在[这个链接](https://github.com/tensorflow/tensorflow/blob/r1.3/tensorflow/contrib/learn/python/learn/estimators/kmeans.py)中定义。它创建一个模型来运行 K 均值和推理。 根据 TensorFlow 文档,一旦创建了`KmeansClustering`类对象,就可以使用以下`__init__`方法实例化该对象:
......@@ -247,7 +247,7 @@ fit(
根据 TensorFlow 文档,对于`KmeansClustering`估算器,我们需要向`fit()`提供`input_fn()``cluster`方法返回聚类中心,`predict_cluster_idx`方法返回预测的聚类索引。
# 怎么做...
# 操作步骤
这是我们进行食谱的方法:
......@@ -335,7 +335,7 @@ ScatterPlot(x[:,0], x[:,1], assignments, clusters)
`+`标记是三个簇的质心。
# 这个怎么运作...
# 工作原理
前面的配方使用 TensorFlow 的 K 均值聚类估计器将给定数据聚类为聚类。 在这里,由于我们知道集群的数量,我们决定保留`num_clusters=3`,但是在大多数情况下,如果使用未标记的数据,则永远无法确定存在多少集群。 可以使用弯头法确定最佳簇数。 该方法基于以下原则:我们应选择能减少**平方误差和****SSE**)距离的簇数。 如果`k`是簇数,则随着`k`增加,SSE 减少,`SSE = 0`; 当`k`等于数据点数时,每个点都是其自己的簇。 我们想要一个`k`较低的值,以使 SSE 也较低。 在 TensorFlow 中,我们可以使用`KmeansClustering`类中定义的`score()`方法找到 SSE; 该方法将距离的总和返回到最近的聚类:
......@@ -347,11 +347,11 @@ sum_distances = kmeans.score(input_fn=input_fn, steps=100)
![](img/fc2034f7-b673-471b-8ba0-8b1fdb58810c.png)
# 还有更多...
# 更多
K 均值聚类非常流行,因为它快速,简单且健壮。 它还有一些缺点:最大的缺点是用户必须指定簇的数量。 其次,该算法不能保证全局最优。 第三,它对异常值非常敏感。
# 也可以看看
# 另见
* `Kanungo, Tapas, et al. An efficient k-means clustering algorithm: Analysis and implementation. IEEE transactions on pattern analysis and machine intelligence 24.7 (2002): 881-892.`
......@@ -373,7 +373,7 @@ K 均值聚类非常流行,因为它快速,简单且健壮。 它还有一
SOM 通过竞争性学习来学习。 可以将其视为 PCA 的非线性概括,因此,像 PCA 一样,可以用于降维。
# 做好准备
# 准备
为了实现 SOM,让我们首先了解它是如何工作的。 第一步,将网络的权重初始化为某个随机值,或者通过从输入中获取随机样本进行初始化。 占据晶格中空间的每个神经元将被分配特定的位置。 现在,作为输入出现,与输入距离最小的神经元被宣布为 Winner(WTU)。 这是通过测量所有神经元的权重向量(`W`)和输入向量(`X`)之间的距离来完成的:
......@@ -395,7 +395,7 @@ SOM 通过竞争性学习来学习。 可以将其视为 PCA 的非线性概括
我们继续所有输入的过程,并重复给定的迭代次数。 随着迭代的进行,我们将学习率和半径减小一个取决于迭代次数的因素。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -601,11 +601,11 @@ for i, m in enumerate(mapped):
![](img/deea96ca-b33c-4152-bc29-e0588cd3fec0.png)
# 这个怎么运作...
# 工作原理
SOM 在计算上很昂贵,因此对于非常大的数据集并没有真正的用处。 尽管如此,它们仍然易于理解,并且可以很好地找到输入数据之间的相似性。 因此,它们已被用于图像分割和确定 NLP 中的单词相似度图。
# 也可以看看
# 另见
* [这是一篇非常不错的博客文章,用简单的语言解释了 SOM](http://www.ai-junkie.com/ann/som/som1.html)
* [关于 SOM 的简要介绍](https://en.wikipedia.org/wiki/Self-organizing_map)
......@@ -621,7 +621,7 @@ SOM 在计算上很昂贵,因此对于非常大的数据集并没有真正的
RBM 可用于降维,特征提取和协作过滤。 RBM 中的训练可分为三个部分:前进,后退和比较。
# 做好准备
# 准备
让我们看看制作 RBM 所需的表达式:
......@@ -649,7 +649,7 @@ RBM 可用于降维,特征提取和协作过滤。 RBM 中的训练可分为
在此,`η`是学习率。 对于偏差`b``c`存在相似的表达式。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -767,7 +767,7 @@ with tf.Session() as sess:
![](img/5b8add14-511e-4c68-abe3-5c634f3b6164.png)
# 这个怎么运作...
# 工作原理
由于其具有重建图像的能力,RBM 可用于从现有数据中生成更多数据。 通过制作一个小的助手绘图代码,我们可以看到原始和重建的 MNIST 图像:
......@@ -786,7 +786,7 @@ for fig, row in zip([Xtest_noisy,out], axarr):
![](img/ceafa00a-4ca3-442a-8258-6a45a8494ef7.png)
# 也可以看看
# 另见
* `Smolensky, Paul. Information processing in dynamical systems: Foundations of harmony theory. No. CU-CS-321-86. COLORADO UNIV AT BOULDER DEPT OF COMPUTER SCIENCE, 1986.`
......@@ -806,11 +806,11 @@ for fig, row in zip([Xtest_noisy,out], axarr):
网上零售商广泛使用推荐系统向客户推荐产品。 例如,亚马逊会告诉您购买此商品的其他客户对什么感兴趣,或者 Netflix 根据您所观看的内容以及有相同兴趣的其他 Netflix 用户所观看的内容推荐电视连续剧和电影。 这些推荐器系统在协作筛选的基础上工作。 在协作过滤中,系统根据用户的过去行为来构建模型。 我们将使用上一个食谱中的 RBM 构建一个使用协作过滤来推荐电影的推荐器系统。 这项工作中的一个重要挑战是,大多数用户不会对所有产品/电影进行评分,因此大多数数据都将丢失。 如果有 M 个产品和 N 个用户,则我们需要构建一个数组`N x M`,其中包含用户的已知等级并将所有未知值设为零。
# 做好准备
# 准备
为了使用协作过滤创建推荐系统,我们需要修改数据。 作为说明,我们将使用来自[这里](https://grouplens.org/datasets/movielens/)的电影数据集。 数据由两个`.dat`文件组成:`movies.dat``ratings.dat``movies.dat`文件包含 3 列:3883 个电影的 MovieID,Title 和 Genre。 `ratings.dat`文件包含四列:UserID,MovieID,Rating 和 Time。 我们需要合并这两个数据文件,以便能够构建一个数组,其中对于每个用户,我们对所有 3,883 部电影都有一个评分。 问题在于用户通常不会对所有电影进行评级,因此我们仅对某些电影进行非零(标准化)评级。 其余部分设为零,因此不会对隐藏层有所贡献。
# 怎么做...
# 操作步骤
1. 我们将使用在先前配方中创建的`RBM`类。 让我们定义我们的 RBM 网络; 可见单位的数量将是电影的数量,在我们的示例中为 3883(`movies_df`是包含`movies.dat`文件中的数据的数据帧):
......@@ -851,7 +851,7 @@ with tf.Session() as sess:
![](img/c9170c8b-d8d0-49eb-8a78-ac7b95a3386b.png)
# 还有更多...
# 更多
杰弗里·欣顿(Geoffrey Hinton)教授领导的多伦多大学团队赢得了 Netflix 最佳协作过滤竞赛的冠军,该协作过滤使用 [RBM](https://en.wikipedia.org/wiki/Netflix_Prize) 来预测电影的用户收视率。 [可以从他们的论文中获取其工作的详细信息](http://www.cs.toronto.edu/~hinton/absps/netflixICML.pdf)
......@@ -861,7 +861,7 @@ with tf.Session() as sess:
在本食谱中,我们将学习如何首先堆叠 RBM 来制作 DBN,然后训练它来检测情绪。 食谱中有趣的部分是我们采用了两种不同的学习范例:首先,我们使用无监督学习对 RBM 进行了预训练,最后,我们有了一个 MLP 层,该层是使用监督学习进行了训练的。
# 做好准备
# 准备
我们使用已经在配方*受限玻尔兹曼机*中创建的 RBM 类,只需进行一次更改即可,现在无需在训练后重建图像。 取而代之的是,我们栈式 RBM 将仅将数据转发至 DBN 的最后一个 MLP 层。 这是通过从类中删除`reconstruct()`函数并将其替换为`rbm_output()`函数来实现的:
......@@ -916,7 +916,7 @@ def preprocess_data(dataframe):
使用前面代码中定义的函数,我们以训练所需的格式获取数据。 基于本文针对 MNIST 提到的相似原理,我们构建了[情感检测 DBN](https://www.cs.toronto.edu/~hinton/absps/fastnc.pdf)
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -1131,7 +1131,7 @@ with tf.Session() as sess:
y_pred = nNet.predict(X_test)
```
# 这个怎么运作...
# 工作原理
RBM 使用无监督学习来学习模型的隐藏表示/功能,然后对与预训练 RBM 一起添加的全连接层进行微调。
......@@ -1144,7 +1144,7 @@ X_val = np.divide(np.subtract(X_val,mean_image), std_image)
X_test = np.divide(np.subtract(X_test,mean_image), std_image)
```
# 还有更多...
# 更多
在前面的示例中,没有进行预处理,这三个数据集的准确性大约为 40%。 但是,当我们添加预处理时,训练数据的准确性将提高到 90%,但是对于验证和测试,我们仍然可以获得约 45% 的准确性。
......
......@@ -28,7 +28,7 @@
自编码器的明显应用之一是在降维领域[2]。 结果表明,与 PCA 相比,自编码器产生了更好的结果。 自编码器还可以用于特征提取[3],文档检索[2],分类和异常检测。
# 也可以看看
# 另见
* `Rumelhart, David E., Geoffrey E. Hinton, and Ronald J. Williams. Learning internal representations by error propagation. No. ICS-8506. California Univ San Diego La Jolla Inst for Cognitive Science, 1985. (http://www.cs.toronto.edu/~fritz/absps/pdp8.pdf)`
......@@ -46,11 +46,11 @@ Hinton 提出的普通自编码器仅包含一个隐藏层。 隐藏层中神经
具有单个隐藏层的自动编码器
# 做好准备
# 准备
此食谱将使用自编码器进行图像重建; 我们将在 MNIST 数据库上训练自编码器,并将其用于重建测试图像。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -190,7 +190,7 @@ for fig, row in zip([Xtest,out], axarr):
![](img/951eb569-661c-4e83-8c85-0aab18434120.png)
# 这个怎么运作...
# 工作原理
有趣的是,在前面的代码中,我们将输入的尺寸从 784 减少到 256,并且我们的网络仍可以重建原始图像。 让我们比较一下具有相同隐藏层尺寸的 RBM(第 7 章,无监督学习)的性能:
......@@ -198,7 +198,7 @@ for fig, row in zip([Xtest,out], axarr):
我们可以看到,自编码器重建的图像比 RBM 重建的图像更清晰。 原因是,在自编码器中,还有其他权重(从隐藏层到解码器输出层的权重)需要训练,因此保留了学习知识。 随着自编码器了解更多,即使两者都将信息压缩到相同的尺寸,它的性能也比 RBM 更好。
# 还有更多...
# 更多
诸如 PCA 之类的自编码器可以用于降维,但是 PCA 仅可以表示线性变换,但是我们可以在自编码器中使用非线性激活函数,从而在编码中引入非线性。 这是从 Hinton 论文复制的结果,该结果使用*神经网络*降低了数据的维数。 该结果将 PCA(A)的结果与栈式 RBM 作为具有 784-1000-500-250-2 架构的自编码器的结果进行了比较:
......@@ -228,7 +228,7 @@ loss = Mean squared error + Regularization for sparsity parameter
![](img/9787a812-e35c-4503-9ade-e270c508c780.png)
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -396,7 +396,7 @@ for fig, row in zip([Xtest,out], axarr):
![](img/f3aebf0d-dfa5-434f-a485-2ca028be22e1.png)
# 这个怎么运作...
# 工作原理
您必须已经注意到,稀疏自编码器的主要代码与普通自编码器的主要代码完全相同,这是因为稀疏自编码器只有一个主要变化-增加了 KL 发散损耗以确保稀疏性。 隐藏的(瓶颈)层。 但是,如果比较这两个重构,则可以发现即使在隐藏层中具有相同数量的单位,稀疏自编码器也比标准编码器好得多:
......@@ -404,13 +404,13 @@ for fig, row in zip([Xtest,out], axarr):
训练 MNIST 数据集的原始自编码器后的重建损失为 0.022,而稀疏自编码器则为 0.006。 因此,添加约束会迫使网络学习数据的隐藏表示。
# 还有更多...
# 更多
输入的紧凑表示形式以权重存储; 让我们可视化网络学习到的权重。 这分别是标准自编码器和稀疏自编码器的编码器层的权重。 我们可以看到,在标准自编码器中,许多隐藏单元的权重非常大,表明它们工作过度:
![](img/e8efa159-8004-4b18-a8ed-6d9f7d095f4f.png)
# 也可以看看
# 另见
* <http://web.engr.illinois.edu/~hanj/cs412/bk3/KL-divergence.pdf>
* <https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence>
......@@ -432,7 +432,7 @@ def corruption(x, noise_factor = 0.3): #corruption of the input
return noisy_imgs
```
# 怎么做...
# 操作步骤
1. 像往常一样,第一步是导入必要的模块-TensorFlow,numpy 来操纵输入数据,matplotlib 来进行绘制,等等:
......@@ -610,7 +610,7 @@ for fig, row in zip([Xtest_noisy,out], axarr):
![](img/6fdcf058-4368-4143-afe9-0b5b7ea91212.png)
# 也可以看看
# 另见
* <https://cs.stanford.edu/people/karpathy/convnetjs/demo/autoencoder.html>
* <http://blackecho.github.io/blog/machine-learning/2016/02/29/denoising-autoencoder-tensorflow.html>
......@@ -625,7 +625,7 @@ CAE 是其中编码器和解码器均为 CNN 网络的一种 CAE。 编码器的
从第 4 章“卷积神经网络”中,您了解到,随着添加卷积层,传递到下一层的信息在空间范围上会减少,但是在自编码器中,重建的图像应该有输入图像的相同的大小和深度。 这意味着解码器应以某种方式对图像进行大小调整和卷积以重建原始图像。 与卷积一起增加空间范围的一种方法是借助**转置的卷积层**。 通过`tf.nn.conv2d_transpose`可以轻松地在 TensorFlow 中实现这些功能,但是发现转置的卷积层会在最终图像中产生伪像。 奥古斯都·奥德纳(Augustus Odena)等。 [1]在他们的工作中表明,可以通过使用最近邻或双线性插值(上采样)再加上卷积层来调整图层的大小来避免这些伪像。 他们通过`tf.image.resize_images`实现了最近邻插值,取得了最佳结果; 我们将在此处采用相同的方法。
# 怎么做...
# 操作步骤
1. 与往常一样,第一步包括必要的模块:
......@@ -778,15 +778,15 @@ for images, row in zip([noisy_imgs, reconstructed], axes):
sess.close()
```
# 这个怎么运作...
# 工作原理
前面的 CAE 是降噪 CAE,与仅由一个瓶颈层组成的简单降噪自编码器相比,我们可以看到它在降噪图像方面更好。
# 还有更多...
# 更多
研究人员已将 CAE 用于语义分割。 有趣的读物是 Badrinayanan 等人在 2015 年发表的论文 [Segnet:一种用于图像分割的深度卷积编码器-解码器体系结构](https://arxiv.org/pdf/1511.00561.pdf)。 该网络使用 VGG16 的卷积层作为其编码器网络,并包含一层解码器,每个解码器对应一个解码器层次作为其解码器网络。 解码器使用从相应的编码器接收的最大池索引,并对输入特征图执行非线性上采样。 本文的链接在本食谱的另请参见部分以及 GitHub 链接中给出。
# 也可以看看
# 另见
1. <https://distill.pub/2016/deconv-checkerboard/>
2. <https://pgaleone.eu/neural-networks/2016/11/24/convolutional-autoencoders/>
......@@ -801,7 +801,7 @@ sess.close()
在配方中,我们将使用贪婪分层方法来训练栈式自编码器; 为了简化任务,我们将使用共享权重,因此相应的编码器/解码器权重将相互转换。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -995,15 +995,15 @@ plt.ylabel('Fine Tuning Reconstruction Error')
![](img/85ffa24b-e9a5-4258-a24f-4f162d4e025a.png)
# 这个怎么运作...
# 工作原理
在栈式自编码器上进行的实验表明,应以较低的学习率值进行预训练。 这样可以确保在微调期间具有更好的收敛性和性能。
# 还有更多...
# 更多
整章都是关于自编码器的,尽管目前它们仅用于降维和信息检索,但它们引起了很多兴趣。 首先,因为它们不受监督,其次,因为它们可以与 FCN 一起使用。 它们可以帮助我们应对维度的诅咒。 研究人员已经证明,它们也可以用于分类和异常检测。
# 也可以看看
# 另见
* [关于栈式自编码器的一个不错的教程](http://ufldl.stanford.edu/wiki/index.php/Stacked_Autoencoders)
* `Schwenk, Holger. "The diabolo classifier." Neural Computation 10.8 (1998): 2175-2200.`
......
......@@ -45,11 +45,11 @@ AlphaGo 在基于 RL 算法的深度神经网络与最先进的树搜索算法
我们将使用 OpenAI Gym 为我们的代理商提供一个环境。 OpenAI Gym 是一个开源工具包,用于开发和比较 RL 算法。 它包含各种模拟环境,可用于训练代理和开发新的 RL 算法。
# 做好准备
# 准备
首先要做的是安装 OpenAI Gym; 使用`pip install gym`可以完成最少的安装。 OpenAI 运动场提供了多种环境,例如 Atari,棋盘游戏以及 2D 或 3D 物理引擎。 最小安装可在 Windows 上运行,并且仅支持基本环境-算法,`toy_text``classic_control`-但如果您要探索其他环境,则它们将需要更多的依赖项。 OSX 和 Ubuntu 支持完整版本。 可以在 OpenAI Gym 的 [GitHub 链接](https://github.com/openai/gym#installing-dependencies-for-specific-environments)上阅读详细说明。
# 怎么做...
# 操作步骤
让我们从食谱开始:
......@@ -111,7 +111,7 @@ for step in range(1000): # 1000 steps max
env.close()
```
# 这个怎么运作...
# 工作原理
前面的代码实现了一个随机代理; 代理会随机选择以下四个动作之一:
......@@ -119,7 +119,7 @@ env.close()
要观察的另一件重要事情是,在这种环境中,动作空间是离散的,而观察空间是盒子类型的。 OpenAI 中关于空间(动作/观察)的术语“离散”和“框”是指允许的值。 离散空间允许固定范围的非负数,在我们的情况下为(`0,1,2,3`)。 另一方面,盒子空间表示一个`n`维盒子,因此对于吃豆人来说,任何有效观察结果都是`210×160×3`数字的数组。
# 还有更多...
# 更多
OpenAI Gym 由许多不同的环境组成,其活跃的贡献社区在其中添加了许多环境。 要获取所有现有环境的列表,可以运行[以下简单代码](https://github.com/openai/gym)
......@@ -135,7 +135,7 @@ for env_id in sorted(env_ids):
![](img/7c36b894-9b73-4530-8439-85ae9b5cd5dc.jpg)
# 也可以看看
# 另见
* 可以从[这里](https://gym.openai.com/envs)获取有关不同环境的详细信息。
*[这个链接](https://github.com/openai/gym/wiki)中为某些环境维护了 Wiki 页面
......@@ -145,13 +145,13 @@ for env_id in sorted(env_ids):
让我们首先构建一个简单的神经网络代理来玩“吃豆人”游戏。 我们将创建具有一组随机权重和偏差的代理。 然后,这些特工将尝试玩游戏; 我们选择能够发挥最长平均持续时间的特工,并假设他们是最佳策略。
# 做好准备
# 准备
此配方中的代理没有学习任何策略; 他们根据初始权重(固定政策)做出决策。 代理根据神经网络给出的概率来选择动作。 每个代理做出的决定仅基于对环境的当前观察。
我们通过完全连接的神经网络来实现。 NN 的输入由环境的观察空间决定; 输出神经元的数量由可能的离散动作的数量决定。 吃豆人游戏有九种可能的离散动作-无操作,右转,左转,上转,向下转,左移,右移,上移和下移-因此我们的 NN 具有九个输出神经元。
# 怎么做...
# 操作步骤
让我们从食谱开始:
......@@ -296,7 +296,7 @@ if __name__ == '__main__':
Q 学习的最简单实现涉及维护和更新状态-作用值查找表; 表的大小将为`N×M`,其中`N`是所有可能状态的数量,`M`是所有可能动作的数量。 对于大多数环境,此表将很大。 表越大,搜索所需的时间就越多,并且存储表所需的内存也就越多,因此这不是可行的解决方案。 在本食谱中,我们将使用 Q 学习的 NN 实现。 在此,将神经网络用作函数逼近器来预测值函数(Q)。 NN 具有等于可能动作数的输出节点,并且它们的输出表示相应动作的值函数。
# 做好准备
# 准备
我们将训练一个线性神经网络来解决[`'CartPole-v0'`环境](https://github.com/openai/gym/wiki/CartPole-v0)。 目的是平衡手推车上的杆。 观测状态由四个连续值参数组成:推车位置`[-2.4, 2.4]`,推车速度`[-∞, ∞]`,极角`[~-41.8º, ~41.8º]`和极限速度`[-∞, ∞]`。 可以通过向左或向右推推车来实现平衡,因此动作空间由两个可能的动作组成。 您可以看到`CartPole-v0`环境空间:
......@@ -334,7 +334,7 @@ def transform(self, observations):
return self.featurizer.transform(scaled)
```
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -482,11 +482,11 @@ if __name__ == '__main__':
![](img/0f523609-75af-4e1c-bfc0-d25c0339de13.png)
# 还有更多...
# 更多
可以使用相同的逻辑为 OpenAI 的其他环境创建代理。 但是,对于诸如 Breakout 或 Pac-Man 之类的 Atari 游戏,观察空间并不只是由四个数字组成的数组。 相反,它非常大(210×160 = 33,600 像素,具有 3 个 RGB 值); 如果没有某种形式的量化,则这种简单的 NN 可能的状态是无限的,并且不会产生良好的结果。 我们将在深度 Q 学习食谱中使用 CNN 解决此问题。
# 也可以看看
# 另见
尽管有很多有关 Q 学习的 Web 链接,但一些有用的链接如下:
......@@ -501,7 +501,7 @@ if __name__ == '__main__':
此食谱基于 DeepMind 的原始 DQN 论文《使用深度强化学习玩 Atari》。 在本文中,他们使用了一种称为“经验重放”的概念,该概念涉及随机采样先前的游戏动作(状态,动作奖励,下一状态)。位于前脑底部的核称为“基底神经节”, 根据神经科学,它们负责选择动作,即帮助我们确定在任何给定时间执行几种可能动作中的哪一种。
# 做好准备
# 准备
如先前的食谱所述,“用 Q 学习平衡 CartPole”,对于像《吃豆人》或 Breakout 之类的 Atari 游戏,我们需要预处理观察状态空间,该状态空间由 33,600 个像素组成,具有 3 个 RGB 值。 这些像素中的每个像素都可以采用 0 到 255 之间的任何值。我们的`preprocess`函数应该能够量化像素的可能值,同时减少观察状态空间。
......@@ -531,7 +531,7 @@ def update_state(state, obs):
最后,为了解决训练时的稳定性问题,我们使用了`target_network`的概念,它是 DQN 的副本,但更新频率不高。 我们使用目标网络来生成 DQN 网络的目标值函数,而 DQN 在每个步骤/片段都进行更新,并且`target_network`在固定间隔后进行更新(与 DQN 相同)。 由于所有更新都在 TensorFlow 会话中进行,因此我们使用名称范围来区分`target_network`和 DQN 网络。
# 怎么做...
# 操作步骤
1. 我们导入必要的模块。 我们正在使用`sys`模块的`stdout.flush()`来帮助我们强制 Python *刷新*标准输出(在我们的情况下为计算机监视器)中的数据。 `random`模块用于从经验重放缓冲区(我们存储过去经验的缓冲区)中获取随机样本。 `datetime`模块用于跟踪训练时间:
......@@ -824,7 +824,7 @@ if __name__ == '__main__':
这只是在训练的前 500 集之后; 为了获得更好的效果,您将需要训练更长的时间,约 10,000 集。
# 还有更多...
# 更多
训练代理需要花费很多时间,这既浪费时间又消耗内存。 OpenAI Gym 提供了一个包装器来将游戏另存为视频,因此,除了使用渲染之外,您还可以使用包装器来保存视频并随后监视代理的学习方式。 AI 工程师和发烧友可以上传这些视频以显示结果。 为此,我们需要首先导入包装器,然后创建环境,最后使用监视器。 默认情况下,它将存储 1、8、27、64 等视频,然后每第 1000 集(带有完美立方体的情节编号)存储; 默认情况下,每项训练都保存在一个文件夹中。 为此要添加的代码如下:
......@@ -837,7 +837,7 @@ env = wrappers.Monitor(env, '/save-path')
如果您想在下一个训练中使用相同的文件夹,可以将`force=True`添加到监视器。
# 也可以看看
# 另见
* `Mnih, Volodymyr, and others, Playing Atari with deep reinforcement learning, arXiv preprint arXiv:1312.5602 (2013) (https://arxiv.org/pdf/1312.5602.pdf)`
* `Mnih, Volodymyr, et al. Human-level control through deep reinforcement learning, Nature 518.7540 (2015): 529-533`
......@@ -847,7 +847,7 @@ env = wrappers.Monitor(env, '/save-path')
到目前为止,策略梯度是最常用的 RL 算法之一。 研究表明,经过适当调优后,它们的性能要优于 DQN,同时不会遭受过多的内存和计算缺点。 与 Q 学习不同,策略梯度使用参数化策略,该策略可以选择操作而不咨询值函数。 在策略梯度中,我们讨论了性能度量`η(θ[p])`; 目标是最大程度地提高性能,因此根据梯度上升算法更新 NN 的权重。 但是,TensorFlow 没有`maximum`优化器,因此我们使用性能梯度的负值`-∇η(θ[p])`并将其最小化。
# 做好准备
# 准备
Pong 的游戏是一个两人游戏,目标是将球弹回另一位玩家。 代理可以上下移动操纵杆(是的,是标准`NoOp`)。 OpenAI 环境中的一名玩家是一位体面的 AI 玩家,他知道如何很好地玩游戏。 我们的目标是使用策略梯度来训练第二个代理。 我们的经纪人精通所玩的每款游戏。 虽然代码已构建为只能运行 500 集,但我们应该添加一条规定以将代理状态保存在指定的检查点,并且在下一次运行时,首先加载上一个检查点。 为此,我们首先声明一个保护程序,然后使用 TensorFlow `saver.save`方法保存当前的网络状态(检查点),最后从最后保存的检查点加载网络。 为完成本食谱的部分,在“操作步骤”一节中定义的以下`PolicyNetwork`类方法可以执行此工作:
......@@ -877,7 +877,7 @@ def save(self):
print("SAVED MODEL #{}".format(n))
```
# 怎么做...
# 操作步骤
1. 此食谱的代码基于 [Andrej Karpathy 博客](http://karpathy.github.io/2016/05/31/rl/),并且其中一部分已由 [Sam Greydanus](https://gist.github.com/karpathy/a4166c7fe253700972fcbc77e4ea32c5) 的代码进行了改编。
2. 我们有通常的进口:
......@@ -1058,11 +1058,11 @@ if __name__ == '__main__':
![](img/adcea32f-f3b0-4fcf-a9b9-b2e824ba6eff.png)
# 这个怎么运作...
# 工作原理
权重使用 Xavier 初始化进行了初始化,这确保了我们的权重既不会太大也不会太小。 两种情况都阻碍了网络的学习。 在 Xavier 初始化中,为权重分配一个具有零均值和特定方差`2/(nin+nout)`的值,其中`nin``nout`该层的输入和输出数。 要了解有关 Xavier 初始化的更多信息,请参阅 Glorot 和 Bengio 在 2009 年发表的论文。 有关详细信息,请参见“另见”部分。
# 还有更多...
# 更多
看到代理商第一次学习演奏的任何人都会对此感到惊讶-看起来很像人。 最初的举动总是很笨拙。 缓慢地,坐席会学习走哪条路,尽管速度很慢并且经常会错过球。 但是,随着学习的继续,代理将成为专家。
......@@ -1078,7 +1078,7 @@ AlphaGo Zero 使用深层神经网络,该网络将原始板表示形式(当
在配备 4 个 TPU 的单台机器上仅进行了 3 天的训练,AlphaGo Zero 以 100-0 击败 AlphaGo。 AlphaGo Zero 完全基于 RL。 可以在 2017 年 10 月发表于《自然》上的论文《掌握无人掌握的围棋游戏》中阅读其实现的详细信息。
# 也可以看看
# 另见
* <https://arxiv.org/pdf/1602.01783.pdf>
* <http://ufal.mff.cuni.cz/~straka/courses/npfl114/2016/sutton-bookdraft2016sep.pdf>
......
......@@ -29,11 +29,11 @@
在本食谱中,我们将学习如何为移动环境设置 TensorFlow。 我的环境是 macOS,我为 Android 开发。 但是,在以下食谱中将描述其他配置。
# 做好准备
# 准备
我们将使用 Android Studio,这是适用于 Google Android 操作系统的官方**集成开发环境****IDE**)。
# 怎么做...
# 操作步骤
我们继续按以下步骤安装适用于 macOS 和 Android 的 TensorFlow mobile:
......@@ -94,11 +94,11 @@ testCompile 'junit:junit:4.12'
在 AndroidStudio 中创建 TensorFlow 移动应用程序的示例。 一个简单的`Hello World`应用程序
# 这个怎么运作...
# 工作原理
使用 Android Studio 设置 Android TensorFlow 非常简单。 您只需要在应用程序的`build.gradle`文件中添加一些配置行,Android Studio 就会代表您执行所有操作。
# 还有更多...
# 更多
如果要直接从 TensorFlow 源构建,则需要安装 Bazel 和 TensorFlow。 Bazel 是一个快速,可扩展,多语言和可扩展的构建系统。 Google 内部使用了构建工具 Blaze,并将 Blaze 工具的开源部分称为 Bazel。 名称是 Blaze 的字谜。
......@@ -126,7 +126,7 @@ git clone https://github.com/TensorFlow/TensorFlow.git
在本食谱中,我们将考虑 TensorFlow 发行版中提供的标准 Android 示例并将其安装在我们的移动设备上。
# 做好准备
# 准备
TensorFlow 移动 Android 应用程序[可在 GitHub 上的以下地址获得](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/examples/android)。 2017 年 10 月,该页面包含以下示例:
......@@ -135,7 +135,7 @@ TensorFlow 移动 Android 应用程序[可在 GitHub 上的以下地址获得](h
* **TF 风格化**:使用基于*艺术风格的学习表示*的模型将相机预览图像重新设置为许多不同艺术风格的图像。
* **TF 语音**:运行在音频训练教程中构建的简单语音识别模型。 侦听一小部分单词,并在识别它们时在 UI 中突出显示它们。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -164,7 +164,7 @@ adb install -r TensorFlow_demo.apk
![](img/14cf32c8-a750-4010-9122-933384624efa.png)
# 这个怎么运作...
# 工作原理
如果您使用夜间构建演示和`adb`工具在设备上安装 APK,则安装 Android 的 TensorFlow 示例非常容易。
......@@ -172,11 +172,11 @@ adb install -r TensorFlow_demo.apk
在本食谱中,我们将学习如何在移动环境中设置 TensorFlow。 我的环境是 macOS,这里的想法是为 iOS 和 iPhone 开发。
# 做好准备
# 准备
我们将使用 Xcode 开发环境和 CocoaPods 来预安装 TensorFlow。 我将假定您的环境中已经安装了 Xcode。 如果没有,请从[这里](https://developer.apple.com/xcode/)下载。
# 怎么做...
# 操作步骤
我们将按照以下步骤进行操作:
......@@ -251,11 +251,11 @@ open tf_benchmark_example.xcworkspace
用于 Tensorflow 计算的 Iphone 应用示例
# 这个怎么运作...
# 工作原理
Xcode 和 CocoaPods 用于编译 TensorFlow 应用程序,该应用程序用于对不同 Inception 类别中的图像进行分类。 结果使用 iPhone 模拟器可视化。
# 还有更多...
# 更多
您可以直接在应用程序中使用 TensorFlow。 [可在此处获得更多信息](https://github.com/TensorFlow/TensorFlow/blob/master/TensorFlow/examples/ios/README.md)
......@@ -263,11 +263,11 @@ Xcode 和 CocoaPods 用于编译 TensorFlow 应用程序,该应用程序用于
在本食谱中,我们将考虑不同的选项来优化在移动设备上运行的 TensorFlow 代码。 从减小模型的大小到量化,分析了不同的选项。
# 做好准备
# 准备
我们将使用 Bazel 构建 TensorFlow 的不同组件。 因此,第一步是确保同时安装了 Bazel 和 TensorFlow。
# 怎么做...
# 操作步骤
我们按以下步骤进行优化:
......@@ -351,7 +351,7 @@ ls -lah /tmp/TensorFlow_inception_quantized.pb
-rw-r--r-- 1 gulli wheel 13M Oct 15 18:56 /tmp/TensorFlow_inception_quantized.pb
```
# 这个怎么运作...
# 工作原理
量化通过将常量操作从 32 位缩减为 8 位来帮助减小模型的大小。 通常,该模型不会遭受性能的显着降低。 但是,这必须根据具体情况进行验证。
......@@ -359,11 +359,11 @@ ls -lah /tmp/TensorFlow_inception_quantized.pb
在本食谱中,我们将考虑不同的选项来优化 TensorFlow 代码以在移动设备上运行。 从减小模型的大小到量化,分析了不同的选项。
# 做好准备
# 准备
我们将使用 Bazel 构建 TensorFlow 的不同组件。 因此,第一步是确保同时安装了 Bazel 和 TensorFlow。
# 怎么做...
# 操作步骤
我们进行如下分析:
......@@ -439,7 +439,7 @@ generic_x86:/ $
/data/local/tmp/benchmark_model --graph=/data/local/tmp/TensorFlow_inception_graph.pb --show_run_order=false --show_time=false --show_memory=false --show_summary=true
```
# 这个怎么运作...
# 工作原理
正如预期的那样,该模型在 Conv2D 操作上花费了大量时间。 总体而言,这大约占我台式机平均时间的 77.5%。 如果在移动设备上运行此程序,那么花时间执行神经网络中的每一层并确保它们处于受控状态至关重要。 要考虑的另一个方面是内存占用。 在这种情况下,桌面执行约为 10 Mb。
......@@ -449,11 +449,11 @@ generic_x86:/ $
**What is a graph transform tool?** According to https://github.com/tensorflow/tensorflow/blob/master/tensorflow/tools/graph_transforms/README.md "When you have finished training a model and want to deploy it in production, you'll often want to modify it to better run in its final environment. For example if you're targeting a phone you might want to shrink the file size by quantizing the weights, or optimize away batch normalization or other training-only features. The Graph Transform framework offers a suite of tools for modifying computational graphs, and a framework to make it easy to write your own modifications".
# 做好准备
# 准备
我们将使用 Bazel 构建 TensorFlow 的不同组件。 因此,第一步是确保同时安装了 Bazel 和 TensorFlow。
# 怎么做...
# 操作步骤
这是我们如何转换 TensorFlow 的方法:
......@@ -512,6 +512,6 @@ INFO: Running command line: bazel-bin/TensorFlow/tools/graph_transforms/transfor
2017-10-15 22:26:59.388721: I TensorFlow/tools/graph_transforms/transform_graph.cc:264] Applying fold_old_batch_norms
```
# 这个怎么运作...
# 工作原理
为了创建可以在设备上加载的更轻的模型,我们使用了图形变换工具应用的`strip_unused_nodes`规则删除了所有不需要的节点。 该操作将删除用于学习的所有操作,并保留用于推理的操作。
\ No newline at end of file
......@@ -74,11 +74,11 @@ GAN 最酷的用途之一是对生成器矢量`Z`的面部进行算术。换句
Ian J.Goodfellow,Jean Pouget-Abadie,Mehdi Mirza,Bing Xu,David Warde-Farley,Sherjil Ozair,Aaron Courville,Yoshua Bengio 等人撰写的 Generative Adversarial Networks(2014)是更好地理解 GAN 的好论文。 在本食谱中,我们将学习如何使用以 Generator-Discriminator 体系结构组织的全连接层网络来伪造 MNIST 手写数字。
# 做好准备
# 准备
此食谱基于[这个页面](https://github.com/TengdaHan/GAN-TensorFlow)上可用的代码。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -267,7 +267,7 @@ feed_dict={X: batch_X, z: batch_noise})
train(logdir=args.logdir, batch_size=args.batch_size)
```
# 这个怎么运作...
# 工作原理
在每个时期,生成器都会进行许多预测(它会生成伪造的 MNIST 图像),鉴别器会在将预测与实际 MNIST 图像混合后尝试学习如何生成伪造的图像。 在 32 个周期之后,生成器学习伪造这组手写数字。 没有人对机器进行编程来编写,但是它学会了如何编写与人类所写的数字没有区别的数字。 请注意,训练 GAN 可能非常困难,因为有必要在两个参与者之间找到平衡。 如果您对该主题感兴趣,我建议您看看[从业者收集的一系列技巧](https://github.com/soumith/ganhacks)
......@@ -288,11 +288,11 @@ Example of forged MNIST-like characters with a GAN
在本食谱中,我们将使用一个简单的 GAN,它使用 CNN 来学习如何伪造 MNIST 图像并创建不属于原始数据集的新图像。 这个想法是 CNN 与 GAN 一起使用将提高处理图像数据集的能力。 请注意,先前的方法是将 GAN 与完全连接的网络一起使用,而在此我们重点介绍 CNN。
# 做好准备
# 准备
此食谱基于[这个页面](https://github.com/TengdaHan/GAN-TensorFlow)上可用的代码。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -519,7 +519,7 @@ feed_dict={z: batch_noise})
train(logdir=args.logdir, batch_size=args.batch_size)
```
# 这个怎么运作...
# 工作原理
将 CNN 与 GAN 一起使用可提高学习能力。 让我们看一下不同时期的许多实际示例,以了解机器将如何学习以改善其编写过程。 例如,将以下配方中的四次迭代后获得的结果与先前配方中的四次迭代后获得的结果进行比较。 你看得到差别吗? 我希望自己可以学习这种艺术!
......@@ -546,11 +546,11 @@ Example of forged MNIST-like with DCGAN
请注意,在包装中,相对于原始纸张进行了更改,以避免`D`(鉴别器)网络快速收敛,`G`(发电机)网络每次`D`网络更新都会更新两次。
# 做好准备
# 准备
此食谱基于[这个页面](https://github.com/carpedm20/DCGAN-tensorflow)上提供的代码。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -589,7 +589,7 @@ $ mkdir data/DATASET_NAME
$ python main.py --dataset=eyes --input_fname_pattern="*_cropped.png" --train
```
# 这个怎么运作...
# 工作原理
生成器学习如何生成名人的伪造图像,鉴别器学习如何将伪造的图像与真实的图像区分开。 两个网络中的每个周期都在竞争以改善和减少损失。 下表报告了前五个时期:
......@@ -604,7 +604,7 @@ $ mkdir data/DATASET_NAME
Example of forged celebrities with a DCGAN
# 还有更多...
# 更多
内容感知填充是摄影师使用的一种工具,用于填充不需要的或丢失的图像部分。论文[《具有感知和上下文损失的语义图像修复》](https://arxiv.org/abs/1607.07539)使用 DCGAN 进行图像补全,并学习如何填充部分图像。
......@@ -626,7 +626,7 @@ Example of forged celebrities with a DCGAN
对 VAE 进行训练后,我们只能使用解码器网络来生成新图像。
# 怎么做...
# 操作步骤
此处的代码基于 Kingma 和 Welling 的论文[自动编码变分贝叶斯](https://arxiv.org/pdf/1312.6114.pdf),并改编自 [GitHub](https://jmetzen.github.io/2015-11-27/vae.html)
......@@ -878,7 +878,7 @@ plt.tight_layout()
由自动编码器生成的一系列 MNIST 字符
# 这个怎么运作...
# 工作原理
VAE 学会重建并同时生成新图像。 生成的图像取决于潜在空间。 生成的图像与训练的数据集具有相同的分布。
......@@ -895,13 +895,13 @@ def transform(self, X):
![](img/2bb795f1-19cc-4f46-8c1f-d896d3b0e01c.png)
# 还有更多...
# 更多
VAE 的生成图像取决于潜在空间尺寸。 模糊减少了潜在空间的尺寸,增加了。 分别针对 5 维,10 维和 20 维潜在维度的重构图像如下:
![](img/7619532a-5c71-4c3f-9a89-4093fede393a.png)
# 也可以看看...
# 另见...
[Kingma 和 Welling 的论文](https://arxiv.org/pdf/1312.6114.pdf)是该领域的开创性论文。 他们会经历完整的建筑思维过程以及优雅的数学运算。 对于对 VAE 感兴趣的任何人,必须阅读。
......@@ -943,11 +943,11 @@ VAE 的生成图像取决于潜在空间尺寸。 模糊减少了潜在空间的
该体系结构很浅,只有两个卷积层和一个完全连接的层。 Conv1 具有 256 个`9×9`卷积核,步幅为 1,并具有 ReLU 激活函数。 该层的作用是将像素强度转换为局部特征检测器的活动,然后将其用作主胶囊的输入。 PrimaryCapsules 是具有 32 个通道的卷积胶囊层。 每个主胶囊包含 8 个卷积单元,其内核为`9×9`,步幅为 2。 总计,PrimaryCapsules 具有`[32, 6, 6]`胶囊输出(每个输出是 8D 矢量),并且`[6, 6]`网格中的每个胶囊彼此共享重量。 最后一层(DigitCaps)每位数字类具有一个 16D 胶囊,这些胶囊中的每个胶囊都接收来自下一层中所有其他胶囊的输入。 路由仅发生在两个连续的胶囊层之间(例如 PrimaryCapsules 和 DigitCaps)。
# 做好准备
# 准备
此食谱基于[这个页面](https://github.com/debarko/CapsNet-Tensorflow)上提供的代码,而该代码又基于[这个页面](https://github.com/naturomics/CapsNet-Tensorflow.git)
# 怎么做...
# 操作步骤
这是我们如何进行配方的方法:
......@@ -1297,7 +1297,7 @@ def _summary(self):
self.test_summary = tf.summary.merge(test_summary)
```
# 这个怎么运作...
# 工作原理
CapsNet 与最先进的深度学习网络有很大的不同。 CapsNet 并没有添加更多的层并使网络更深,而是使用了浅层网络,其中,胶囊层嵌套在其他层内。 每个胶囊专门用于检测图像中的特定实体,并且使用动态路由机制将检测到的实体发送给父层。 使用 CNN,您必须从许多不同角度考虑成千上万张图像,以便从不同角度识别物体。 Hinton 认为,这些层中的冗余将使胶囊网络能够从多个角度和在不同情况下以 CNN 通常使用的较少数据识别对象。 让我们检查一下 tensorboad 所示的网络:
......@@ -1332,7 +1332,7 @@ CapsNet 与最先进的深度学习网络有很大的不同。 CapsNet 并没有
CapsNet 提高准确性的示例
# 还有更多...
# 更多
CapsNets 在 MNIST 上可以很好地工作,但是在理解是否可以在其他数据集(例如 CIFAR)或更通用的图像集合上获得相同的令人印象深刻的结果方面,还有很多研究工作要做。 如果您有兴趣了解更多信息,请查看以下内容:
......
......@@ -60,11 +60,11 @@
在本食谱中,我们将学习如何在 GPU 上使用 TensorFlow:执行的操作是在 CPU 或 GPU 上的简单矩阵乘法。
# 做好准备
# 准备
第一步是安装支持 GPU 的 TensorFlow 版本。 [正式的 TensorFlow 安装说明是您的起点](https://www.tensorflow.org/)。 请记住,您需要一个通过 CUDA 或 CuDNN 支持 GPU 的环境。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -109,7 +109,7 @@ print("Shape:", shape, "Device:", device_name)
print("Time taken:", datetime.now() - startTime)
```
# 这个怎么运作...
# 工作原理
本食谱说明了如何将 TensorFlow 计算分配给 CPU 或 GPU。 该代码非常简单,它将用作下一个食谱的基础。
......@@ -117,11 +117,11 @@ print("Time taken:", datetime.now() - startTime)
我们将展示一个数据并行化的示例,其中数据被拆分到多个 GPU 中
# 做好准备
# 准备
此食谱的灵感来自尼尔·特内霍尔茨(Neil Tenenholtz)撰写的一篇不错的博客文章,[该文章可在线获取](https://clindatsci.com/blog/2017/5/31/distributed-tensorflow)
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -181,7 +181,7 @@ with tf.Session() as sess:
print sess.run(output)
```
# 这个怎么运作...
# 工作原理
这是一个非常简单的方法,其中通过将 CPU 用作主对象并将其分配到两个用作分布式工作程序的 GPU,将图形分为两部分。 计算结果被收集回 CPU。
......@@ -189,11 +189,11 @@ with tf.Session() as sess:
在本食谱中,我们将学习如何在多个服务器之间分配 TensorFlow 计算。 关键假设是工作程序和参数服务器的代码都相同。 因此,每个计算节点的角色都传递给命令行参数。
# 做好准备
# 准备
同样,此食谱的灵感来自尼尔·特纳霍尔茨(Neil Tenenholtz)撰写的一篇不错的博客文章,[该文章可在线获取](https://clindatsci.com/blog/2017/5/31/distributed-tensorflow)
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -246,13 +246,13 @@ with tf.Session(server.target):
# train your model here
```
# 这个怎么运作...
# 工作原理
在本食谱中,我们已经看到了如何创建具有多个计算节点的集群。 节点既可以扮演参数服务器的角色,也可以扮演工作者的角色。
在这两种情况下,根据从命令行收集的参数,执行的代码相同,但是代码的执行不同。 参数服务器仅需要等待,直到工作人员发送更新。 请注意,`tf.train.replica_device_setter(..)`的作用是将操作自动分配给可用设备,而`tf.train.ClusterSpec(..)`则用于集群设置。
# 还有更多...
# 更多
可以在[这个页面](https://github.com/ischlag/distributed-tensorflow-example/blob/master/example.py)在线获取针对 MNIST 的分布式训练的示例。
......@@ -262,11 +262,11 @@ with tf.Session(server.target):
此配方用于以分布式方式训练完​​整的 MNIST 分类器。 该食谱的灵感来自[这个页面](http://ischlag.github.io/2016/06/12/async-distributed-tensorflow/)中的博客文章,[此处提供了在 TensorFlow 1.2 上运行的代码](https://github.com/ischlag/distributed-tensorflow-example)
# 做好准备
# 准备
此食谱基于上一个食谱。 因此,按顺序阅读它们可能会很方便。
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -409,7 +409,7 @@ with sv.prepare_or_wait_for_session(server.target) as sess:
print("done")
```
# 这个怎么运作...
# 工作原理
本食谱描述了分布式 MNIST 分类器的示例。 在此示例中,TensorFlow 允许我们定义三台机器的集群。 一台充当参数服务器,另外两台机器用作工作人员,负责处理不同批次的训练数据。
......@@ -417,11 +417,11 @@ with sv.prepare_or_wait_for_session(server.target) as sess:
在本食谱中,我们将展示如何为 TensorFlow Serving 运行 Docker 容器,这是一组组件以导出经过训练的 TensorFlow 模型并使用标准`tensorflow_model_server`为其提供服务。 TensorFlow Serving 服务器发现新导出的模型并运行 gRPC 服务来为其服务。
# 做好准备
# 准备
我们将使用 Docker,并假设您熟悉该系统。 如果没有,[请确保查看并安装](https://www.docker.com/)。 我们要做的是构建 TF 服务版本。
# 怎么做...
# 操作步骤
这是我们进行食谱的方法:
......@@ -477,11 +477,11 @@ builder.save()
tensorflow_model_server --port=9000 --model_name=mnist --model_base_path=/tmp/mnist_model/
```
# 这个怎么运作...
# 工作原理
Google 在 2016 年 2 月发布了 [TensorFlow Serving](https://www.tensorflow.org/serving/),这是一种针对机器学习模型的高性能服务系统,专为生产环境而设计。 截至 2017 年 8 月,谷歌内部有 800 多个使用 TensorFlow Serving 的项目投入生产。
# 还有更多...
# 更多
TensoFlow Serving 是一款非常通用的软件,在本食谱中,我们只是初步探究了潜在用途。 如果您有兴趣进一步了解高级功能。 例如大批量运行或动态加载模型,则应查看[这个页面](https://github.com/tensorflow/serving/blob/master/tensorflow_serving/g3doc/serving_advanced.md)
......@@ -489,11 +489,11 @@ TensoFlow Serving 是一款非常通用的软件,在本食谱中,我们只
在本食谱中,我们将学习如何在 Google Cloud(GCP)上使用 Google Tensorflow。 我们将要审查的示例是经典 MNIST。
# 做好准备
# 准备
看看 GCP 在 [GoogleCloud](https://cloud.google.com/) 中的工作方式会很好。 请注意,GCP 提供 300 美元的免费赠金,以开始使用任何 GCP 产品。 此外,在免费试用期间和之后,某些产品针对符合条件的客户可以免费使用。 (优惠如有更改,请参见[这个页面](https://cloud.google.com/free/)
# 怎么做...
# 操作步骤
这是我们进行食谱的方法:
......@@ -571,11 +571,11 @@ gcloud compute instances create \
./scripts/start-training.sh gs://${BUCKET}
```
# 这个怎么运作...
# 工作原理
演示脚本将代码移动到每个 VM 并开始分布式计算。 这两个工作程序在公共存储桶上共享的相同 MNIST 数据上并行运行。 计算结束后,脚本将打印训练后的模型的位置。
# 还有更多...
# 更多
如果我们不想管理 TensorFlow,那么我们可以决定使用 Google 代表您运行的托管版本。 这是在下一个食谱中描述的 CloudML 服务。 此外,如果您决定不将 GPU 与 CloudML 一起使用,[那么此 URL 是一个不错的起点](https://cloud.google.com/ml-engine/docs/using-gpus)
......@@ -583,11 +583,11 @@ gcloud compute instances create \
CloudML 是 Google 运行的 Tensorflow 的托管版本。 无需自己运行 TF,您只需使用 CloudML 即可,而无需考虑与基础架构和可伸缩性相关的所有问题。
# 做好准备
# 准备
在这里,我们假设您已经创建了一个 Cloud Platform Project,为您的项目启用计费,并启用了 Google Compute Engine 和 Cloud Machine Learning API。 这些步骤类似于先前食谱中描述的步骤。 此食谱的灵感来自[这个页面](https://cloud.google.com/ml-engine/docs/distributed-tensorflow-mnist-cloud-datalab)中提供的 MNIST 训练代码。
# 怎么做...
# 操作步骤
我们继续在 Google CloudML 上运行分布式 TensorFlow:
......@@ -648,11 +648,11 @@ gcloud ml-engine versions set-default --model ${MODEL_NAME} ${VERSION_NAME}
gcloud ml-engine predict --model ${MODEL_NAME} --json-instances request.json
```
# 这个怎么运作...
# 工作原理
CloudML 是使用 Google 运行的托管版本的 TensorFlow 的便捷解决方案。 除了直接照顾基础设施和运营,还可以直接专注于开发机器学习模型。
# 还有更多...
# 更多
CloudML 的一项非常酷的功能是能够通过并行运行多个试验来自动调整模型中包含的超参数的能力。 这为您提供了超参数的优化值,从而最大化了模型的预测精度。 如果您有兴趣了解更多信息,那么看看[这里](https://cloud.google.com/ml-engine/docs/hyperparameter-tuning-overview)
......@@ -660,11 +660,11 @@ CloudML 的一项非常酷的功能是能够通过并行运行多个试验来自
Microsoft Azure 提供了一项名为 Batch AI 的服务,该服务使我们能够在 Azure 虚拟机的群集上运行机器学习模型。
# 做好准备
# 准备
第一步,我们需要一个 Azure 帐户:如果您还没有 Azure 帐户,则可以[在此处免费创建一个帐户](https://azure.microsoft.com/en-us/services/batch-ai/) 。 Azure 向新用户提供为期 30 天的 200 美元信用额度。 此食谱将遵循 Microsoft Azure 提供的示例,以使用 TensorFlow 分布式在两个 GPU 上运行 MNIST,相关代码可[在 Github 上获得](https://github.com/Azure/batch-shipyard/tree/master/recipes/TensorFlow-Distributed)
# 怎么做...
# 操作步骤
我们按以下步骤进行:
......@@ -762,7 +762,7 @@ az batchai cluster create -n nc6 -i UbuntuDSVM -s Standard_NC6 --min 2 --max 2 -
az batchai job create -n distibuted_tensorflow --cluster-name nc6 -c job.json
```
# 这个怎么运作...
# 工作原理
Batch AI 自行管理资源,您只需要指定作业,输入的位置以及存储输出的位置即可。 如果在执行作业期间想要查看结果,则可以使用以下命令:
......@@ -772,7 +772,7 @@ az batchai job stream-file --job-name myjob --output-directory-id stdouterr --na
作业结束后,您可以使用`az batchai job delete``az batchai cluster delete`命令删除作业和群集。
# 还有更多...
# 更多
上面我们学习了如何使用 Azure 命令行工具将 Microsoft Azure Batch AI 用于分布式 TensorFlow。 我们也可以使用 Jupyter 笔记本做同样的事情。 这将涉及设置 Azure Active Directory 并进行新的 App 注册。 [可以在以下链接上获得详细信息](https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-group-create-service-principal-portal)
......@@ -792,7 +792,7 @@ GPU 仅在 P2 实例创建中可用,并且默认情况下不可用,要获得
您可以选择提供 p2.xlarge 实例的任何区域。 新的限制值决定了您可以使用的实例的最大数量,请谨慎选择数量,因为该服务不是免费的,并且每小时的费用约为 1 美元。 AWS 大约需要 24 小时才能响应请求。
# 做好准备
# 准备
现在您已经可以使用 AWS 账户和 p2.xlarge 实例,现在就可以从 EC2 仪表板创建自己的实例了。 第一步是选择机器映像,到目前为止,Amazon 提供了预装有深度学习库的特殊机器映像,您可以选择 Ubuntu 或 Linux 版本。 接下来,选择 GPU 以计算实例类型。
......@@ -802,7 +802,7 @@ GPU 仅在 P2 实例创建中可用,并且默认情况下不可用,要获得
最后,在启动实例时,将要求您创建一个密钥对,以允许您登录到特定实例,您将需要创建一个密钥对并下载相应的`.pem`文件,您将使用文件以便后续记录。
# 怎么做...
# 操作步骤
1. 第一步是连接到实例,您可以使用命令行通过 SSH 或浏览器来实现。 我们使用 CLI。
......@@ -826,11 +826,11 @@ ssh -i " <security-keypair-filename>.pem" ubuntu@ec2-XXXXXXXXXXXXX.compute-1.ama
![](img/ebb26449-ae6a-4899-a75c-995e10a1ef3a.png)
# 这个怎么运作...
# 工作原理
您可以运行在我们创建的实例上学到的代码。 工作结束后,不要忘记退出,并从仪表板停止实例。 有关价格和使用情况的更多详细信息,请参见[这里](https://aws.amazon.com/documentation/ec2/)
# 还有更多...
# 更多
AWS 市场上提供了带有预配置库和 API 的大量 Docker 映像和机器映像。 要启动 jupyter 笔记本,请在命令行中使用`<jupyter notebook --ip=0.0.0.0 --no-browser>`。 这将导致输出,如下所示:
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册