2020-12-27 14:58:03

new/begin-app-dev-tf-keras/2.md

@@ -27,7 +27,7 @@
 
 卷积神经网络因处理具有网格状结构的问题而臭名昭著。 它们最初是为了对图像进行分类而创建的，但已用于许多其他领域，从语音识别到自动驾驶车辆。
 
-CNN 的基本见解是将紧密相关的数据用作培训过程的要素，而不仅仅是单个数据输入。 这个想法在图像的上下文中特别有效，因为位于另一个像素右边的一个像素也与该像素有关，因为它们构成了较大合成的部分。 在这种情况下，网络正在训练预测该组成。 因此，将几个像素组合在一起比单独使用单个像素更好。
+CNN 的基本见解是将紧密相关的数据用作训练过程的要素，而不仅仅是单个数据输入。 这个想法在图像的上下文中特别有效，因为位于另一个像素右边的一个像素也与该像素有关，因为它们构成了较大合成的部分。 在这种情况下，网络正在训练预测该组成。 因此，将几个像素组合在一起比单独使用单个像素更好。
 
 **卷积**的名称是，以表示此过程的数学表达式：
 
@@ -279,7 +279,7 @@ lambda x: normalizations.point_relative_normalization(x))
 
 ![Activity 3 – Exploring the Bitcoin Dataset and Preparing Data for Model](img/image02_26.jpg)
 
-图 14：使用几周来创建培训和测试集
+图 14：使用几周来创建训练和测试集
 
 最后，将导航到`Storing Output`部分，并将过滤后的变量保存到磁盘，如下所示：
 
@@ -400,7 +400,7 @@ Keras 用作较低级程序的接口； 在这种情况下，使用 TensorFlow
 model.save('bitcoin_lstm_v0.h5')
 ```
 
-模型`'bitcoin_lstm_v0.h5'`尚未训练。 如果在没有事先培训的情况下保存模型，则只能有效地保存模型的架构。 稍后可以使用 Keras 的`load_model()`函数来加载相同的模型，如下所示：
+模型`'bitcoin_lstm_v0.h5'`尚未训练。 如果在没有事先训练的情况下保存模型，则只能有效地保存模型的架构。 稍后可以使用 Keras 的`load_model()`函数来加载相同的模型，如下所示：
 
 ```py
 1  model = keras.models.load_model('bitcoin_lstm_v0.h5')
@@ -434,7 +434,7 @@ model.save('bitcoin_lstm_v0.h5')
 
 *   网络架构
 *   网络有多少层和神经元
-*   培训过程中将使用多少数据
+*   训练过程中将使用多少数据
 
 其他因素也可能极大地影响网络训练所需的时间，但是神经网络在解决业务问题时可以进行的大多数优化来自探索这三个方面。
 

new/begin-app-dev-tf-keras/3.md

@@ -122,7 +122,7 @@ TensorBoard 擅长评估神经网络。 正如“第 1 课”，“神经网络
 
 # 实现模型评估指标
 
-在回归和分类问题中，我们将输入数据集分为其他三个数据集：训练，验证和测试。 训练和验证集都用于训练网络。 网络将训练集用作输入，损失函数将验证集用作输入，以将神经网络的输出与实际数据进行比较，计算预测的错误程度。 最后，在对网络进行培训之后，可以使用测试集来测量网络如何处理从未见过的数据。
+在回归和分类问题中，我们将输入数据集分为其他三个数据集：训练，验证和测试。 训练和验证集都用于训练网络。 网络将训练集用作输入，损失函数将验证集用作输入，以将神经网络的输出与实际数据进行比较，计算预测的错误程度。 最后，在对网络进行训练之后，可以使用测试集来测量网络如何处理从未见过的数据。
 
 ### 注意
 
@@ -165,7 +165,7 @@ Keras 提供了`model.evaluate(),`方法，该方法使针对测试集评估训
 
 我们还在“第 2 课”，“模型结构”并将经过训练的网络存储在磁盘上（`bitcoin_lstm_v0).` 我们现在可以在测试集中的 19 周数据中的每一个中使用`evaluate()`方法，并检查第一个神经网络的性能。
 
-为了做到这一点，我们必须在前几周提供 76 个。 我们之所以必须这样做，是因为我们的网络已经过训练，可以准确地使用 76 周的连续数据来预测一周的数据（在第 4 课，“产品化”中）。当我们将神经网络部署为 Web 应用程序时，我们将通过定期对网络进行较大的定期培训来解决此问题：
+为了做到这一点，我们必须在前几周提供 76 个。 我们之所以必须这样做，是因为我们的网络已经过训练，可以准确地使用 76 周的连续数据来预测一周的数据（在第 4 课，“产品化”中）。当我们将神经网络部署为 Web 应用程序时，我们将通过定期对网络进行较大的定期训练来解决此问题：
 
 ```py
  combined_set = np.concatenate((train_data, test_data), axis=1)
@@ -417,7 +417,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
 在本节中，我们学习了如何使用损失函数评估网络。 我们了解到，损失函数是神经网络的关键元素，因为它们在每个时期评估网络的性能，并且是将调整传播回层和节点的起点。 我们还探讨了为什么某些损失函数可能难以解释（例如 MSE）的原因，并开发了使用其他两个函数（RMSE 和 MAPE）的策略来解释 LSTM 模型的预测结果。
 
-最重要的是，本课以一个活跃的培训环境结束。 我们现在拥有一个可以训练深度学习模型并不断评估其结果的系统。 当我们在下一个会话中转向优化我们的网络时，这将是关键。
+最重要的是，本课以一个活跃的训练环境结束。 我们现在拥有一个可以训练深度学习模型并不断评估其结果的系统。 当我们在下一个会话中转向优化我们的网络时，这将是关键。
 
 ### 超参数优化
 
@@ -732,7 +732,7 @@ L2 正则化使用`λ`参数来确定对模型神经元的惩罚程度。 通常
 
     我们在本节中使用了`tanh`功能，但是请随时尝试其他激活函数。 查看[这个页面](https://keras.io/activations/)上可用的列表，然后尝试其他可能性。
 
-    我们的最终选择是尝试不同的正则化策略。 这显然更加复杂，并且可能需要花费一些迭代才能注意到任何收益，尤其是数据量很少时。 此外，添加正则化策略通常会增加网络的培训时间。
+    我们的最终选择是尝试不同的正则化策略。 这显然更加复杂，并且可能需要花费一些迭代才能注意到任何收益，尤其是数据量很少时。 此外，添加正则化策略通常会增加网络的训练时间。
 
 7.  现在，导航至笔记本中的标题**正则化策略**。 在本部分中，您需要实现`Dropout()`正则化策略。 找到合适的位置放置该步骤并将其实现到我们的模型中。
 8.  您也可以在这里尝试进行 L2 正则化（或将两者结合使用）。 与`Dropout()`相同，但现在使用`ActivityRegularization(l2=0.0001)`。

new/handson-dl-img-tf/3.md

@@ -89,7 +89,7 @@ ReLu 非线性函数-大于零。
 
 加载数据中
 
-我们加载培训和测试数据以及培训和测试输出。 然后，我们进行归一化，这意味着将除以最大值，我们知道它将是`255`。 然后，我们将输出变量分解为分类编码或一键编码。 对于我们的训练和测试数据集，我们以完全相同的方式执行这两件事（归一化和一次性编码）。 在尝试将其用于我们的机器学习模型之前，必须以相同的方式准备好所有数据，这一点很重要。 这是有关形状的快速说明。 请注意，训练数据（`x`和`y`）的初始编号相同：
+我们加载训练和测试数据以及训练和测试输出。 然后，我们进行归一化，这意味着将除以最大值，我们知道它将是`255`。 然后，我们将输出变量分解为分类编码或一键编码。 对于我们的训练和测试数据集，我们以完全相同的方式执行这两件事（归一化和一次性编码）。 在尝试将其用于我们的机器学习模型之前，必须以相同的方式准备好所有数据，这一点很重要。 这是有关形状的快速说明。 请注意，训练数据（`x`和`y`）的初始编号相同：
 
 ![](img/7b333062-bed5-400c-9745-34d7cdc2d593.png)
 
@@ -107,7 +107,7 @@ ReLu 非线性函数-大于零。
 
 过拟合本质上是指您的机器学习模型存储一组输入时。 您可以将其视为一个非常复杂的哈希表，该哈希表已使用大量数字对输入和输出映射进行了编码。 但是，通过机器学习，即使我们可以轻松拥有一个哈希表，我们也不需要哈希表。 相反，我们希望有一个模型可以处理未知输入，然后预测适当的输出。 测试数据代表那些未知的输入。 当您跨训练数据训练模型并提供测试数据时，可以使用测试数据来验证您的机器学习模型可以处理和预测从未见过的数据。
 
-好吧，既然我们已经加载了培训和测试数据，我们将继续学习`Dropout`和`Flatten`，并建立一个实际的神经网络。
+好吧，既然我们已经加载了训练和测试数据，我们将继续学习`Dropout`和`Flatten`，并建立一个实际的神经网络。
 
 # 丢弃和扁平化
 
@@ -161,7 +161,7 @@ Keras 功能模型
 
 我们还将介绍可训练的参数（这些是求解器学习的参数），不可训练的参数（模型中不需要训练的其他参数），最后，超参数（传统的求解器不能学习的参数）。
 
-在我们的“模型摘要输出”的屏幕截图中，请注意屏幕截图底部代码中突出显示的部分中可训练参数的数量。 这就是我们的模型`adam`优化器与我们的分类交叉熵`loss`函数一起将在模型内部包含的单个浮点数的数目，以便找到可能的最佳参数值。 因此，此可训练的参数编号是我们的`optimizer`函数学习的唯一编号集合。 但是，此代码和前面的屏幕快照中还有许多其他数字。 这些不可训练的参数呢？ 在我们当前的模型中，有零个不可训练参数。 但是，Keras 中不同种类的图层可能具有恒定值，因此它们将显示为不可训练的。 再次，这只是意味着不需要对其进行培训，并且我们的`optimizer`函数将不会尝试更改其值。
+在我们的“模型摘要输出”的屏幕截图中，请注意屏幕截图底部代码中突出显示的部分中可训练参数的数量。 这就是我们的模型`adam`优化器与我们的分类交叉熵`loss`函数一起将在模型内部包含的单个浮点数的数目，以便找到可能的最佳参数值。 因此，此可训练的参数编号是我们的`optimizer`函数学习的唯一编号集合。 但是，此代码和前面的屏幕快照中还有许多其他数字。 这些不可训练的参数呢？ 在我们当前的模型中，有零个不可训练参数。 但是，Keras 中不同种类的图层可能具有恒定值，因此它们将显示为不可训练的。 再次，这只是意味着不需要对其进行训练，并且我们的`optimizer`函数将不会尝试更改其值。
 
 那么，什么是超参数？ 好吧，非常简单，超参数是模型本身之外的值（参数）。 因此，认为超参数最简单的是实际的模型结构。 在这种情况下，我们创建层的次数是一个超参数，层的大小是一个超参数，我们在密集层中选择的`32`单位是一个超参数，`0.1`的丢弃设置是超参数，甚至激活函数本身（例如，选择`relu`而不是`sigmoid`）都是超参数。 现在您可能在想，“请稍等，我不得不在这里选择很多参数；我以为机器应该在学习”。 它是！ 但是，诀窍在于`optimizer`无法学习我们需要了解的所有知识，以组成一个最佳模型。
 

new/handson-meta-learn-py/01.md

@@ -16,7 +16,7 @@
 
 近年来，借助强大的算法（如生成对抗网络和胶囊网络），深度学习取得了飞速的发展。 但是深度神经网络的问题在于，我们需要拥有大量的训练集来训练我们的模型，而当我们只有很少的数据点时，它将突然失败。 假设我们训练了一个深度学习模型来执行任务`A`。 现在，当我们有一个新任务`B`，与`A`密切相关时，我们不能使用相同的模型。 我们需要从头开始为任务`B`训练模型。 因此，对于每项任务，我们都需要从头开始训练模型，尽管它们可能是相关的。
 
-深度学习真的是真正的 AI 吗？ 好吧，不是。 人类如何学习？ 我们将学习概括为多个概念并从中学习。 但是当前的学习算法仅能完成一项任务。 这就是元学习的用武之地。元学习产生了一个通用的 AI 模型，该模型可以学习执行各种任务，而无需从头开始进行培训。 我们使用很少的数据点在各种相关任务上训练我们的元学习模型，因此对于新的相关任务，它可以利用从先前任务中获得的学习知识，而不必从头开始进行训练。 许多研究人员和科学家认为，元学习可以使我们更接近实现 AGI。 在接下来的部分中，我们将确切学习元学习模型如何元学习过程。
+深度学习真的是真正的 AI 吗？ 好吧，不是。 人类如何学习？ 我们将学习概括为多个概念并从中学习。 但是当前的学习算法仅能完成一项任务。 这就是元学习的用武之地。元学习产生了一个通用的 AI 模型，该模型可以学习执行各种任务，而无需从头开始进行训练。 我们使用很少的数据点在各种相关任务上训练我们的元学习模型，因此对于新的相关任务，它可以利用从先前任务中获得的学习知识，而不必从头开始进行训练。 许多研究人员和科学家认为，元学习可以使我们更接近实现 AGI。 在接下来的部分中，我们将确切学习元学习模型如何元学习过程。
 
 # 元学习和少样本
 
@@ -155,7 +155,7 @@
 3.  什么是支持集？
 4.  什么是查询集？
 5.  基于度量的学习称为什么？
-6.  我们如何进行元学习培训？
+6.  我们如何进行元学习训练？
 
 # 进一步阅读
 

new/handson-meta-learn-py/03.md

@@ -37,7 +37,7 @@
 
 在找到类原型与查询点嵌入之间的距离后，我们将 softmax 应用于该距离并获得概率。 由于我们有狮子，大象和狗这三个类，因此我们将获得三个概率。 因此，概率最高的类别将是我们查询点的类别。
 
-由于我们希望网络从几个数据点中学习，也就是说，我们希望执行几次快照学习，因此我们以相同的方式训练网络。 因此，我们使用了间歇式训练-对于每个情节，我们从数据集中的每个班级随机采样一些数据点，我们称其为支持集，仅使用支持集而不是整个数据集来训练网络。 同样，我们从数据集中随机抽取一个点作为查询点，并尝试预测其类别。 因此，通过这种方式，我们的网络受到了如何从较小的数据点集中学习的培训。
+由于我们希望网络从几个数据点中学习，也就是说，我们希望执行几次快照学习，因此我们以相同的方式训练网络。 因此，我们使用了间歇式训练-对于每个情节，我们从数据集中的每个班级随机采样一些数据点，我们称其为支持集，仅使用支持集而不是整个数据集来训练网络。 同样，我们从数据集中随机抽取一个点作为查询点，并尝试预测其类别。 因此，通过这种方式，我们的网络受到了如何从较小的数据点集中学习的训练。
 
 下图显示了我们原型网络的整体流程。 如您所见，首先，我们将为支持集中的所有数据点生成嵌入，并通过在类中获取数据点的平均嵌入来构建类原型。 我们还为查询点生成嵌入。 然后，我们计算类原型与查询点嵌入之间的距离。 我们使用欧几里得距离作为距离度量。 然后，我们将 softmax 应用于此距离并获得概率。 如下图所示，由于我们的查询点是狮子，因此狮子的概率很高，为 0.9：
 

new/handson-meta-learn-py/06.md

@@ -226,7 +226,7 @@ def __init__(self):
         return 1.0 / (1 + np.exp(-a))
 ```
 
-现在，让我们开始培训：
+现在，让我们开始训练：
 
 ```py
     def train(self):
@@ -457,7 +457,7 @@ Sampling Next Batch of Tasks
 
 # MAML 强化学习
 
-如何在**强化学习**（**RL**）设置中应用 MAML？ 在 RL 中，我们的目标是找到正确的策略函数，该功能将告诉我们在每种状态下要执行哪些操作。 但是我们如何在 RL 中应用元学习呢？ 假设我们训练了智能体以解决两臂老虎机问题。 但是，我们不能使用相同的智能体来解决四臂老虎机问题。 我们必须再次从头开始训练智能体，以解决这个新的四臂老虎机问题。 当另一名`n`臂老虎机进来时，情况也是如此。我们一直在从头训练智能体以解决新问题，即使它与智能体已经学会解决的问题密切相关。 因此，代替执行此操作，我们可以应用元学习并在一组相关任务上对智能体进行培训，以便智能体可以利用其先前的知识在最短的时间内学习新的相关任务，而无需从头开始进行培训。
+如何在**强化学习**（**RL**）设置中应用 MAML？ 在 RL 中，我们的目标是找到正确的策略函数，该功能将告诉我们在每种状态下要执行哪些操作。 但是我们如何在 RL 中应用元学习呢？ 假设我们训练了智能体以解决两臂老虎机问题。 但是，我们不能使用相同的智能体来解决四臂老虎机问题。 我们必须再次从头开始训练智能体，以解决这个新的四臂老虎机问题。 当另一名`n`臂老虎机进来时，情况也是如此。我们一直在从头训练智能体以解决新问题，即使它与智能体已经学会解决的问题密切相关。 因此，代替执行此操作，我们可以应用元学习并在一组相关任务上对智能体进行训练，以便智能体可以利用其先前的知识在最短的时间内学习新的相关任务，而无需从头开始进行训练。
 
 在 RL 中，我们可以将轨迹称为包含一系列观察和动作的元组。 因此，我们在这些轨迹上训练模型以学习最佳策略。 但是，同样，我们应该使用哪种算法来训练我们的模型？ 对于 MAML，我们可以使用可以通过梯度下降训练的任何 RL 算法。 我们使用策略梯度来训练我们的模型。 策略梯度通过直接将带有某些参数`θ`的策略`π`参数化为`π[θ]`来找到最佳策略。 因此，使用 MAML，我们尝试找到可在各个任务之间推广的最佳参数`θ`。
 

new/handson-meta-learn-py/07.md

@@ -27,7 +27,7 @@
 
 我们通常将参数`θ`设置为某个随机值，并在训练过程中尝试找到最佳值，然后将学习率`α`的值设置为一个小数值，或者将其随时间衰减，以及跟随梯度的更新方向。 我们是否可以通过元学习来学习梯度下降的所有这些关键要素，以便可以从几个数据点快速学习？ 在上一章中，我们已经看到 MAML 如何找到可在各个任务之间推广的最佳初始参数`θ`。 有了最佳的初始参数，我们就可以减少梯度步骤，并快速学习新任务。
 
-因此，现在我们是否可以学习最佳的学习率和更新方向，从而可以跨任务进行概括，从而实现更快的收敛和培训？ 让我们看看如何通过将其与 MAML 进行比较在元 SGD 中学习。 如果您还记得，请在 MAML 内循环中，通过最小化梯度下降带来的损失，找到每个任务`T[i]`的最佳参数`θ'[i]`：
+因此，现在我们是否可以学习最佳的学习率和更新方向，从而可以跨任务进行概括，从而实现更快的收敛和训练？ 让我们看看如何通过将其与 MAML 进行比较在元 SGD 中学习。 如果您还记得，请在 MAML 内循环中，通过最小化梯度下降带来的损失，找到每个任务`T[i]`的最佳参数`θ'[i]`：
 
 ![](img/fbd9f509-c789-4ef5-bfa1-c7eee18e09a3.png)
 

new/handson-meta-learn-py/09.md

@@ -167,7 +167,7 @@ MIL 中涉及的步骤如下：
 
 我们已经了解了 MAML 如何帮助我们找到最佳的初始模型参数，以便可以将其推广到许多其他相关任务。 我们还了解了 MAML 如何在监督学习和强化学习设置中使用。 但是，我们如何在没有数据点标签的无监督学习环境中应用 MAML？ 因此，我们引入了一种称为 **CACTUS** 的新算法，该算法是`Clustering to Automatically Generate Tasks for Unsupervised Model Agnostic Meta Learning`的缩写。
 
-假设我们有一个数据集`D`，其中包含未标记的示例：`D = {x[1], ..., x[n]}`。 现在，我们可以使用该数据集做什么？ 我们如何在该数据集上应用 MAML？ 首先，使用 MAML 进行培训需要什么？ 我们需要按任务分布，并通过对一批任务进行采样并找到最佳模型参数来训练模型。 任务应包含功能及其标签。 但是，如何从未标记的数据集中生成任务？
+假设我们有一个数据集`D`，其中包含未标记的示例：`D = {x[1], ..., x[n]}`。 现在，我们可以使用该数据集做什么？ 我们如何在该数据集上应用 MAML？ 首先，使用 MAML 进行训练需要什么？ 我们需要按任务分布，并通过对一批任务进行采样并找到最佳模型参数来训练模型。 任务应包含功能及其标签。 但是，如何从未标记的数据集中生成任务？
 
 在下一部分中，让我们看看如何使用 CACTUS 生成任务。 生成任务后，我们可以轻松地将其插入 MAML 算法并找到最佳模型参数。
 
@@ -187,7 +187,7 @@ MIL 中涉及的步骤如下：
 
 # 概念空间中的元学习
 
-现在，我们将看到如何使用深度元学习在概念空间中元学习。 首先，我们如何进行元学习？ 我们在每个任务中抽样一批相关任务和一些`k`数据点，并训练我们的元学习者。 我们可以将深度学习的力量与元学习结合起来，而不仅仅是使用我们的原始元学习技术进行培训。 因此，当我们对一批任务以及每个任务中的一些`k`数据点进行采样时，我们将使用深度神经网络学习每个`k`数据点的表示形式，然后对这些表示进行元学习。
+现在，我们将看到如何使用深度元学习在概念空间中元学习。 首先，我们如何进行元学习？ 我们在每个任务中抽样一批相关任务和一些`k`数据点，并训练我们的元学习者。 我们可以将深度学习的力量与元学习结合起来，而不仅仅是使用我们的原始元学习技术进行训练。 因此，当我们对一批任务以及每个任务中的一些`k`数据点进行采样时，我们将使用深度神经网络学习每个`k`数据点的表示形式，然后对这些表示进行元学习。
 
 我们的框架包含三个组件：
 
@@ -201,7 +201,7 @@ MIL 中涉及的步骤如下：
 
 ![](img/ab57f770-1198-4573-a9ab-a4e9ba34bb85.png)
 
-但是，为什么我们要这样做呢？ 代替在原始数据集上执行元学习，我们在概念空间中执行元学习。 我们如何学习这些概念？ 这些概念由概念生成器通过学习输入的嵌入来生成。 因此，我们在各种相关任务上训练概念生成器和元学习器； 与此相伴的是，我们通过向概念生成器提供外部数据集，从而通过概念判别器改进了概念生成器，以便可以更好地学习概念。 通过联合培训过程，我们的概念生成器可以学习各种概念并在相关任务上表现更好； 我们输入外部数据集只是为了增强概念生成器的性能，当我们输入一组新的输入时，它会不断学习。 因此，这是一个终身学习系统。
+但是，为什么我们要这样做呢？ 代替在原始数据集上执行元学习，我们在概念空间中执行元学习。 我们如何学习这些概念？ 这些概念由概念生成器通过学习输入的嵌入来生成。 因此，我们在各种相关任务上训练概念生成器和元学习器； 与此相伴的是，我们通过向概念生成器提供外部数据集，从而通过概念判别器改进了概念生成器，以便可以更好地学习概念。 通过联合训练过程，我们的概念生成器可以学习各种概念并在相关任务上表现更好； 我们输入外部数据集只是为了增强概念生成器的性能，当我们输入一组新的输入时，它会不断学习。 因此，这是一个终身学习系统。
 
 # 关键组件
 

new/handson-meta-learn-py/10.md

@@ -2,7 +2,7 @@
 
 # 第 1 章：元学习简介
 
-1.  元学习产生了一种通用的 AI 模型，该模型可以学习执行各种任务，而无需从头开始进行培训。 我们使用几个数据点在各种相关任务上训练我们的元学习模型，因此对于新的但相关的任务，该模型可以利用从先前任务中学到的知识而不必从头开始进行训练。
+1.  元学习产生了一种通用的 AI 模型，该模型可以学习执行各种任务，而无需从头开始进行训练。 我们使用几个数据点在各种相关任务上训练我们的元学习模型，因此对于新的但相关的任务，该模型可以利用从先前任务中学到的知识而不必从头开始进行训练。
 2.  从更少的数据点学习称为**少样本学习**或 **K 次学习**，其中`k`表示在数据集的每个类别中的数据点的数量。
 3.  为了使我们的模型从一些数据点中学习，我们将以相同的方式对其进行训练。 因此，当我们有一个数据集`D`时，我们从数据集中存在的每个类中采样一些数据点，并将其称为支持集。
 4.  我们从与支持集不同的每个类中采样不同的数据点，并将其称为查询集。

new/handson-rl-py/02.md

@@ -255,7 +255,7 @@ for _ in range(1000):
 
 ![](img/00012.gif)
 
-OpenAI Gym 提供了许多模拟环境，用于培训，评估和构建我们的智能体。 我们可以通过检查其网站或输入以下内容来检查可用的环境，这些将列出可用的环境：
+OpenAI Gym 提供了许多模拟环境，用于训练，评估和构建我们的智能体。 我们可以通过检查其网站或输入以下内容来检查可用的环境，这些将列出可用的环境：
 
 ```py
 from gym import envs

new/handson-rl-py/12.md

@@ -646,7 +646,7 @@ last_frame_count = 0.0
 state = env.reset()
 ```
 
-现在，让我们开始培训：
+现在，让我们开始训练：
 
 ```py
 while num_frames <= TOTAL_FRAMES+1:
@@ -676,7 +676,7 @@ while num_frames <= TOTAL_FRAMES+1:
     state = next_state
 ```
 
-培训智能体：
+训练智能体：
 
 ```py
     if num_frames>=TRAIN_AFTER_FRAMES:

new/handson-rl-py/13.md

@@ -49,7 +49,7 @@ I2A 的架构如下：
 
 向人类学习是 RL 的重大突破。 该算法由 OpenAI 和 DeepMind 的研究人员提出。 该算法背后的思想是使智能体根据人的反馈进行学习。 最初，智能体会随机行动，然后将执行动作的智能体的两个视频片段提供给人类。 人们可以检查视频剪辑，并告诉智能体哪个视频剪辑更好，也就是说，智能体在哪个视频中更好地执行任务，并将其实现目标。 给出反馈后，智能体将尝试执行人类喜欢的操作并相应地设置奖励。 设计奖励功能是 RL 中的主要挑战之一，因此，与智能体进行人为互动可以直接帮助我们克服挑战，也可以最大程度地减少编写复杂目标功能的过程。
 
-培训过程如下图所示：
+训练过程如下图所示：
 
 ![](img/00421.gif)
 
@@ -66,9 +66,9 @@ I2A 的架构如下：
 
 # 来自演示的深度 Q 学习
 
-我们已经了解了很多有关 DQN 的知识。 我们从原始 DQN 开始，然后看到了各种改进，例如双重 DQN，决斗的网络架构和优先级的经验回放。 我们还学会了构建 DQN 来玩 Atari 游戏。 我们将智能体与环境的交互存储在经验缓冲区中，并使智能体从这些经验中学习。 但是问题是，我们花了很多培训时间来提高性能。 对于在模拟环境中学习，这很好，但是当我们让智能体在现实环境中学习时，会引起很多问题。 为了克服这个问题，谷歌公司 DeepMind 的研究人员在演示（**DQfd**）的基础上，对 DQN 进行了改进，称为**深度 Q 学习**。
+我们已经了解了很多有关 DQN 的知识。 我们从原始 DQN 开始，然后看到了各种改进，例如双重 DQN，决斗的网络架构和优先级的经验回放。 我们还学会了构建 DQN 来玩 Atari 游戏。 我们将智能体与环境的交互存储在经验缓冲区中，并使智能体从这些经验中学习。 但是问题是，我们花了很多训练时间来提高性能。 对于在模拟环境中学习，这很好，但是当我们让智能体在现实环境中学习时，会引起很多问题。 为了克服这个问题，谷歌公司 DeepMind 的研究人员在演示（**DQfd**）的基础上，对 DQN 进行了改进，称为**深度 Q 学习**。
 
-如果我们已经有了一些演示数据，则可以将这些演示直接添加到经验回放缓冲区中。 例如，考虑一个学习玩 Atari 游戏的智能体。 如果我们已经有了一些演示数据来告诉我们的智能体，哪个状态更好，哪个动作可以提供良好的回报，那么智能体可以直接使用此数据进行学习。 即使是少量的演示，也可以提高智能体的表现并最大程度地减少培训时间。 由于演示的数据将直接添加到优先经验重放缓冲区中，因此智能体可以从演示数据中使用的数据量以及智能体可以从其自己的交互中用于学习的数据量将由优先经验重放来控制缓冲区，因为经验将被优先考虑。
+如果我们已经有了一些演示数据，则可以将这些演示直接添加到经验回放缓冲区中。 例如，考虑一个学习玩 Atari 游戏的智能体。 如果我们已经有了一些演示数据来告诉我们的智能体，哪个状态更好，哪个动作可以提供良好的回报，那么智能体可以直接使用此数据进行学习。 即使是少量的演示，也可以提高智能体的表现并最大程度地减少训练时间。 由于演示的数据将直接添加到优先经验重放缓冲区中，因此智能体可以从演示数据中使用的数据量以及智能体可以从其自己的交互中用于学习的数据量将由优先经验重放来控制缓冲区，因为经验将被优先考虑。
 
 DQfd 中的损失函数将是各种损失的总和。 为了防止我们的智能体过度适合演示数据，我们在网络权重上计算 L2 正则化损失。 我们像往常一样计算 TD 损失，也计算监督损失，以了解我们的智能体如何从演示数据中学习。 本文的作者在 DQfd 和各种环境下进行了实验，并且 DQfd 的性能比双重决斗 DQN 优先排序的性能更好，更快。
 
@@ -167,7 +167,7 @@ RL 周围有各种改进和进步。 现在，您已经阅读完本书，可以
 
 # 总结
 
-在本章中，我们了解了 RL 的一些最新进展。 我们看到了 I2A 架构如何将想象力核心用于前瞻性计划，然后如何根据人的喜好来训练智能体。 我们还了解了 DQfd，它可以通过从演示中学习来提高 DQN 的性能并减少其培训时间。 然后，我们研究了事后的经验回放，从中我们了解了智能体如何从失败中学习。
+在本章中，我们了解了 RL 的一些最新进展。 我们看到了 I2A 架构如何将想象力核心用于前瞻性计划，然后如何根据人的喜好来训练智能体。 我们还了解了 DQfd，它可以通过从演示中学习来提高 DQN 的性能并减少其训练时间。 然后，我们研究了事后的经验回放，从中我们了解了智能体如何从失败中学习。
 
 接下来，我们学习了层次 RL，其中目标被解压缩为子目标层次。 我们了解了反向 RL，其中智能体尝试根据给定策略来学习奖励函数。 RL 每天都在以有趣的进步发展。 既然您已经了解了各种强化学习算法，则可以构建智能体以执行各种任务并为 RL 研究做出贡献。
 

new/handson-rl-py/14.md

@@ -8,7 +8,7 @@
 4.  策略函数指定在每个状态下要执行的操作，而值函数指定每个状态的值。
 5.  在基于模型的智能体中，使用以前的经验，而在无模型的学习中，则不会有任何以前的经验。
 6.  确定性的，随机的，完全可观察的，部分可观察的，离散的连续的，事件的和非事件的。
-7.  OpenAI Universe 为培训 RL 智能体提供了丰富的环境。
+7.  OpenAI Universe 为训练 RL 智能体提供了丰富的环境。
 8.  请参阅 RL 的“应用”部分。
 
 # 第 2 章
@@ -127,7 +127,7 @@
 1.  智能体中的想象力指定了采取任何行动之前的可视化和计划。
 2.  想象力核心由执行想象力的策略网络和环境模型组成。
 3.  智能体反复从人类那里获得反馈，并根据人类的喜好改变目标。
-4.  DQfd 使用一些演示数据进行培训，因为 DQN 并未预先使用任何演示数据。
+4.  DQfd 使用一些演示数据进行训练，因为 DQN 并未预先使用任何演示数据。
 5.  请参阅**事后经验回放**（**HER**）部分。
 
 6.  提出了**分层强化学习**（**HRL**），以解决维数诅咒，其中我们将大问题解压缩为层次结构中的小子问题

new/intel-proj-py/02.md

@@ -10,7 +10,7 @@
 *   学习制定适合当前问题的成本函数
 *   定义适当的度量标准以衡量训练模型的性能
 *   使用仿射变换生成其他数据
-*   与适当的学习率，优化器的选择等有关的培训错综复杂
+*   与适当的学习率，优化器的选择等有关的训练错综复杂
 *   查看端到端 Python 实现
 
 # 技术要求
@@ -421,13 +421,13 @@ reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.50,
 'kera1-5fold-run-01-v1-fold-' + str('%02d' % (k + 1)) + '-run-' + str('%02d' % (1 + 1)) + '.check'
 ```
 
-在`keras-5fold-run-01-v1-epochs_ib.log` 日志文件中跟踪训练过程的每个时期的验证日志损失，如果验证日志损失有所改善，为了保存模型，请参考该文件， 或决定何时降低学习率或停止培训。
+在`keras-5fold-run-01-v1-epochs_ib.log` 日志文件中跟踪训练过程的每个时期的验证日志损失，如果验证日志损失有所改善，为了保存模型，请参考该文件， 或决定何时降低学习率或停止训练。
 
 通过使用`keras save`函数在用户定义的路径中保存每个折叠中的模型，而在推理过程中，使用`keras.load_model`函数将模型加载到内存中。
 
 # Python 实现训练过程
 
-以下 Python 代码块显示了培训过程的端到端实现。 它由前面各节中讨论的所有功能块组成。 让我们首先调用所需的所有 Python 程序包，如下所示：
+以下 Python 代码块显示了训练过程的端到端实现。 它由前面各节中讨论的所有功能块组成。 让我们首先调用所需的所有 Python 程序包，如下所示：
 
 ```py
 import numpy as np
@@ -1188,7 +1188,7 @@ folds=5):
 python TransferLearning_reg.py --path '/media/santanu/9eb9b6dc-b380-486e-b4fd-c424a325b976/book AI/Diabetic Retinopathy/Extra/assignment2_train_dataset/' --class_folders '["class0","class1","class2","class3","class4"]' --dim 224 --lr 1e-4 --batch_size 32 --epochs 5 --initial_layers_to_freeze 10 --model InceptionV3 --folds 5 --outdir '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/'
 ```
 
-培训的输出日志如下：
+训练的输出日志如下：
 
 ```py
 Model saved to dest: {1: '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/InceptionV3___1', 2: '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/InceptionV3___2', 3: '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/InceptionV3___3', 4: '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/InceptionV3___4', 5: '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/InceptionV3___5'}

new/intel-proj-py/03.md

@@ -195,7 +195,7 @@
 
 # 神经机器翻译
 
-**神经机器翻译**（**NMT**）使用深度神经网络来执行从源语言到目标语言的机器翻译。 神经翻译机将源语言中的文本作为输入序列，并将其编码为隐藏的表示形式，然后将其解码回以生成目标语言中的翻译文本序列。 该 NMT 系统的主要优势之一是，整个机器翻译系统可以从端到端一起进行培训，这与基于规则的机器翻译系统和统计机器翻译系统不同。 一般而言，在[ 神经翻译机架构。
+**神经机器翻译**（**NMT**）使用深度神经网络来执行从源语言到目标语言的机器翻译。 神经翻译机将源语言中的文本作为输入序列，并将其编码为隐藏的表示形式，然后将其解码回以生成目标语言中的翻译文本序列。 该 NMT 系统的主要优势之一是，整个机器翻译系统可以从端到端一起进行训练，这与基于规则的机器翻译系统和统计机器翻译系统不同。 一般而言，在[ 神经翻译机架构。
 
 NMT 与其他传统方法相比的一些优点如下：
 
@@ -404,7 +404,7 @@ NMT 与其他传统方法相比的一些优点如下：
 
 ```
 
-从前面的统计数据可以看出，`40000`语料库中输入的英语单词的数量为`8658`，文本句子的数量为`8658`，而对应的法语单词的数量为`16297`。 这表明以下事实：每个英语单词平均发出大约两个法语单词。 同样，我们看到英语句子中的最大单词数为`7`，而法语句子中的最大单词数为`14`（如果您排除了我们在法语句子中添加的`[START]`和`[END]`字符） 培训目的。 这也证实了以下事实：平均而言，每个要翻译的英语句子将产生双倍的单词数。
+从前面的统计数据可以看出，`40000`语料库中输入的英语单词的数量为`8658`，文本句子的数量为`8658`，而对应的法语单词的数量为`16297`。 这表明以下事实：每个英语单词平均发出大约两个法语单词。 同样，我们看到英语句子中的最大单词数为`7`，而法语句子中的最大单词数为`14`（如果您排除了我们在法语句子中添加的`[START]`和`[END]`字符） 训练目的。 这也证实了以下事实：平均而言，每个要翻译的英语句子将产生双倍的单词数。
 
 让我们看一下神经翻译机的输入和目标的形状：
 

new/intel-proj-py/04.md

@@ -11,7 +11,7 @@
 *   我们将讨论 DiscoGAN 背后的工作原理和数学基础
 *   我们将比较和对比 DiscoGAN 与 CycleGAN，后者在架构和工作原理上非常相似
 *   我们将训练一个 DiscoGAN，该系统学习从给定的袋子素描中生成袋子的图像
-*   最后，我们将讨论与培训 DiscoGAN 有关的复杂性
+*   最后，我们将讨论与训练 DiscoGAN 有关的复杂性
 
 # 技术要求
 
@@ -481,7 +481,7 @@ def build_network(self):
 
 前四个损耗组成了判别器损耗，需要根据判别器的参数将其最小化。 ]。 最后两个损耗组成了生成器损耗，需要根据生成器的参数将其最小化。 。
 
-损失变量通过`tf.summary.scaler` 与 TensorBoard 绑定，以便可以在训练过程中监控这些损失，以确保以期望的​​方式减少损失。 稍后，我们将在培训进行时在 TensorBoard 中看到这些损失痕迹。
+损失变量通过`tf.summary.scaler` 与 TensorBoard 绑定，以便可以在训练过程中监控这些损失，以确保以期望的​​方式减少损失。 稍后，我们将在训练进行时在 TensorBoard 中看到这些损失痕迹。
 
 # 建立训练流程
 
@@ -702,7 +702,7 @@ Epoch: [ 0] [ 19/ 156] time: 13.7525
 
 2.  执行完步骤 1 中的命令后，导航到 TensorBoard 的`localhost:6006`站点：
 
-以下屏幕快照中展示了在项目中实现的 DiscoGAN 培训期间在 TensorBoard 中查看的一些生成器和判别器损耗的痕迹：
+以下屏幕快照中展示了在项目中实现的 DiscoGAN 训练期间在 TensorBoard 中查看的一些生成器和判别器损耗的痕迹：
 
 ![](img/8c1362f9-bf37-4c56-ac05-30bb6d00a579.png)
 

new/intel-proj-py/05.md

@@ -474,7 +474,7 @@ unk => A substitute for a word that is not included in the vocabulary
 
 在本节中，我们将所有部分放在一起以构建用于训练视频字幕模型的功能。
 
-首先，我们结合培训和测试数据集中的视频字幕，创建单词词汇词典。 完成此操作后，我们将结合两个 LSTM 调用`build_model`函数来创建视频字幕网络。 对于每个带有特定*开始*和*结束*的视频，都有多个输出视频字幕。 在每个批量中，从开始和结束的特定视频的输出视频字幕是从多个可用的视频字幕中随机选择的。 调整 LSTM 2 的输入文本标题，使其在时间步`N + 1`处的起始词为`<bos>`，而输出文本标题的结束词被调整为最终文本标签`<eos>`。 每个时间步长上的分类交叉熵损失之和被视为特定视频的总交叉熵损失。 在每个时间步中，我们计算完整单词词汇上的分类交叉熵损失，可以表示为：
+首先，我们结合训练和测试数据集中的视频字幕，创建单词词汇词典。 完成此操作后，我们将结合两个 LSTM 调用`build_model`函数来创建视频字幕网络。 对于每个带有特定*开始*和*结束*的视频，都有多个输出视频字幕。 在每个批量中，从开始和结束的特定视频的输出视频字幕是从多个可用的视频字幕中随机选择的。 调整 LSTM 2 的输入文本标题，使其在时间步`N + 1`处的起始词为`<bos>`，而输出文本标题的结束词被调整为最终文本标签`<eos>`。 每个时间步长上的分类交叉熵损失之和被视为特定视频的总交叉熵损失。 在每个时间步中，我们计算完整单词词汇上的分类交叉熵损失，可以表示为：
 
 ![](img/21a19e2b-fef3-4156-b1b2-8812e5a6b329.png)
 
@@ -671,7 +671,7 @@ python Video_seq2seq.py process_main --path_prj '/media/santanu/9eb9b6dc-b380-48
 | `out_steps` | `20` |
 | `h_dim` | `512` |
 
-培训的输出日志如下：
+训练的输出日志如下：
 
 ```py
 Batch starting index: 1728 Epoch: 99 loss: 17.723186 Elapsed time: 0.21822428703308105

new/intel-proj-py/06.md

@@ -409,7 +409,7 @@ RBM 的参数是可见层单位`i`与隐藏层单位之间的广义权重连接`
 
 # 处理输入
 
-每行中的输入评级文件记录包含字段`userId`，`movieId`，`rating`和`timestamp`。 我们处理每条记录以创建`numpy`数组形式的训练文件，其中三个维度分别与`userId`，`movieId`和`rating`有关。 从 1 到 5 的评级是一热编码的，因此沿评级维度的长度为 5。 我们使用 80% 的输入记录创建培训数据，而其余 20% 保留用于测试。 用户已评分的电影数量为`1682`。 培训文件包含`943`用户，因此培训数据的维度为`(943,1682,5)`。 培训文件中的每个用户都是 RBM 的培训记录，其中将包含用户已评分的几部电影和用户尚未评分的几部电影。 一些电影分级也已删除，将包含在测试文件中。 将对 RBM 进行可用分级的培训，在隐藏单元中捕获输入数据的隐藏结构，然后尝试从捕获的隐藏结构中为每个用户重建所有电影的输入分级。 我们还创建了两个字典，以将实际电影 ID 的交叉引用及其索引存储在训练/测试数据集中。 以下是用于创建培训和测试文件的详细代码：
+每行中的输入评级文件记录包含字段`userId`，`movieId`，`rating`和`timestamp`。 我们处理每条记录以创建`numpy`数组形式的训练文件，其中三个维度分别与`userId`，`movieId`和`rating`有关。 从 1 到 5 的评级是一热编码的，因此沿评级维度的长度为 5。 我们使用 80% 的输入记录创建训练数据，而其余 20% 保留用于测试。 用户已评分的电影数量为`1682`。 训练文件包含`943`用户，因此训练数据的维度为`(943,1682,5)`。 训练文件中的每个用户都是 RBM 的训练记录，其中将包含用户已评分的几部电影和用户尚未评分的几部电影。 一些电影分级也已删除，将包含在测试文件中。 将对 RBM 进行可用分级的训练，在隐藏单元中捕获输入数据的隐藏结构，然后尝试从捕获的隐藏结构中为每个用户重建所有电影的输入分级。 我们还创建了两个字典，以将实际电影 ID 的交叉引用及其索引存储在训练/测试数据集中。 以下是用于创建训练和测试文件的详细代码：
 
 ```py
 """
@@ -643,7 +643,7 @@ def next_batch(self):
         yield train_X
 ```
 
-需要注意的一件事是，在培训结束时，我们会预测所有用户对所有电影的收视率，无论它们是否被评级。 具有最高可能性的评级，将从五个可能的评级（即从 1 到 5）中给出最终评级。 由于在 Python 中，索引从零开始，因此在使用`argmax`获得最高概率的位置之后，我们加一以获得实际评分。 因此，在培训结束时，我们有一个`pred_all_recs.csv`文件，其中包含所有培训和测试记录的预测评分。 请注意，测试记录已嵌入培训记录中，并且评分的所有索引（从 1 到 5）都设置为零。
+需要注意的一件事是，在训练结束时，我们会预测所有用户对所有电影的收视率，无论它们是否被评级。 具有最高可能性的评级，将从五个可能的评级（即从 1 到 5）中给出最终评级。 由于在 Python 中，索引从零开始，因此在使用`argmax`获得最高概率的位置之后，我们加一以获得实际评分。 因此，在训练结束时，我们有一个`pred_all_recs.csv`文件，其中包含所有训练和测试记录的预测评分。 请注意，测试记录已嵌入训练记录中，并且评分的所有索引（从 1 到 5）都设置为零。
 
 但是，一旦我们从用户观看过的电影的隐藏表示中充分训练了模型，就可以学习从用户未看过的电影中生成评分。
 
@@ -660,7 +660,7 @@ RBM training Completed !
 52.012 s: process RBM 
 ```
 
-请注意，受限玻尔兹曼机网络已在配备 GeForce Zotac 1070 GPU 和 64 GB RAM 的 Ubuntu 机器上进行了培训。 培训时间可能会根据用于培训网络的系统而有所不同。
+请注意，受限玻尔兹曼机网络已在配备 GeForce Zotac 1070 GPU 和 64 GB RAM 的 Ubuntu 机器上进行了训练。 训练时间可能会根据用于训练网络的系统而有所不同。
 
 # 将训练后的 RBM 用于推理
 

new/intel-proj-py/07.md

@@ -327,7 +327,7 @@ def batch_gen(self,X,y,batch_size):
 python movie_review_model_train.py process_main --path /home/santanu/Downloads/Mobile_App/ --epochs 10
 ```
 
-培训的输出如下：
+训练的输出如下：
 
 ```py
 Using TensorFlow backend.

new/intel-proj-py/09.md

@@ -859,7 +859,7 @@ def model_save(path,name,agent,R):
     print('Memory pickle dumped')
 ```
 
-可以如下调用自动驾驶汽车强化学习过程的培训
+可以如下调用自动驾驶汽车强化学习过程的训练
 
 ```py
  python main.py --environment_name 'CarRacing-v0' --model_path '/home/santanu/Autonomous Car/train/' --train_mode True --test_mode False --epsilon_greedy True --render True --width 96 --height 96 --num_stack 4 --huber_loss_thresh 1 --dropout 0.2 --memory_size 10000 --batch_size 128 --max_num_episodes 500
@@ -877,7 +877,7 @@ def model_save(path,name,agent,R):
 
 ![](img/5cfd38f7-00b9-4f68-813f-464f36b8aa63.png)
 
-图 9.5（B）：经过充分培训后，汽车成功驾驶
+图 9.5（B）：经过充分训练后，汽车成功驾驶
 
 # 总结
 

new/intel-proj-py/10.md

@@ -119,7 +119,7 @@ python CaptchaGenerator.py --outdir_train '/home/santanu/Downloads/Captcha Gener
 --outdir_test '/home/santanu/Downloads/Captcha Generation/captcha_test/' --num_captchas_test 4000 --font "/home/santanu/Android/Sdk/platforms/android-28/data/fonts/DancingScript-Regular.ttf"
 ```
 
-脚本使用了`3.328 mins`来生成`16000`培训 CAPTCHA，`4000`验证 CAPTCHA 和`4000`测试 CAPTCHA，如我们从脚本的以下日志中所见：
+脚本使用了`3.328 mins`来生成`16000`训练 CAPTCHA，`4000`验证 CAPTCHA 和`4000`测试 CAPTCHA，如我们从脚本的以下日志中所见：
 
 ```py
 3.328 min: main_process
@@ -280,7 +280,7 @@ def train(dest_train,dest_val,outdir,batch_size,n_classes,dim,shuffle,epochs,lr)
     model.save(outdir + 'captcha_breaker.h5')
 ```
 
-对于批量中的 CAPTCHA，将考虑所有四个字符进行培训。 我们使用`DataGenerator`类定义`train_generator`和`val_generator`对象。 这些数据生成器动态地提供了用于训练和验证的批量。
+对于批量中的 CAPTCHA，将考虑所有四个字符进行训练。 我们使用`DataGenerator`类定义`train_generator`和`val_generator`对象。 这些数据生成器动态地提供了用于训练和验证的批量。
 
 可以通过使用`train`参数运行`captcha_solver.py`脚本来调用训练，如下所示：
 
@@ -303,7 +303,7 @@ Epoch 20/20
 4.412 min: captcha_solver
 ```
 
-使用 GeForce GTX 1070 GPU，大约`16000` 98.3s（即`64000` CAPTCHA 字符）的`20`时期的训练时间约为`4.412 min`。 建议读者使用基于 GPU 的机器进行更快的培训。
+使用 GeForce GTX 1070 GPU，大约`16000` 98.3s（即`64000` CAPTCHA 字符）的`20`时期的训练时间约为`4.412 min`。 建议读者使用基于 GPU 的机器进行更快的训练。
 
 # 测试数据集的准确性
 
@@ -509,7 +509,7 @@ def discriminator(img_dim,alpha=0.2):
 
 # 训练 GAN
 
-为生成对抗网络建立培训流程并非一帆风顺，因为这需要很多技术方面的考虑。 我们定义了以下三个培训网络：
+为生成对抗网络建立训练流程并非一帆风顺，因为这需要很多技术方面的考虑。 我们定义了以下三个训练网络：
 
 *   带有参数`θ`的生成器网络`g`
 *   带有参数`φ`的判别器网络`d`
@@ -660,7 +660,7 @@ python captcha_gan.py train --dest_train '/home/santanu/Downloads/train_32x32.ma
 | `epochs` | `100` | 这是要运行的时期数。 |
 | `smooth_coef` | `0.1` | 设计该平滑系数的目的是减少真实样本对判别器的损失。 例如，`0.1`的`smooth_coef`可以将归因于真实图像的损失减少到原始损失的 90%。 这有助于 GAN 更好地融合。 |
 
-使用 GeForce GTX 1070 GPU，用这些参数训练 GAN 大约需要 3.12 小时。 建议读者使用 GPU 进行更快的培训。
+使用 GeForce GTX 1070 GPU，用这些参数训练 GAN 大约需要 3.12 小时。 建议读者使用 GPU 进行更快的训练。
 
 # 训练期间的验证码的质量
 

new/master-pred-anal-sklearn-tf/0.md

@@ -14,7 +14,7 @@ Python 是一种编程语言，可提供数据科学领域的各种功能。 在
 
 第 1 章，“回归和分类的集成方法”涵盖了集成方法或算法的应用，以产生模型的准确预测。 我们将通过集成方法来解决回归和分类问题。
 
-第 2 章，“交叉验证和参数调整”探索了各种技术来组合和构建更好的模型。 我们将学习不同的交叉验证方法，包括保持交叉验证和 k 折交叉验证。 我们还将讨论什么是超参数调优。
+第 2 章，“交叉验证和参数调整”探索了各种技术来组合和构建更好的模型。 我们将学习不同的交叉验证方法，包括保留交叉验证和 k 折交叉验证。 我们还将讨论什么是超参数调优。
 
 第 3 章，“处理特征”，探讨了特征选择方法，降维，PCA 和要素工程。 我们还将研究通过特征工程改进模型的方法。
 

new/master-pred-anal-sklearn-tf/1.md

-# 回归和分类的综合方法
+# 回归和分类的集成方法
 
 商业企业广泛使用高级分析工具，以解决使用数据的问题。 分析工具的目的是分析数据并提取相关信息，这些信息可用于解决问题或提高业务某些方面的绩效。 它还涉及各种机器学习算法，通过这些算法我们可以创建预测模型以获得更好的结果。
 
@@ -6,11 +6,11 @@
 
 我们将在本章中介绍以下主题：
 
-*   合奏方法及其工作
+*   集成方法及其工作
 *   集成回归方法
 *   归类方法
 
-# 合奏方法及其工作
+# 集成方法及其工作
 
 集成方法基于一个非常简单的思想：我们不是使用单个模型进行预测，而是使用许多模型，然后使用某种方法来**汇总**预测。 具有不同的模型就像具有不同的观点，并且已经证明，通过汇总提供不同观点的模型，可以得到不同的结果。 预测可以更准确。 这些方法进一步提高了单个模型的通用性，因为它们降低了选择效果不佳的分类器的风险：
 
@@ -20,7 +20,7 @@
 
 集成学习将所有这些单独的预测合并为一个预测。 通过组合三个边界进行的预测通常比单个模型所产生的预测具有更好的性能。 这是集成方法（也称为**集成学习**）背后的简单思想。
 
-最常用的合奏方法如下：
+最常用的集成方法如下：
 
 *   自举采样
 *   装袋
@@ -45,9 +45,9 @@
 
 # 装袋
 
-套袋（也称为引导聚合）是减少机器学习模型中差异的通用过程。 它基于自举抽样技术，通常与回归树或分类树一起使用，但是原则上该套袋技术可以与任何模型一起使用。
+装袋（也称为引导聚合）是减少机器学习模型中差异的通用过程。 它基于自举抽样技术，通常与回归树或分类树一起使用，但是原则上该装袋技术可以与任何模型一起使用。
 
-套袋过程涉及以下步骤：
+装袋过程涉及以下步骤：
 
 1.  我们选择要使用的估计量或单个模型的数量。 让我们将其视为参数`B`。
 2.  我们使用训练集中的自举抽样从`B`抽取样本数据集并进行替换。
@@ -62,7 +62,7 @@
 
 该集成方法是专门为回归树或分类树创建的。 它与装袋非常相似，因为在这里，每棵树都是在训练数据集的引导样本上训练的。 装袋的不同之处在于，它使模型非常强大，并且在从树中拆分节点时，选择的拆分在要素的随机子集中是最好的。 因此，每个预测变量都会考虑特征的随机子集。 这具有使每个单独的预测变量稍微更差，更偏颇的效果，但是由于各个预测变量的相关性，总体上总体上要比单个预测变量更好。
 
-# 助推
+# 提升
 
 提升是集成学习的另一种方法。 提升的方法很多，但是人们用于整体学习的最成功，最流行的方法之一就是 **AdaBoost** 算法。 也称为**自适应增强**。 该算法背后的核心思想是，我们可以拟合一系列弱学习者，而不是单独拟合许多单独的预测变量。 下一个算法取决于上一个算法的结果。 在 AdaBoost 算法中，每次迭代都会对所有这些样本进行加权。 此处的训练数据根据以前的单个学习者或单个模型的结果进行加权。
 
@@ -140,9 +140,9 @@ import pandas as pd
 
 在前面的模型中，我们可以看到制作 KNN 时使用的过程。 我们将使用 20 个邻居。 我们正在使用`euclidean`度量来测量点之间的距离，然后将训练模型。 此处，由于该值仅为`1`（均方误差），因此可以保存性能指标。
 
-# 套袋模型
+# 装袋模型
 
-套袋是一种整体学习模型。 套袋方法可以使用任何估算器。 因此，让我们来看一下使用 KNN 的情况，如以下屏幕截图所示：
+装袋是一种整体学习模型。 装袋方法可以使用任何估算器。 因此，让我们来看一下使用 KNN 的情况，如以下屏幕截图所示：
 
 ![](img/6e77b966-f186-47b0-a62d-df853ab1477c.png)
 
@@ -170,7 +170,7 @@ import pandas as pd
 
 ![](img/12d93d64-a55f-4309-b819-93c9523166cf.png)
 
-现在，当我们比较所有这些模型的结果时，我们可以看到随机森林模型是最成功的。 套袋模型和 KNN 模型分别排在第二和第三。 这就是为什么我们将 KNN 模型与装袋模型一起使用的原因。
+现在，当我们比较所有这些模型的结果时，我们可以看到随机森林模型是最成功的。 装袋模型和 KNN 模型分别排在第二和第三。 这就是为什么我们将 KNN 模型与装袋模型一起使用的原因。
 
 以下屏幕截图显示了在测试数据集时用于在预测价格和观察到的价格之间生成图形表示的算法，还显示了随机森林模型的性能：
 
@@ -263,7 +263,7 @@ def CMatrix(CM, labels=['pay', 'default']):
 
 稍后，我们将把它们保存到我们刚刚创建的`pandas`数据帧中。
 
-# 套袋模型
+# 装袋模型
 
 使用集成学习技术中的方法训练装袋模型涉及使用逻辑回归方法导入装袋分类器。 为此，我们将拟合其中的 10 个逻辑回归模型，然后使用装袋将 10 个单独的预测合并为一个预测。 之后，我们将其保存到指标数据帧中。
 

new/master-pred-anal-sklearn-tf/2.md

@@ -4,22 +4,22 @@
 
 交叉验证是一种评估技术，用于评估统计分析结果的一种验证技术，该结果可推广到一个独立的数据集，该数据集提供了样本外准确性的度量。 它通过将数据的几个随机分区平均为训练样本和测试样本来完成任务。 它通常通过对参数的几个可能值进行交叉验证并选择给出最低交叉验证平均误差的参数值来进行超参数调优。
 
-交叉验证有两种：穷举性和非穷举性。 K 折是非穷举性交叉验证的一个示例。 这是一种用于对模型性能进行更准确评估的技术。 使用 k 折交叉验证，我们可以进行超参数调优。 这是关于为我们的模型选择最佳的超参数。 k 折交叉验证和超参数调优等技术对于构建出色的预测分析模型至关重要。 交叉验证有很多类型或方法，例如，保持交叉验证和 k 折交叉验证。
+交叉验证有两种：穷举性和非穷举性。 K 折是非穷举性交叉验证的一个示例。 这是一种用于对模型性能进行更准确评估的技术。 使用 k 折交叉验证，我们可以进行超参数调优。 这是关于为我们的模型选择最佳的超参数。 k 折交叉验证和超参数调优等技术对于构建出色的预测分析模型至关重要。 交叉验证有很多类型或方法，例如，保留交叉验证和 k 折交叉验证。
 
 在本章中，我们将涵盖以下主题：
 
-*   保持交叉验证
+*   保留交叉验证
 *   K 折交叉验证
 *   将模型与 K 折交叉验证进行比较
 *   超参数调优简介
 
-# 保持交叉验证
+# 保留交叉验证
 
-在保留交叉验证中，我们保留了一定百分比的观察值，因此我们得到了两个数据集。 一个称为训练数据集，另一个称为测试数据集。 在这里，我们使用测试数据集计算评估指标，其余数据用于训练模型。 这是保持交叉验证的过程。
+在保留交叉验证中，我们保留了一定百分比的观察值，因此我们得到了两个数据集。 一个称为训练数据集，另一个称为测试数据集。 在这里，我们使用测试数据集计算评估指标，其余数据用于训练模型。 这是保留交叉验证的过程。
 
 保留交叉验证的主要优点在于，它非常易于实现，并且是一种非常直观的交叉验证方法。
 
-这种交叉验证的问题在于，它为模型的评估指标提供了一个估计。 这是有问题的，因为某些模型依赖于随机性。 因此，原则上，由于随机机会，有时在测试中计算出的评估指标可能会有很大差异。 因此，保持交叉验证的主要问题在于，我们只能获得评估指标的一个估计值。
+这种交叉验证的问题在于，它为模型的评估指标提供了一个估计。 这是有问题的，因为某些模型依赖于随机性。 因此，原则上，由于随机机会，有时在测试中计算出的评估指标可能会有很大差异。 因此，保留交叉验证的主要问题在于，我们只能获得评估指标的一个估计值。
 
 # K 折交叉验证
 
@@ -29,13 +29,13 @@
 
 ![](img/da18d7be-8cc3-4aa7-a092-e74201a63185.png)
 
-在这里，我们看到我们的数据集分为五个部分。 我们将第一部分用于测试，其余部分用于培训。
+在这里，我们看到我们的数据集分为五个部分。 我们将第一部分用于测试，其余部分用于训练。
 
 以下是我们采用 5 倍交叉验证方法执行的步骤：
 
 1.  我们对评估指标进行了首次估算。
-2.  我们将第二部分用于测试，其余部分用于培训，然后使用它来获得评估指标的第二估计。
-3.  我们将第三部分用于测试，将其余部分用于培训，依此类推。 这样，我们获得了评估指标的五种估计。
+2.  我们将第二部分用于测试，其余部分用于训练，然后使用它来获得评估指标的第二估计。
+3.  我们将第三部分用于测试，将其余部分用于训练，依此类推。 这样，我们获得了评估指标的五种估计。
 
 在 K 折交叉验证中，观察到评估矩阵的`k`估计后，取其平均值。 这将使我们可以更好地估计模型的性能。 因此，我们可以通过 K 折交叉验证获得`n`个估计数，而不是仅对这一评估指标进行一次估计，然后取平均值，以获得对性能的更好估计。 该模型。
 
@@ -378,7 +378,7 @@ RF_tunned_test_mse = mean_squared_error(y_pred=RF_classifier.predict(X_test), y_
 
 # 总结
 
-在本章中，我们学习了交叉验证以及各种交叉验证方法，包括保持交叉验证和 k 折交叉验证。 我们知道 k 折交叉验证不过是多次进行保持交叉验证而已。 我们使用`diamond`数据集实现了 k 折交叉验证。 我们还使用 K 折交叉验证比较了不同的模型，并找到了性能最佳的模型，即随机森林模型。
+在本章中，我们学习了交叉验证以及各种交叉验证方法，包括保留交叉验证和 k 折交叉验证。 我们知道 k 折交叉验证不过是多次进行保留交叉验证而已。 我们使用`diamond`数据集实现了 k 折交叉验证。 我们还使用 K 折交叉验证比较了不同的模型，并找到了性能最佳的模型，即随机森林模型。
 
 然后，我们讨论了超参数调优。 我们遇到了详尽的网格搜索方法，该方法用于执行超参数调优。 我们再次使用`diamond`数据集实现了超参数调优。 我们还比较了调整后的模型和未调整的模型，发现调整后的参数使模型的性能优于未调整的模型。
 

new/master-pred-anal-sklearn-tf/3.md

-# 使用功能
+# 使用特征
 
 在本章中，我们将仔细研究要素如何在要素工程技术中发挥重要作用。 我们将学习一些技术，这些技术将使我们能够通过两种方式改进预测分析模型：就模型的性能指标而言，以及了解功能与我们试图预测的目标变量之间的关系。
 
@@ -27,7 +27,7 @@
 
 您可以删除超过`x%`的样本中所有为 0 或 1 的虚拟特征，或者可以为这些特征的方差建立最小阈值。 现在，可以使用前面的公式获得这些特征的方差，其中`p`是您的虚拟特征中`1`的数量或比例。 我们将在 Jupyter 笔记本中查看其工作原理。
 
-# 统计确定重要特征
+# 通过统计确定重要特征
 
 此方法将帮助您利用一些统计测试来识别和选择相关功能。 因此，例如，对于分类任务，我们可以使用 ANOVA F 统计量来评估数字特征和目标之间的关系，这将是分类特征，因为这是经典任务的一个示例。 或者，为了评估分类特征与目标之间的统计关系，我们将使用卡方检验来评估这种关系。 在`scikit-learn`中，我们可以使用`SelectKBest`对象，我们将在 Jupyter 笔记本中了解如何使用这些对象。
 
@@ -213,7 +213,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 有多种实现要素工程的方法。 您可能会发现所有技术都不可行，并且最终可能会排除其中的一些技术。 这样做的目的不是要就此主题进行学术讨论，而是要向您展示在使用要素和尝试创建新要素时我们所做的一些常见操作。 第一个是缩放功能，用于将其范围转换为更合适的功能。 另一个是以更好的方式对信息进行编码，我们将在本章后面看到一个示例。 特征工程涉及从现有特征创建新特征，以便您可以通过对现有特征执行一些数学运算来组合它们。
 创建新功能的另一种方法是使用降维技术，例如我们之前看到的 PCA。 只要您使它具有创造力，使用哪种技术都没有关系。 如前所述，您对问题的了解越多越好。
 
-# 创建新功能
+# 创建新特征
 
 我们将在此处使用信用卡默认值和钻石数据集。 现在，让我们转到 Jupyter 笔记本创建新功能，并了解这些技术在实践中的用途：
 

new/master-pred-anal-sklearn-tf/4.md

@@ -77,7 +77,7 @@
 
 这是一种更紧凑的可视化方式，但实际上是同一网络。 因此，我们为每个观察结果添加了一个不变的特征`1`，而不是具有三个偏差。`1`的值乘以不同的偏差，并作为对我们隐藏层中神经元的输入。`x1`的值乘以一定的权重，并作为下一个神经元的输入，`x2`的值也是如此。 然后，将隐藏层中神经元的结果用作我们网络中最后一个感知器的输入，这是总输出。
 
-# 深度神经网络模型的要素
+# 深度神经网络模型的元素
 
 **深度神经网络**（**DNN**）的动机是相似的，这里的问题是，如果不使用一个隐藏层，那么如果我们使用多个隐藏层怎么办？ 因此，在这种情况下，我们的模型将类似于以下内容：
 
@@ -95,7 +95,7 @@
 *   他们通常需要大量数据和大量计算能力才能使这些模型表现出色
 *   这些模型现在被认为是许多应用程序的最新技术，例如计算机视觉，语音识别和游戏
 
-# MLP 模型的要素
+# MLP 模型的元素
 
 在多层感知器中构建深度学习模型时，需要考虑很多因素。 您必须考虑架构，激活函数，优化算法，`loss`函数，权重初始化策略，正则化策略和训练策略。 我们将在以下列表中讨论有关它们的更多信息：
 

new/master-pred-anal-sklearn-tf/5.md

@@ -40,7 +40,7 @@ from tensorflow.contrib.layers import fully_connected
 
 2.  我们将从`tensorflow.contrib.layers`导入`fully_connected`函数，该函数将用于构建我们的网络层。
 
-# DNN 模型的要素
+# DNN 模型的元素
 
 在运行模型之前，我们首先必须确定用于构建多层感知器模型的元素。 以下是我们将在此模型中使用的元素：
 
@@ -116,17 +116,17 @@ y = tf.placeholder(tf.int64)
 
 现在，使用这种交叉熵，我们可以将损失计算为将在此处获得的向量的平均值。 因此，这是`loss`函数和交叉熵的平均值。
 
-# 定义优化器和培训操作
+# 定义优化器和训练操作
 
-优化器的目标是最大程度地减少损耗，它可以通过调整网络所有层中的不同权重来实现。 这里使用的优化器是学习速率为`0.01`的梯度下降。 以下屏幕快照显示了用于定义优化器的代码行，还显示了培训操作。
+优化器的目标是最大程度地减少损耗，它可以通过调整网络所有层中的不同权重来实现。 这里使用的优化器是学习速率为`0.01`的梯度下降。 以下屏幕快照显示了用于定义优化器的代码行，还显示了训练操作。
 
 ![](img/2861b9b5-3425-4cbc-917c-34c6bebfb8fc.png)
 
 每次我们运行训练操作`training_op`时，优化器都会稍微改变这些权重的值。 这样做可以最大程度地减少损失，并且预测值和实际值应尽可能接近。
 
-# 培训策略和分类准确性评估
+# 训练策略和分类准确性评估
 
-在这里，我们设置培训策略。 我们将使用 20 个时期，批量大小为 80。在所有这些单元格中，我们已经建立了将在该程序中使用的计算图。 以下屏幕截图显示了用于显示训练策略的代码行以及用于评估分类准确性的两个节点：
+在这里，我们设置训练策略。 我们将使用 20 个时期，批量大小为 80。在所有这些单元格中，我们已经建立了将在该程序中使用的计算图。 以下屏幕截图显示了用于显示训练策略的代码行以及用于评估分类准确性的两个节点：
 
 ![](img/c059d22e-2a90-4e34-94ba-d7f806e01d5a.png)
 
@@ -156,7 +156,7 @@ y = tf.placeholder(tf.int64)
 
 我们将使用`tensorflow.contrib.layers`模型中的`fully_ connected`函数。
 
-# DNN 模型的要素
+# DNN 模型的元素
 
 在运行模型之前，我们首先必须确定用于构建多层感知器模型的元素，如下所示：
 
@@ -180,11 +180,11 @@ y = tf.placeholder(tf.int64)
 
 # 建模对象
 
-导入数据集后，我们准备对象以进行建模。 因此，我们在这里进行了`x`和`y`的培训和测试。 以下屏幕快照显示了用于准备对象以进行建模的代码行：
+导入数据集后，我们准备对象以进行建模。 因此，我们在这里进行了`x`和`y`的训练和测试。 以下屏幕快照显示了用于准备对象以进行建模的代码行：
 
 ![](img/e9278a94-5327-4ee6-bd04-3a925170420e.png)
 
-# 培训策略
+# 训练策略
 
 这是具有 40 个周期且批量大小为 50 个的训练策略。它是使用以下代码行创建的：
 
@@ -234,11 +234,11 @@ y = tf.placeholder(y_train.dtype)
 
 ![](img/cedfa97e-88ee-4564-9297-6299ce5e7652.png)
 
-# 定义优化器和培训操作
+# 定义优化器和训练操作
 
 优化器的目标是最大程度地减少损耗，它可以通过调整网络所有层中的不同权重来实现。 此处使用的优化器是学习率为 0.001 的 Adam 优化器。
 
-以下屏幕快照显示了用于定义优化器的代码行，还显示了培训操作：
+以下屏幕快照显示了用于定义优化器的代码行，还显示了训练操作：
 
 ![](img/d34af37c-db85-4d8d-82ec-1274c6805ea2.png)
 
@@ -258,7 +258,7 @@ y = tf.placeholder(y_train.dtype)
 
 ![](img/e9121538-21c3-43f6-8fe0-59ecaa8da16e.png)
 
-在最后一次测试的 MSE（周期 40）中，我们获得了培训和测试的 MSE 的最终价值。
+在最后一次测试的 MSE（周期 40）中，我们获得了训练和测试的 MSE 的最终价值。
 
 我们从网络获得了实际的预测，并且值相对接近。 在这里，我们可以看到预测价格。 对于廉价钻石，该网络产生的价值相对接近。 对于非常昂贵的钻石，网络产生了很高的价值。 而且，预测值与观察值非常接近。 以下屏幕截图显示了我们从网络获得的实际值和预测值：
 
@@ -288,7 +288,7 @@ y = tf.placeholder(y_train.dtype)
 
 我们还将从`sklearn.model_selection`导入`train_test_split`功能，从`sklearn.preprocessiong`导入`RobustScaler`功能，并从`sklearn.metrics`导入`precision_score`，`recall_score`和`accuracy_score`。 我们还从`tensorflow.contrib.layers`导入`fully_connected`函数以构建我们的网络层。
 
-# DNN 模型的要素
+# DNN 模型的元素
 
 在运行模型之前，我们首先必须确定在构建多层感知器模型的
 中将使用的元素，如下所示：
@@ -322,15 +322,15 @@ y = tf.placeholder(y_train.dtype)
 
 ![](img/dfee505c-4e6a-46e0-aafc-a1a73825fa69.png)
 
-# 生产用于建模的对象
+# 生成用于建模的对象
 
 现在，我们生成用于建模的对象。 我们将使用 10% 的测试
-和 90% 的培训。 以下屏幕截图显示了
+和 90% 的训练。 以下屏幕截图显示了
 用于生成建模对象的代码行：
 
 ![](img/57d58fe3-2781-4cb0-b875-cbf1ef50ebcb.png) 
 
-# 培训策略
+# 训练策略
 
 这是我们前面提到的训练策略，共 40 个时期，批量大小为
 100。以下代码块显示了我们在此策略中设置的参数：
@@ -398,11 +398,11 @@ TensorFlow，`tf.nn.elu`中获得此功能，从中您可以获得许多功能
 
 `softmax`函数用于提供不同类别的概率。
 
-# 优化器和培训操作
+# 优化器和训练操作
 
 优化器的目标是使损失最小化，它可以通过调整网络所有层中的不同权重来实现。
 
-以下屏幕快照显示了用于定义优化器的代码行，并显示了培训操作：
+以下屏幕快照显示了用于定义优化器的代码行，并显示了训练操作：
 
 ![](img/31bcbcf6-c2aa-4cd5-a759-3cf5b0a68f49.png)
 

new/whats-new-tf2/0.md

@@ -2,7 +2,7 @@
 
 TensorFlow 是最受欢迎的机器学习框架之一，其新版本 TensorFlow 2.0 改善了其简单性和易用性。 本书将帮助您了解和利用最新的 TensorFlow 功能。
 
-《TensorFlow 2.0 的新增功能》首先关注高级概念，例如新的 TensorFlow Keras API，急切执行和高效的分发策略，这些策略可帮助您在多个 GPU 和 TPU 上运行机器学习模型。 本书随后将引导您完成构建数据摄取和培训管道的过程，并提供建议和最佳实践，以将数据提供给使用新`tf.keras` API 创建的模型。 您将探索使用 TensorFlow 服务和其他多平台部署构建推理管道的过程，然后再继续探索新发布的 AIY（本质上是自己动手的 AI）。 本书深入研究了核心 API，可帮助您构建统一的卷积层和循环层，并使用 TensorBoard 通过假设分析来可视化深度学习模型。
+《TensorFlow 2.0 的新增功能》首先关注高级概念，例如新的 TensorFlow Keras API，急切执行和高效的分发策略，这些策略可帮助您在多个 GPU 和 TPU 上运行机器学习模型。 本书随后将引导您完成构建数据摄取和训练管道的过程，并提供建议和最佳实践，以将数据提供给使用新`tf.keras` API 创建的模型。 您将探索使用 TensorFlow 服务和其他多平台部署构建推理管道的过程，然后再继续探索新发布的 AIY（本质上是自己动手的 AI）。 本书深入研究了核心 API，可帮助您构建统一的卷积层和循环层，并使用 TensorBoard 通过假设分析来可视化深度学习模型。
 
 到这本书的结尾，您将了解 TensorFlow 2.0 和 TensorFlow 1.x 之间的兼容性，并将能够平稳地迁移到 TensorFlow 2.0。
 

new/whats-new-tf2/1.md

@@ -19,7 +19,7 @@ TF 2.0 的理念基于简单性和易用性。 主要更新包括使用`tf.keras
 
 ![](img/b7664abb-104a-4e94-a8e4-2b1889ad47f3.png)
 
-上图着重于使用 Python API 进行培训和部署； 但是，其他受支持的语言（包括 Julia，JavaScript 和 R）也遵循相同的过程。TF 2.0 的流程是...
+上图着重于使用 Python API 进行训练和部署； 但是，其他受支持的语言（包括 Julia，JavaScript 和 R）也遵循相同的过程。TF 2.0 的流程是...
 
 # 从 TF 1.x 更改
 
@@ -138,7 +138,7 @@ TF 2.0 可以通过两种主要方式使用-使用低级 API 和使用高级 API
 
 编写低级代码的代码流程是定义函数内部的前向传递，该函数将输入数据作为参数。 然后使用`tf.function`装饰器对该功能进行注释，以便在图形模式下运行它及其所有优点。 为了记录和获得前向通过的梯度，装饰器函数和损失函数都在`tf.GradientTape`上下文管理器中运行，可以从中计算梯度并将其应用于模型变量。
 
-培训代码也可以使用低级 API 编写，用于...
+训练代码也可以使用低级 API 编写，用于...
 
 # 丰富的扩展
 

new/whats-new-tf2/2.md

@@ -136,7 +136,7 @@ model_using_generator = tf.keras.Sequential(layers=get_layers(10))
 
 # 训练模式
 
-**训练模型**指的是为不同网络组件学习权重的过程，这些过程在给定的一组示例中将损失函数降至最低。 简而言之，训练神经网络意味着找到网络价值的最佳组合。 如您所知，培训过程也与评估和预测过程紧密相关。 借助抽象的强大功能，Keras 提供了强大的高级界面来实现和管理端到端的培训过程。 让我们看一下它为使用顺序和函数式 API 创建的模型提供的训练 API。 它为此阶段提供的一些功能如下：
+**训练模型**指的是为不同网络组件学习权重的过程，这些过程在给定的一组示例中将损失函数降至最低。 简而言之，训练神经网络意味着找到网络价值的最佳组合。 如您所知，训练过程也与评估和预测过程紧密相关。 借助抽象的强大功能，Keras 提供了强大的高级界面来实现和管理端到端的训练过程。 让我们看一下它为使用顺序和函数式 API 创建的模型提供的训练 API。 它为此阶段提供的一些功能如下：
 
 *   `model.compile()`：此功能用于配置训练过程。 用户指定详细信息，例如优化器的类型（以及超参数（如果有的话）），损失函数的类型以及要评估的指标。 这些也是可以使用 TensorBoard 可视化的指标。 下面的示例代码片段描述了一个带有**随机梯度下降**（**SGD**）优化器，`CategoricalCrossentropy`损失函数和记录`Accuracy`指标的样本训练配置：
 
@@ -166,7 +166,7 @@ model.fit(
 )
 ```
 
-*   `model.evaluate()`：如前所述，培训和评估过程是相互联系的，并且紧密相连。 训练神经网络需要经常更新权重，以找到最佳的权重集。 为此，有必要在当前阶段计算某种类型的网络状态。 此过程称为**评估**。 更具体地说，评估是针对给定数据集在当前阶段计算网络的损耗和其他指标的过程。 请记住，此方法执行的计算是分批执行的。 该函数返回与损失函数相对应的标量。 它还返回与`model.compile()`阶段中提供的任何度量对应的值。 以下代码段描述了一个评估函数，该函数以批量大小`32`来计算记录（`test_x`）和标签（`test_y`）上的度量：
+*   `model.evaluate()`：如前所述，训练和评估过程是相互联系的，并且紧密相连。 训练神经网络需要经常更新权重，以找到最佳的权重集。 为此，有必要在当前阶段计算某种类型的网络状态。 此过程称为**评估**。 更具体地说，评估是针对给定数据集在当前阶段计算网络的损耗和其他指标的过程。 请记住，此方法执行的计算是分批执行的。 该函数返回与损失函数相对应的标量。 它还返回与`model.compile()`阶段中提供的任何度量对应的值。 以下代码段描述了一个评估函数，该函数以批量大小`32`来计算记录（`test_x`）和标签（`test_y`）上的度量：
 
 ```py
 results = model.evaluate(
@@ -220,7 +220,7 @@ my_model_weights = my_model.get_weights()
 replica_my_model.set_weights(my_model_weights)
 ```
 
-如我们所见，可以使用`get_config()`或`get_weights()`与`from_config`或`set_weights()`的组合存储整个模型。 但是，此过程的局限性在于它不存储有关培训过程的任何信息。
+如我们所见，可以使用`get_config()`或`get_weights()`与`from_config`或`set_weights()`的组合存储整个模型。 但是，此过程的局限性在于它不存储有关训练过程的任何信息。
 
 为了更好地理解这一点，让我们看一个例子。 考虑一个具有一个输入层，一个隐藏层和一个输出层的简单模型。 然后，我们将仅使用上一节中讨论的方法来创建此模型的副本。 步骤如下：
 
@@ -266,7 +266,7 @@ my_model_replica.set_weights(
 
 # 保存和加载整个模型
 
-上一节中描述的过程的主要限制之一是它不包括培训过程。 这可能是用例中的主要障碍，这些用例涉及培训过程中某个时刻的检查点。 为了克服它，TensorFlow 可以完整保存模型。 这主要可以通过两种方式实现-使用 Keras API 或使用`SavedModel` API。
+上一节中描述的过程的主要限制之一是它不包括训练过程。 这可能是用例中的主要障碍，这些用例涉及训练过程中某个时刻的检查点。 为了克服它，TensorFlow 可以完整保存模型。 这主要可以通过两种方式实现-使用 Keras API 或使用`SavedModel` API。
 
 在以下各节中，我们将简要讨论方法及其语法。 我们还提供了有关何时使用它们的见解。
 
@@ -303,7 +303,7 @@ loaded_model = tf.keras.models.load_model(
 
 *   一个包含模型权重的 TensorFlow 检查点
 *   包含底层 TensorFlow 图的`SavedModel`原型：
-    *   默认情况下，为预测阶段保存了单独的图表（培训和评估阶段也分别在适用时存储）
+    *   默认情况下，为预测阶段保存了单独的图表（训练和评估阶段也分别在适用时存储）
 *   模型的架构配置（如果有）
 
 在 Python API 中，与`SavedModel ...`进行交互
@@ -363,7 +363,7 @@ import tensorflow as tfimport tensorflow.keras as keras
 
 # 估算器
 
-从头开始构建机器学习模型时，从业人员通常会经历多个高级阶段。 其中包括培训，评估，预测和装运，以供大规模使用（或出口）。 到目前为止，开发人员必须编写自定义代码才能实现这些步骤中的每个步骤。 在所有应用程序中，运行这些过程所需的许多样板代码都保持不变。 更糟的是，此代码很容易需要在低抽象级别上进行操作。 这些问题放在一起，可能会在开发过程中造成极大的效率低下。
+从头开始构建机器学习模型时，从业人员通常会经历多个高级阶段。 其中包括训练，评估，预测和装运，以供大规模使用（或出口）。 到目前为止，开发人员必须编写自定义代码才能实现这些步骤中的每个步骤。 在所有应用程序中，运行这些过程所需的许多样板代码都保持不变。 更糟的是，此代码很容易需要在低抽象级别上进行操作。 这些问题放在一起，可能会在开发过程中造成极大的效率低下。
 
 TensorFlow 团队尝试通过引入 Estimators 来解决此问题，Estimators 是一个高级 API，旨在抽象出在上述阶段执行不同任务时产生的许多复杂性。 具体来说，估算器是用于封装以下类别任务的高级 API：
 

new/whats-new-tf2/3.md

@@ -361,7 +361,7 @@ ds = ds.filter(lambda x: x > 3) # ==> [1, 2]
 
 ![](img/2b600952-f4a1-46eb-8466-fab7d2eaacba.png)
 
-此外，最近的机器学习算法和深度神经网络在 GPU，TPU 和大量 CPU 上进行了分布式培训。 这些 GPU 或 TPU 中的每一个都有自己的内存限制（例如，NVIDIA 的 1080Ti GPU 具有 11 GB 的可用内存，而 Tesla V100 GPU 具有 16 GB 的可用内存）。 由于基于反向传播的梯度下降用于训练和学习 ML 模型的权重和偏差，因此开发人员使用小批量梯度下降; 因此，重要的是要有足够的批量大小，以确保可用的 GPU（或 TPU）不会耗尽内存。
+此外，最近的机器学习算法和深度神经网络在 GPU，TPU 和大量 CPU 上进行了分布式训练。 这些 GPU 或 TPU 中的每一个都有自己的内存限制（例如，NVIDIA 的 1080Ti GPU 具有 11 GB 的可用内存，而 Tesla V100 GPU 具有 16 GB 的可用内存）。 由于基于反向传播的梯度下降用于训练和学习 ML 模型的权重和偏差，因此开发人员使用小批量梯度下降; 因此，重要的是要有足够的批量大小，以确保可用的 GPU（或 TPU）不会耗尽内存。
 
 `tf.data.Dataset`提供了一种以高效且无缝的方式创建一批样本的好方法，如以下代码块所示：
 
@@ -406,7 +406,7 @@ TF 2.0 中创建输入数据管道的一个主要区别在于其简单性。 TF
 
 为了运行基于 CIFAR10 的端到端示例，您需要从[这里](https://www.cs.toronto.edu/~kriz/cifar.html)下载必要的数据。 该数据集摘自[《从微小图像中学习多层特征》](https://www.cs.toronto.edu/~kriz/learning-features-2009-TR.pdf)。 该数据集包含以下信息：
 
-*   50,000 张带有标签的图像进行培训
+*   50,000 张带有标签的图像进行训练
 *   10,000 张带有标签的图像进行测试
 *   10 类标签
 
@@ -425,7 +425,7 @@ TF 2.0 中创建输入数据管道的一个主要区别在于其简单性。 TF
 
 # 使用 Pickle 文件创建 TFRecords
 
-出于说明目的，我们将使用`data_batch_*`文件之一作为验证数据。 我们将其余的用于培训。 例如，如果我们选择`data_batch_4`作为验证数据，则`data_batch_1`，`data_batch_2`，`data_batch_3`和`data_batch_5`将用作训练数据。
+出于说明目的，我们将使用`data_batch_*`文件之一作为验证数据。 我们将其余的用于训练。 例如，如果我们选择`data_batch_4`作为验证数据，则`data_batch_1`，`data_batch_2`，`data_batch_3`和`data_batch_5`将用作训练数据。
 
 1.  让我们使用 CIFAR10 数据创建 TFRecords：
 

new/whats-new-tf2/4.md

@@ -4,15 +4,15 @@
 
 TensorFlow 1.x 版本强烈支持低级和中级 API，以构建机器学习模型。 它还具有 Estimator API，包括预制的估算器，例如`LinearClassifier`和`DNNRegressor`，以及用作高级 TF API 的定制估算器。 TF 1.x 中对估算器的支持是提供高级 API，与低级和中级 TF API 相比，它们更易于构建。 从 TensorFlow 2.0 开始，主要变化之一是采用 Keras API 标准作为高级 API 而不是 Estimators。 对于 TensorFlow 开发团队而言，这非常有意义，因为 Keras API 是迄今为止机器学习社区中采用的最大 API 集，并且 Keras 的创建者 Francois Chollet 也是一位出色的人工智能（AI）研究人员，现在已经加入 TensorFlow 开发团队的成员。 TensorFlow 1.x 版本已经提供对`tf.keras`的初始支持; 但是，在 TF 2.0 版本中可以获得`tf.keras`的完整而完整的体验。
 
-在本章中，我们将浏览`tf.keras` API，包括 API 的顺序，功能和模型子分类类型。 您将学习如何使用`tf.data.Dataset`将输入数据流水线馈入模型流水线，以及特征列的可能分类结构。 我们还将介绍如何定义损失函数，最常见的优化器，基于 TensorBoard 的数据，模型调试，可视化和性能分析等。 从 TensorFlow 2.0 开始，`tf.keras` API 已紧密集成到 TensorFlow 生态系统中，其中包括对`tf.data`的改进支持和最新可用的分发策略，可用于跨多种 GPU 和 TPU 进行分布式培训。 `tf.keras`还无缝支持导出训练有素的模型，这些模型可以使用 TensorFlow 服务和其他技术在 TensorFlow Lite 的移动和嵌入式设备上进行服务和部署。
+在本章中，我们将浏览`tf.keras` API，包括 API 的顺序，功能和模型子分类类型。 您将学习如何使用`tf.data.Dataset`将输入数据流水线馈入模型流水线，以及特征列的可能分类结构。 我们还将介绍如何定义损失函数，最常见的优化器，基于 TensorBoard 的数据，模型调试，可视化和性能分析等。 从 TensorFlow 2.0 开始，`tf.keras` API 已紧密集成到 TensorFlow 生态系统中，其中包括对`tf.data`的改进支持和最新可用的分发策略，可用于跨多种 GPU 和 TPU 进行分布式训练。 `tf.keras`还无缝支持导出训练有素的模型，这些模型可以使用 TensorFlow 服务和其他技术在 TensorFlow Lite 的移动和嵌入式设备上进行服务和部署。
 
 我们将在本章介绍以下主题：
 
 *   比较 Keras 和`tf.keras`
 *   使用`tf.keras` 2.0 创建模型
-*   模型编制与培训
-*   定制培训逻辑
-*   分布式培训
+*   模型编制与训练
+*   定制训练逻辑
+*   分布式训练
 *   张量板
 
 # 技术要求
@@ -193,7 +193,7 @@ self.num_filters = 32
 
 使用任何 API 创建模型后，最好使用`model.summary()`和/或`tf.keras.utils.plot_model(...)`查看模型详细信息。
 
-# 模型编制与培训
+# 模型编制与训练
 
 神经网络对复杂的非线性函数建模，例如`sin(x)`，`x ** 2`和`x ** 3`，仅举几个简单的函数， 由层的网络（堆栈）组成。 这些层可以是卷积层，循环层或简单的前馈层的混合。 每层由神经元组成。 神经元有两种模型化非线性的成分：前一层的加权总和，然后是激活函数。 神经网络试图以迭代方式学习给定训练数据的分布。 一旦通过指定激活函数以层栈的形式构建了神经网络，就需要定义一个目标函数（也称为损失函数）以使用适当的模型来改善模型权重。
 
@@ -288,7 +288,7 @@ model.save('my_model.h5')
 new_model = keras.models.load_model('my_model.h5') ...
 ```
 
-# 定制培训逻辑
+# 定制训练逻辑
 
 如前所述，TF 2.0 带来了默认的紧急执行，这意味着基于图的代码流的传统 TF 1.x 自定义训练逻辑实现现在已过时。 为了在 TF 2.0 中实现有关急切执行的自定义训练逻辑，可以使用`tf.GradientTape`。 `tf.GradientTape`的目的是记录用于自动微分的运算，或者用于计算运算或计算相对于其输入变量的梯度。 这可以通过使用`tf.GradientTape`作为上下文管理器来完成。 TensorFlow 将在`tf.GradientTape`上下文中执行的所有操作记录到磁带上，然后将其与梯度一起与那些操作关联，以使用反向模式微分计算记录的操作的梯度。
 
@@ -359,7 +359,7 @@ class CustomModel(tf.keras.models.Model):
       return input_data // 2
 ```
 
-以下代码段是培训中的`tf.function`示例：
+以下代码段是训练中的`tf.function`示例：
 
 ```py
 compute_loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
@@ -410,7 +410,7 @@ def clip_gradient_by_norm(x, norm):
 
 有关如何使用`tf.custom_gradient`的更多示例，请参见[这里](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/custom_gradient)。
 
-# 分布式培训
+# 分布式训练
 
 TF 2.0 的优点之一是能够在多个 GPU 和 TPU 上以分布式方式训练和推断模型，而无需编写大量代码。 使用分发策略 API `tf.distribute.Strategy(...)`可以简化此过程，该 API 随时可用。 “`fit()` API”部分介绍了`tf.keras.Model.fit(...)`，该部分说明了如何使用此功能训练模型。 在本节中，我们将展示如何使用分布策略跨多个 GPU 和 TPU 训练基于`tf.keras`的模型。 值得注意的是，`tf.distribute.Strategy(...)`可与`tf.keras`和`tf.estimator`等高级 API 一起使用，并支持自定义训练循环或...中的任何计算。
 

new/whats-new-tf2/7.md

@@ -291,7 +291,7 @@ test_out = model(test_data, training=False)
 
 # 升级训练循环
 
-将 TF 1.x 代码转换为惯用的 TF 2.0 代码的第二步是升级培训管道。 TF 1.x 培训管道涉及对优化器，损失和预测的多个`tf.Session.run()`调用。 这样的训练循环还涉及样板代码，该样板代码被编写为将训练结果记录到控制台以方便监督。
+将 TF 1.x 代码转换为惯用的 TF 2.0 代码的第二步是升级训练管道。 TF 1.x 训练管道涉及对优化器，损失和预测的多个`tf.Session.run()`调用。 这样的训练循环还涉及样板代码，该样板代码被编写为将训练结果记录到控制台以方便监督。
 
 在 TF 2.0 中，可以使用三种类型的训练循环。 这些循环中的每一个都有不同的优点和缺点，并且难度，API 级别和复杂性各不相同。 它们如下：
 
@@ -371,7 +371,7 @@ print(' accuracy: {:.3f}'.format(mean_accuracy))
 
 # TF 2.0 的未来
 
-TF 2.0 目前处于 beta 版本，因此仍在开发中。 即将出现的一些关键功能包括对软件包的修改，例如 TensorBoard，TensorFlow Lite，TensorFlow.js，用于 TensorFlow 的 Swift 和 TensorFlow Extended，以及对基本 API 的微小更改。 TensorBoard 将看到增强功能，例如改进的超参数调优功能，引入托管功能以使共享仪表板变得容易，并使插件能够使用不同的前端技术，例如 ReactJS。 TensorFlow Lite 将扩大支持的操作范围，将 TF 2.0 模型更轻松地转换为 TFLite，并扩展对 Edge TPU 和 AIY 板的支持。 TensorFlow.js 和用于 TensorFlow 的 Swift 都将看到速度和性能方面的改进，并且很快将包含一组丰富的示例和带有端到端教程的入门指南。 TF Extended 即将与 TF 2.0 基本 API 完全集成，并将包括完全协调的端到端工作流程和培训功能。
+TF 2.0 目前处于 beta 版本，因此仍在开发中。 即将出现的一些关键功能包括对软件包的修改，例如 TensorBoard，TensorFlow Lite，TensorFlow.js，用于 TensorFlow 的 Swift 和 TensorFlow Extended，以及对基本 API 的微小更改。 TensorBoard 将看到增强功能，例如改进的超参数调优功能，引入托管功能以使共享仪表板变得容易，并使插件能够使用不同的前端技术，例如 ReactJS。 TensorFlow Lite 将扩大支持的操作范围，将 TF 2.0 模型更轻松地转换为 TFLite，并扩展对 Edge TPU 和 AIY 板的支持。 TensorFlow.js 和用于 TensorFlow 的 Swift 都将看到速度和性能方面的改进，并且很快将包含一组丰富的示例和带有端到端教程的入门指南。 TF Extended 即将与 TF 2.0 基本 API 完全集成，并将包括完全协调的端到端工作流程和训练功能。
 
 TF 2.0 基本 API 将包括针对任务的更多预制估算器，例如增强树，随机森林，最近邻搜索和 k 均值聚类。 `tf.distribute.Strategy`模型将扩展其对 Keras 子模型，TPU 和多节点训练的支持，以在多个处理器上实现更优化和更快的训练。
 

new/whats-new-tf2/pt2.md

-# 第 2 部分：TensorFlow 2.0-数据和模型培训管道
+# 第 2 部分：TensorFlow 2.0-数据和模型训练管道
 
-本书的这一部分将概述总体输入数据和培训模型管道。 它还将详细介绍使用`tf.keras` API 创建模型，培训和验证流程。
+本书的这一部分将概述总体输入数据和训练模型管道。 它还将详细介绍使用`tf.keras` API 创建模型，训练和验证流程。
 
 本节包含以下章节：