2020-08-13 22:50:27

docs/tf-1x-dl-cookbook/00.md

@@ -10,7 +10,7 @@
 
 “回归”讨论了回归及其应用。 我们将讨论回归所涉及的概念，了解回归与聚类和分类的不同之处。 我们将学习可能的不同类型的损失函数以及如何在 Tensorflow 中实现它们。 我们学习如何实现 L1 和 L2 正则化。 我们将讨论梯度下降算法，学习如何优化它并在 Tensorflow 中实现它。 我们将简要了解交叉熵函数及其实现。
 
-“神经网络感知器”，涵盖了人工神经网络，并解释了为什么它可以完成 DNN 最近声称的出色任务。 我们将学习激活功能的不同选择。 我们将使用所有这些来构建一个简单的感知器，并将其用于功能建模。 我们将在培训之前了解数据的正则化。 我们还将学习逐步构建多层感知器（MLP）。 我们将看到 TensorFlow 的自动区分器如何使我们的工作更轻松。
+“神经网络感知器”，涵盖了人工神经网络，并解释了为什么它可以完成 DNN 最近声称的出色任务。 我们将学习激活功能的不同选择。 我们将使用所有这些来构建一个简单的感知器，并将其用于功能建模。 我们将在训练之前了解数据的正则化。 我们还将学习逐步构建多层感知器（MLP）。 我们将看到 TensorFlow 的自动区分器如何使我们的工作更轻松。
 
 “TensorFlow 卷积神经网络”，讨论了卷积的过程及其如何提取特征。 我们将学习 CNN 的三个重要层：卷积层，池化层和完全连接层。 我们还将学习辍学，如何提高性能以及不同的 CNN 架构（例如 LeNET 和 GoogleNET）。
 
@@ -18,7 +18,7 @@
 
 “循环神经网络”讨论了循环神经网络。 我们将学习 RNN 的基本单元 RNN 单元。 我们将学习单词嵌入和时间排序。 我们将简要讨论 LSTM 网络。 我们将学习 seq2seq RNN。 我们将学习如何将 RNN 应用于机器翻译，生成文本和预测未来价值
 
-“无监督学习”，讲授无监督学习范例。 我们将学习聚类和降维。 我们将学习诸如主成分分析（PCA）之类的技术，并了解如何将其用于降维。 我们将学习 k 均值聚类。 我们将了解地形图的概念，并学习如何训练自组织图。 我们将学习受限玻尔兹曼机（RBM）。 我们将讨论 RBM 的体系结构和培训。 我们将学习如何堆叠 RBM 来构成深度信念网络，并且将学习如何对其进行训练。 我们将使用预训练和微调进行情绪检测的概念来训练 DBN。
+“无监督学习”，讲授无监督学习范例。 我们将学习聚类和降维。 我们将学习诸如主成分分析（PCA）之类的技术，并了解如何将其用于降维。 我们将学习 k 均值聚类。 我们将了解地形图的概念，并学习如何训练自组织图。 我们将学习受限玻尔兹曼机（RBM）。 我们将讨论 RBM 的体系结构和训练。 我们将学习如何堆叠 RBM 来构成深度信念网络，并且将学习如何对其进行训练。 我们将使用预训练和微调进行情绪检测的概念来训练 DBN。
 
 “自编码器”，使自编码器神秘化。 我们将学习自编码器及其应用。 我们将讨论可以使用自编码器的各种实际示例。 我们将讨论编码和后续重构的过程。 我们将学习重建误差。 我们将学习稀疏自编码器，即 KL 散度的概念。 我们将学习去噪自编码器，并在给定嘈杂图像的情况下使用它们来重建清晰图像。 我们将学习如何构建卷积自编码器和堆叠式自编码器。
 

docs/tf-1x-dl-cookbook/02.md

@@ -17,21 +17,21 @@
 
 有多种可用的回归方法：
 
-*   **线性回归**：这是最广泛使用的建模技术之一。 它已有 200 多年的历史，几乎从所有可能的角度进行了探索。 线性回归假设输入变量（ *X* ）和单个输出变量（ *Y* ）**之间存在线性关系。** 它涉及寻找以下形式的预测值 *Y* 的线性方程：
+*   **线性回归**：这是最广泛使用的建模技术之一。 它已有 200 多年的历史，几乎从所有可能的角度进行了探索。 线性回归假设输入变量（`X`）和单个输出变量（`Y`）之间存在**线性关系**。 它涉及寻找以下形式的预测值`Y`的线性方程：
 
-**![](img/5f56fc4e-0ef5-4339-8a40-6728f006267c.png)**
+![](img/5f56fc4e-0ef5-4339-8a40-6728f006267c.png)
 
-在这里， *X* =（ *x <sub>1</sub> ，x <sub>2</sub> ，...，x <sub>n</sub>* ）是 *n* 输入变量和 *W =（w <sub>1</sub> ，w <sub>2</sub> ，... w <sub>n</sub>* ）是 线性系数，以 *b* 为偏差项。 目标是找到系数 *W* 的最佳估计，以使预测 *Y* 的误差最小。 线性系数 *W* s 使用最小二乘法估算，即最小化预测值（ *Y <sub>hat</sub>* ）之间的平方差之和。 值（ *Y* ）。 因此，我们尝试最小化*损失*函数：
+在这里，`X = (x[1], x[2], ..., x[n])`是`n`个输入变量和`W = (w[1], w[2], ... w[n])`是线性系数，以`b`为偏差项。 目标是找到系数`W`的最佳估计，以使预测`Y`的误差最小。 线性系数`W`使用最小二乘法估算，即最小化预测值（`Y_hat`）和值（`Y`）之间的平方差之和。因此，我们尝试最小化*损失*函数：
 
 ![](img/989fcbf6-aa62-4d79-9313-d27833b11e02.png)
 
-在这里，总和是所有训练样本的总和。 根据输入变量 *X* 的数量和类型，可以使用不同类型的线性回归：简单线性回归（一个输入变量，一个输出变量），多个线性回归（许多独立输入变量，一个输出变量） ）或多元线性回归（许多独立的输入变量和多个输出变量）。 有关线性回归的更多信息，请参考 [https://en.wikipedia.org/wiki/Linear_regression](https://en.wikipedia.org/wiki/Linear_regression) 。
+在这里，总和是所有训练样本的总和。 根据输入变量`X`的数量和类型，可以使用不同类型的线性回归：简单线性回归（一个输入变量，一个输出变量），多个线性回归（许多独立输入变量，一个输出变量） ）或多元线性回归（许多独立的输入变量和多个输出变量）。 有关线性回归的更多信息，请参考 [https://en.wikipedia.org/wiki/Linear_regression](https://en.wikipedia.org/wiki/Linear_regression) 。
 
 *   **Logistic 回归**：用于确定事件的概率。 按照惯例，事件表示为分类因变量。 使用`logit`函数（`sigmoid`函数）表示事件的可能性：
 
 ![](img/1941eb7b-63c3-4357-80d9-970e8938003d.png)
 
-现在的目标是估计权重 *W =（w1，w2，... wn* ）和偏差项 *b* 。 在逻辑回归中，使用最大似然估计器或随机梯度下降法估计系数。 通常将损耗定义为互熵项，如下所示：
+现在的目标是估计权重`W = (w1, w2, ... wn)`和偏差项`b`。 在逻辑回归中，使用最大似然估计器或随机梯度下降法估计系数。 通常将损耗定义为互熵项，如下所示：
 
 ![](img/12190d93-01ea-46a9-a8c4-6a884071651a.png)
 
@@ -39,7 +39,7 @@ Logistic 回归用于分类问题，例如，给定医学数据，我们可以
 
 ![](img/45534cbd-30d1-46b6-b2f7-f83b946bf478.png)
 
-在此， *K* 是类别的总数。 有关逻辑回归的更多信息，请参见 [https://en.wikipedia.org/wiki/Logistic_regression](https://en.wikipedia.org/wiki/Logistic_regression) 。
+在此， `K`是类别的总数。 有关逻辑回归的更多信息，请参见 [https://en.wikipedia.org/wiki/Logistic_regression](https://en.wikipedia.org/wiki/Logistic_regression) 。
 
 这是两种常用的回归技术。
 
@@ -49,7 +49,7 @@ Logistic 回归用于分类问题，例如，给定医学数据，我们可以
 
 ![](img/1b5d16bd-6cbd-41ce-8b7d-85bec85bb7f4.png)
 
-在希腊字母上方，lambda（*λ*）是正则化参数。
+在希腊字母上方，lambda（`λ`）是正则化参数。
 
 # 选择损失函数
 
@@ -98,7 +98,7 @@ w1 = tf.Variable(tf.random_normal([n,1]))
 
 # The Linear Regression ModelY_hat = tf.matmul(X, w1) + w0
 
-*#* Multiple linear regression loss functionloss = tf.reduce_mean(tf.square(Y - Y_hat, name='loss')
+# Multiple linear regression loss functionloss = tf.reduce_mean(tf.square(Y - Y_hat, name='loss')
 ```
 
 3.  在逻辑回归的情况下，`loss`函数由交叉熵定义。 现在，输出`Y`的尺寸将等于训练数据集中的类数。 通过`P`个类，我们将具有以下内容：
@@ -149,9 +149,9 @@ loss += regularization_param
 
 # 做好准备
 
-系数（ *W* 和 *b* ）的更新与`loss`函数的梯度的负值成比例地完成。 根据训练样本的大小，梯度下降有三种变化：
+系数（`W`和`b`）的更新与`loss`函数的梯度的负值成比例地完成。 根据训练样本的大小，梯度下降有三种变化：
 
-*   **香草梯度下降**：在香草梯度下降（有时也称为**批次梯度下降**）中，为每个时期的整个训练集计算`loss`函数的梯度。 对于非常大的数据集，此过程可能很慢且难以处理。 对于凸`loss`函数，可以保证收敛到全局最小值，但是对于非凸`loss`函数，可以收敛到局部最小值。
+*   **普通梯度下降**：在普通梯度下降（有时也称为**全量梯度下降**）中，为每个时期的整个训练集计算`loss`函数的梯度。 对于非常大的数据集，此过程可能很慢且难以处理。 对于凸`loss`函数，可以保证收敛到全局最小值，但是对于非凸`loss`函数，可以收敛到局部最小值。
 *   **随机梯度下降**：在随机梯度下降中，一次显示一个训练样本，权重和偏差得到更新，以使`loss`函数的梯度减小，然后我们移至下一个训练样本 。 重复整个过程许多时期。 由于它一次执行一次更新，因此它比普通更新要快，但是同时，由于频繁更新，`loss`功能可能会有很大差异。
 *   **小批量梯度下降**：结合了前两种产品的最佳质量； 在这里，为一批训练样本更新了参数。
 
@@ -196,9 +196,9 @@ with tf.Session() as sess:
     ...
 ```
 
-5.  馈送到`feed_dict`的`X`和`Y`数据可以是单个`X`和`Y`点（随机梯度），整个训练集（香草）或批次。
+5.  馈送到`feed_dict`的`X`和`Y`数据可以是单个`X`和`Y`点（随机梯度），整个训练集（普通）或批次。
 
-6.  梯度下降的另一个变化是增加了动量项（我们将在第 3 章和*神经网络-感知器*中找到更多相关信息）。 为此，我们使用优化器`tf.train.MomentumOptimizer()`。 它同时将`learning_rate`和`momentum`作为`init`参数：
+6.  梯度下降的另一个变化是增加了动量项（我们将在第 3 章“神经网络感知器”中找到更多相关信息）。 为此，我们使用优化器`tf.train.MomentumOptimizer()`。 它同时将`learning_rate`和`momentum`作为`init`参数：
 
 ```py
 optimizer = tf.train.MomentumOtimizer(learning_rate=0.01, momentum=0.5).minimize(loss)
@@ -262,7 +262,7 @@ learning_rate = tf.train.exponential_decay(initial_learning_rate, global_step, d
 
 以下是一些针对不同优化器的良好链接：
 
-*   **[https://arxiv.org/pdf/1609.04747.pdf](https://arxiv.org/pdf/1609.04747.pdf) ：**该白皮书很好地概述了各种优化算法。
+*   [https://arxiv.org/pdf/1609.04747.pdf](https://arxiv.org/pdf/1609.04747.pdf) ：该白皮书很好地概述了各种优化算法。
 *   [https://www.tensorflow.org/api_guides/python/train#Optimizers](https://www.tensorflow.org/api_guides/python/train#Optimizers) ：这是 TensorFlow.org 链接，其中详细介绍了如何使用 TensorFlow 中包含的不同优化器。
 *   [https://arxiv.org/pdf/1412.6980.pdf](https://arxiv.org/pdf/1412.6980.pdf) ：有关 Adam 优化器的论文。
 
@@ -274,20 +274,20 @@ learning_rate = tf.train.exponential_decay(initial_learning_rate, global_step, d
 
 我们将考虑 Harrison 和 Rubinfield 在 1978 年收集的波士顿住房价格数据集（ [http://lib.stat.cmu.edu/datasets/boston](http://lib.stat.cmu.edu/datasets/boston) ）。该数据集包含 506 个样本案例。 每个房屋都有 14 个属性：
 
-*   **CRIM** ：按城镇划分的人均犯罪率
-*   **ZN** ：已划定 25,000 平方英尺以上土地的居住用地比例
-*   **印度**：每个城镇的非零售营业面积比例
-*   **CHAS** ：查尔斯河虚拟变量（如果束缚河，则为 1；否则为 0）
-*   **NOX** ：一氧化氮浓度（百万分之几）
-*   **RM** ：每个住宅的平均房间数
-*   **年龄**：1940 年之前建造的自有住房的比例
-*   **DIS** ：到五个波士顿就业中心的加权距离
-*   **RAD** ：径向公路的可达性指数
-*   **税**：每 10,000 美元的全值财产税率
-*   **PTRATIO** ：按城镇划分的师生比率
-*   **B** ：1000（Bk-0.63）^ 2，其中 Bk 是按城镇划分的黑人比例
-*   **LSTAT** ：人口状况降低的百分比
-*   **MEDV** ：自有住房的中位数价值为$ 1,000
+*   **`CRIM`**：按城镇划分的人均犯罪率
+*   **`ZN`**：已划定 25,000 平方英尺以上土地的居住用地比例
+*   **`INDIA`**：每个城镇的非零售营业面积比例
+*   **`CHAS`**：查尔斯河虚拟变量（如果束缚河，则为 1；否则为 0）
+*   **`NOX`**：一氧化氮浓度（百万分之几）
+*   **`RM`**：每个住宅的平均房间数
+*   **`AGE`**：1940 年之前建造的自有住房的比例
+*   **`DIS`**：到五个波士顿就业中心的加权距离
+*   **`RAD`**：径向公路的可达性指数
+*   **`TAX`**：每 10,000 美元的全值财产税率
+*   **`PTRATIO`**：按城镇划分的师生比率
+*   **`B`**：`1000(Bk-0.63)^2`，其中`Bk`是按城镇划分的黑人比例
+*   **`LSTAT`**：人口状况降低的百分比
+*   **`MEDV`**：自有住房的中位数价值，单位为 1,000 美元
 
 # 怎么做…
 
@@ -336,9 +336,9 @@ label = data[-1]
 ```py
 # minimum number elements in the queue after a dequeuemin_after_dequeue = 10 * BATCH_SIZE
 
-*# the maximum number of elements in the queue* capacity = 20 * BATCH_SIZE
+# the maximum number of elements in the queue capacity = 20 * BATCH_SIZE
 
-*# shuffle the data to generate BATCH_SIZE sample pairs* feature_batch, label_batch = tf.train.shuffle_batch([features, label], batch_size=BATCH_SIZE,
+# shuffle the data to generate BATCH_SIZE sample pairs feature_batch, label_batch = tf.train.shuffle_batch([features, label], batch_size=BATCH_SIZE,
                                                  capacity=capacity, min_after_dequeue=min_after_dequeue)
 
 return feature_batch, label_batch
@@ -457,7 +457,7 @@ Y_hat = X * w + b
 total = []
 ```
 
-10.  现在，我们开始计算图。 我们进行了 100 个时期的培训：
+10.  现在，我们开始计算图。 我们进行了 100 个时期的训练：
 
 ```py
 *# Computation Graph* with tf.Session() as sess:
@@ -638,7 +638,7 @@ print('Predicted value: ${0}  Actual value: / ${1}'.format(Y_pred[0]*1000, Y_tra
 
 此配方基于 [https://www.tensorflow.org/get_started/mnist/beginners](https://www.tensorflow.org/get_started/mnist/beginners) 提供的 MNIST 的逻辑回归，但我们将添加一些 TensorBoard 摘要以更好地理解它。 你们大多数人必须已经熟悉 MNIST 数据集-就像机器学习的 ABC 一样。 它包含手写数字的图像和每个图像的标签，说明它是哪个数字。
 
-对于逻辑回归，我们对输出 Y 使用一热编码。因此，我们有 10 位代表输出； 每个位可以具有 0 或 1 的值，并且为 1 热点意味着对于标签 Y 中的每个图像，10 个位中只有 1 个位的值为 1，其余为 0。 在这里，您可以看到手写数字 8 的图像及其热编码值 **[0 0 0 0 0 0 0 0 0 1 0]** ：
+对于逻辑回归，我们对输出 Y 使用一热编码。因此，我们有 10 位代表输出； 每个位可以具有 0 或 1 的值，并且为 1 热点意味着对于标签 Y 中的每个图像，10 个位中只有 1 个位的值为 1，其余为 0。 在这里，您可以看到手写数字 8 的图像及其热编码值 **[0 0 0 0 0 0 0 0 0 1 0]**：
 
 ![](img/47ba5240-9d42-4475-866b-5ab156ecbdb0.png)
 

docs/tf-1x-dl-cookbook/03.md

@@ -18,7 +18,7 @@
 
 从那时起，众所周知，添加多层神经元并建立一个深而密集的网络将有助于神经网络解决复杂的任务。 正如母亲为孩子的成就感到自豪一样，科学家和工程师对使用**神经网络**（**NN**）（ [https：// www。 youtube.com/watch?v=jPHUlQiwD9Y](https://www.youtube.com/watch?v=jPHUlQiwD9Y) ）。 这些声明不是虚假的，但是由于硬件计算的限制和复杂的网络结构，当时根本不可能实现它们。 这导致了 1970 年代和 1980 年代的 **AI Winters** 。 在这些寒战中，由于很少或几乎没有对基于 AI 的项目提供资金，因此该领域的进展放缓了。
 
-随着 DNN 和 GPU 的出现，情况发生了变化。 今天，我们拥有的网络可以在较少的调整参数的情况下实现更好的性能，诸如辍学和转移学习之类的技术可以进一步减少培训时间，最后，硬件公司正在提出专门的硬件芯片来执行基于 NN 的快速计算。
+随着 DNN 和 GPU 的出现，情况发生了变化。 今天，我们拥有的网络可以在较少的调整参数的情况下实现更好的性能，诸如辍学和转移学习之类的技术可以进一步减少训练时间，最后，硬件公司正在提出专门的硬件芯片来执行基于 NN 的快速计算。
 
 人工神经元是所有神经网络的核心。 它由两个主要部分组成-加法器（对加权后的神经元的所有输入求和），以及处理单元，对加权后的总和进行加权，并基于称为**激活函数**的预定义函数生成输出。 。 每个人工神经元都有其自己的一组权重和阈值（偏差）。 它通过不同的学习算法来学习这些权重和阈值：
 
@@ -387,7 +387,7 @@ def sigmaprime(x):
      return tf.multiply(tf.sigmoid(x), tf.subtract(tf.constant(1.0), tf.sigmoid(x))) 
 ```
 
-5.  为培训数据创建占位符：
+5.  为训练数据创建占位符：
 
 ```py
 x_in = tf.placeholder(tf.float32, [None, n_input])
@@ -625,7 +625,7 @@ Hornik *等人*（ [http://www.cs.cmu.edu/~bhiksha/courses/deeplearning/Fall.201
 
 这是我们从使用 MLP 进行函数逼近开始的方法：
 
-1.  导入所需的模块-`sklearn`用于数据集，预处理数据，并将其拆分为训练和测试； 熊猫了解数据集； 和`matplotlib`和`seaborn`可视化：
+1.  导入所需的模块-`sklearn`用于数据集，预处理数据，并将其拆分为训练和测试； Pandas 用于了解数据集； `matplotlib`和`seaborn`用于可视化：
 
 ```py
 import tensorflow as tf 
@@ -639,7 +639,7 @@ import seaborn as sns
 %matplotlib inline
 ```
 
-2.  加载数据集并创建一个熊猫数据框以了解数据：
+2.  加载数据集并创建一个 Pandas 数据帧以了解数据：
 
 ```py
 # Data 
@@ -673,7 +673,7 @@ _ = sns.heatmap( corr, cmap = cmap, square=True, cbar_kws={ 'shrink' : .9 }, ax=
 
 ![](img/17069a14-5c69-4456-8329-d9750c1147cd.png)
 
-5.  从前面的代码中，我们可以看到`RM`，`PTRATIO`和`LSTAT`这三个参数的相关性在大小上大于 0.5。 我们选择它们进行培训。 将数据集拆分为训练和测试数据集。 我们还使用`MinMaxScaler`归一化我们的数据集。 需要注意的一个重要变化是，由于我们的神经网络使用了 Sigmoid 激活函数（Sigmoid 的输出只能在 0-1 之间），因此我们也必须将目标值`Y`标准化：
+5.  从前面的代码中，我们可以看到`RM`，`PTRATIO`和`LSTAT`这三个参数的相关性在大小上大于 0.5。 我们选择它们进行训练。 将数据集拆分为训练和测试数据集。 我们还使用`MinMaxScaler`归一化我们的数据集。 需要注意的一个重要变化是，由于我们的神经网络使用了 Sigmoid 激活函数（Sigmoid 的输出只能在 0-1 之间），因此我们也必须将目标值`Y`标准化：
 
 ```py
 # Create Test Train Split 

docs/tf-1x-dl-cookbook/04.md

@@ -16,7 +16,7 @@ CNN 由许多神经网络层组成。 卷积和池化两种不同类型的层通
 
 An example of Convolutional Neural Network as seen is https://commons.wikimedia.org/wiki/File:Typical_cnn.png
 
-卷积网络背后有三个主要的直觉：**本地接受域**，**共享权重**和**池**。 让我们一起回顾一下。
+卷积网络背后有三个主要的直觉**：本地接受域**，**共享权重**和**池**。 让我们一起回顾一下。
 
 # 当地接受领域
 
@@ -345,7 +345,7 @@ An example of train and test accuracy increase
 
 # 这个怎么运作...
 
-使用 ConvNets，我们将 MNIST 数据集的性能提高了近 95％。 我们的 ConvNet 由两层组成，分别是卷积，ReLU 和 maxpooling，然后是两个完全连接的带有 dropout 的层。 培训以 Adam 为优化器，以 128 的大小批量进行，学习率为 0.001，最大迭代次数为 500。
+使用 ConvNets，我们将 MNIST 数据集的性能提高了近 95％。 我们的 ConvNet 由两层组成，分别是卷积，ReLU 和 maxpooling，然后是两个完全连接的带有 dropout 的层。 训练以 Adam 为优化器，以 128 的大小批量进行，学习率为 0.001，最大迭代次数为 500。
 
 # 创建一个 ConvNet 对 CIFAR-10 进行分类
 
@@ -396,7 +396,7 @@ img_prep.add_featurewise_zero_center()
 img_prep.add_featurewise_stdnorm()
 ```
 
-4.  通过左右随机执行以及随机旋转来增强数据集。 此步骤是一个简单的技巧，用于增加可用于培训的数据：
+4.  通过左右随机执行以及随机旋转来增强数据集。 此步骤是一个简单的技巧，用于增加可用于训练的数据：
 
 ```py
 # Real-time data augmentation 
@@ -946,7 +946,7 @@ model = Model(inputs=base_model.input, outputs=top_model(base_model.output))
 model.compile(loss = "binary_crossentropy", optimizer = optimizers.SGD(lr=0.0001, momentum=0.9), metrics=["accuracy"])
 ```
 
-8.  重新培训并列的新模型，仍将 VGG16 的最低 15 层冻结。 在这个特定的例子中，我们还使用图像增幅器来增加训练集：
+8.  重新训练并列的新模型，仍将 VGG16 的最低 15 层冻结。 在这个特定的例子中，我们还使用图像增幅器来增加训练集：
 
 ```py
 # Initiate the train and test generators with data Augumentation
@@ -982,7 +982,7 @@ scores = model.predict_generator(validation_generator, nb_validation_samples/bat
 
 # 这个怎么运作...
 
-标准的 VGG16 网络已经在整个 ImageNet 上进行了预训练，并具有从 Internet 下载的预先计算的权重。 然后，将该网络与也已单独培训的自定义网络并置。 然后，并列的网络作为一个整体进行了重新训练，使 VGG16 的 15 个较低层保持冻结。
+标准的 VGG16 网络已经在整个 ImageNet 上进行了预训练，并具有从 Internet 下载的预先计算的权重。 然后，将该网络与也已单独训练的自定义网络并置。 然后，并列的网络作为一个整体进行了重新训练，使 VGG16 的 15 个较低层保持冻结。
 
 这种组合非常有效。 通过对网络在 ImageNet 上学到的知识进行转移学习，将其应用于我们的新特定领域，从而执行微调分类任务，它可以节省大量的计算能力，并重复使用已为 VGG16 执行的工作。
 

docs/tf-1x-dl-cookbook/05.md

@@ -262,7 +262,7 @@ vis_images.append(img)
 
 因此，这就是神经网络在内部代表鸟类的方式。 这是一种令人毛骨悚然的形象，但我发誓没有为网络本身提供任何特定种类的人造药物！ 这正是这种特殊的人工网络自然学到的东西。
 
-6.  您是否仍然想了解更多？ 好吧，让我们选择一个较早的层，并代表网络如何在内部看到相同的`American Dipper`培训课程：
+6.  您是否仍然想了解更多？ 好吧，让我们选择一个较早的层，并代表网络如何在内部看到相同的`American Dipper`训练课程：
 
 ```py
 layer_name = 'block3_conv1'
@@ -335,7 +335,7 @@ Xception 是 Inception 的扩展，在 *Xception：具有深度可分离卷积
 
 # 做好准备
 
-此食谱使用 Keras，因为该框架已预先完成了上述模块的实现。 Keras 首次使用时会自动下载每个网络的权重，并将这些权重存储在本地磁盘上。 换句话说，您不需要重新培训网络，而是可以利用 Internet 上已经可用的培训。 在您希望将网络分类为 1000 个预定义类别的假设下，这是正确的。 在下一个食谱中，我们将了解如何从这 1,000 个类别开始，并通过称为转移学习的过程将它们扩展到自定义集合。
+此食谱使用 Keras，因为该框架已预先完成了上述模块的实现。 Keras 首次使用时会自动下载每个网络的权重，并将这些权重存储在本地磁盘上。 换句话说，您不需要重新训练网络，而是可以利用 Internet 上已经可用的训练。 在您希望将网络分类为 1000 个预定义类别的假设下，这是正确的。 在下一个食谱中，我们将了解如何从这 1,000 个类别开始，并通过称为转移学习的过程将它们扩展到自定义集合。
 
 # 怎么做...
 
@@ -646,7 +646,7 @@ AlexNet 是最早的堆叠式深层网络之一，它仅包含八层，前五层
 
 关于深度神经网络的最新研究主要集中在提高准确性上。 较小的 DNN 架构具有同等的准确性，至少具有三个优点：
 
-*   较小的 CNN 在分布式培训期间需要较少的跨服务器通信。
+*   较小的 CNN 在分布式训练期间需要较少的跨服务器通信。
 *   较小的 CNN 需要较少的带宽才能将新模型从云导出到提供模型的位置。
 *   较小的 CNN 在具有有限内存的 FPGA 和其他硬件上部署更可行。 为了提供所有这些优点，在​​论文 *SqueezeNet 中提出了 SqueezeNet：AlexNet 级精度，参数减少 50 倍，模型尺寸< 0.5MB* ，Forrest N. Iandola，Song Han，MatthewW。 Moskewicz，Khalid Ashraf，William J.Dally，Kurt Keutzer，2016 年， [https://arxiv.org/abs/1602.07360](https://arxiv.org/abs/1602.07360) 。 SqueezeNet 通过减少 50 倍的参数在 ImageNet 上达到 AlexNet 级别的准确性。 此外，借助模型压缩技术，我们可以将 SqueezeNet 压缩到小于 0.5 MB（比 AlexNet 小 510 倍）。 Keras 将 SqueezeNet 作为单独的模块在线实现（ [https://github.com/DT42/squeezenet_demo](https://github.com/DT42/squeezenet_demo) ）。
 
@@ -702,7 +702,7 @@ features = model.predict(x)
 
 较低的层标识较低阶的特征（例如颜色和边缘），较高的层将这些较低阶的特征组合为较高阶的特征（例如形状或对象）。 因此，中间层具有从图像中提取重要特征的能力，并且这些特征更有可能有助于不同种类的分类。
 
-这具有多个优点。 首先，我们可以依靠公开提供的大规模培训，并将这种学习转移到新颖的领域。 其次，我们可以节省昂贵的大型培训时间。 第三，即使我们没有针对该领域的大量培训示例，我们也可以提供合理的解决方案。 对于手头的任务，我们也有一个很好的起始网络形状，而不是猜测它。
+这具有多个优点。 首先，我们可以依靠公开提供的大规模训练，并将这种学习转移到新颖的领域。 其次，我们可以节省昂贵的大型训练时间。 第三，即使我们没有针对该领域的大量训练示例，我们也可以提供合理的解决方案。 对于手头的任务，我们也有一个很好的起始网络形状，而不是猜测它。
 
 # 用于迁移学习的非常深的 InceptionV3 Net
 
@@ -710,7 +710,7 @@ features = model.predict(x)
 
 按照这种思路，计算机视觉研究人员现在通常使用经过预训练的 CNN 来生成新任务的表示形式，其中数据集可能不足以从头训练整个 CNN。 另一个常见的策略是采用经过预先训练的 ImageNet 网络，然后将整个网络微调到新颖的任务。
 
-InceptionV3 Net 是 Google 开发的非常深入的 ConvNet。 Keras 实现了整个网络，如下图所示，并且已在 ImageNet 上进行了预培训。 该型号的默认输入大小在三个通道上为 299x299：
+InceptionV3 Net 是 Google 开发的非常深入的 ConvNet。 Keras 实现了整个网络，如下图所示，并且已在 ImageNet 上进行了预训练。 该型号的默认输入大小在三个通道上为 299x299：
 
 ![](img/37918887-6078-449a-9216-4179bd7e4637.png)
 
@@ -802,7 +802,7 @@ layer.trainable = False
 
 # 这个怎么运作...
 
-现在，我们有了一个新的深度网络，该网络可以重用标准的 Inception-v3 网络，但可以通过迁移学习在新的域 D 上进行训练。 当然，有许多参数需要微调以获得良好的精度。 但是，我们现在正在通过迁移学习重新使用非常庞大的预训练网络作为起点。 这样，我们可以通过重复使用 Keras 中已经可用的内容来节省对机器进行培训的需求。
+现在，我们有了一个新的深度网络，该网络可以重用标准的 Inception-v3 网络，但可以通过迁移学习在新的域 D 上进行训练。 当然，有许多参数需要微调以获得良好的精度。 但是，我们现在正在通过迁移学习重新使用非常庞大的预训练网络作为起点。 这样，我们可以通过重复使用 Keras 中已经可用的内容来节省对机器进行训练的需求。
 
 # 还有更多...
 
@@ -1235,7 +1235,7 @@ print str(round(y_output[0,label]*100,2)).zfill(5), "% ", labelencoder.inverse_t
 
 # 通过六种不同方式对视频进行预训练网络分类
 
-对视频进行分类是一个活跃的研究领域，因为处理此类媒体需要大量数据。 内存需求经常达到现代 GPU 的极限，可能需要在多台机器上进行分布式培训。 目前，研究正在探索复杂性不断提高的不同方向，让我们对其进行回顾。
+对视频进行分类是一个活跃的研究领域，因为处理此类媒体需要大量数据。 内存需求经常达到现代 GPU 的极限，可能需要在多台机器上进行分布式训练。 目前，研究正在探索复杂性不断提高的不同方向，让我们对其进行回顾。
 
 第一种方法包括一次将一个视频帧分类，方法是将每个视频帧视为使用 2D CNN 处理的单独图像。 这种方法只是将视频分类问题简化为图像分类问题。 每个视频帧*发出*分类输出，并且通过考虑每个帧的更频繁选择的类别对视频进行分类。
 

docs/tf-1x-dl-cookbook/06.md

@@ -53,7 +53,7 @@ An example of simple tanh cell
 
 Examples of gradient
 
-**渐变裁剪**包括对渐变施加最大值，以使其无法无限增长。 下图所示的简单解决方案为**爆炸梯度问题提供了简单的解决方案：**
+**渐变裁剪**包括对渐变施加最大值，以使其无法无限增长。 下图所示的简单解决方案为**爆炸梯度问题提供了简单的解决方案**：
 
 ![](img/1ddb8b2f-e13b-479f-9568-488a01b4c539.png)
 
@@ -129,7 +129,7 @@ An example of encoder-decoder as seen in https://github.com/lmthang/thesis/blob/
 
 让我们看一个 RNN 的示例，该语句将“她爱可爱的猫咪”翻译成 Elle Aime les chat Mignons。
 
-有两种 RNN：一种充当编码器，另一种充当解码器。 源句“她爱可爱的猫”后跟一个分隔符-目标句是 Elle aime les chats mignons。 这两个连接的句子在输入中提供给编码器进行训练，并且解码器将生成目标目标。 当然，我们需要像这样的多个示例来获得良好的培训：
+有两种 RNN：一种充当编码器，另一种充当解码器。 源句“她爱可爱的猫”后跟一个分隔符-目标句是 Elle aime les chats mignons。 这两个连接的句子在输入中提供给编码器进行训练，并且解码器将生成目标目标。 当然，我们需要像这样的多个示例来获得良好的训练：
 
 ![](img/8e9fd11b-d547-4740-9010-ca4e1ebb30f9.png)
 
@@ -301,8 +301,8 @@ An example of sequence models for NMT with probabilities as seen in https://gith
 
 使用解码器的输出有多种策略：
 
-*   **贪婪：**发出与最大 logit 对应的字
-*   **采样：**通过对 logits 发出的 logit 进行采样来发出单词
+*   **贪婪**：发出与最大 logit 对应的字
+*   **采样**：通过对 logits 发出的 logit 进行采样来发出单词
 *   **波束搜索**：一个以上的预测，因此创建了可能的扩展树
 
 # 怎么做...
@@ -341,8 +341,8 @@ python -m nmt.nmt \
 
 将两个 RNN *打包在一起*，以形成编码器-解码器 RNN 网络。 解码器发出 logit，然后将其贪婪地转换为目标语言的单词。 例如，此处显示了从越南语到英语的自动翻译：
 
-*   **用英语输入的句子：**小时候，我认为朝鲜是世界上最好的国家，我经常唱歌&。 我们没有什么可嫉妒的。
-*   **翻译成英语的输出句子：**当我非常好时，我将去了解最重要的事情，而我不确定该说些什么。
+*   **用英语输入的句子**：小时候，我认为朝鲜是世界上最好的国家，我经常唱歌&。 我们没有什么可嫉妒的。
+*   **翻译成英语的输出句子**：当我非常好时，我将去了解最重要的事情，而我不确定该说些什么。
 
 # 您只需要关注-seq2seq RNN 的另一个示例
 
@@ -636,7 +636,7 @@ And the provest and stand,
 git clone https://github.com/guillaume-chevalier/seq2seq-signal-prediction.git
 ```
 
-2.  给定前面的存储库，请考虑以下函数，这些函数可加载和标准化 USD 或 EUR 比特币值的比特币历史数据。 这些功能在`dataset.py`中定义。 培训和测试数据根据 80/20 规则分开。 因此，测试数据的 20％是最新的历史比特币值。 每个示例在要素轴/维度中包含 40 个 USD 数据点，然后包含 EUR 数据。 根据平均值和标准偏差对数据进行归一化。 函数`generate_x_y_data_v4`生成大小为`batch_size`的训练数据（分别是测试数据）的随机样本：
+2.  给定前面的存储库，请考虑以下函数，这些函数可加载和标准化 USD 或 EUR 比特币值的比特币历史数据。 这些功能在`dataset.py`中定义。 训练和测试数据根据 80/20 规则分开。 因此，测试数据的 20％是最新的历史比特币值。 每个示例在要素轴/维度中包含 40 个 USD 数据点，然后包含 EUR 数据。 根据平均值和标准偏差对数据进行归一化。 函数`generate_x_y_data_v4`生成大小为`batch_size`的训练数据（分别是测试数据）的随机样本：
 
 ```py
 def loadCurrency(curr, window_size):

docs/tf-1x-dl-cookbook/07.md

@@ -611,7 +611,7 @@ SOM 在计算上很昂贵，因此对于非常大的数据集并没有真正的
 
 # 受限玻尔兹曼机
 
-**受限玻尔兹曼机**（**RBM**）是两层神经网络，第一层称为**可见层**，第二层称为[HTG6 隐藏层。 它们被称为**浅层神经网络**，因为它们只有两层深。 它们最初是由 1986 年由保罗·斯莫伦斯基（Paul Smolensky）（他称其为 Harmony Networks <sup>[1]</sup> ）提出的，后来由 Geoffrey Hinton 提出，于 2006 年提出了**对比发散**（**CD**）作为培训他们的方法。 可见层中的所有神经元都与隐藏层中的所有神经元相连，但是存在**限制**-同一层中没有神经元可以连接。 所有神经元本质上都是二进制的：
+**受限玻尔兹曼机**（**RBM**）是两层神经网络，第一层称为**可见层**，第二层称为[HTG6 隐藏层。 它们被称为**浅层神经网络**，因为它们只有两层深。 它们最初是由 1986 年由保罗·斯莫伦斯基（Paul Smolensky）（他称其为 Harmony Networks <sup>[1]</sup> ）提出的，后来由 Geoffrey Hinton 提出，于 2006 年提出了**对比发散**（**CD**）作为训练他们的方法。 可见层中的所有神经元都与隐藏层中的所有神经元相连，但是存在**限制**-同一层中没有神经元可以连接。 所有神经元本质上都是二进制的：
 
 ![](img/06c4c832-db20-40c8-bf83-39d907a5a660.png)
 
@@ -695,7 +695,7 @@ self.free_energy(self.V))
 labels=self._X, logits=reconstructed_input))
 ```
 
-3.  我们在`RBM`类中定义`fit()`方法。 在`__init__`中声明了所有操作后，培训只是在会话中调用`train_op`。 我们使用批量培训：
+3.  我们在`RBM`类中定义`fit()`方法。 在`__init__`中声明了所有操作后，训练只是在会话中调用`train_op`。 我们使用批量训练：
 
 ```py
  def fit(self, X, epochs = 1, batch_size = 100):
@@ -812,7 +812,7 @@ n = 20  # Number of Hidden units
 recommender = rbm.RBM(m,n)
 ```
 
-2.  我们使用熊猫合并和`groupby`命令创建了一个列表`trX`，该列表包含大约 1,000 个用户的规范化电影评分。 列表的大小为 1000 x3883。我们使用它来训练我们的 RBM：
+2.  我们使用 Pandas 合并和`groupby`命令创建了一个列表`trX`，该列表包含大约 1,000 个用户的规范化电影评分。 列表的大小为 1000 x3883。我们使用它来训练我们的 RBM：
 
 ```py
 Xtrain = np.array(trX) 
@@ -827,7 +827,7 @@ with tf.Session() as sess:
 
 ![](img/4f6d416b-0f30-4dc2-82c3-07136f577161.png)
 
-4.  网络现已接受培训； 我们使用它为索引为 150 的随机用户（可能是任何现有用户）获得推荐：
+4.  网络现已接受训练； 我们使用它为索引为 150 的随机用户（可能是任何现有用户）获得推荐：
 
 ```py
 user_index = 150
@@ -839,7 +839,7 @@ with tf.Session() as sess:
  out = recommender.reconstruct(x.astype(np.float32))
 ```
 
-5.  结果与现有数据框合并，我们可以看到该用户的推荐分数：
+5.  结果与现有数据帧合并，我们可以看到该用户的推荐分数：
 
 ![](img/c9170c8b-d8d0-49eb-8a78-ac7b95a3386b.png)
 
@@ -847,11 +847,11 @@ with tf.Session() as sess:
 
 杰弗里·欣顿（Geoffrey Hinton）教授领导的多伦多大学团队赢得了 Netflix 最佳协作过滤竞赛的冠军，该协作过滤使用 RBM [（https://en.wikipedia.org/wiki/Netflix_Prize）](https://en.wikipedia.org/wiki/Netflix_Prize)来预测电影的用户收视率。 可以从他们的论文中获取其工作的详细信息： [http://www.cs.toronto.edu/~hinton/absps/netflixICML.pdf](http://www.cs.toronto.edu/~hinton/absps/netflixICML.pdf) 。
 
-一个 RBM 的隐藏单元的输出可以馈送到另一个 RBM 的可见单元，可以重复此过程以形成 RBM 的堆栈。 这导致**堆叠的 RBM** 。 假定不存在其他堆叠式 RBM，则对其进行独立训练。 大量堆叠的 RBM 构成了**深度信任网络（DBN）**。 可以使用有监督或无监督的培训来训练 DBN。 您将在下一个食谱中了解有关它们的更多信息。
+一个 RBM 的隐藏单元的输出可以馈送到另一个 RBM 的可见单元，可以重复此过程以形成 RBM 的堆栈。 这导致**堆叠的 RBM** 。 假定不存在其他堆叠式 RBM，则对其进行独立训练。 大量堆叠的 RBM 构成了**深度信任网络（DBN）**。 可以使用有监督或无监督的训练来训练 DBN。 您将在下一个食谱中了解有关它们的更多信息。
 
 # DBN 用于情绪检测
 
-在本食谱中，我们将学习如何首先堆叠 RBM 来制作 DBN，然后训练它来检测情绪。 食谱中有趣的部分是我们采用了两种不同的学习范例：首先，我们使用无监督学习对 RBM 进行了预培训，最后，我们有了一个 MLP 层，该层是使用监督学习进行了培训的。
+在本食谱中，我们将学习如何首先堆叠 RBM 来制作 DBN，然后训练它来检测情绪。 食谱中有趣的部分是我们采用了两种不同的学习范例：首先，我们使用无监督学习对 RBM 进行了预训练，最后，我们有了一个 MLP 层，该层是使用监督学习进行了训练的。
 
 # 做好准备
 
@@ -918,7 +918,7 @@ import pandas as pd
 import matplotlib.pyplot as plt
 ```
 
-2.  培训，验证和测试数据是使用帮助程序功能获得的：
+2.  训练，验证和测试数据是使用帮助程序功能获得的：
 
 ```py
 X_train, Y_train = preprocess_data(train_data)

docs/tf-1x-dl-cookbook/08.md

@@ -2,7 +2,7 @@
 
 自编码器是前馈，非循环神经网络，可通过无监督学习来学习。 他们具有学习数据的紧凑表示的固有能力。 它们是深度信任网络的中心，可在图像重建，聚类，机器翻译等领域找到应用。 在本章中，您将学习和实现自编码器的不同变体，并最终学习如何堆叠自编码器。 本章包括以下主题：
 
-*   香草自编码器
+*   普通自编码器
 *   稀疏自编码器
 *   去噪自编码器
 *   卷积汽车编码器
@@ -38,9 +38,9 @@
 
 *   Japkowicz，Nathalie，Catherine Myers 和 Mark Gluck。 *一种新颖的分类检测方法*。 IJCAI。 卷 1995 年 1 月。（ [http://www.ijcai.org/Proceedings/95-1/Papers/068.pdf](http://www.ijcai.org/Proceedings/95-1/Papers/068.pdf) ）
 
-# 香草自编码器
+# 普通自编码器
 
-Hinton 提出的香草自编码器仅包含一个隐藏层。 隐藏层中神经元的数量少于输入（或输出）层中神经元的数量。 这导致对网络中信息流产生瓶颈效应，因此我们可以将隐藏层视为瓶颈层，从而限制了要存储的信息。 自编码器中的学习包括在隐藏层上开发输入信号的紧凑表示，以便输出层可以忠实地再现原始输入：
+Hinton 提出的普通自编码器仅包含一个隐藏层。 隐藏层中神经元的数量少于输入（或输出）层中神经元的数量。 这导致对网络中信息流产生瓶颈效应，因此我们可以将隐藏层视为瓶颈层，从而限制了要存储的信息。 自编码器中的学习包括在隐藏层上开发输入信号的紧凑表示，以便输出层可以忠实地再现原始输入：
 
 ![](img/7ca4c522-394e-49e6-bd32-e6679893f099.png)
 
@@ -158,7 +158,7 @@ with tf.Session() as sess:
     out = autoEncoder.reconstruct(Xtest[0:100])
 ```
 
-5.  我们可以通过绘制误差与时期的关系图来验证我们的网络在训练时是否确实优化了 MSE。 为了获得良好的培训，应该使用`epochs`来减少错误：
+5.  我们可以通过绘制误差与时期的关系图来验证我们的网络在训练时是否确实优化了 MSE。 为了获得良好的训练，应该使用`epochs`来减少错误：
 
 ```py
 plt.plot(err)
@@ -170,7 +170,7 @@ plt.ylabel('cost')
 
 ![](img/0817554f-9ed5-42f8-9658-ca75699c4915.png)
 
-我们可以看到，随着网络的学习，损耗/成本正在降低，到我们达到 5,000 个时代时，损耗/成本几乎在一条线上振荡。 这意味着进一步增加时期将是无用的。 如果现在要改善培训，则应该更改超参数，例如学习率，批处理大小和使用的优化程序。
+我们可以看到，随着网络的学习，损耗/成本正在降低，到我们达到 5,000 个时代时，损耗/成本几乎在一条线上振荡。 这意味着进一步增加时期将是无用的。 如果现在要改善训练，则应该更改超参数，例如学习率，批处理大小和使用的优化程序。
 
 6.  现在让我们看一下重建的图像。 在这里，您可以同时看到由我们的自编码器生成的原始图像和重建图像：
 
@@ -398,7 +398,7 @@ for fig, row in zip([Xtest,out], axarr):
 
 # 这个怎么运作...
 
-您必须已经注意到，稀疏自编码器的主要代码与香草自编码器的主要代码完全相同，这是因为稀疏自编码器只有一个主要变化-增加了 KL 发散损耗以确保稀疏性。 隐藏的（瓶颈）层。 但是，如果比较这两个重构，则可以发现即使在隐藏层中具有相同数量的单位，稀疏自编码器也比标准编码器好得多：
+您必须已经注意到，稀疏自编码器的主要代码与普通自编码器的主要代码完全相同，这是因为稀疏自编码器只有一个主要变化-增加了 KL 发散损耗以确保稀疏性。 隐藏的（瓶颈）层。 但是，如果比较这两个重构，则可以发现即使在隐藏层中具有相同数量的单位，稀疏自编码器也比标准编码器好得多：
 
 ![](img/faa06c5a-28a5-4527-b367-f774f025a756.png)
 

docs/tf-1x-dl-cookbook/09.md

@@ -103,7 +103,7 @@ for step in range(1000): # 1000 steps max
      break
 ```
 
-`obs`告诉代理程序环境是什么样的； 对于我们的环境，它对应于大小为 210 x 160 x 3 的 RGB 图像。在每个步骤中，代理将获得 0 或 1 奖励，根据 OpenAI Gym Wiki，其`reward`为`[-inf, inf]`。 游戏结束后，环境将`done`返回为`True`。 `info`可用于调试，但代理不使用。 `env.render()`命令弹出一个窗口，显示环境的当前状态。 当包含此命令时，您可以通过弹出窗口查看座席如何尝试玩耍和学习。 最好在座席接受培训时对此进行评论，以节省时间。
+`obs`告诉代理程序环境是什么样的； 对于我们的环境，它对应于大小为 210 x 160 x 3 的 RGB 图像。在每个步骤中，代理将获得 0 或 1 奖励，根据 OpenAI Gym Wiki，其`reward`为`[-inf, inf]`。 游戏结束后，环境将`done`返回为`True`。 `info`可用于调试，但代理不使用。 `env.render()`命令弹出一个窗口，显示环境的当前状态。 当包含此命令时，您可以通过弹出窗口查看座席如何尝试玩耍和学习。 最好在座席接受训练时对此进行评论，以节省时间。
 
 9.  最后，关闭环境：
 
@@ -521,7 +521,7 @@ def preprocess(img):
 
 ![](img/1986c35e-a3c2-478b-946c-234b2d685e7b.png)
 
-要注意的另一重要事项是，当前的观察空间不能完全显示游戏情况。 例如，参见上图，您无法确定桨叶是向左还是向右移动。 因此，为了完全理解游戏的当前状态，我们需要考虑动作和观察的顺序。 在配方中，我们考虑了四个动作和观察序列，以确定当前情况并培训代理商。 这是借助`state_update`函数完成的，该函数将当前的观察状态附加到先前的状态，从而生成一系列状态：
+要注意的另一重要事项是，当前的观察空间不能完全显示游戏情况。 例如，参见上图，您无法确定桨叶是向左还是向右移动。 因此，为了完全理解游戏的当前状态，我们需要考虑动作和观察的顺序。 在配方中，我们考虑了四个动作和观察序列，以确定当前情况并训练代理商。 这是借助`state_update`函数完成的，该函数将当前的观察状态附加到先前的状态，从而生成一系列状态：
 
 ```py
 def update_state(state, obs):
@@ -533,7 +533,7 @@ def update_state(state, obs):
 
 # 怎么做...
 
-1.  我们导入必要的模块。 我们正在使用`sys`模块的`stdout.flush()`来帮助我们强制 Python *刷新*标准输出（在我们的情况下为计算机监视器）中的数据。 `random`模块用于从体验重播缓冲区（我们存储过去经验的缓冲区）中获取随机样本。 `datetime`模块用于跟踪培训时间：
+1.  我们导入必要的模块。 我们正在使用`sys`模块的`stdout.flush()`来帮助我们强制 Python *刷新*标准输出（在我们的情况下为计算机监视器）中的数据。 `random`模块用于从体验重播缓冲区（我们存储过去经验的缓冲区）中获取随机样本。 `datetime`模块用于跟踪训练时间：
 
 ```py
 import gym
@@ -556,7 +556,7 @@ IM_SIZE = 80
 K = 4
 ```
 
-3.  定义了类`DQN`； 其构造函数使用`tf.contrib.layers.conv2d`函数构建 CNN 网络，并定义成本和培训操作：
+3.  定义了类`DQN`； 其构造函数使用`tf.contrib.layers.conv2d`函数构建 CNN 网络，并定义成本和训练操作：
 
 ```py
 class DQN:
@@ -628,7 +628,7 @@ def sample_action(self, x, eps):
         return np.argmax(self.predict([x])[0])
 ```
 
-5.  我们还定义了加载和保存网络的方法，因为培训可能会花费一些时间：
+5.  我们还定义了加载和保存网络的方法，因为训练可能会花费一些时间：
 
 ```py
 def load(self):
@@ -818,7 +818,7 @@ if __name__ == '__main__':
 
 ![](img/84e64725-a283-4127-959c-72601fd0180e.png)
 
-从上图中我们可以看到，特工通过培训获得了更高的报酬，并且通过每 100 集的平均报酬图可以清楚地看到情况：
+从上图中我们可以看到，特工通过训练获得了更高的报酬，并且通过每 100 集的平均报酬图可以清楚地看到情况：
 
 ![](img/a569353d-5591-460b-a73b-89c14c6977dd.png)
 
@@ -835,7 +835,7 @@ env = gym.make('Breakout-v0)
 env = wrappers.Monitor(env, '/save-path')
 ```
 
-如果您想在下一个培训中使用相同的文件夹，可以将`force=True`添加到 Monitor。
+如果您想在下一个训练中使用相同的文件夹，可以将`force=True`添加到 Monitor。
 
 # 也可以看看
 
@@ -889,7 +889,7 @@ import matplotlib.pyplot as plt
 import tensorflow as tf
 ```
 
-3.  我们定义我们的`PolicyNetwork`类。 在类构建期间，还将初始化模型超参数。 `__init__`方法定义输入状态`self.tf_x`的占位符； 预测作用，`self.tf.y`； 相应的奖励，`self.tf_epr`； 网络权重； 并预测行动价值，培训和更新。 您可以看到该类构造还启动了一个交互式 TensorFlow 会话：
+3.  我们定义我们的`PolicyNetwork`类。 在类构建期间，还将初始化模型超参数。 `__init__`方法定义输入状态`self.tf_x`的占位符； 预测作用，`self.tf.y`； 相应的奖励，`self.tf_epr`； 网络权重； 并预测行动价值，训练和更新。 您可以看到该类构造还启动了一个交互式 TensorFlow 会话：
 
 ```py
 class PolicyNetwork(object):
@@ -1076,7 +1076,7 @@ AlphaGo Zero 使用深层神经网络，该网络将原始板表示形式（当
 
 最初，神经网络的权重是随机初始化的。 在每个迭代步骤中，都会生成许多自玩游戏。 在每个时间步，使用神经网络的先前迭代对可能的策略执行 MCTS 搜索，然后通过对搜索概率进行采样来进行移动。 重复此过程直到该特定游戏终止。 存储游戏状态，采取的策略以及游戏每个时间步骤的奖励。 并行地，根据自播放的先前迭代的所有时间步长之间均匀采样的数据训练神经网络。 调整神经网络的权重，以最小化预测值和自赢者之间的误差，并使神经网络移动概率与搜索概率的相似性最大化。
 
-在配备 4 个 TPU 的单台机器上仅进行了 3 天的培训，AlphaGo Zero 以 100-0 击败 AlphaGo。 AlphaGo Zero 完全基于 RL。 可以在*于 2017 年 10 月发表于《自然》上的论文*掌握无人掌握的围棋游戏*中阅读其实现的详细信息。*
+在配备 4 个 TPU 的单台机器上仅进行了 3 天的训练，AlphaGo Zero 以 100-0 击败 AlphaGo。 AlphaGo Zero 完全基于 RL。 可以在*于 2017 年 10 月发表于《自然》上的论文*掌握无人掌握的围棋游戏*中阅读其实现的详细信息。*
 
 # 也可以看看
 

docs/tf-1x-dl-cookbook/10.md

@@ -133,7 +133,7 @@ TensorFlow 移动 Android 应用程序可在 GitHub 上的以下地址获得：
 *   **TF 分类**：使用 Google Inception 模型实时对相机帧进行分类，并在相机图像上以重叠显示顶部结果。
 *   **TF 检测**：演示使用 TensorFlow 对象检测 API 训练的 SSD-Mobilenet 模型。 这是在现代卷积目标检测器的速度/精度折衷中引入的，以实时定位和跟踪摄像机预览中的目标（来自 80 个类别）。
 *   **TF 风格化**：使用基于*艺术风格的学习表示*的模型将相机预览图像重新设置为许多不同艺术风格的图像。
-*   **TF 语音**：运行在音频培训教程中构建的简单语音识别模型。 侦听一小部分单词，并在识别它们时在 UI 中突出显示它们。
+*   **TF 语音**：运行在音频训练教程中构建的简单语音识别模型。 侦听一小部分单词，并在识别它们时在 UI 中突出显示它们。
 
 # 怎么做...
 

docs/tf-1x-dl-cookbook/11.md

@@ -40,7 +40,7 @@ An example of convergence for Generator and Discriminator
 
 ![](img/8a65baee-568b-4c4f-bb07-a60ad7bb16f8.png)
 
-现在，让我们看看 GAN 如何学习**伪造** MNIST 数据集。 在这种情况下，它是用于生成器和鉴别器网络的 GAN 和 ConvNets 的组合。 最初，生成器不会产生任何可理解的东西，但是经过几次迭代，合成的伪造数字变得越来越清晰。 在下图中，通过增加培训时期来对面板进行排序，您可以看到面板之间的质量改进：
+现在，让我们看看 GAN 如何学习**伪造** MNIST 数据集。 在这种情况下，它是用于生成器和鉴别器网络的 GAN 和 ConvNets 的组合。 最初，生成器不会产生任何可理解的东西，但是经过几次迭代，合成的伪造数字变得越来越清晰。 在下图中，通过增加训练时期来对面板进行排序，您可以看到面板之间的质量改进：
 
 ![](img/850e0191-0019-4bfc-906b-4043e91ce23f.png)
 
@@ -62,7 +62,7 @@ GAN 最酷的用途之一是对生成器矢量 Z 的面部进行算术。换句
 
 ![](img/098bf513-346d-4c13-b692-c15567295ae9.png)An example of generated bedrooms
 
-**专辑封面：**这些图像不是真实的，而是由 GAN 生成的。 专辑封面看起来很真实：
+**专辑封面**：这些图像不是真实的，而是由 GAN 生成的。 专辑封面看起来很真实：
 
 ![](img/3f94861f-9f24-4b33-92d1-44b413fb0408.png)
 
@@ -86,7 +86,7 @@ Ian J.Goodfellow，Jean Pouget-Abadie，Mehdi Mirza，Bing Xu，David Warde-Farl
 git clone https://github.com/TengdaHan/GAN-TensorFlow
 ```
 
-2.  如论文*中所述，定义 Xavier 初始化程序。了解由 Xavier Glorot，Yoshua 编写的深度前馈神经网络的培训[2009]* *Bengio，http：//citeseerx.ist.psu.edu/viewdoc /download?doi=10.1.1.207.2059 & rep = rep1 & type = pdf* 事实证明，初始化程序可让 GAN 更好地收敛：
+2.  如论文*中所述，定义 Xavier 初始化程序。了解由 Xavier Glorot，Yoshua 编写的深度前馈神经网络的训练[2009]* *Bengio，http：//citeseerx.ist.psu.edu/viewdoc /download?doi=10.1.1.207.2059 & rep = rep1 & type = pdf* 事实证明，初始化程序可让 GAN 更好地收敛：
 
 ```py
 def xavier_init(size):
@@ -617,7 +617,7 @@ Example of Encoder-Decoder for Autoencoders.
 
 生成损失确保解码器生成的图像和用于训练网络的图像相同，而潜在损失确保后验分布*qᵩ（z | x）*接近先前的 *p <sub>ϴ</sub> （z）*。 由于编码器使用高斯分布进行采样，因此潜在损失可以衡量潜在变量与单位高斯的匹配程度。
 
-对 VAE 进行培训后，我们只能使用解码器网络来生成新图像。
+对 VAE 进行训练后，我们只能使用解码器网络来生成新图像。
 
 # 怎么做...
 
@@ -846,7 +846,7 @@ for i in range(5):
 
 An example of MNIST reconstructed characters
 
-9.  以下是使用经过培训的 VAE 生成的手写数字示例：
+9.  以下是使用经过训练的 VAE 生成的手写数字示例：
 
 ```py
 nx = ny = 20

docs/tf-1x-dl-cookbook/12.md

@@ -252,7 +252,7 @@ with tf.Session(server.target):
 
 # 还有更多...
 
-可以在 [https://github.com/ischlag/distributed-tensorflow-example/blob/master/example.py](https://github.com/ischlag/distributed-tensorflow-example/blob/master/example.py) 在线获取针对 MNIST 的分布式培训的示例。
+可以在 [https://github.com/ischlag/distributed-tensorflow-example/blob/master/example.py](https://github.com/ischlag/distributed-tensorflow-example/blob/master/example.py) 在线获取针对 MNIST 的分布式训练的示例。
 
 此外，请注意，出于效率考虑，您可以决定拥有多个参数服务器。 使用参数，服务器可以提供更好的网络利用率，并且可以将模型扩展到更多并行计算机。 可以分配多个参数服务器。 有兴趣的读者可以看看 [https://www.tensorflow.org/deploy/distributed](https://www.tensorflow.org/deploy/distributed)
 
@@ -409,7 +409,7 @@ with sv.prepare_or_wait_for_session(server.target) as sess:
 
 # 这个怎么运作...
 
-本食谱描述了分布式 MNIST 分类器的示例。 在此示例中，TensorFlow 允许我们定义三台机器的集群。 一台充当参数服务器，另外两台机器用作工作人员，负责处理不同批次的培训数据。
+本食谱描述了分布式 MNIST 分类器的示例。 在此示例中，TensorFlow 允许我们定义三台机器的集群。 一台充当参数服务器，另外两台机器用作工作人员，负责处理不同批次的训练数据。
 
 # 使用 TensorFlow Serving 和 Docker
 
@@ -581,7 +581,7 @@ CloudML 是 Google 运行的 Tensorflow 的托管版本。 无需自己运行 TF
 
 # 做好准备
 
-在这里，我们假设您已经创建了一个 Cloud Platform Project，为您的项目启用计费，并启用了 Google Compute Engine 和 Cloud Machine Learning API。 这些步骤类似于先前食谱中描述的步骤。 此食谱的灵感来自 [https://cloud.google.com/ml-engine/docs/distributed-tensorflow-mnist-cloud-datalab](https://cloud.google.com/ml-engine/docs/distributed-tensorflow-mnist-cloud-datalab) 中提供的 MNIST 培训代码。
+在这里，我们假设您已经创建了一个 Cloud Platform Project，为您的项目启用计费，并启用了 Google Compute Engine 和 Cloud Machine Learning API。 这些步骤类似于先前食谱中描述的步骤。 此食谱的灵感来自 [https://cloud.google.com/ml-engine/docs/distributed-tensorflow-mnist-cloud-datalab](https://cloud.google.com/ml-engine/docs/distributed-tensorflow-mnist-cloud-datalab) 中提供的 MNIST 训练代码。
 
 # 怎么做...
 
@@ -603,7 +603,7 @@ gsutil cp /tmp/data/train.tfrecords gs://${BUCKET}/data/
 gsutil cp /tmp/data/test.tfrecords gs://${BUCKET}/data/
 ```
 
-3.  提交培训工作非常简单：我们可以使用 CloudML 引擎简单地调用培训步骤。 在此示例中，培训人员代码在 us-central1 区域中运行 1000 次迭代。 输入数据是从存储桶中提取的，而输出桶将被提交到其他存储桶中。
+3.  提交训练工作非常简单：我们可以使用 CloudML 引擎简单地调用训练步骤。 在此示例中，训练人员代码在 us-central1 区域中运行 1000 次迭代。 输入数据是从存储桶中提取的，而输出桶将被提交到其他存储桶中。
 
 ```py
 JOB_NAME="job_$(date +%Y%m%d_%H%M%S)"
@@ -621,8 +621,8 @@ gcloud ml-engine jobs submit training ${JOB_NAME} \
  --train_steps 10000
 ```
 
-4.  如果需要，您可以通过访问 [https://pantheon.google.com/mlengine/](https://pantheon.google.com/mlengine/) 中的 CloudML 控制台来控制培训过程。
-5.  培训结束后，就可以直接从 CloudML 服务模型了
+4.  如果需要，您可以通过访问 [https://pantheon.google.com/mlengine/](https://pantheon.google.com/mlengine/) 中的 CloudML 控制台来控制训练过程。
+5.  训练结束后，就可以直接从 CloudML 服务模型了
 
 ```py
 MODEL_NAME=MNIST

docs/tf-1x-dl-cookbook/13.md

@@ -30,7 +30,7 @@ Quoc 和 Barret 将 AutoML 技术用于神经体系结构搜索应用于 Penn Tr
 
 # 元学习新任务
 
-可以对元学习系统进行培训以完成大量任务，然后对其元学习新任务的能力进行测试。 这种元学习的一个著名例子是在高级 CNN 章节中讨论的所谓转移学习，其中网络可以从相对较小的数据集中成功学习基于图像的新任务。 但是，对于诸如语音，语言和文本之类的非视觉领域，没有类似的预训练方案。
+可以对元学习系统进行训练以完成大量任务，然后对其元学习新任务的能力进行测试。 这种元学习的一个著名例子是在高级 CNN 章节中讨论的所谓转移学习，其中网络可以从相对较小的数据集中成功学习基于图像的新任务。 但是，对于诸如语音，语言和文本之类的非视觉领域，没有类似的预训练方案。
 
 *用于快速适应深度网络的模型不可知元学习*，切尔西·芬恩（Chelsea Finn），彼得·阿比尔（Siety Levine），2017 年， [https://arxiv.org/abs/1703.03400](https://arxiv.org/abs/1703.03400) 提出了一个模型 -不可知论方法的名称为 MAML，它与经过梯度下降训练的任何模型兼容，并且适用于各种不同的学习问题，包括分类，回归和强化学习。 元学习的目标是针对各种学习任务训练模型，以便仅使用少量训练样本即可解决新的学习任务。 元学习器旨在找到一种可以快速（以很少的步骤）并有效地（仅使用几个示例）快速适应各种问题的初始化。 用参数为θ的参数化函数 f <sub>θ</sub>表示的模型。 当适应新任务 T <sub>i</sub> 时，模型参数θ变为θ <sub>i</sub> <sup>〜</sup>。 在 MAML 中，使用对任务 T <sub>i</sub> 的一个或多个梯度下降更新来计算更新的参数向量θ <sub>i</sub> <sup>'</sup>。
 
@@ -98,7 +98,7 @@ L ![](img/32f13c94-c144-4116-bd64-e97805948eb6.png)
 
 ●`visualize.py`：这只是用于可视化结果的包装。
 
-经过前 100,000 个培训步骤，结果是：
+经过前 100,000 个训练步骤，结果是：
 
 ![](img/8b5c32c0-e504-4d4d-bdaf-24d3eb4ccef3.png)