2020-12-22 22:23:16

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

@@ -403,7 +403,7 @@ CIFAR 数据集是机器学习数据集，其中包含按不同类别组织的
 
 利用这一刻来说明神经网络在训练过程中尽早达到高准确度的能力。
 
-我们可以看到，在大约 200 个纪元（或步骤）内，网络的准确性超过了 90%。 也就是说，网络正确获取了测试集中 90% 的数字。 在训练到第 2000 步时，网络继续获得准确性，在此期间结束时达到 97% 的准确性。
+我们可以看到，在大约 200 个周期（或步骤）内，网络的准确性超过了 90%。 也就是说，网络正确获取了测试集中 90% 的数字。 在训练到第 2000 步时，网络继续获得准确性，在此期间结束时达到 97% 的准确性。
 
 现在，让我们也测试那些网络在看不见的数据下的性能。 我们将使用 Shafeen Tejani 创建的开源 Web 应用程序来探索受过训练的网络是否正确地预测了我们创建的手写数字。
 
@@ -461,7 +461,7 @@ $ tensorboard --logdir=mnist_example/
 
 准确性图衡量网络能够猜测测试集标签的准确性。 最初，网络猜测这些标签完全错误。 发生这种情况是因为我们已使用随机值初始化了网络的权重和偏差，因此其首次尝试只是一个猜测。 然后，网络将在第二次运行中更改其层的权重和偏差； 网络将继续通过改变其权重和偏见来投资于那些能带来积极成果的节点，并通过逐渐减少其对网络的影响（最终达到`0`）来惩罚那些没有结果的节点。 如您所见，这是一种非常有效的技术，可以快速产生出色的结果。
 
-让我们将注意力集中在**精度**图表上。 看看在大约 1,000 个纪元后，该算法如何达到很高的准确性（> 95% ）？ 在 1,000 到 2,000 个时代之间会发生什么？ 如果我们继续训练更多的时期，它将变得更加准确吗？
+让我们将注意力集中在**精度**图表上。 看看在大约 1,000 个周期后，该算法如何达到很高的准确性（> 95% ）？ 在 1,000 到 2,000 个时代之间会发生什么？ 如果我们继续训练更多的时期，它将变得更加准确吗？
 
 当网络的精度继续提高时，在 1,000 到 2,000 之间，但是的速率下降。 如果训练更多的时间段，网络可能会略有改善，但是在当前架构下，其精度不会达到 100%。
 

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

@@ -517,7 +517,7 @@ batch_size = 1
 
 历元是网络响应于数据通过及其丢失功能而调整其权重的次数。 为更多时期运行模型可以使它从数据中学到更多，但同时也存在过拟合的风险。
 
-训练模型时，最好以指数形式增加历时，直到损失函数开始趋于平稳。 在`bitcoin_lstm_v0`模型的情况下，其损失函数稳定在大约 100 个纪元。
+训练模型时，最好以指数形式增加历时，直到损失函数开始趋于平稳。 在`bitcoin_lstm_v0`模型的情况下，其损失函数稳定在大约 100 个周期。
 
 我们的 LSTM 模型使用少量数据进行训练，因此增加时期数不会显着影响其性能。 例如，如果尝试在 103 个时代训练它，该模型几乎没有任何改进。 如果要训练的模型使用大量数据，则情况并非如此。 在这些情况下，大量的时间对于实现良好的性能至关重要。
 
@@ -525,7 +525,7 @@ batch_size = 1
 
 ###### 时代-实施
 
-我们的比特币数据集非常小，因此增加了模型训练可能会对的性能产生边际影响的时期。 为了使模型具有更多的纪元，只需更改`model.fit()`中的`epochs`参数即可：
+我们的比特币数据集非常小，因此增加了模型训练可能会对的性能产生边际影响的时期。 为了使模型具有更多的周期，只需更改`model.fit()`中的`epochs`参数即可：
 
 ```py
 number_of_epochs = 10**3
@@ -589,9 +589,9 @@ ReLU 具有非线性属性。 它们的定义是：
 
 ![Rectified Linear Unit](img/image03_26.jpg)
 
-图 13：ReLU 功能示意图
+图 13：ReLU 函数示意图
 
-在尝试其他功能之前，通常建议将 ReLU 功能作为起点。 ReLU 倾向于惩罚负值。 因此，如果输入数据（例如，在`-1`和`1`之间进行归一化）包含负值，则这些数据现在将受到 ReLU 的惩罚。 可能不是预期的行为。
+在尝试其他功能之前，通常建议将 ReLU 函数作为起点。 ReLU 倾向于惩罚负值。 因此，如果输入数据（例如，在`-1`和`1`之间进行归一化）包含负值，则这些数据现在将受到 ReLU 的惩罚。 可能不是预期的行为。
 
 我们不会在网络中使用 ReLU 函数，因为我们的规范化过程会创建许多负值，从而导致学习模型慢得多。
 
@@ -760,7 +760,7 @@ MAPE（整个系列）
 
     此时，您有兴趣确保模型不会过拟合训练数据。 您想避免这种情况，因为如果这样做，它将无法预测训练数据中表示的模式，但测试数据中具有不同的表示形式。
 
-    在尝试了新纪元之后，请转到下一个优化技术：激活函数。
+    在尝试了新周期之后，请转到下一个优化技术：激活函数。
 
 6.  现在，导航至笔记本中的标题`Activation Functions`。 在本节中，您只需要更改以下变量：
 

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

@@ -145,7 +145,7 @@ Keras 功能模型
 
 `loss`函数是一个数学函数，它告诉`optimizer`做得如何。 `optimizer`函数是一种数学程序，可搜索可用参数以最小化`loss`函数。 `metrics`参数是您的机器学习模型的输出，应该为人类可读，以便您可以了解模型的运行状况。 现在，这些`loss`和`optimizer`参数充满了数学运算。 总的来说，您可以将其作为一本食谱。 使用 Keras 运行机器学习模型时，您应该有效地选择`adam`（默认设置）。 就`loss`功能而言，当您处理诸如 MNIST 数字之类的分类问题时，应使用分类交叉熵。 此食谱类型的配方应该对您有帮助。
 
-现在，我们准备用`x`训练数据（由实际的 MNIST 数字图像组成）和`y`训练参数（由零至九个分类输出标签组成）拟合模型。 我们这里有一个新概念是`batch_size`。 这是每个执行循环的图像数。 通常，这受可用内存的限制，但是较小的批处理大小（32 到 64）通常会更好。 那么这个奇怪的词呢？ 历元只是指循环数。 例如，当我们说八个纪元时，我们的意思是机器学习模型将遍历训练数据八次，并将使用测试数据来查看模型变得八次准确的程度。 当模型反复查看相同的数据时，它会提高准确性，如以下屏幕截图所示：
+现在，我们准备用`x`训练数据（由实际的 MNIST 数字图像组成）和`y`训练参数（由零至九个分类输出标签组成）拟合模型。 我们这里有一个新概念是`batch_size`。 这是每个执行循环的图像数。 通常，这受可用内存的限制，但是较小的批量大小（32 到 64）通常会更好。 那么这个奇怪的词呢？ 历元只是指循环数。 例如，当我们说八个周期时，我们的意思是机器学习模型将遍历训练数据八次，并将使用测试数据来查看模型变得八次准确的程度。 当模型反复查看相同的数据时，它会提高准确性，如以下屏幕截图所示：
 
 ![](img/9395b3ec-e56e-484e-a1b9-ffa61aa0871f.png)
 

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

@@ -300,7 +300,7 @@ def eucl_dist_output_shape(shapes):
 distance = Lambda(euclidean_distance, output_shape=eucl_dist_output_shape)([feat_vecs_a, feat_vecs_b]) 
 ```
 
-现在，我们将纪元长度设置为`13`，并使用 RMS 属性进行优化并定义我们的模型：
+现在，我们将周期长度设置为`13`，并使用 RMS 属性进行优化并定义我们的模型：
 
 ```py
 epochs = 13
@@ -543,7 +543,7 @@ def eucl_dist_output_shape(shapes):
 distance = Lambda(euclidean_distance, output_shape=eucl_dist_output_shape)([feat_vecs_a, feat_vecs_b])
 ```
 
-接下来，我们将纪元长度设置为`13`，并使用 RMS 属性进行优化：
+接下来，我们将周期长度设置为`13`，并使用 RMS 属性进行优化：
 
 ```py
 epochs = 13

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

@@ -73,7 +73,7 @@ MAML 的基本思想是找到一个更好的初始参数，以便具有良好的
 
 我们应始终牢记，在更新外循环中的模型参数θ时，不应使用找到最佳参数![](img/954fc01c-6c18-4ded-b14d-e1f8ccf54f3d.png)的同一组任务`Ti`。
 
-因此，简而言之，在 MAML 中，我们对一批任务进行了采样，对于批处理中的每个任务`Ti`，我们使用梯度下降使损失最小化并获得最佳参数 ![](img/0b2f0e5a-6aa9-46d2-ae78-b44a02f9b340.png)。 然后，在采样另一批任务之前，我们通过计算一组新任务`Ti`中最佳参数![](img/2512d04a-c678-4f01-acdf-0a1273b11fff.png)的梯度来更新随机初始化的模型参数θ。
+因此，简而言之，在 MAML 中，我们对一批任务进行了采样，对于批量中的每个任务`Ti`，我们使用梯度下降使损失最小化并获得最佳参数 ![](img/0b2f0e5a-6aa9-46d2-ae78-b44a02f9b340.png)。 然后，在采样另一批任务之前，我们通过计算一组新任务`Ti`中最佳参数![](img/2512d04a-c678-4f01-acdf-0a1273b11fff.png)的梯度来更新随机初始化的模型参数θ。
 
 # 监督学习中的 MAML
 
@@ -189,7 +189,7 @@ def __init__(self):
         self.num_samples = 10
 ```
 
-以下是纪元数，即训练迭代：
+以下是周期数，即训练迭代：
 
 ```py
         self.epochs = 1000

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

@@ -446,7 +446,7 @@ Sampling Next Batch of Tasks
 
 # 爬行动物算法
 
-爬行动物是一种简单而有效的算法。 爬行动物可以实现串行和批处理版本。 在串行版本中，我们仅从任务分发中抽样一个任务，而在批处理版本中，我们对一批任务进行抽样并尝试找到最佳参数。 我们将看到 Reptile 的串行版本如何工作。 爬行动物所涉及的步骤顺序如下：
+爬行动物是一种简单而有效的算法。 爬行动物可以实现串行和批量版本。 在串行版本中，我们仅从任务分发中抽样一个任务，而在批量版本中，我们对一批任务进行抽样并尝试找到最佳参数。 我们将看到 Reptile 的串行版本如何工作。 爬行动物所涉及的步骤顺序如下：
 
 1.  假设我们有任务![](img/1024a056-8186-4c04-96dd-c60de2fd985b.png)的分布，并且我们随机初始化模型参数![](img/91b92f8b-de9b-42fc-866c-4aef6f620f33.png)。
 2.  现在我们从任务分配![](img/a7a4e492-c505-4001-bd7c-48007efbf0f1.png)中抽取任务`T`。

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

@@ -47,7 +47,7 @@
 
 ![](img/bf3a2201-8469-4802-8e8b-1a77b6c35ad8.png)
 
-假设我们抽样了一批任务。 然后，对于批处理中的每个任务，我们对`k`个数据点进行采样，计算损失，更新梯度，并找到每个任务的最佳参数![](img/0e057c74-bf55-427f-80f8-ad8f9c980161.png)。 与此同时，我们还将每个任务的梯度更新向量存储在![](img/d3270793-e1ed-4c1b-9cf5-0749201fb690.png)中。 可以计算为![](img/885389fb-9c2a-4a41-9600-270f46c23850.png)。
+假设我们抽样了一批任务。 然后，对于批量中的每个任务，我们对`k`个数据点进行采样，计算损失，更新梯度，并找到每个任务的最佳参数![](img/0e057c74-bf55-427f-80f8-ad8f9c980161.png)。 与此同时，我们还将每个任务的梯度更新向量存储在![](img/d3270793-e1ed-4c1b-9cf5-0749201fb690.png)中。 可以计算为![](img/885389fb-9c2a-4a41-9600-270f46c23850.png)。
 
 因此，![](img/db1dd637-56c6-490d-85ef-047f78be9815.png)任务的权重是![](img/af4e2919-4e2b-47f7-9060-12e4f5b1b242.png)和![](img/6c387c39-bc77-4e18-88f0-48060009e4d3.png)的内积之和除以归一化因子。 归一化因子与![](img/d2497d95-29c0-40d4-8073-ccda9852f5d2.png)和![](img/a7fa1fc1-556f-40dd-af23-15f759a7dca7.png)的内积成正比。
 

new/handson-rl-py/05.md

@@ -359,7 +359,7 @@ env.close()
 2.  我们通过 epsilon-greedy 策略（![](img/00134.jpeg)）选择一个动作，然后从一种状态转移到另一种状态
 3.  我们遵循更新规则![](img/00135.jpeg)来更新`Q`值的先前状态，其中`a'`是由`ε`贪婪策略（![](img/00136.jpeg)）选择的操作
 
-现在，我们将逐步了解算法。 让我们考虑相同的冰冻湖的例子。 假设我们处于`(4, 2)`状态。 我们根据 epsilon-greedy 策略决定采取的措施。 假设我们使用概率为 1- epsilon 并选择最佳操作，即**对**：
+现在，我们将逐步了解算法。 让我们考虑相同的冰冻湖的例子。 假设我们处于`(4, 2)`状态。 我们根据 epsilon-greedy 策略决定采取的措施。 假设我们使用概率为 1-epsilon 并选择最佳操作，即**向右**：
 
 ![](img/00137.jpeg)
 
@@ -377,7 +377,7 @@ Q( (4,2), right) = Q( (4,2),right) + 0.1 ( 0.3 + 1 Q( (4,3), action)) - Q((4,2)
 
 ![](img/00139.jpeg)
 
-我们在这里也遵循 epsilon-greedy 策略。 我们要么以概率 epsilon 进行探索，要么以概率 1 epsilon 进行利用。 假设我们选择概率ε并探索新的动作。 我们探索一个新动作**，紧接着**，然后选择该动作：
+我们在这里也遵循 epsilon-greedy 策略。 我们要么以概率 epsilon 进行探索，要么以概率 1 epsilon 进行利用。 假设我们选择概率ε并探索新的动作。 我们探索一个新动作**向右**，然后选择该动作：
 
 ![](img/00140.jpeg)
 

new/handson-rl-py/06.md

 # 多臂老虎机问题
 
-在前面的章节中，我们学习了**强化学习**（**RL**）的基本概念和几种 RL 算法，以及如何将 RL 问题建模为 **Markov Decision 处理**（**MDP**）。 我们还看到了用于解决 MDP 的不同的基于模型和无模型的算法。 在本章中，我们将看到 RL 中的经典问题之一，称为**多臂老虎机**（**MAB**）问题。 我们将看到什么是 MAB 问题，以及如何使用不同的算法解决该问题，然后了解如何使用 MAB 识别将接收大部分点击的正确广告横幅。 我们还将学习广泛用于构建推荐系统的上下文老虎机。
+在前面的章节中，我们学习了**强化学习**（**RL**）的基本概念和几种 RL 算法，以及如何将 RL 问题建模为**马尔可夫决策过程**（**MDP**）。 我们还看到了用于解决 MDP 的不同的基于模型和无模型的算法。 在本章中，我们将看到 RL 中的经典问题之一，称为**多臂老虎机**（**MAB**）问题。 我们将看到什么是 MAB 问题，以及如何使用不同的算法解决该问题，然后了解如何使用 MAB 识别将接收大部分点击的正确广告横幅。 我们还将学习广泛用于构建推荐系统的上下文老虎机。
 
 在本章中，您将了解以下内容：
 

new/handson-rl-py/07.md

@@ -67,7 +67,7 @@
 
 ![](img/00166.gif)
 
-*   **ReLU 功能**：ReLU 也称为整流线性单元。 它是使用最广泛的激活功能之一。 ReLU 函数可以定义为`f(z) = max(0, z)`，即当`z`小于 0 且`f(z)`为 0。 当`z`大于或等于`0`时，等于`z`：
+*   **ReLU 函数**：ReLU 也称为整流线性单元。 它是使用最广泛的激活功能之一。 ReLU 函数可以定义为`f(z) = max(0, z)`，即当`z`小于 0 且`f(z)`为 0。 当`z`大于或等于`0`时，等于`z`：
 
 ![](img/00168.gif)
 
@@ -232,13 +232,13 @@ Why += -alpha * dJ_dWxh
 
 在继续之前，让我们熟悉一下神经网络中一些常用的术语：
 
-*   **正向传递**：正向传递意味着从输入层到输出层的正向传播。
-*   **向后传递**：向后传递表示从输出层向输入层的反向传播。
-*   **纪元**：纪元指定了神经网络看到我们整个训练数据的次数。 因此，对于所有训练样本，我们可以说一个时期等于一个向前通过和一个向后通过。
-*   **批处理大小**：批处理大小指定了我们在一次向前和向后一次通过中使用的训练样本数。
+*   **正向传播**：正向传播意味着从输入层到输出层的正向传播。
+*   **反向传播**：反向传播表示从输出层向输入层的反向传播。
+*   **周期**：周期指定了神经网络看到我们整个训练数据的次数。 因此，对于所有训练样本，我们可以说一个时期等于一个向前通过和一个向后通过。
+*   **批量大小**：批量大小指定了我们在一次向前和向后一次通过中使用的训练样本数。
 *   **迭代次数**：迭代次数表示通过次数，其中`一遍 = 一次正向 + 一次反向`。
 
-假设我们有 12,000 个训练样本，而我们的批次大小为 6,000。 我们将需要两个迭代来完成一个纪元。 也就是说，在第一次迭代中，我们传递了前 6,000 个样本，并执行了前向遍历和后向遍历； 在第二次迭代中，我们传递接下来的 6,000 个样本，并执行正向传递和反向传递。 经过两次迭代，我们的神经网络将看到整个 12,000 个训练样本，这使它成为一个纪元。
+假设我们有 12,000 个训练样本，而我们的批次大小为 6,000。 我们将需要两个迭代来完成一个周期。 也就是说，在第一次迭代中，我们传递了前 6,000 个样本，并执行了前向遍历和后向遍历； 在第二次迭代中，我们传递接下来的 6,000 个样本，并执行正向传播和反向传递。 经过两次迭代，我们的神经网络将看到整个 12,000 个训练样本，这使它成为一个周期。
 
 # TensorFlow 中的神经网络
 
@@ -657,7 +657,7 @@ def predict(seed,i):
     return indices
 ```
 
-我们设置`batch_size`，批数和`epochs`的数量以及`shift`值以生成批处理：
+我们设置`batch_size`，批数和`epochs`的数量以及`shift`值以生成批量：
 
 ```py
 batch_size=100

new/intel-proj-py/02.md

@@ -397,7 +397,7 @@ adam = optimizers.Adam(lr=0.00001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, deca
 
 # 根据验证日志丢失对检查点进行建模
 
-它始终是一个很好的做法，以保存模型时所选择的评估验证分数提高。 对于我们的项目，我们将跟踪验证日志丢失，并随着验证得分在不同时期的提高而保存模型。 这样，在训练之后，我们将保存提供最佳验证分数的模型权重，而不是保存我们停止训练后的最终模型权重。 训练将继续进行，直到达到为训练定义的最大纪元数，或者直到连续`10`个纪元的验证日志丢失都没有减少为止。 当`3`时期的验证日志丢失没有改善时，我们还将降低学习率。 以下代码块可用于执行学习率降低和检查点操作：
+它始终是一个很好的做法，以保存模型时所选择的评估验证分数提高。 对于我们的项目，我们将跟踪验证日志丢失，并随着验证得分在不同时期的提高而保存模型。 这样，在训练之后，我们将保存提供最佳验证分数的模型权重，而不是保存我们停止训练后的最终模型权重。 训练将继续进行，直到达到为训练定义的最大周期数，或者直到连续`10`个周期的验证日志丢失都没有减少为止。 当`3`时期的验证日志丢失没有改善时，我们还将降低学习率。 以下代码块可用于执行学习率降低和检查点操作：
 
 ```py
 reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.50,
@@ -740,7 +740,7 @@ def main(self):
       print("Processing Time",time.time() - start_time,' secs')
 ```
 
-我们可以更改几个参数，例如学习率，批处理大小，图像大小等，并且我们可以进行实验以得出一个不错的模型。 在训练阶段，模型位置保存在`model_save_dest`字典中，该字典被写入`dict_model`文件中。
+我们可以更改几个参数，例如学习率，批量大小，图像大小等，并且我们可以进行实验以得出一个不错的模型。 在训练阶段，模型位置保存在`model_save_dest`字典中，该字典被写入`dict_model`文件中。
 
 在推理阶段，该模型仅基于训练后的模型对新的测试数据进行预测。
 
@@ -769,11 +769,11 @@ Processing Time 26009.3344039917 secs
 
 **问题是，我们是否需要一次将所有数据加载到内存中？**
 
-由于神经网络适用于小型批次，因此我们只需要与一个小型批次对应的数据即可一次通过反向传播训练模型。 类似地，对于下一个反向传播，我们可以丢弃与当前批次相对应的数据，然后处理下一个批次。 因此，以某种方式，每个小型批处理中的内存需求仅是与该批处理相对应的数据。 因此，我们可以在训练时创建动态批处理，从而避免在内存较少的机器上训练深度学习模型。 Keras 具有在训练时创建动态批次的良好功能，我们将在下一节中讨论。
+由于神经网络适用于小型批次，因此我们只需要与一个小型批次对应的数据即可一次通过反向传播训练模型。 类似地，对于下一个反向传播，我们可以丢弃与当前批次相对应的数据，然后处理下一个批次。 因此，以某种方式，每个小型批量中的内存需求仅是与该批量相对应的数据。 因此，我们可以在训练时创建动态批量，从而避免在内存较少的机器上训练深度学习模型。 Keras 具有在训练时创建动态批次的良好功能，我们将在下一节中讨论。
 
 # 训练期间动态创建迷你批次
 
-仅加载与小批量对应的数据的一种方法是通过从其位置随机处理图像来动态创建小批量。 小批量处理的图像数量将等于我们指定的小批量大小。 当然，由于在训练期间会动态创建小批量生产，因此在训练过程中会遇到一些瓶颈，但是这一瓶颈可以忽略不计。 特殊的软件包，例如`keras`，具有有效的动态批处理创建机制。 我们将在训练过程中利用 keras 中的`flow_from_directory`功能动态创建迷你批，以减少训练过程的内存需求。 我们仍将继续使用`ImageDataGenerator`进行图像增强。 可以如下定义火车生成器和验证生成器。
+仅加载与小批量对应的数据的一种方法是通过从其位置随机处理图像来动态创建小批量。 小批量处理的图像数量将等于我们指定的小批量大小。 当然，由于在训练期间会动态创建小批量生产，因此在训练过程中会遇到一些瓶颈，但是这一瓶颈可以忽略不计。 特殊的软件包，例如`keras`，具有有效的动态批量创建机制。 我们将在训练过程中利用 keras 中的`flow_from_directory`功能动态创建迷你批，以减少训练过程的内存需求。 我们仍将继续使用`ImageDataGenerator`进行图像增强。 可以如下定义火车生成器和验证生成器。
 
 通过将`pre_process`函数作为输入输入到`ImageDataGenerator`的`preprocessing_function`中，完成从三个通道中减去平均图像像素强度的图像预处理步骤：
 
@@ -1004,7 +1004,7 @@ def inception_pseudo(dim=224,freeze_layers=30,full_freeze='N'):
 
 # 使用 keras 顺序 utils 作为生成器
 
-Keras 具有一个名为`keras.utils.sequence()`的优秀批处理生成器，可帮助您以极大的灵活性自定义批处理创建。 实际上，使用`keras.utils.sequence()`可以设计整个纪元流水线。 我们将在此回归问题中使用此实用程序以习惯该实用程序。 对于迁移学习问题，我们可以使用`keras.utils.sequence()`设计生成器类，如下所示：
+Keras 具有一个名为`keras.utils.sequence()`的优秀批量生成器，可帮助您以极大的灵活性自定义批量创建。 实际上，使用`keras.utils.sequence()`可以设计整个周期流水线。 我们将在此回归问题中使用此实用程序以习惯该实用程序。 对于迁移学习问题，我们可以使用`keras.utils.sequence()`设计生成器类，如下所示：
 
 ```py
 class DataGenerator(keras.utils.Sequence):
@@ -1071,11 +1071,11 @@ class DataGenerator(keras.utils.Sequence):
 
 在前面的代码中，我们使用`keras.utils.Sequence`定义了`DataGenerator`类。
 
-我们定义数据生成器以接受图像文件名，标签，批处理大小，类数以及我们希望将图像调整大小的尺寸。 另外，我们指定是否希望将图像在一个时代中的处理顺序进行混排。
+我们定义数据生成器以接受图像文件名，标签，批量大小，类数以及我们希望将图像调整大小的尺寸。 另外，我们指定是否希望将图像在一个时代中的处理顺序进行混排。
 
 我们指定的功能是从`keras.utils.Sequence`继承的，因此，这些功能中每个功能的特定活动都无法在其他位置指定。`len`函数用于计算一个时期中的批次数。
 
-类似地，在`on_epoch_end`函数中，我们可以指定在纪元结束时要执行的活动，例如改组纪元中要处理输入的顺序。 我们可以在每个时期创建一组不同的数据集进行处理。 当我们有大量数据并且我们不想在每个时期处理所有数据时，这通常很有用。 `__getitem__`功能通过提取与特定于批次的所有数据点索引相对应的数据来帮助创建批次。 如果数据创建过程更复杂，则可以利用`__data_generation `函数具有特定于批处理中每个单独数据点提取的逻辑。 例如，我们将与批处理中的数据点索引相对应的文件名传递给`__data_generation`函数，以使用`opencv`读取每个图像，并使用`preprocess`函数对其进行预处理，我们必须进行平均像素减法。
+类似地，在`on_epoch_end`函数中，我们可以指定在周期结束时要执行的活动，例如改组周期中要处理输入的顺序。 我们可以在每个时期创建一组不同的数据集进行处理。 当我们有大量数据并且我们不想在每个时期处理所有数据时，这通常很有用。 `__getitem__`功能通过提取与特定于批次的所有数据点索引相对应的数据来帮助创建批次。 如果数据创建过程更复杂，则可以利用`__data_generation `函数具有特定于批量中每个单独数据点提取的逻辑。 例如，我们将与批量中的数据点索引相对应的文件名传递给`__data_generation`函数，以使用`opencv`读取每个图像，并使用`preprocess`函数对其进行预处理，我们必须进行平均像素减法。
 
 基于回归的迁移学习的训练函数可以编码如下：
 

new/intel-proj-py/04.md

@@ -300,7 +300,7 @@ def build_generator(self,image,reuse=False,name='generator'):
 
 # DiscoGAN 的区别
 
-DiscoGAN 的区分者将学会在特定域中将真实图像与假图像区分开。 我们将有两个鉴别符：一个用于域 A，一个用于域 B。这些鉴别器也是可以执行二进制分类的卷积网络。 与传统的基于分类的卷积网络不同，鉴别器没有任何全连接层。 使用步长为 2 的卷积对输入图像进行下采样，直到最终层（输出为 1 x 1）为止。同样，我们使用泄漏的 ReLU 作为激活函数并使用批处理归一化以实现稳定和快速的收敛。 以下代码显示了 TensorFlow 中鉴别器构建函数的实现：
+DiscoGAN 的区分者将学会在特定域中将真实图像与假图像区分开。 我们将有两个鉴别符：一个用于域 A，一个用于域 B。这些鉴别器也是可以执行二进制分类的卷积网络。 与传统的基于分类的卷积网络不同，鉴别器没有任何全连接层。 使用步长为 2 的卷积对输入图像进行下采样，直到最终层（输出为 1 x 1）为止。同样，我们使用泄漏的 ReLU 作为激活函数并使用批量归一化以实现稳定和快速的收敛。 以下代码显示了 TensorFlow 中鉴别器构建函数的实现：
 
 ```py
 def build_discriminator(self,image,reuse=False,name='discriminator'):
@@ -604,7 +604,7 @@ def save_model(self,checkpoint_dir,step):
 | Adam 优化器的学习率 | `self.l_r = 2e-4` | 我们应该始终训练学习率较低的 GAN 网络以获得更好的稳定性，而 DiscoGAN 也不例外。 |
 | Adam 优化器的衰减率 | `self.beta1 = 0.5` `self.beta2 = 0.99` | 参数`beta1`定义梯度的衰减平均值，而参数`beta2`定义梯度平方的衰减平均值。 |
 | 时代 | `self.epoch = 200` | 在此实现中，`200`时期足以满足 DiscoGAN 网络的收敛要求。 |
-| 批量大小 | `self.batch_size = 64` | `64`的批处理大小非常适合此实现。 但是，由于资源限制，我们可能不得不选择较小的批处理大小。 |
+| 批量大小 | `self.batch_size = 64` | `64`的批量大小非常适合此实现。 但是，由于资源限制，我们可能不得不选择较小的批量大小。 |
 | 学习率线性下降的时期 | `epoch_step = 10` | 在`epoch_step`指定的时期数之后，学习率呈线性下降，由以下方案确定：`lr = self.l_r if epoch < self.epoch_step else self.l_r*(self.epoch-epoch)/(self.epoch-self.epoch_step)` |
 
 # 调用培训

new/intel-proj-py/05.md

@@ -376,7 +376,7 @@ probs = []
 
 # 为每个迷你批次建立损失
 
-在 LSTM 2 的每个时间步长上，优化的损失是关于从字幕单词的整个语料库中预测正确单词的分类交叉熵损失。 对于批处理中的所有数据点，在解码阶段的每个步骤中都会累积相同的内容。 与解码阶段的损耗累积相关的代码如下：
+在 LSTM 2 的每个时间步长上，优化的损失是关于从字幕单词的整个语料库中预测正确单词的分类交叉熵损失。 对于批量中的所有数据点，在解码阶段的每个步骤中都会累积相同的内容。 与解码阶段的损耗累积相关的代码如下：
 
 ```py
             labels = tf.expand_dims(caption[:, i+1], 1)

new/intel-proj-py/06.md

@@ -633,7 +633,7 @@ TensorFlow ops `self.x_`指的是给定隐藏层激活`self.h`的可见层激活
             print("RBM training Completed !")
 ```
 
-在前面的函数中要强调的重要一点是使用自定义`next_batch`函数创建随机批次。 该函数在下面的代码片段中定义，并且用于定义迭代器`batch_gen`，该迭代器可以由`next`方法调用以检索下一个迷你批处理：
+在前面的函数中要强调的重要一点是使用自定义`next_batch`函数创建随机批次。 该函数在下面的代码片段中定义，并且用于定义迭代器`batch_gen`，该迭代器可以由`next`方法调用以检索下一个迷你批量：
 
 ```py
 def next_batch(self):

new/intel-proj-py/07.md

@@ -301,11 +301,11 @@ def _build_model(self):
             print(results)
 ```
 
-# 批处理生成器
+# 批量生成器
 
-在`train`函数中，我们将使用批次生成器根据传递的批次大小生成随机批次。 生成器功能可以定义如下。 请注意，这些功能使用`yield`代替`return`。 通过使用所需参数调用函数，将创建批处理的迭代器对象。 可以通过将`next`方法应用于迭代器对象来检索批次。 我们将在每个时期开始时调用生成器函数，以便在每个时期中批次都是随机的。
+在`train`函数中，我们将使用批次生成器根据传递的批次大小生成随机批次。 生成器功能可以定义如下。 请注意，这些功能使用`yield`代替`return`。 通过使用所需参数调用函数，将创建批量的迭代器对象。 可以通过将`next`方法应用于迭代器对象来检索批次。 我们将在每个时期开始时调用生成器函数，以便在每个时期中批次都是随机的。
 
-以下代码段说明了用于生成批处理迭代器对象的函数：
+以下代码段说明了用于生成批量迭代器对象的函数：
 
 ```py
 def batch_gen(self,X,y,batch_size):

new/intel-proj-py/09.md

@@ -77,7 +77,7 @@ Q 值表也通过迭代`t`进行索引，因为代理只能查看到目前为止
 
 该图学习将每对状态`(s, a)`和动作映射到输出 Q 值输出`Q(s, a)`，而在右侧图中，对于每个状态`s`，我们学习与每个动作`a`有关的 Q 值。 如果每个状态都有`n`个可能的动作，则网络的输出会产生`n`输出`Q(s, a[1]), Q(s, a[2]), ..., Q(s, a[n])`。
 
-深度 Q 学习网络的训练方法很简单，称为体验重播。 让 RL 代理与环境交互并将经验以`(s, a, r, s')`的元组形式存储在重播缓冲区中。 可以从此重播缓冲区采样迷你批处理以训练网络。 首先，重播缓冲区是随机存储的。
+深度 Q 学习网络的训练方法很简单，称为体验重播。 让 RL 代理与环境交互并将经验以`(s, a, r, s')`的元组形式存储在重播缓冲区中。 可以从此重播缓冲区采样迷你批量以训练网络。 首先，重播缓冲区是随机存储的。
 
 # 制定成本函数
 

new/intel-proj-py/10.md

@@ -197,9 +197,9 @@ def create_dict_char_to_index():
 
 # 数据产生器
 
-动态生成一批训练和验证数据对于有效训练 CNN 至关重要。 在训练开始之前将所有数据加载到内存中可能会导致数据存储问题，因此在训练期间读取 CAPTCHA 并动态构建批处理是有意义的。 这导致资源的最佳利用。
+动态生成一批训练和验证数据对于有效训练 CNN 至关重要。 在训练开始之前将所有数据加载到内存中可能会导致数据存储问题，因此在训练期间读取 CAPTCHA 并动态构建批量是有意义的。 这导致资源的最佳利用。
 
-我们将使用一个可用于构建训练和验证批次的数据生成器。 生成器将在初始化期间存储 CAPTCHA 文件的位置，并在每个时期动态构建批处理。 在每个文件之后，文件的顺序会随机打乱，以免在每个纪元中都不能以相同的顺序遍历验证码图像。 这通常可以确保模型在训练期间不会卡在不良的局部最小值上。 数据生成器类可以如下编码：
+我们将使用一个可用于构建训练和验证批次的数据生成器。 生成器将在初始化期间存储 CAPTCHA 文件的位置，并在每个时期动态构建批量。 在每个文件之后，文件的顺序会随机打乱，以免在每个周期中都不能以相同的顺序遍历验证码图像。 这通常可以确保模型在训练期间不会卡在不良的局部最小值上。 数据生成器类可以如下编码：
 
 ```py
 class DataGenerator(keras.utils.Sequence):
@@ -497,7 +497,7 @@ def discriminator(img_dim,alpha=0.2):
     return model
 ```
 
-在上一个代码块中定义的鉴别器网络将伪造的生成器图像和真实的 SVHN 图像作为输入，并将它们传递到最终输出层之前的`3` 2D 卷积集。 在该网络中的卷积之后没有合并，而是通过批处理规范化和`LeakyReLU`激活。
+在上一个代码块中定义的鉴别器网络将伪造的生成器图像和真实的 SVHN 图像作为输入，并将它们传递到最终输出层之前的`3` 2D 卷积集。 在该网络中的卷积之后没有合并，而是通过批量规范化和`LeakyReLU`激活。
 
 下图显示了鉴别器的网络架构（“图 10.6”）：
 
@@ -517,7 +517,7 @@ def discriminator(img_dim,alpha=0.2):
 
 生成器`g`创建`d`鉴别器将评估的伪造图像，并尝试将其标记为伪造。
 
-在`g_d`网络中，`g`生成器创建伪造的图像，然后尝试欺骗`d`鉴别器，使其相信它们是真实的。 鉴别器网络使用二进制交叉熵损失进行编译，并且针对鉴别器参数![](img/6aa6ad30-837f-4350-9b4e-b85ee34c1e2c.png)优化了损失，而`g_d`网络则针对`g`发生器的参数![](img/22188bac-edd4-466e-ab93-79220d59ab05.png)进行了编译 为了欺骗歧视者。 因此，`g_d`网络损失是与鉴别器将所有伪造图像标记为真实图像有关的二进制交叉熵损失。 在每个小型批处理中，基于与`g_d`和`d`网络相关的损耗的优化来更新生成器和鉴别器权重：
+在`g_d`网络中，`g`生成器创建伪造的图像，然后尝试欺骗`d`鉴别器，使其相信它们是真实的。 鉴别器网络使用二进制交叉熵损失进行编译，并且针对鉴别器参数![](img/6aa6ad30-837f-4350-9b4e-b85ee34c1e2c.png)优化了损失，而`g_d`网络则针对`g`发生器的参数![](img/22188bac-edd4-466e-ab93-79220d59ab05.png)进行了编译 为了欺骗歧视者。 因此，`g_d`网络损失是与鉴别器将所有伪造图像标记为真实图像有关的二进制交叉熵损失。 在每个小型批量中，基于与`g_d`和`d`网络相关的损耗的优化来更新生成器和鉴别器权重：
 
 ```py
 def train(dest_train,outdir,
@@ -669,11 +669,11 @@ python captcha_gan.py train --dest_train '/home/santanu/Downloads/train_32x32.ma
 
 图 10.7a：在第 5 阶段生成的示例验证码
 
-以下屏幕截图显示了在纪元 51 生成的示例验证码的结果：
+以下屏幕截图显示了在周期 51 生成的示例验证码的结果：
 
 ![](img/7a319546-7c50-4437-bf92-75247fc7826d.png)
 
-图 10.7b：在纪元 51 生成的样本验证码
+图 10.7b：在周期 51 生成的样本验证码
 
 以下屏幕截图显示了在时期 100 生成的示例验证码的结果：
 

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

@@ -110,7 +110,7 @@
 *   **权重初始化策略**：必须使用一些值来初始化网络中每个感知器的权重，并且优化算法将逐步更改这些值以最大程度地减少损失。 您可以通过多种方式初始化这些值。 您可以用全零初始化。 多年来，研究人员习惯于使用随机正态分布进行初始化，但近年来，研究人员提出了更好的选择，包括 Xavier 初始化和 He 初始化。
 *   **正则化策略**：这是一项可选功能，但强烈建议您使用该功能，因为深度学习模型由于计算出的参数数量过多，往往会过拟合数据。 您可以使用许多选择，包括 L1 正则化，L2 正则化和辍学正则化策略。 在本书中，我们不会在示例中使用正则化，但请记住，如果您要构建真正有效的深度学习模型，则很有可能需要正则化策略。
 
-*   **训练策略**：训练策略是指将数据呈现给训练算法的方式。 这不是模型本身的一部分，但是会影响模型的结果和性能。 在谈论训练深度学习模型时，您会听到“ epoch”一词。 一个时期是所有训练实例通过网络的第一步。 在这些深度学习模型中，您将不得不多次将数据呈现给网络，以便网络可以为模型学习最佳参数。 这里还有另一个概念：批量大小。 这是同时显示给训练算法的元素数量。 因此，在深度学习模型的情况下，我们不向模型提供整个训练数据集。 我们要做的是呈现数据集的批次，并且在每批次中，我们仅发送几个示例，也许是 100 或 50，这就是我们训练深度学习模型的方式。 现在，您可以使用时期和批处理大小来计算模型中的迭代次数，这就是训练步骤数，这是优化算法对模型权重进行调整的次数。 因此，例如，如果您有 1,000 个训练示例，并且将使用的批处理大小为 100，则将需要 10 次迭代才能完成一个纪元。 您可以使用以下公式获得迭代总数：
+*   **训练策略**：训练策略是指将数据呈现给训练算法的方式。 这不是模型本身的一部分，但是会影响模型的结果和性能。 在谈论训练深度学习模型时，您会听到“ epoch”一词。 一个时期是所有训练实例通过网络的第一步。 在这些深度学习模型中，您将不得不多次将数据呈现给网络，以便网络可以为模型学习最佳参数。 这里还有另一个概念：批量大小。 这是同时显示给训练算法的元素数量。 因此，在深度学习模型的情况下，我们不向模型提供整个训练数据集。 我们要做的是呈现数据集的批次，并且在每批次中，我们仅发送几个示例，也许是 100 或 50，这就是我们训练深度学习模型的方式。 现在，您可以使用时期和批量大小来计算模型中的迭代次数，这就是训练步骤数，这是优化算法对模型权重进行调整的次数。 因此，例如，如果您有 1,000 个训练示例，并且将使用的批量大小为 100，则将需要 10 次迭代才能完成一个周期。 您可以使用以下公式获得迭代总数：
 
 ![](img/c5dca712-14af-4483-8080-112349aedbb5.png)
 

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

@@ -65,7 +65,7 @@ relu = np.vectorize(relu)
 *   **权重初始化策略**：为此，我们将使用 Xavier 初始化程序，该方法实际上是 TensorFlow 的`fully_connected`函数默认提供的方法。
 *   **正则化策略**：我们将不使用任何正则化策略。
 
-*   **训练策略**：我们将使用 20 个纪元。 数据集将被呈现给网络 20 次，并且在每次迭代中，我们将使用 80 的批处理大小。因此，我们将数据一次呈现给网络 80 个点，并将整个数据集呈现给网络 20 次。
+*   **训练策略**：我们将使用 20 个周期。 数据集将被呈现给网络 20 次，并且在每次迭代中，我们将使用 80 的批量大小。因此，我们将数据一次呈现给网络 80 个点，并将整个数据集呈现给网络 20 次。
 
 # 建立 DNN
 
@@ -126,7 +126,7 @@ y = tf.placeholder(tf.int64)
 
 # 培训策略和分类准确性评估
 
-在这里，我们设置培训策略。 我们将使用 20 个时期，批处理大小为 80。在所有这些单元格中，我们已经建立了将在该程序中使用的计算图。 以下屏幕截图显示了用于显示训练策略的代码行以及用于评估分类准确性的两个节点：
+在这里，我们设置培训策略。 我们将使用 20 个时期，批量大小为 80。在所有这些单元格中，我们已经建立了将在该程序中使用的计算图。 以下屏幕截图显示了用于显示训练策略的代码行以及用于评估分类准确性的两个节点：
 
 ![](img/c059d22e-2a90-4e34-94ba-d7f806e01d5a.png)
 
@@ -138,7 +138,7 @@ y = tf.placeholder(tf.int64)
 
 在第 3 行中，我们初始化程序中的所有变量。 现在，在这里，我们没有任何明确的变量。 但是，内部的变量是全连接。 `fully_connected`函数是我们包含权重的所有隐藏层的地方。 这些就是变量，这就是为什么我们必须使用`global_ variables_initializer`对象初始化变量并运行此节点的原因。 对于每个时期，我们运行此循环 20 次。 现在，对于批次数量超过 80 的示例数量中的每次迭代，我们将获得要素和目标的值。 因此，每次迭代将有 80 个数据点。 然后，我们运行训练操作，并将通过`x`； 我们将传递特征值，在这里我们将传递目标值。 请记住，`x`和`y`是我们的占位符。 然后，我们评估训练的准确性，然后评估测试数据集中的准确性，从而获得测试数据集。 我们来自`mnist.test.images`，因此现在这些都是功能，`test.labels`是目标。 然后，在这两个循环完成之后，我们将打印两个精度。
 
-然后，我们为测试数据集中的前 15 张图像生成一些单独的预测。 运行此步骤后，我们获得了第一个纪元，其训练准确度为 86%，测试准确度为 88-89%。 以下屏幕截图显示了训练的结果以及不同时期的测试结果：
+然后，我们为测试数据集中的前 15 张图像生成一些单独的预测。 运行此步骤后，我们获得了第一个周期，其训练准确度为 86%，测试准确度为 88-89%。 以下屏幕截图显示了训练的结果以及不同时期的测试结果：
 
 ![](img/16acb53f-7d10-4c38-9d16-273f6bd7b386.png)
 
@@ -166,7 +166,7 @@ y = tf.placeholder(tf.int64)
 *   **损失函数**：我们将使用均方误差，因为我们在这里进行回归问题，这是`loss`函数的最佳选择之一。
 *   **权重初始化策略：**为此，我们将使用 Xavier 初始化程序，它是 TensorFlow 中`fully_connected`函数的默认设置。
 *   **正则化策略**：我们将不使用任何正则化策略。
-*   **训练策略**：我们将使用 40 个纪元。 我们将数据集呈现给网络 40 次，并且在每次迭代中，每次运行训练操作时，我们都会使用 50 个数据点的批次。 因此，我们将使用数据集中的 50 个元素。
+*   **训练策略**：我们将使用 40 个周期。 我们将数据集呈现给网络 40 次，并且在每次迭代中，每次运行训练操作时，我们都会使用 50 个数据点的批次。 因此，我们将使用数据集中的 50 个元素。
 
 # 建立 DNN
 
@@ -186,7 +186,7 @@ y = tf.placeholder(tf.int64)
 
 # 培训策略
 
-这是具有 40 个纪元且批量大小为 50 个的训练策略。它是使用以下代码行创建的：
+这是具有 40 个周期且批量大小为 50 个的训练策略。它是使用以下代码行创建的：
 
 ```py
 n_epochs = 40
@@ -252,7 +252,7 @@ y = tf.placeholder(y_train.dtype)
 
 ![](img/ea17818a-74ea-4811-ad41-4040102b4673.png)
 
-变量是`fully_connected`函数中隐含的权重。 然后，对于每个时期，我们初始化迭代器对象并传递训练数据集。 在这里，我们有`batch_data`，我们运行此`next_ element`节点，并得到 50 个批次。我们可以获取特征值和标签，我们可以获取标签，然后可以运行训练操作。 当对象数据用完时，我们会收到错误消息。 在这种情况下，当我们遇到这些错误之一时，这意味着我们已经使用了所有训练数据集。 然后，我们从`while`循环中跳出，进入下一个纪元。 稍后，我们产生一些单独的预测，因此您可以查看该神经网络所做的具体预测。
+变量是`fully_connected`函数中隐含的权重。 然后，对于每个时期，我们初始化迭代器对象并传递训练数据集。 在这里，我们有`batch_data`，我们运行此`next_ element`节点，并得到 50 个批次。我们可以获取特征值和标签，我们可以获取标签，然后可以运行训练操作。 当对象数据用完时，我们会收到错误消息。 在这种情况下，当我们遇到这些错误之一时，这意味着我们已经使用了所有训练数据集。 然后，我们从`while`循环中跳出，进入下一个周期。 稍后，我们产生一些单独的预测，因此您可以查看该神经网络所做的具体预测。
 
 以下屏幕截图显示了在我们向该网络展示数据时所有 40 个时期的训练和测试 MSE 的行为：
 
@@ -278,7 +278,7 @@ y = tf.placeholder(y_train.dtype)
 
 ![](img/1e4604f6-28a4-4da0-9faa-de706a4da045.png)
 
-上面的屏幕截图显示，在`0`处，我们没有拐角。 对于 ReLU 功能，我们有一个角落。 在此函数中，我们将 ELU 函数缓慢地移至负 alpha 参数，而不是将单个值移至`0`。
+上面的屏幕截图显示，在`0`处，我们没有拐角。 对于 ReLU 函数，我们有一个角落。 在此函数中，我们将 ELU 函数缓慢地移至负 alpha 参数，而不是将单个值移至`0`。
 
 # DNN 分类
 
@@ -307,8 +307,8 @@ y = tf.placeholder(y_train.dtype)
     方法的默认方法，该方法与
     TensorFlow 中的`fully_connected`函数一起提供。
 *   **正则化策略**：我们将不使用任何正则化策略。
-*   **训练策略**：我们将使用 40 个纪元。 因此，我们将 40 次数据集
-    呈现给网络，并且在每次迭代中，我们将使用 100 的批处理大小。
+*   **训练策略**：我们将使用 40 个周期。 因此，我们将 40 次数据集
+    呈现给网络，并且在每次迭代中，我们将使用 100 的批量大小。
 
 # 建立 DNN
 
@@ -332,7 +332,7 @@ y = tf.placeholder(y_train.dtype)
 
 # 培训策略
 
-这是我们前面提到的训练策略，共 40 个时期，批处理大小为
+这是我们前面提到的训练策略，共 40 个时期，批量大小为
 100。以下代码块显示了我们在此策略中设置的参数：
 
 ```py

new/whats-new-tf2/2.md

@@ -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(

new/whats-new-tf2/3.md

 # 设计和构建输入数据管道
 
-本章将概述如何构建复杂的输入数据管道，以使用由`TFRecords`组成的`tf.data` API 来以最常见的格式（例如 CSV 文件，图像，文本等）提取大型训练/推理数据集。 和`tf.data.Dataset`方法。 您还将获得有关协议缓冲区，协议消息以及如何使用 **TensorFlow 2.0**（**TF 2.0**）中的`TFRecords`和`tf.Example`方法实现的一般概念。 本章还说明了在数据的混洗，批处理和预取方面使用`tf.data.Dataset`方法的最佳实践，并针对 TF 2.0 提供了建议。 最后，我们将讨论内置的 TensorFlow 数据集...
+本章将概述如何构建复杂的输入数据管道，以使用由`TFRecords`组成的`tf.data` API 来以最常见的格式（例如 CSV 文件，图像，文本等）提取大型训练/推理数据集。 和`tf.data.Dataset`方法。 您还将获得有关协议缓冲区，协议消息以及如何使用 **TensorFlow 2.0**（**TF 2.0**）中的`TFRecords`和`tf.Example`方法实现的一般概念。 本章还说明了在数据的混洗，批量和预取方面使用`tf.data.Dataset`方法的最佳实践，并针对 TF 2.0 提供了建议。 最后，我们将讨论内置的 TensorFlow 数据集...
 
 # 技术要求
 
@@ -20,7 +20,7 @@
 
 # 将数据拆分为训练，验证和测试数据
 
-ML 模型训练的数据准备的关键特征之一是能够将现有数据分为训练，验证和测试集。 训练数据是已看到并用于拟合或训练模型的数据； 例如，神经网络的学习权重和偏见。 验证数据（有时称为开发数据）用于微调模型的超参数，例如学习率，要使用的优化程序等等。 模型会经常查看此数据（例如，在每次迭代或新纪元之后）并评估模型。
+ML 模型训练的数据准备的关键特征之一是能够将现有数据分为训练，验证和测试集。 训练数据是已看到并用于拟合或训练模型的数据； 例如，神经网络的学习权重和偏见。 验证数据（有时称为开发数据）用于微调模型的超参数，例如学习率，要使用的优化程序等等。 模型会经常查看此数据（例如，在每次迭代或新周期之后）并评估模型。
 
 请注意，验证数据仅可帮助您微调模型。 它不会更新权重和偏见。
 
@@ -32,7 +32,7 @@ TFRecords 的创建是输入数据管道的核心，因此您可以创建`tf.dat
 
 ![](img/41f35661-5631-45f1-8c96-42505714c4a3.png)
 
-**TFRecords** 通过将数据序列化到磁盘来帮助我们有效地读取数据，并且可以存储在一组 **TFRecords** 文件中。 每个文件的建议大小为 100 MB 到 200 MB。 应该注意的是`TFRecord`是可以存储任何类型数据的二进制格式。 由于是二进制格式，因此它占用的磁盘空间更少，并且从磁盘存储进行复制或读取所需的时间也更少。 当训练数据太大而无法存储在内存服务器，GPU 和/或 TPU 中时，还需要 **TFRecords** 。 使用带有数据集的 **TFRecords** ，可以按批形式从磁盘按需加载数据（将在本章稍后的*批处理*中对此进行解释） 部分）。
+**TFRecords** 通过将数据序列化到磁盘来帮助我们有效地读取数据，并且可以存储在一组 **TFRecords** 文件中。 每个文件的建议大小为 100 MB 到 200 MB。 应该注意的是`TFRecord`是可以存储任何类型数据的二进制格式。 由于是二进制格式，因此它占用的磁盘空间更少，并且从磁盘存储进行复制或读取所需的时间也更少。 当训练数据太大而无法存储在内存服务器，GPU 和/或 TPU 中时，还需要 **TFRecords** 。 使用带有数据集的 **TFRecords** ，可以按批形式从磁盘按需加载数据（将在本章稍后的*批量*中对此进行解释） 部分）。
 
 `TFRecords`有四个重要组成部分：
 
@@ -349,7 +349,7 @@ ds = ds.filter(lambda x: x > 3) # ==> [1, 2]
 
 良好的随机播放还有助于减少数据的差异，该数据用于模型...
 
-# 批处理
+# 批量
 
 梯度下降与反向传播相结合是最近机器学习或深度神经网络系统中最流行的学习算法。 梯度下降有三种：
 
@@ -357,11 +357,11 @@ 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`提供了一种以高效且无缝的方式创建一批样本的好方法，如以下代码块所示：
 
@@ -372,11 +372,11 @@ dataset = dataset.repeat(count = None)
 dataset = dataset.batch(batch_size, drop_remainder=True)
 ```
 
-`batch(...)` API 将此数据集的连续元素合并为批处理。 `batch_size`是传递给此 API 的超参数。 在第 4 章，“模型训练和 TensorBoard 的使用”中，我们将讨论并提供批量建议。
+`batch(...)` API 将此数据集的连续元素合并为批量。 `batch_size`是传递给此 API 的超参数。 在第 4 章，“模型训练和 TensorBoard 的使用”中，我们将讨论并提供批量建议。
 
 # 预取
 
-批处理完成后，建议使用`prefetch(...)` API。 该 API 将输入数据集转换为新数据集，该数据集可从输入数据集中预提取元素。 该 API 之所以重要，是因为它收集了在模型为当前批次提供服务时将加载到输入管道中的下一个批次：
+批量完成后，建议使用`prefetch(...)` API。 该 API 将输入数据集转换为新数据集，该数据集可从输入数据集中预提取元素。 该 API 之所以重要，是因为它收集了在模型为当前批次提供服务时将加载到输入管道中的下一个批次：
 
 ```py
 dataset = tf.data.TFRecordsDataset(...)dataset = dataset.shuffle(buffer_size, seed=None, reshuffle_each_iteration=None)dataset = dataset.repeat(count = None)dataset = dataset.batch(batch_size, drop_remainder=True)dataset = dataset.prefetch(buffer_size)
@@ -396,7 +396,7 @@ for data in ds:
 
 # 将创建的数据集馈入模型
 
-一旦创建，转换和改组数据集对象并完成批处理，就需要将其馈入模型（从本章开头记住 ETL 的 L）。 此步骤在 TF 2.0 中进行了重大更改。
+一旦创建，转换和改组数据集对象并完成批量，就需要将其馈入模型（从本章开头记住 ETL 的 L）。 此步骤在 TF 2.0 中进行了重大更改。
 
 TF 2.0 中创建输入数据管道的一个主要区别在于其简单性。 TF 1.x 需要一个迭代器才能将数据集提供给模型。 为了做到这一点，有几个迭代器可以迭代一批数据。 一种是通过使用数据集对象中的`tf.data.Iterator` API。 TF 1.x 中有一个一次性的，可初始化的，可重新初始化的和可填充的迭代器。 尽管这些迭代器功能非常强大，但它们也增加了大量的复杂性，无论从术语上还是...
 
@@ -438,7 +438,7 @@ def create_tfrecords(cifar10_data_folder, validation_data_idx):  """ function to
 这是在 TF 2.0 中建立有效的输入数据管道时应遵循的最佳实践的摘要：
 
 *   建议在重复转换之前使用改组（`shuffle`）API。
-*   使用预取转换可以重叠生产者（获取下一批数据）和使用者（使用当前数据进行训练）的工作。 另外，非常重要的一点是要注意，在对数据管道进行改组（改组），重复（重复）和批处理（批处理）之后，应将预取转换添加到输入管道的末尾。 看起来应该像这样：
+*   使用预取转换可以重叠生产者（获取下一批数据）和使用者（使用当前数据进行训练）的工作。 另外，非常重要的一点是要注意，在对数据管道进行改组（改组），重复（重复）和批量（批量）之后，应将预取转换添加到输入管道的末尾。 看起来应该像这样：
 
 ```py
 # buffer_size could be either 1 or 2 which represents 1 or 2 batches of data

new/whats-new-tf2/4.md

@@ -220,7 +220,7 @@ model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.1),
 
 # fit（）API
 
-`tf.keras.Model.fit(...)`是训练模型的主要 API。 它以输入训练数据以及（可选）批处理大小，回调等作为输入：
+`tf.keras.Model.fit(...)`是训练模型的主要 API。 它以输入训练数据以及（可选）批量大小，回调等作为输入：
 
 ```py
 model.fit(train_dataset, epochs=10,      callbacks=[tensorboard_callback],          validation_data=val_dataset)
@@ -481,7 +481,7 @@ training_history = model.fit(
 
 在 TensorBoard 中写入用于可视化的图像数据时，也使用文件编写器。 TensorFlow 图像摘要 API 可用于轻松记录张量和任意图像并在 TensorBoard 中查看它们。 这有助于采样和检查输入数据，并可视化模型权重和生成的图像。
 
-为了可视化图像，在文件编写器的上下文中调用`tf.summary.image()`记录一个或多个图像。 此功能采用（批处理，高度，宽度，通道）形式的 4 级张量，因此任何非该格式的图像都必须在将其记录到 TensorBoard 之前进行重塑。 只要将其转换为张量，该 API 还可用于记录任何种类的任意图像数据，例如 Matplotlib 图形。
+为了可视化图像，在文件编写器的上下文中调用`tf.summary.image()`记录一个或多个图像。 此功能采用（批量，高度，宽度，通道）形式的 4 级张量，因此任何非该格式的图像都必须在将其记录到 TensorBoard 之前进行重塑。 只要将其转换为张量，该 API 还可用于记录任何种类的任意图像数据，例如 Matplotlib 图形。
 
 以下代码段是如何将单个图像记录到 TensorBoard 的示例：
 

new/whats-new-tf2/7.md

@@ -269,7 +269,7 @@ class CustomLayer(tf.keras.layers.Layer):
 前面的代码创建了一个名为`CustomLayer`的类，该类继承了`tf.keras.layers.Layer`类的属性。 此技术允许在`tf.keras`模型内部使用任何类型的低级代码，而不管它是使用`Sequential` API 还是`functional` API 的模型。 此类中有两种方法：
 
 *   `build()`：此方法修改继承的类的默认生成方法。 在这种方法中，应该创建模型所需的所有变量。 尽管可以在模型的`the __init__()`方法中完成此操作，但建议使用`build()`，以便在正确的最佳时间构建变量。 可以使用`self.add_weight`函数完成此操作，以使 Keras 跟踪变量和正则化损失。
-*   `call()`：在输入张量上调用模型时，将运行此方法。 此方法通常采用两个参数：`inputs`和`training`。 尽管`inputs`参数是不言自明的，但`training`参数可能不会一直使用，但是对于在该层中使用批处理规范化和辍学的情况而言是必不可少的。 该功能由`tf.function`装饰器批注，以实现签名，基于图的优点以及自动控件的依赖关系。
+*   `call()`：在输入张量上调用模型时，将运行此方法。 此方法通常采用两个参数：`inputs`和`training`。 尽管`inputs`参数是不言自明的，但`training`参数可能不会一直使用，但是对于在该层中使用批量规范化和辍学的情况而言是必不可少的。 该功能由`tf.function`装饰器批注，以实现签名，基于图的优点以及自动控件的依赖关系。
 
 写入此自定义层后，即可在`tf.keras`模块中的任何位置使用它。 对于此转换，将使用`Sequential` API：