diff --git a/new/dl-pt-workshop/1.md b/new/dl-pt-workshop/1.md
index c38a1943643084c88ac446ab78d50582b0e5d53e..8d1542ce3a264fe8eaf0f84401725acda91da0e7 100644
--- a/new/dl-pt-workshop/1.md
+++ b/new/dl-pt-workshop/1.md
@@ -28,11 +28,11 @@ PyTorch 于 2017 年推出，其主要特点是它使用**图形处理单元**
 
     标记数据是指包含一组功能（描述实例的特征）和目标值（要实现的值）的数据； 例如，包含人口统计和财务信息的数据集，其目标特征确定一个人的工资。
 
-    下图显示了在数据量方面深度学习相对于其他算法的性能：
+    下图显示了在数据量方面深度学习相对于其他算法的表现：
 
 ![Figure 1.1: Performance of deep learning against other algorithms ](img/B15778_01_01.jpg)
 
-图 1.1：相对于其他算法的深度学习性能
+图 1.1：相对于其他算法的深度学习表现
 
 如今，由于软件和硬件的进步使我们能够收集和处理这种粒度，这成为可能。
 
diff --git a/new/dl-pt-workshop/2.md b/new/dl-pt-workshop/2.md
index 9f2556141afd315e86affe041eb74297e5250486..185babecc55010612bf14743abe11bcc2a1cb1d8 100644
--- a/new/dl-pt-workshop/2.md
+++ b/new/dl-pt-workshop/2.md
@@ -12,7 +12,7 @@
 
 本章的目的是深入探讨神经网络及其主要优点和缺点的主题，以便您了解何时以及如何使用它们。 然后，我们将解释最流行的神经网络架构的构建块：**人工神经网络**（**ANN**），**卷积神经网络**（**CNN**）和**循环神经网络**（**RNN**）。
 
-接下来，将通过解决现实生活中的回归问题来说明建立有效模型的过程。 这包括准备要馈送到神经网络的数据（也称为数据预处理），定义要使用的神经网络架构以及评估模型的性能，目的是确定如何对其进行改进以实现最佳性能。 最佳解决方案。
+接下来，将通过解决现实生活中的回归问题来说明建立有效模型的过程。 这包括准备要馈送到神经网络的数据（也称为数据预处理），定义要使用的神经网络架构以及评估模型的表现，目的是确定如何对其进行改进以实现最佳表现。 最佳解决方案。
 
 上述过程将使用将在本章中讨论的一种神经网络架构来完成，同时考虑到每个数据问题的解决方案应使用对所讨论的数据类型表现最佳的架构进行。 其他架构将在后续章节中使用，以解决更复杂的数据问题，这些问题涉及使用图像和文本序列作为输入数据。
 
@@ -26,7 +26,7 @@
 
 *   **监督学习**：这是最简单的学习形式，因为它包含一个标记的数据集，其中神经网络会找到解释特征和目标之间关系的模式。 学习过程中的迭代旨在最小化预测值和基本事实之间的差异。 一个例子是根据植物的叶子属性对植物进行分类。
 *   **无监督学习**：与前面的方法相反，无监督学习包括使用未标记数据（意味着没有目标值）训练模型。 这样做的目的是为了更好地理解输入数据。 通常，网络获取输入数据，对其进行编码，然后从编码版本中重建内容，理想情况下保留相关信息。 例如，给定一个段落，神经网络可以映射单词，然后建议哪个单词对该段落最重要或最具描述性。 然后可以将它们用作标签。
-*   **强化学习**：这种方法包括从输入数据中学习，其主要目标是从长远来看最大化奖励功能。 这是通过从传入的数据中学习来实现的，而不是通过对静态数据进行训练（如在监督式学习中）来实现的。 因此，决策不是基于即时奖励，而是基于整个学习过程中累积的奖励。 这样的一个示例是一个模型，该模型将资源分配给不同的任务，其目的是最大程度地减少使总体性能变慢的瓶颈。
+*   **强化学习**：这种方法包括从输入数据中学习，其主要目标是从长远来看最大化奖励功能。 这是通过从传入的数据中学习来实现的，而不是通过对静态数据进行训练（如在监督式学习中）来实现的。 因此，决策不是基于即时奖励，而是基于整个学习过程中累积的奖励。 这样的一个示例是一个模型，该模型将资源分配给不同的任务，其目的是最大程度地减少使总体表现变慢的瓶颈。
 
     注意
 
@@ -90,7 +90,7 @@ Rosenblatt 还介绍了权重的概念（`w1`，`w2`，...，`wn`），这些数
 
 在这里，再次使用一组输入来训练模型，但是不是馈入单个感知器，而是将它们馈入第一层中的所有感知器（神经元）。 接下来，将从这一层获得的输出用作后续层中的感知器的输入，依此类推，直到到达最后一层为止，该层负责输出结果。
 
-请注意，感知器的第一层通过对输入进行加权来处理简单的决策过程，而下一层可以根据前一层的输出来处理更复杂和抽象的决策，从而实现最新的性能。 复杂数据问题的深度神经网络（使用多层的网络）。
+请注意，感知器的第一层通过对输入进行加权来处理简单的决策过程，而下一层可以根据前一层的输出来处理更复杂和抽象的决策，从而实现最新的表现。 复杂数据问题的深度神经网络（使用多层的网络）。
 
 与传统的感知器不同，神经网络已经演化为在输出层中具有一个或多个节点，因此它们能够将结果呈现为二进制或多类。
 
@@ -98,7 +98,7 @@ Rosenblatt 还介绍了权重的概念（`w1`，`w2`，...，`wn`），这些数
 
 一般而言，神经网络由多个神经元组成，其中每个神经元都会计算线性函数以及激活函数，以根据某些输入得出输出（激活函数旨在打破线性关系，稍后在本章中有更详细的说明）。 该输出与权重相关联，该权重代表其重要性级别，并将在下一层中用于计算。
 
-而且，这些计算是在整个网络架构中进行的，直到达到最终输出为止。 与地面实况相比，此输出用于确定网络的性能，然后将其用于调整网络的不同参数以重新开始计算过程。
+而且，这些计算是在整个网络架构中进行的，直到达到最终输出为止。 与地面实况相比，此输出用于确定网络的表现，然后将其用于调整网络的不同参数以重新开始计算过程。
 
 考虑到这一点，神经网络的训练过程可以看作是迭代过程，该过程在网络的各个层中前进和后退以达到最佳结果，如下图所示（损失函数将在后面介绍） 在这一章当中）：
 
@@ -176,7 +176,7 @@ Rosenblatt 还介绍了权重的概念（`w1`，`w2`，...，`wn`），这些数
 
 同样，有多种损失函数可供选择。 但是，用于回归和分类任务的最常用损失函数如下：
 
-*   **均方误差（MSE）**：MSE 函数广泛用于衡量回归模型的性能，它计算真实情况值与预测值之间的距离之和：
+*   **均方误差（MSE）**：MSE 函数广泛用于衡量回归模型的表现，它计算真实情况值与预测值之间的距离之和：
 
 ![Figure 2.14: MSE loss function ](img/B15778_02_14.jpg)
 
@@ -226,7 +226,7 @@ Rosenblatt 还介绍了权重的概念（`w1`，`w2`，...，`wn`），这些数
 
 此处，`α`是指学习率，`dw / db`表示给定神经元中权重或偏差的梯度。 从权重或偏差的原始值中减去两个值的乘积，以惩罚较高的值，这有助于计算较大的损失函数。
 
-梯度下降算法的一种改进版本称为随机梯度下降，它基本上遵循相同的过程，区别在于它以随机批量而不是一个块的形式获取输入数据，从而缩短了训练时间，同时达到了出色的性能。 此外，此方法允许使用较大的数据集，因为通过将小批数据集用作输入，我们不再受计算资源的限制。
+梯度下降算法的一种改进版本称为随机梯度下降，它基本上遵循相同的过程，区别在于它以随机批量而不是一个块的形式获取输入数据，从而缩短了训练时间，同时达到了出色的表现。 此外，此方法允许使用较大的数据集，因为通过将小批数据集用作输入，我们不再受计算资源的限制。
 
 ## 优缺点
 
@@ -245,7 +245,7 @@ Rosenblatt 还介绍了权重的概念（`w1`，`w2`，...，`wn`），这些数
 
 仅仅因为使用神经网络有很多优点，并不意味着每个数据问题都应该以这种方式解决。 这是一个常见的错误。 没有一种算法可以很好地解决所有数据问题，并且选择使用哪种算法应取决于可用的资源以及数据问题。
 
-尽管人们认为神经网络的性能优于几乎所有机器学习算法，但也必须考虑它们的缺点，以便您可以权衡最重要的数据问题。 让我们现在通过它们：
+尽管人们认为神经网络的表现优于几乎所有机器学习算法，但也必须考虑它们的缺点，以便您可以权衡最重要的数据问题。 让我们现在通过它们：
 
 *   **黑盒**：这是神经网络最常见的缺点之一。 从根本上讲，尚不清楚神经网络如何以及为什么达到特定输出。 例如，当神经网络错误地将猫的图片预测为狗时，就不可能知道错误的原因是什么。
 *   **数据要求**：为获得最佳结果而需要的大量数据可能是同一个优点和缺点。 神经网络比传统的机器学习算法需要更多的数据，这可能是在某些数据问题和其他算法之间进行选择的主要原因。 当监督手头的任务时，这将成为一个更大的问题，这意味着需要对数据进行标记。
@@ -381,13 +381,13 @@ RNN 允许以输入序列，输出序列或什至同时以两种形式处理数
 
 当然，在收集数据之后，开发任何深度学习模型的第一步都应该是准备数据。 如果我们希望了解手边的数据以正确地概述项目范围，那么这一点至关重要。
 
-许多数据科学家没有这样做，这导致模型的性能很差，甚至导致模型无用，因为他们没有从一开始就回答数据问题。
+许多数据科学家没有这样做，这导致模型的表现很差，甚至导致模型无用，因为他们没有从一开始就回答数据问题。
 
 数据准备过程可以分为三个主要任务：
 
 1.  了解数据并处理任何潜在问题
 2.  重新缩放特征，以确保不会因错误引入偏差
-3.  拆分数据以能够准确地衡量性能
+3.  拆分数据以能够准确地衡量表现
 
 所有这三个任务将在下一节中进一步说明。
 
@@ -414,7 +414,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
 4.  **缺失值**：类似于上述内容，考虑到不同的模型会对这些值做出不同的假设，因此具有许多缺失值的数据集会给模型带来偏差。 同样，当缺失值占要素值的 5% 以上时，应再次使用均值或回归插补技术，通过消除或替换它们来处理它们。
 5.  **定性特征**：最后，考虑到删除或编码数据可能会导致更准确的模型，因此检查数据集是否包含定性数据也是关键的一步。
 
-    此外，在许多研究开发中，对同一数据测试了几种算法，以确定哪种算法性能更好，并且其中某些算法不能容忍使用定性数据，就像神经网络一样。 这证明了转换或编码它们以便能够向所有算法提供相同数据的重要性。
+    此外，在许多研究开发中，对同一数据测试了几种算法，以确定哪种算法表现更好，并且其中某些算法不能容忍使用定性数据，就像神经网络一样。 这证明了转换或编码它们以便能够向所有算法提供相同数据的重要性。
 
 ## 练习 2.02：处理混乱数据
 
@@ -591,9 +591,9 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
 将数据集分为三个子集的目的是，可以在不引入偏差的情况下对模型进行适当的训练，微调和测量。 这是每个集合的说明：
 
 *   **训练集**：顾名思义，该集合被馈送到要训练的神经网络。 对于监督学习，它由特征和目标值组成。 如前所述，考虑到神经网络需要训练大量数据，通常这是三者中最大的集合。
-*   **验证集（开发集）**：该集主要用于测量模型的性能，以便对超参数进行调整以提高性能。 完成此微调过程是为了使我们可以配置能获得最佳结果的超参数。
+*   **验证集（开发集）**：该集主要用于测量模型的表现，以便对超参数进行调整以提高性能。 完成此微调过程是为了使我们可以配置能获得最佳结果的超参数。
 
-    尽管没有对模型进行数据训练，但模型会对模型产生间接影响，这就是为什么不应该对模型进行最终性能评估的原因，因为它可能是有偏差的度量。
+    尽管没有对模型进行数据训练，但模型会对模型产生间接影响，这就是为什么不应该对模型进行最终表现评估的原因，因为它可能是有偏差的度量。
 
 *   **测试集**：该集对模型没有影响，这就是为什么它用于对看不见的数据进行模型的最终评估的原因，这成为模型在未来的数据集上的表现如何的指南。
 
@@ -938,4 +938,4 @@ Ground truth: 1995.0 Prediction: 1998.0279541015625
 
 还讨论了三种主要类型的神经网络的主要架构：人工神经网络，卷积神经网络和循环神经网络。 第一个用于解决传统的分类或回归问题，第二个由于具有解决计算机视觉问题（例如图像分类）的能力而广受欢迎，第三个可按顺序处理数据，用于语言翻译等任务。
 
-在下一章中，将讨论解决回归问题和分类数据问题之间的主要区别。 您还将学习如何解决分类数据问题，以及如何改善其性能以及如何部署模型。
\ No newline at end of file
+在下一章中，将讨论解决回归问题和分类数据问题之间的主要区别。 您还将学习如何解决分类数据问题，以及如何改善其表现以及如何部署模型。
\ No newline at end of file
diff --git a/new/dl-pt-workshop/3.md b/new/dl-pt-workshop/3.md
index a55ab043032f693394448c031e0d1497d25e29ae..a9caf3f55e08db19a8e1ef8f4e14634a43cac9cf 100644
--- a/new/dl-pt-workshop/3.md
+++ b/new/dl-pt-workshop/3.md
@@ -2,7 +2,7 @@
 
 ### 概述
 
-在本章中，我们将看一个银行业中的实际例子，以解决分类数据问题。 您将学习如何利用 PyTorch 的自定义模块来定义网络架构并训练模型。 您还将探索误差分析的概念，以提高模型的性能。 最后，您将研究部署模型的不同方法，以便将来使用它。 到本章结束时，您将对该过程有深刻的了解，以便可以使用**深度神经网络**（**DNN**）在 PyTorch 中。
+在本章中，我们将看一个银行业中的实际例子，以解决分类数据问题。 您将学习如何利用 PyTorch 的自定义模块来定义网络架构并训练模型。 您还将探索误差分析的概念，以提高模型的表现。 最后，您将研究部署模型的不同方法，以便将来使用它。 到本章结束时，您将对该过程有深刻的了解，以便可以使用**深度神经网络**（**DNN**）在 PyTorch 中。
 
 # 简介
 
@@ -22,7 +22,7 @@
 
 定义问题与建立模型或提高准确率一样重要。 这是因为，虽然您可以使用最强大的算法并使用最先进的方法来改善其结果，但是如果您解决错误的问题或使用错误的数据，这可能毫无意义。
 
-至关重要的是，学习如何深入思考以了解可以做什么和不能做什么以及如何可以完成。 考虑到当我们在学习应用机器学习或深度学习算法时，大多数课程中出现的问题总是清晰定义的，因此除训练模型和提高其性能外无需进行进一步分析，这一点尤其重要。 另一方面，在现实生活中，问题常常令人困惑，数据经常混乱。
+至关重要的是，学习如何深入思考以了解可以做什么和不能做什么以及如何可以完成。 考虑到当我们在学习应用机器学习或深度学习算法时，大多数课程中出现的问题总是清晰定义的，因此除训练模型和提高其表现外无需进行进一步分析，这一点尤其重要。 另一方面，在现实生活中，问题常常令人困惑，数据经常混乱。
 
 在本节中，您将学习一些根据组织的需求和手头的数据来定义问题的最佳实践。
 
@@ -80,11 +80,11 @@
 
 考虑到这一点，似乎目标函数应该是说明客户是否会在下次付款时违约，这将导致二进制结果（是/否）。 这意味着要开发的学习任务是分类任务，因此损失函数应该能够测量这种学习类型的差异（例如，交叉熵函数，如上一章所述）。 。
 
-明确定义问题后，您需要确定最终模型的优先级。 这意味着确定所有输出类别是否同样重要。 例如，建立模型的时候，测量肺部肿块是否恶变的模型应主要集中在使**假负例**最小化（模型预测为无恶性肿块，但实际上是恶性的患者）上。 识别手写字符不应只关注一个特定的字符，而应最大化其在平等地识别所有字符方面的性能。
+明确定义问题后，您需要确定最终模型的优先级。 这意味着确定所有输出类别是否同样重要。 例如，建立模型的时候，测量肺部肿块是否恶变的模型应主要集中在使**假负例**最小化（模型预测为无恶性肿块，但实际上是恶性的患者）上。 识别手写字符不应只关注一个特定的字符，而应最大化其在平等地识别所有字符方面的表现。
 
-考虑到这一点以及“意义”语句中的解释，信用卡客户默认**数据集**的模型优先级应该是在不优先考虑任何类别标签的情况下最大化模型的整体性能 。 这主要是因为“为什么”声明宣称研究的主要目的应该是更好地了解银行将要收到的资金，并对可能拖欠付款的客户采取某些措施（例如，提供将债务分成较小的付款），以及针对那些不会违约的人采取不同的行动（例如，提供优惠作为对行为良好的客户的奖励）。
+考虑到这一点以及“意义”语句中的解释，信用卡客户默认**数据集**的模型优先级应该是在不优先考虑任何类别标签的情况下最大化模型的整体表现 。 这主要是因为“为什么”声明宣称研究的主要目的应该是更好地了解银行将要收到的资金，并对可能拖欠付款的客户采取某些措施（例如，提供将债务分成较小的付款），以及针对那些不会违约的人采取不同的行动（例如，提供优惠作为对行为良好的客户的奖励）。
 
-据此，本案例研究中使用的性能指标是**准确率**，其重点是使**正确分类的实例**最大化。 这是指任何类别标签正确分类的实例与实例总数的比率。
+据此，本案例研究中使用的表现指标是**准确率**，其重点是使**正确分类的实例**最大化。 这是指任何类别标签正确分类的实例与实例总数的比率。
 
 下表简要说明了数据集中存在的每个功能，这些功能可以帮助确定它们与研究目的的相关性，并确定一些需要执行的准备任务：
 
@@ -198,7 +198,7 @@ print("rows:",data.shape[0]," columns:", data.shape[1])
 
     **收集更多数据**：尽管这并非总是可用的途径，但它可能有助于平衡类或允许删除过度代表的类而不会严重减少数据集。
 
-    **更改表现指标**：某些指标（例如准确率）不适用于测量不平衡数据集的性能。 反过来，建议使用诸如精度或召回分类问题之类的指标来衡量性能。
+    **更改表现指标**：某些指标（例如准确率）不适用于测量不平衡数据集的表现。 反过来，建议使用诸如精度或召回分类问题之类的指标来衡量表现。
 
     **重采样数据集**：这需要修改数据集以平衡类。 可以通过两种不同的方式来完成此操作：在代表性不足的类中添加实例的副本（称为过采样），或删除代表性不足的类的实例（称为欠采样）。
 
@@ -231,7 +231,7 @@ print("rows:",data.shape[0]," columns:", data.shape[1])
 
 图 3.6：目标特征的类数
 
-为了解决此问题，并且鉴于没有更多数据要添加并且性能指标实际上是准确率的事实，有必要执行数据重采样。
+为了解决此问题，并且鉴于没有更多数据要添加并且表现指标实际上是准确率的事实，有必要执行数据重采样。
 
 以下是对数据集执行过采样的代码片段，随机创建了代表性不足的类的重复行：
 
@@ -298,7 +298,7 @@ final_data.to_csv("dccc_prepared.csv", index=False)
 
 如“活动 2.02”中所示，从“第 2 章”，“神经网络的构建模块”开发用于回归问题的深度学习解决方案，为回归任务而构建的神经网络使用输出作为连续值，这就是为什么在输出层不具有激活函数且仅具有一个输出节点（实际值）的原因，就像在根据房屋和邻里的特征，构建用于预测房价的模型的情况下一样。 
 
-鉴于此，要测量与此类模型相关的性能，您应该计算真实情况值和预测值之间的差，例如，计算 125.3（预测）与 126.38（真实情况值）之间的距离 。 如前所述，有许多方法可以测量此差异，例如**均方误差**（**MSE**），或另一种变化是**均方根误差**（**RMSE**），是最常用的指标。
+鉴于此，要测量与此类模型相关的表现，您应该计算真实情况值和预测值之间的差，例如，计算 125.3（预测）与 126.38（真实情况值）之间的距离 。 如前所述，有许多方法可以测量此差异，例如**均方误差**（**MSE**），或另一种变化是**均方根误差**（**RMSE**），是最常用的指标。
 
 与此相反，分类任务的输出是属于每个输出标签或类的某些输入要素集合的概率，这是使用 Sigmoid（用于二分类）或 softmax（用于多类分类）完成的 ）激活函数。 对于二元分类任务，输出层应包含一个（对于 Sigmoid）或两个（对于 softmax）输出节点，而对于多类分类任务，输出层应等于类标签的数量。
 
@@ -308,7 +308,7 @@ final_data.to_csv("dccc_prepared.csv", index=False)
 
 在 Python 中， **argmax** 函数是能够沿轴返回最大值索引的函数。
 
-考虑到这一点，模型的性能应与实例是否已分类到正确的类别标签有关，而不是与测量两个值之间的距离有关—因此要使用不同的损失函数（ 熵是最常用的），用于训练神经网络进行分类问题，以及使用不同的性能指标，例如准确率，准确率和召回率。
+考虑到这一点，模型的表现应与实例是否已分类到正确的类别标签有关，而不是与测量两个值之间的距离有关—因此要使用不同的损失函数（ 熵是最常用的），用于训练神经网络进行分类问题，以及使用不同的表现指标，例如准确率，准确率和召回率。
 
 ## 好的架构
 
@@ -316,7 +316,7 @@ final_data.to_csv("dccc_prepared.csv", index=False)
 
 修改并准备好数据后，考虑到在确定隐藏层数或每层中的单元数方面没有正确答案，最好的方法是从初始架构开始（可以进行改进） 以提高性能）。
 
-这一点很重要，因为有时需要使用大量参数进行调整，可能难以承诺某些事情并开始开发解决方案。 但是，考虑到这一点，在训练神经网络时，有几种方法可以确定一旦对初始架构进行了训练和测试，就需要改进哪些内容。 实际上，将您的数据集分为三个子集的全部原因是允许使用一组训练数据集，使用另一组测量和微调模型，最后使用一组模型测量最终模型的性能。 最终未使用过的子集。
+这一点很重要，因为有时需要使用大量参数进行调整，可能难以承诺某些事情并开始开发解决方案。 但是，考虑到这一点，在训练神经网络时，有几种方法可以确定一旦对初始架构进行了训练和测试，就需要改进哪些内容。 实际上，将您的数据集分为三个子集的全部原因是允许使用一组训练数据集，使用另一组测量和微调模型，最后使用一组模型测量最终模型的表现。 最终未使用过的子集。
 
 考虑到所有这些，将解释以下一组惯例和经验法则，以帮助决策过程定义 ANN 的初始架构：
 
@@ -330,7 +330,7 @@ final_data.to_csv("dccc_prepared.csv", index=False)
 *   **输出层**：同样，任何 ANN 仅具有一个输出层。 它包含的单元数取决于要开发的学习任务以及数据问题。 对于回归任务，将只有一个单位，即预测值。 但是，对于分类问题，考虑到模型的输出应该是属于每个类别标签的一组要素的概率，单位数量应等于可用的类别标签的数量。
 *   **其他参数**：对于网络的第一种配置，其他参数应保留其默认值。 这主要是因为，在考虑可能表现相同或较差但需要更多资源的更复杂的近似值之前，最好先对数据问题进行最简单的模型测试。
 
-一旦定义了初始架构，就该训练和测量模型的性能以进行进一步分析了，这很可能导致网络架构或其他参数值的更改，例如更改学习率或增加正则化项。
+一旦定义了初始架构，就该训练和测量模型的表现以进行进一步分析了，这很可能导致网络架构或其他参数值的更改，例如更改学习率或增加正则化项。
 
 ## PyTorch 自定义模块
 
@@ -438,7 +438,7 @@ class Classifier(torch.nn.Module):
 
 解决此问题的另一种方法是对输出层使用`log_softmax`激活函数。 这样，损失函数可以定义为负对数似然损失（`nn.NLLLoss`）。 最后，可以通过从网络输出中获取指数来获得属于每个类别标签的一组要素的概率。 这是本章活动中将使用的方法。
 
-一旦定义了模型架构，下一步将是对负责根据训练数据进行模型训练的部分进行编码，并在训练和验证集上测量其性能。
+一旦定义了模型架构，下一步将是对负责根据训练数据进行模型训练的部分进行编码，并在训练和验证集上测量其表现。
 
 按照我们讨论的这些逐步说明进行操作的代码如下：
 
@@ -468,9 +468,9 @@ batch_size = 100
 
     使用`topk`方法可以获得较高的类标签。
 
-    使用 scikit-learn 的“度量”部分，计算准确率，精确度或查全率。 您还可以探索其他性能指标。
+    使用 scikit-learn 的“度量”部分，计算准确率，精确度或查全率。 您还可以探索其他表现指标。
 
-将所有批量的训练数据输入模型后，将关闭梯度计算，以通过验证数据验证当前模型的性能，如下所示：
+将所有批量的训练数据输入模型后，将关闭梯度计算，以通过验证数据验证当前模型的表现，如下所示：
 
 1.  该模型对验证集中的数据执行预测。
 2.  通过将先前的预测与验证集中的标签进行比较来计算损失函数。
@@ -557,7 +557,7 @@ batch_size = 100
 5.  考虑到要素矩阵应为浮点型，而目标矩阵则应为非浮点型，将验证和测试集转换为张量。 目前暂时不要转换训练集，因为它们将进行进一步的转换。
 6.  构建用于定义网络层的自定义模块类。 包括一个前向功能，该功能指定将应用于每层输出的激活函数。 对于除输出之外的所有层，请使用 **ReLU**，在此处应使用`log_softmax`。
 7.  实例化模型并定义训练模型所需的所有变量。 将时期数设置为`50`，并将批大小设置为`128`。 使用`0.001`的学习率。
-8.  使用训练集的数据训练网络。 使用验证集来衡量性能。 为此，请保存每个时期中训练集和验证集的损失和准确率。
+8.  使用训练集的数据训练网络。 使用验证集来衡量表现。 为此，请保存每个时期中训练集和验证集的损失和准确率。
 
     注意
 
@@ -576,26 +576,26 @@ batch_size = 100
 
 有关此活动的解决方案，请参见第 245 页。
 
-您现在已经成功地编程和训练了一个四层神经网络，该网络能够根据历史数据执行推理。 接下来，您将学习如何提高模型的性能，以便对看不见的数据产生可信赖的推断。
+您现在已经成功地编程和训练了一个四层神经网络，该网络能够根据历史数据执行推理。 接下来，您将学习如何提高模型的表现，以便对看不见的数据产生可信赖的推断。
 
 # 处理欠拟合或过拟合的模型
 
-建立深度学习解决方案不仅是定义架构，然后使用输入数据训练模型的问题； 相反，大多数人同意这是容易的部分。 创建高科技模型的技巧要求达到超越人类性能的高精确度。 本节将介绍误差分析主题，该主题通常用于诊断经过训练的模型，以发现哪些操作更可能对模型的性能产生积极影响。
+建立深度学习解决方案不仅是定义架构，然后使用输入数据训练模型的问题； 相反，大多数人同意这是容易的部分。 创建高科技模型的技巧要求达到超越人类表现的高精确度。 本节将介绍误差分析主题，该主题通常用于诊断经过训练的模型，以发现哪些操作更可能对模型的表现产生积极影响。
 
 ## 误差分析
 
-误差分析是指对训练和验证数据集上的错误率进行的初始分析。 然后，使用此分析来确定改善模型性能的最佳措施。
+误差分析是指对训练和验证数据集上的错误率进行的初始分析。 然后，使用此分析来确定改善模型表现的最佳措施。
 
 为了执行误差分析，有必要确定贝叶斯误差（也称为不可约误差），它是可实现的最小误差。 几十年前，贝叶斯错误等同于人为错误，这意味着专家认为可以达到的最低错误级别。
 
-如今，随着技术和算法的改进，由于机器具有超越人类性能的能力，因此难以估计此值。 没有办法衡量他们与人类相比能做的更好，因为我们只能了解我们的能力。
+如今，随着技术和算法的改进，由于机器具有超越人类表现的能力，因此难以估计此值。 没有办法衡量他们与人类相比能做的更好，因为我们只能了解我们的能力。
 
 为了执行误差分析，通常首先将贝叶斯错误设置为等于人为错误。 然而，这种局限性并非一成不变，研究人员认为，超越人类的表现也应是最终目标。
 
 执行误差分析的过程如下：
 
-1.  计算选择的度量标准以衡量模型的性能。 应该在训练和验证数据集上计算该度量。
-2.  使用此度量，通过减去以前从 1 中计算出的性能指标来计算每个集合的错误率。以下面的等式为例：
+1.  计算选择的度量标准以衡量模型的表现。 应该在训练和验证数据集上计算该度量。
+2.  使用此度量，通过减去以前从 1 中计算出的表现指标来计算每个集合的错误率。以下面的等式为例：
 
     ![Figure 3.9: The equation to calculate the error rate of the model over the training set ](img/B15778_03_09.jpg)
 
@@ -613,7 +613,7 @@ batch_size = 100
 
 图 3.10：显示如何执行误差分析的图
 
-这些规则并不表示该模型只能遭受上述问题之一（高偏差或高方差），而是通过误差分析检测到的问题对模型的性能影响更大，这意味着修复它会在很大程度上提高性能。
+这些规则并不表示该模型只能遭受上述问题之一（高偏差或高方差），而是通过误差分析检测到的问题对模型的表现影响更大，这意味着修复它会在很大程度上提高性能。
 
 让我们解释一下如何处理这些问题：
 
@@ -625,11 +625,11 @@ batch_size = 100
 
     通常可以通过将更多数据添加到训练集中，或通过将正则项添加到损失函数来解决此问题。 第一种方法旨在迫使网络将数据概括化，而不是理解少量示例的细节。 另一方面，第二种方法对权重较高的输入进行惩罚，以忽略异常值，并平等地考虑所有值。
 
-鉴于此，处理影响模型的一种情况可能导致另一种情况出现或增加。 例如，遭受高偏差的模型在经过处理后，可能会在训练数据上而非在验证数据上提高其性能，这意味着该模型将开始遭受高方差，并且将需要另一组要采取的补救措施。
+鉴于此，处理影响模型的一种情况可能导致另一种情况出现或增加。 例如，遭受高偏差的模型在经过处理后，可能会在训练数据上而非在验证数据上提高其表现，这意味着该模型将开始遭受高方差，并且将需要另一组要采取的补救措施。
 
-一旦诊断出模型并采取了必要的措施以改善性能，就应该选择最佳模型进行最终测试。 这些模型中的每一个都应用于对测试集（唯一不影响模型构建的集合）进行预测。
+一旦诊断出模型并采取了必要的措施以改善表现，就应该选择最佳模型进行最终测试。 这些模型中的每一个都应用于对测试集（唯一不影响模型构建的集合）进行预测。
 
-考虑到这一点，可以选择最终模型作为对测试数据表现最佳的模型。 这主要是因为测试数据的性能可以作为模型在未来未见数据集上的性能指标，这是最终目标。
+考虑到这一点，可以选择最终模型作为对测试数据表现最佳的模型。 这主要是因为测试数据的表现可以作为模型在未来未见数据集上的表现指标，这是最终目标。
 
 ## 练习 3.02：执行误差分析
 
@@ -658,15 +658,15 @@ batch_size = 100
 
 2.  确定提高模型准确率所需的操作。
 
-    为了提高模型的性能，可以遵循的两个操作过程是增加时期数并增加隐藏层数和/或单元数（每层中的神经元）。
+    为了提高模型的表现，可以遵循的两个操作过程是增加时期数并增加隐藏层数和/或单元数（每层中的神经元）。
 
     据此，可以执行一组测试以便获得最佳结果。
 
 这样，您就成功地执行了误差分析。 该方法是开发最先进的深度学习解决方案的关键，该解决方案在看不见的数据上表现出色。
 
-## 练习 3 .02：提高模型的性能
+## 练习 3 .02：提高模型的表现
 
-对于此活动，我们将实现在练习中定义的操作，以减少影响模型性能的高偏差。 请考虑以下情形：团队成员对您所做的工作和代码的组织印象深刻，但是考虑到他们对客户的承诺，他们却要求您尝试将性能提高到 80%。 请按照以下步骤完成此活动：
+对于此活动，我们将实现在练习中定义的操作，以减少影响模型表现的高偏差。 请考虑以下情形：团队成员对您所做的工作和代码的组织印象深刻，但是考虑到他们对客户的承诺，他们却要求您尝试将表现提高到 80%。 请按照以下步骤完成此活动：
 
 注意
 
@@ -681,7 +681,7 @@ batch_size = 100
     没有正确的方法来选择首先执行哪个测试，因此要有创造性和分析性。 如果模型架构中的更改减少或消除了高偏差但引入了高方差，则应考虑保留这些更改，但增加措施以应对高方差。
 
 4.  绘制两组数据的损失和准确率。
-5.  使用性能最佳的模型，对测试集进行预测（在微调过程中不应使用该预测）。 通过计算该组模型的准确率，将预测结果与真实情况进行比较。
+5.  使用表现最佳的模型，对测试集进行预测（在微调过程中不应使用该预测）。 通过计算该组模型的准确率，将预测结果与真实情况进行比较。
 
 预期输出：通过模型架构和此处定义的参数获得的精度应为 80% 左右。
 
@@ -689,11 +689,11 @@ batch_size = 100
 
 可以在第 250 页上找到此活动的解决方案。
 
-这样，您就可以使用误差分析成功改善模型的性能。 接下来，您将学习如何部署模型以在生产环境中使用它。
+这样，您就可以使用误差分析成功改善模型的表现。 接下来，您将学习如何部署模型以在生产环境中使用它。
 
 # 部署模型
 
-到目前为止，您已经学习并实践了为常规回归和分类问题构建出色的深度学习模型的关键概念和技巧。 在现实生活中，模型不仅仅是为了学习而构建的。 相反，当出于研究目的以外的目的训练模型时，主要思想是能够在将来重用它们以对新数据进行预测，尽管该模型未经过训练，但该模型应具有相似的良好性能。
+到目前为止，您已经学习并实践了为常规回归和分类问题构建出色的深度学习模型的关键概念和技巧。 在现实生活中，模型不仅仅是为了学习而构建的。 相反，当出于研究目的以外的目的训练模型时，主要思想是能够在将来重用它们以对新数据进行预测，尽管该模型未经过训练，但该模型应具有相似的良好表现。
 
 在小型组织中，可以对模型进行序列化和反序列化。 但是，当模型要由大型公司，用户使用或更改非常重要的大型任务时，将模型转换为可以在大多数生产环境中使用的格式（例如 API， 网站以及在线和离线应用）。
 
@@ -911,8 +911,8 @@ prediction = traced_script(input)
 该活动将使用三个 Jupyter 笔记本。 首先，我们将使用上一个活动中的同一笔记本来保存最终模型。 接下来，我们将打开一个新的笔记本，该笔记本将用于加载保存的模型。 最后，将使用第三个笔记本创建 API。
 
 1.  打开用于“活动 3.02”和“提高模型表现”的 Jupyter 笔记本。
-2.  复制包含最佳性能模型的架构的类，并将其保存在 Python 文件中。 确保导入 PyTorch 所需的库和模块。 将其命名为`final_model.py`。
-3.  在 Jupyter 笔记本中，保存性能最佳的模型。 确保保存与输入单元有关的信息以及模型参数。 将其命名为`checkpoint.pth`。
+2.  复制包含最佳表现模型的架构的类，并将其保存在 Python 文件中。 确保导入 PyTorch 所需的库和模块。 将其命名为`final_model.py`。
+3.  在 Jupyter 笔记本中，保存表现最佳的模型。 确保保存与输入单元有关的信息以及模型参数。 将其命名为`checkpoint.pth`。
 4.  打开一个新的 Jupyter 笔记本。
 5.  导入 PyTorch 以及我们在“步骤 2”中创建的 Python 文件。
 6.  创建一个加载模型的函数。
@@ -948,14 +948,14 @@ prediction = traced_script(input)
 
 在涵盖了前几章的大部分理论知识之后，本章使用了一个实际案例研究来巩固我们的知识。 这样做的目的是鼓励通过动手实践来学习。
 
-本章首先介绍了深度学习对要求准确率的众多行业的影响。 推动深度学习发展的主要行业之一是银行和金融业，这些算法被用于诸如贷款申请评估，欺诈检测以及过去决策评估以预测未来行为等领域，这主要是由于在这些方面，算法具有超越人类性能的能力。
+本章首先介绍了深度学习对要求准确率的众多行业的影响。 推动深度学习发展的主要行业之一是银行和金融业，这些算法被用于诸如贷款申请评估，欺诈检测以及过去决策评估以预测未来行为等领域，这主要是由于在这些方面，算法具有超越人类表现的能力。
 
 本章使用来自台湾一家银行的真实数据集，目的是预测客户是否会拖欠付款。 本章通过解释定义任何数据问题的内容，原因和方式以及分析手头的数据以对其进行最佳利用的重要性，开始开发针对此问题的解决方案。
 
-根据问题定义准备好数据后，我们就探索了定义“良好”架构的想法。 即使可以考虑一些经验法则，但主要的收获还是要构建一个初始架构而又不去想太多，以便获得一些可用于执行误差分析以改善模型性能的结果。
+根据问题定义准备好数据后，我们就探索了定义“良好”架构的想法。 即使可以考虑一些经验法则，但主要的收获还是要构建一个初始架构而又不去想太多，以便获得一些可用于执行误差分析以改善模型表现的结果。
 
-误差分析的思想需要在训练和验证集上分析模型的误差率，以便确定模型是遭受更大的偏差还是承受更大的偏差。 然后，对模型的这种诊断将用于更改模型的架构和一些学习参数，这将导致性能的提高。
+误差分析的思想需要在训练和验证集上分析模型的误差率，以便确定模型是遭受更大的偏差还是承受更大的偏差。 然后，对模型的这种诊断将用于更改模型的架构和一些学习参数，这将导致表现的提高。
 
-最后，我们探索了使用最佳性能模型的三种主要方法。 第一种方法是保存模型，然后将其重新加载到任何编码平台中，以便我们可以继续训练或执行推理。 第二种方法主要用于将模型投入生产，并通过使用 PyTorch 的 JIT 模块来实现，该模块创建可以在 C++ 上运行的模型的序列化表示。 最后，第三种方法包括创建一个可供其他程序访问的 API，以便它可以向模型发送信息或从模型接收信息。
+最后，我们探索了使用最佳表现模型的三种主要方法。 第一种方法是保存模型，然后将其重新加载到任何编码平台中，以便我们可以继续训练或执行推理。 第二种方法主要用于将模型投入生产，并通过使用 PyTorch 的 JIT 模块来实现，该模块创建可以在 C++ 上运行的模型的序列化表示。 最后，第三种方法包括创建一个可供其他程序访问的 API，以便它可以向模型发送信息或从模型接收信息。
 
 在下一章中，我们将重点介绍使用 CNN 解决图像分类任务。
\ No newline at end of file
diff --git a/new/dl-pt-workshop/4.md b/new/dl-pt-workshop/4.md
index 75185e584ce9e6285c7003679045629272833446..28eee46c57ed138f75986e8698a4beac97807651 100644
--- a/new/dl-pt-workshop/4.md
+++ b/new/dl-pt-workshop/4.md
@@ -2,7 +2,7 @@
 
 ### 概述
 
-本章介绍了训练**卷积神经网络**（**CNN**）的过程-也就是说，发生在不同层的计算通常可以在 CNN 架构中找到，其目的可在训练过程中发现。 您将学习如何通过对模型应用数据扩充和批量规范化来改善计算机视觉模型的性能。 到本章末，您将能够使用 CNN 通过 PyTorch 解决图像分类问题。 这将是在计算机视觉领域实现其他解决方案的起点。
+本章介绍了训练**卷积神经网络**（**CNN**）的过程-也就是说，发生在不同层的计算通常可以在 CNN 架构中找到，其目的可在训练过程中发现。 您将学习如何通过对模型应用数据扩充和批量规范化来改善计算机视觉模型的表现。 到本章末，您将能够使用 CNN 通过 PyTorch 解决图像分类问题。 这将是在计算机视觉领域实现其他解决方案的起点。
 
 # 简介
 
@@ -14,7 +14,7 @@
 
 本章将重点介绍在处理图像时 CNN 优于其他架构的原因，并更详细地说明其架构的组成部分。 它将涵盖用于构建 CNN 来解决图像分类数据问题的主要编码结构。
 
-此外，我们将探讨数据扩充和批量规范化的概念，这些概念将用于改善模型的性能。 本章的最终目标是比较三种不同方法的结果，以便使用 CNN 解决图像分类问题。
+此外，我们将探讨数据扩充和批量规范化的概念，这些概念将用于改善模型的表现。 本章的最终目标是比较三种不同方法的结果，以便使用 CNN 解决图像分类问题。
 
 注意
 
@@ -524,7 +524,7 @@ test_loader = torch.utils.data.DataLoader(test_data, \
                                           batch_size=batch_size)
 ```
 
-`DataLoader()`函数用于为每组数据批量加载图像。 首先，将包含集合的变量作为参数传递，然后定义批量大小。 最后，我们在上一步中创建的采样器用于确保随机创建每次迭代中使用的批量，这有助于提高模型的性能。 此函数的结果变量（`train_loader`，`dev_loader`和`test_loader`）将分别包含功能部件和目标的值。
+`DataLoader()`函数用于为每组数据批量加载图像。 首先，将包含集合的变量作为参数传递，然后定义批量大小。 最后，我们在上一步中创建的采样器用于确保随机创建每次迭代中使用的批量，这有助于提高模型的表现。 此函数的结果变量（`train_loader`，`dev_loader`和`test_loader`）将分别包含功能部件和目标的值。
 
 注意
 
@@ -582,7 +582,7 @@ test_loader = torch.utils.data.DataLoader(test_data, \
 
 # 数据扩充
 
-学习如何有效地编码神经网络是开发性能良好的解决方案所涉及的步骤之一。 此外，要开发出色的深度学习解决方案，至关重要的是找到一个感兴趣的领域，我们可以在其中提供解决当前挑战的解决方案。 但是一旦完成所有这些操作，我们通常会面临相同的问题：通过自收集或通过从互联网和其他可用来源下载来获得适当大小的数据集以从模型中获得良好的性能。
+学习如何有效地编码神经网络是开发表现良好的解决方案所涉及的步骤之一。 此外，要开发出色的深度学习解决方案，至关重要的是找到一个感兴趣的领域，我们可以在其中提供解决当前挑战的解决方案。 但是一旦完成所有这些操作，我们通常会面临相同的问题：通过自收集或通过从互联网和其他可用来源下载来获得适当大小的数据集以从模型中获得良好的表现。
 
 您可能会想到，即使现在可以收集和存储大量数据，但由于与之相关的成本，这并不是一件容易的事。 因此，在大多数情况下，我们只能处理包含数万个条目的数据集，而在引用图像时甚至更少。
 
@@ -665,7 +665,7 @@ test_data = datasets.CIFAR10('data', train=False, download=True, \
 
 在此活动中，数据扩充将引入到我们在上一个活动中创建的模型中，以测试其准确率是否可以提高。 让我们看一下以下情况。
 
-您创建的模型不错，但是其准确率达不到期望的水平。 您被要求考虑一种可以改善模型性能的方法。 请按照以下步骤完成此活动：
+您创建的模型不错，但是其准确率达不到期望的水平。 您被要求考虑一种可以改善模型表现的方法。 请按照以下步骤完成此活动：
 
 1.  复制上一个活动中的笔记本。
 2.  修改`transform`变量的定义，使其除了将数据归一化并转换为张量外，还包括以下转换：
@@ -690,7 +690,7 @@ test_data = datasets.CIFAR10('data', train=False, download=True, \
 
 4.  计算测试集上所得模型的准确率。
 
-预期输出：模型在测试集上的性能应为 75% 左右。
+预期输出：模型在测试集上的表现应为 75% 左右。
 
 注意
 
@@ -710,7 +710,7 @@ test_data = datasets.CIFAR10('data', train=False, download=True, \
 
 图 4.20：猫分类器-即使仅使用黑猫训练后，模型也可以识别有色猫
 
-此外，批量归一化为模型的训练过程带来了以下好处，最终可以帮助您获得性能更好的模型：
+此外，批量归一化为模型的训练过程带来了以下好处，最终可以帮助您获得表现更好的模型：
 
 *   它允许设置更高的学习率，因为批量归一化有助于确保任何输出都不是太高或太低。 更高的学习率等同于更快的学习时间。
 *   它有助于减少过拟合，因为它具有正则化效应。这使得可以将丢弃概率设置为一个较低的值，这意味着在每个前向通道中忽略的信息较少。
@@ -754,9 +754,9 @@ class CNN(nn.Module):
 
 ## 活动 4.03：实现批量归一化
 
-对于此活动，我们将在前一个活动的架构上实现批量归一化，以查看是否有可能进一步提高测试集上模型的性能。 让我们看一下以下情况。
+对于此活动，我们将在前一个活动的架构上实现批量归一化，以查看是否有可能进一步提高测试集上模型的表现。 让我们看一下以下情况。
 
-您在性能方面所做的最后改进使您的队友印象深刻，现在他们对您的期望更高。 他们要求您最后一次尝试改进模型，以使准确率提高到 80%。 请按照以下步骤完成此活动：
+您在表现方面所做的最后改进使您的队友印象深刻，现在他们对您的期望更高。 他们要求您最后一次尝试改进模型，以使准确率提高到 80%。 请按照以下步骤完成此活动：
 
 1.  复制上一个活动中的笔记本。
 2.  将批量归一化添加到每个卷积层以及第一个 FC 层。
@@ -788,7 +788,7 @@ class CNN(nn.Module):
 
 这导致引入了图像分类问题，该问题着重于对车辆和动物的图像进行分类。 这个问题的目的是将 CNN 的不同构建块付诸实践，以解决图像分类数据问题。
 
-接下来，数据扩充被引入为一种工具，它通过增加训练示例的数量来提高网络性能，而无需收集更多图像。 该技术专注于创建现有图像的变体，以创建要馈送到模型的“新”图像。
+接下来，数据扩充被引入为一种工具，它通过增加训练示例的数量来提高网络表现，而无需收集更多图像。 该技术专注于创建现有图像的变体，以创建要馈送到模型的“新”图像。
 
 通过实现数据扩充，本章的第二个活动旨在解决相同的图像分类问题，目的是比较结果。
 
diff --git a/new/dl-pt-workshop/5.md b/new/dl-pt-workshop/5.md
index 56aa37b91229d481769a3e1f969ba43607c32804..2f6a6ac5b766913d61ba6208955b6dd29a2fa17b 100644
--- a/new/dl-pt-workshop/5.md
+++ b/new/dl-pt-workshop/5.md
@@ -2,13 +2,13 @@
 
 ### 概述
 
-本章介绍了使用预训练的模型来创建或利用性能良好的算法而不必收集大量数据的过程。 在本章中，您将学习如何从 PyTorch 加载预训练的模型以创建样式迁移模型。 到本章末，您将能够通过使用预训练的模型来执行样式迁移。
+本章介绍了使用预训练的模型来创建或利用表现良好的算法而不必收集大量数据的过程。 在本章中，您将学习如何从 PyTorch 加载预训练的模型以创建样式迁移模型。 到本章末，您将能够通过使用预训练的模型来执行样式迁移。
 
 # 简介
 
-上一章介绍了传统 CNN 的不同构建块，以及一些改进其性能并减少训练时间的技术。 此处说明的架构虽然很典型，但并不是一成不变的，并且出现了许多 CNN 架构来解决不同的数据问题，这在计算机视觉领域最为普遍。
+上一章介绍了传统 CNN 的不同构建块，以及一些改进其表现并减少训练时间的技术。 此处说明的架构虽然很典型，但并不是一成不变的，并且出现了许多 CNN 架构来解决不同的数据问题，这在计算机视觉领域最为普遍。
 
-这些架构的配置和学习任务各不相同。 如今，由牛津机器人学院的 Karen Simonyan 和 Andrew Zisserman 创建的**视觉几何组**（**VGG**）架构是一种非常流行的方法。 它是为对象识别而开发的，并由于网络所依赖的大量参数而达到了最先进的性能。 它在数据科学家中受欢迎的主要原因之一是训练后的模型的参数（权重和偏差）的可用性，这使研究人员无需训练即可使用它，并且模型具有出色的性能。
+这些架构的配置和学习任务各不相同。 如今，由牛津机器人学院的 Karen Simonyan 和 Andrew Zisserman 创建的**视觉几何组**（**VGG**）架构是一种非常流行的方法。 它是为对象识别而开发的，并由于网络所依赖的大量参数而达到了最先进的表现。 它在数据科学家中受欢迎的主要原因之一是训练后的模型的参数（权重和偏差）的可用性，这使研究人员无需训练即可使用它，并且模型具有出色的表现。
 
 在本章中，我们将使用这种经过预训练的模型来解决计算机视觉问题，该问题由于专门用于共享图像的社交媒体渠道的普及而特别著名。 它包括执行样式迁移，以便使用一个图像的样式（颜色和纹理）以及另一个图像的内容（形状和对象）创建新图像。
 
@@ -676,7 +676,7 @@ style_features = features_extractor(style_img, model, \
 
 接下来，加载预训练的模型。 如本章所述，VGG-19 是解决此类任务的最常用架构之一。 它由 19 个层组成，包括卷积层，池化层和全连接层，其中对于所讨论的任务，仅使用某些卷积层。 考虑到 PyTorch 提供了一个包含多个预训练网络架构的子包，加载预训练模型的过程非常简单。
 
-一旦加载了网络，在检测某些对于样式迁移至关重要的功能时，网络的某些层将被识别为性能卓越的提供商。 尽管五个不同的层都具有提取与图像样式相关的特征（例如颜色和纹理）的能力，但是只有一层可以非常出色地提取内容特征（例如边缘和形状）。 因此，至关重要的是定义将用于从输入图像中提取信息以创建所需目标图像的那些层。
+一旦加载了网络，在检测某些对于样式迁移至关重要的功能时，网络的某些层将被识别为表现卓越的提供商。 尽管五个不同的层都具有提取与图像样式相关的特征（例如颜色和纹理）的能力，但是只有一层可以非常出色地提取内容特征（例如边缘和形状）。 因此，至关重要的是定义将用于从输入图像中提取信息以创建所需目标图像的那些层。
 
 最后，是时候对该迭代过程进行编码了，以用于创建具有所需功能的目标图像。 为此，计算了三种不同的损失。 有一个用于比较内容图像和目标图像之间的内容差异（内容损失），另一个用于比较样式图像和目标图像之间的风格差异（样式损失）， 通过计算克矩阵实现。 最后，有一个结合了内容损失和样式损失（总损失）。
 
diff --git a/new/dl-pt-workshop/6.md b/new/dl-pt-workshop/6.md
index 9cc78b8f0a0a5dd14c2cccb50bd3ea15db3e32ee..057489615f5f660be8757769599e1430e50a96a1 100644
--- a/new/dl-pt-workshop/6.md
+++ b/new/dl-pt-workshop/6.md
@@ -678,7 +678,7 @@ while starter[-1] != "." and counter < 50:
 
 注意
 
-值得一提的是，尽管本次活动中的网络经过了足够的迭代训练以显示出令人满意的结果，但并未对其进行训练和配置以实现最佳性能。 鼓励您使用它来提高性能。
+值得一提的是，尽管本次活动中的网络经过了足够的迭代训练以显示出令人满意的结果，但并未对其进行训练和配置以实现最佳表现。 鼓励您使用它来提高性能。
 
 1.  导入所需的库。
 2.  打开并将*爱丽丝梦游仙境*中的文本读到笔记本中。 打印前 50 个字符和文本文件总长度的摘录。
@@ -692,7 +692,7 @@ while starter[-1] != "." and counter < 50:
 
     注意
 
-    根据您的资源，训练过程将花费很长时间，这就是为什么建议仅运行 20 个周期的原因。 但是，本书的 GitHub 存储库中提供了可以在 GPU 上运行的代码的等效版本。 这将使您运行更多的时代并获得出色的性能。
+    根据您的资源，训练过程将花费很长时间，这就是为什么建议仅运行 20 个周期的原因。 但是，本书的 GitHub 存储库中提供了可以在 GPU 上运行的代码的等效版本。 这将使您运行更多的时代并获得出色的表现。
 
 0.  在每一个时代，数据必须被划分为 50 个序列长度的批次。这意味着每个时代将有 100 个序列，每个序列的长度为 50。
 
diff --git a/new/dl-pt-workshop/7.md b/new/dl-pt-workshop/7.md
index 2bd9c99e8a3f556ef9545e51cb78aa40c9f619e9..0fe22e6bbe0bc540300c340fa1d6a3c19a6affb3 100644
--- a/new/dl-pt-workshop/7.md
+++ b/new/dl-pt-workshop/7.md
@@ -396,7 +396,7 @@
     batch_size = 128
     ```
 
-8.  使用训练集的数据来训练网络。使用验证集来衡量性能。要做到这一点，请保存每个时代的训练集和验证集的损失和准确率。
+8.  使用训练集的数据来训练网络。使用验证集来衡量表现。要做到这一点，请保存每个时代的训练集和验证集的损失和准确率。
 
     ```py
     train_losses, dev_losses, \
@@ -520,7 +520,7 @@
 
 3.  考虑到该模型存在较高的偏差，重点应放在增加周期的数量上，或通过在每层中增加额外的层或单位来增加网络的规模。目标应该是将验证集的准确度近似到 80%。
 
-    之后，将显示性能最佳的模型，该模型是在几次微调尝试之后实现的。 首先，定义模型架构和正向传播，如以下代码片段所示：
+    之后，将显示表现最佳的模型，该模型是在几次微调尝试之后实现的。 首先，定义模型架构和正向传播，如以下代码片段所示：
 
     ```py
     class Classifier(nn.Module):
@@ -602,7 +602,7 @@
 
     注意
 
-    可以在以前共享的 GitHub 存储库中找到此活动随附的 Jupyter 笔记本。 在那里，您会发现对模型进行微调的各种尝试及其结果。 性能最佳的型号可以在笔记本电脑的末尾找到。
+    可以在以前共享的 GitHub 存储库中找到此活动随附的 Jupyter 笔记本。 在那里，您会发现对模型进行微调的各种尝试及其结果。 表现最佳的型号可以在笔记本电脑的末尾找到。
 
 4.  绘制两组数据的损失和准确率。
 
@@ -642,7 +642,7 @@
 
     图 3.18：显示集合精度的图
 
-5.  使用性能最好的模型，对测试集（在微调过程中不应该使用）进行预测。通过计算模型在该集上的准确度，将预测结果与基本事实进行比较。
+5.  使用表现最好的模型，对测试集（在微调过程中不应该使用）进行预测。通过计算模型在该集上的准确度，将预测结果与基本事实进行比较。
 
     ```py
     model.eval()
@@ -666,7 +666,7 @@
 ### 解决方案
 
 1.  打开用于上一个活动的 Jupyter 笔记本。
-2.  复制包含最佳性能模型架构的类，并将其保存在 Python 文件中。确保导入了 PyTorch 所需的库和模块，并将其命名为`final_model.py`。将其命名为`final_model.py`。
+2.  复制包含最佳表现模型架构的类，并将其保存在 Python 文件中。确保导入了 PyTorch 所需的库和模块，并将其命名为`final_model.py`。将其命名为`final_model.py`。
 
     该文件应如下所示：
 
@@ -1126,7 +1126,7 @@
     print(acc_test/iter_3)
     ```
 
-    测试集的准确率与其他两组所达到的准确率非常相似，这意味着该模型能够对看不见的数据表现出同样出色的性能。 它应该在 72% 左右。
+    测试集的准确率与其他两组所达到的准确率非常相似，这意味着该模型能够对看不见的数据表现出同样出色的表现。 它应该在 72% 左右。
 
     注意
 
@@ -1178,11 +1178,11 @@
 
     图 4.26：结果图显示了集合的准确率
 
-    通过添加数据扩充，可以改善模型的性能，并减少发生的过拟合。
+    通过添加数据扩充，可以改善模型的表现，并减少发生的过拟合。
 
 4.  计算所得模型在测试集上的精度。
 
-    该模型在测试设备上的性能提高了约 75%。
+    该模型在测试设备上的表现提高了约 75%。
 
     注意
 
@@ -1243,7 +1243,7 @@
 
     图 4.28：结果图显示集合的丢失
 
-    尽管过拟合再次引入了模型，但是我们可以看到两组的性能都有所提高。
+    尽管过拟合再次引入了模型，但是我们可以看到两组的表现都有所提高。
 
     注意
 
@@ -1251,7 +1251,7 @@
 
 4.  计算所得模型在测试集上的精度。
 
-    该模型在测试设备上的性能已提高了约 78%。
+    该模型在测试设备上的表现已提高了约 78%。
 
     注意
 
diff --git a/new/handson-1shot-learn-py/1.md b/new/handson-1shot-learn-py/1.md
index 86840a767d8e777b1b986f800c2afdcb464766c3..ecb38c69cf944bb976ccb3efd43261e2819f8df7 100644
--- a/new/handson-1shot-learn-py/1.md
+++ b/new/handson-1shot-learn-py/1.md
@@ -2,7 +2,7 @@
 
 人们可以通过少量示例学习新事物。 当受到刺激时，人类似乎能够快速理解新概念，然后在将来认识到这些概念的变体。 孩子可以从一张图片中学会识别狗，但是机器学习系统需要大量示例来学习狗的特征并在将来识别它们。 作为一个领域，机器学习在各种任务（例如分类和 Web 搜索以及图像和语音识别）上都取得了巨大的成功。 但是，这些模型通常在没有大量数据（示例）可供学习的情况下表现不佳。 本书的主要动机是使用很少的示例来训练模型，而无需进行大量的重新训练就能够将其概括为不熟悉的类别。
 
-深度学习在机器学习的发展中发挥了重要作用，但它也需要大量的数据集。 不同的技术（例如正则化）可以减少在低数据环境中的过拟合，但不能解决较少的训练示例所固有的问题。 此外，大型数据集导致学习缓慢，需要使用梯度下降法进行许多权重更新。 这主要是由于 ML 算法的参数方面，在该方面需要慢慢学习训练示例。 相反，许多已知的非参数模型（例如最近邻居）不需要任何训练，但是性能取决于有时任意选择的距离度量（例如 L2 距离）。 一次学习是计算机视觉中的对象分类问题。 尽管大多数基于 ML 的对象分类算法都需要数百或数千张图像和非常大的数据集进行训练，但是一次学习的目的是从一个或仅几个训练图像中学习有关对象类别的信息。 在本章中，我们将学习一次学习的基础知识，并探索其实际应用。
+深度学习在机器学习的发展中发挥了重要作用，但它也需要大量的数据集。 不同的技术（例如正则化）可以减少在低数据环境中的过拟合，但不能解决较少的训练示例所固有的问题。 此外，大型数据集导致学习缓慢，需要使用梯度下降法进行许多权重更新。 这主要是由于 ML 算法的参数方面，在该方面需要慢慢学习训练示例。 相反，许多已知的非参数模型（例如最近邻居）不需要任何训练，但是表现取决于有时任意选择的距离度量（例如 L2 距离）。 一次学习是计算机视觉中的对象分类问题。 尽管大多数基于 ML 的对象分类算法都需要数百或数千张图像和非常大的数据集进行训练，但是一次学习的目的是从一个或仅几个训练图像中学习有关对象类别的信息。 在本章中，我们将学习一次学习的基础知识，并探索其实际应用。
 
 本章将涵盖以下主题：
 
@@ -86,7 +86,7 @@
 
 在某些情况下，我们观察到只能具有非常低的特征提取水平。 在这些情况下，我们只能依靠非参数或概率方法，因为要学习参数，我们需要足够数量的数据。 即使我们以某种方式强迫神经网络几乎不学习任何数据，也将导致过拟合。
 
-在下一部分中，我们将进行简短的编码练习，以了解当我们拥有小的数据集时，简单的非参数 kNN 的性能要优于神经网络。 不幸的是，它在现实世界中可能无法很好地工作，因为我们仍然存在学习良好的特征表示并选择合适的距离函数的问题。
+在下一部分中，我们将进行简短的编码练习，以了解当我们拥有小的数据集时，简单的非参数 kNN 的表现要优于神经网络。 不幸的是，它在现实世界中可能无法很好地工作，因为我们仍然存在学习良好的特征表示并选择合适的距离函数的问题。
 
 # 一次学习的类型
 
@@ -152,7 +152,7 @@ jupyter notebook
 
 # 编码练习
 
-在本节中，我们将探索一种基本的一次学习方法。 作为人类，我们有一种分层的思维方式。 例如，如果我们看到一些未知的东西，我们会寻找它与我们已经知道的对象的相似性。 同样，在本练习中，我们将使用非参数 kNN 方法查找类。 我们还将其性能与基本神经网络架构进行比较。
+在本节中，我们将探索一种基本的一次学习方法。 作为人类，我们有一种分层的思维方式。 例如，如果我们看到一些未知的东西，我们会寻找它与我们已经知道的对象的相似性。 同样，在本练习中，我们将使用非参数 kNN 方法查找类。 我们还将其表现与基本神经网络架构进行比较。
 
 # kNN – 基本的一次学习
 
diff --git a/new/handson-1shot-learn-py/2.md b/new/handson-1shot-learn-py/2.md
index 16962756abb6efc7e2beb9b09adc985fb2800d90..c2cbf05dfb51727bf7a35959d3cfecc7000faf1a 100644
--- a/new/handson-1shot-learn-py/2.md
+++ b/new/handson-1shot-learn-py/2.md
@@ -1,6 +1,6 @@
 # 基于指标的方法
 
-深度学习已在各种应用中成功实现了最先进的性能，例如图像分类，对象检测，语音识别等。 但是，深度学习架构在被迫对几乎没有监督信息的数据进行预测时常常会失败。 众所周知，数学是所有机器学习和深度学习模型的基础。 我们使用数据的数学表示将数据和目标传达给机器。 这些表示形式可以有多种形式，特别是如果我们想学习复杂的任务（例如疾病检测），或者如果我们希望我们的架构根据不同的目标学习表示形式，例如，计算两个图像之间的相似度，我们可以计算欧几里得距离和余弦相似度。
+深度学习已在各种应用中成功实现了最先进的表现，例如图像分类，对象检测，语音识别等。 但是，深度学习架构在被迫对几乎没有监督信息的数据进行预测时常常会失败。 众所周知，数学是所有机器学习和深度学习模型的基础。 我们使用数据的数学表示将数据和目标传达给机器。 这些表示形式可以有多种形式，特别是如果我们想学习复杂的任务（例如疾病检测），或者如果我们希望我们的架构根据不同的目标学习表示形式，例如，计算两个图像之间的相似度，我们可以计算欧几里得距离和余弦相似度。
 
 在本章中，我们将学习可以从较小的数据集中学习正确的数学表示形式的深度学习架构。 总体而言，我们的目标是创建一种无需大量数据收集或训练过程即可概括不熟悉类别的架构。
 
diff --git a/new/handson-1shot-learn-py/3.md b/new/handson-1shot-learn-py/3.md
index 1621c0e9b2d5500a4e52666f8cce90b837e72f3f..66e7196b006081e53e01fe235bbb671d8c515ddd 100644
--- a/new/handson-1shot-learn-py/3.md
+++ b/new/handson-1shot-learn-py/3.md
@@ -22,7 +22,7 @@
 *   神经网络仅接受固定大小的输入，这在输入长度可变的现实生活中不会有太大帮助。
 *   神经网络无法将值绑定到我们已知的两个信息系统（人脑和计算机）大量使用的数据结构中的特定位置。 简单来说，在神经网络中，我们无法将特定的权重设置到特定的位置。
 
-第一个问题可以通过在各种任务上实现最先进性能的 RNN 来解决。 通过查看**神经图灵机**（**NTM**）可以解决第二个问题。 在本节中，我们将讨论 NTM 的总体架构，这是理解**记忆增强神经网络**（**MANN**）的基础，这些神经网络修改了 NMT 的架构并使之适用于一次学习任务。
+第一个问题可以通过在各种任务上实现最先进表现的 RNN 来解决。 通过查看**神经图灵机**（**NTM**）可以解决第二个问题。 在本节中，我们将讨论 NTM 的总体架构，这是理解**记忆增强神经网络**（**MANN**）的基础，这些神经网络修改了 NMT 的架构并使之适用于一次学习任务。
 
 # NTM 的架构
 
@@ -80,7 +80,7 @@
 
 ![](img/f6a0bbfd-bfe5-4d2d-8d0e-015fc55c1642.png)
 
-所有操作（包括读取，写入和寻址的四个阶段）都是差分的，因此可以使用反向传播和任何基于梯度下降的优化器从头到尾训练整个 NMT 模型。 控制器是一个神经网络，可以是前馈网络，也可以是循环神经网络，例如**长短期记忆**（**LSTM**）。 它已显示在各种算法任务（例如复制任务）上均具有良好的性能，这些任务将在本章的稍后部分实现。
+所有操作（包括读取，写入和寻址的四个阶段）都是差分的，因此可以使用反向传播和任何基于梯度下降的优化器从头到尾训练整个 NMT 模型。 控制器是一个神经网络，可以是前馈网络，也可以是循环神经网络，例如**长短期记忆**（**LSTM**）。 它已显示在各种算法任务（例如复制任务）上均具有良好的表现，这些任务将在本章的稍后部分实现。
 
 既然我们了解了 NTM 的架构和工作原理，我们就可以开始研究 MANN，这是对 NMT 的修改，并且经过修改可以在一次学习中表现出色。
 
diff --git a/new/handson-1shot-learn-py/4.md b/new/handson-1shot-learn-py/4.md
index 8a41ffdbcac9d80643bdeaf2f818d95b29f16973..e8ade32460ef7f06742aed806ec4cdf991425707 100644
--- a/new/handson-1shot-learn-py/4.md
+++ b/new/handson-1shot-learn-py/4.md
@@ -19,7 +19,7 @@
 
 # 梯度下降概述
 
-如果我们研究神经网络架构的学习方法，它通常由很多参数组成，并使用梯度下降算法进行了优化，该算法需要对许多示例进行许多迭代以使其性能良好。 但是，梯度下降算法在其模型中提供了不错的性能，但是在某些情况下，梯度下降优化算法会失败。 让我们在接下来的部分中介绍这种情况。
+如果我们研究神经网络架构的学习方法，它通常由很多参数组成，并使用梯度下降算法进行了优化，该算法需要对许多示例进行许多迭代以使其表现良好。 但是，梯度下降算法在其模型中提供了不错的表现，但是在某些情况下，梯度下降优化算法会失败。 让我们在接下来的部分中介绍这种情况。
 
 当给出有限数量的数据时，梯度下降算法无法优化神经网络的主要原因有两个：
 
@@ -30,7 +30,7 @@
 
 # 了解模型不可知的元学习
 
-**与模型无关的元学习**（**MAML**）尝试通过为每个新任务提供更好的权重初始化来解决梯度下降方法的缺点。 这种方法的关键思想是使用不同的数据集训练模型的参数。 当将其用于新任务时，该模型通过使用已初始化的参数通过一个或多个梯度步骤来微调架构，从而提供更好的性能。 从特征学习的角度来看，这种训练模型参数以使一些梯度步骤可以优化损失函数的方法也可以从构建内部表示的角度来看。 在这种方法中，我们选择通用模型的架构，以便可以将其用于各种任务。 MAML 的主要贡献是一种与模型和任务无关的简单快速学习算法。
+**与模型无关的元学习**（**MAML**）尝试通过为每个新任务提供更好的权重初始化来解决梯度下降方法的缺点。 这种方法的关键思想是使用不同的数据集训练模型的参数。 当将其用于新任务时，该模型通过使用已初始化的参数通过一个或多个梯度步骤来微调架构，从而提供更好的表现。 从特征学习的角度来看，这种训练模型参数以使一些梯度步骤可以优化损失函数的方法也可以从构建内部表示的角度来看。 在这种方法中，我们选择通用模型的架构，以便可以将其用于各种任务。 MAML 的主要贡献是一种与模型和任务无关的简单快速学习算法。
 
 # 了解 MAML 背后的逻辑
 
@@ -76,7 +76,7 @@ MAML 的目的是为模型的参数提供良好的初始化，从而以较少的
 
 结束`repeat`循环。
 
-对于 Omniglot 和 mini-ImageNet 数据集，MAML 能够实现比连体网络，匹配网络和内存增强神经网络更好的性能。 由于事实证明 MAML 的性能更好，因此还有许多其他任务可以使用 MAML。 让我们来看一个这样的变体-**域自适应元学习**（**DAML**）。
+对于 Omniglot 和 mini-ImageNet 数据集，MAML 能够实现比连体网络，匹配网络和内存增强神经网络更好的表现。 由于事实证明 MAML 的表现更好，因此还有许多其他任务可以使用 MAML。 让我们来看一个这样的变体-**域自适应元学习**（**DAML**）。
 
 # MAML 应用–域自适应元学习
 
diff --git a/new/handson-1shot-learn-py/5.md b/new/handson-1shot-learn-py/5.md
index 5e2f58e674ae873863dbd2cfb7f1cf6e0855a44c..16ae761a66f482b5cabdd6b895d90cea4f4401d5 100644
--- a/new/handson-1shot-learn-py/5.md
+++ b/new/handson-1shot-learn-py/5.md
@@ -74,7 +74,7 @@
 
 ![](img/06cbc1c2-9840-44aa-b8f3-a41e2abac4c4.png)
 
-首先，人们倾向于仅从一个或几个示例中学习关于对象的有意义的信息，例如对象边界，并对其进行高精度分类（请参见上图中的`i)`部分）。 另一方面，深度学习模型需要大量带标签的数据才能在诸如对象识别之类的任务上达到人类水平的性能。
+首先，人们倾向于仅从一个或几个示例中学习关于对象的有意义的信息，例如对象边界，并对其进行高精度分类（请参见上图中的`i)`部分）。 另一方面，深度学习模型需要大量带标签的数据才能在诸如对象识别之类的任务上达到人类水平的表现。
 
 其次，人类从一个示例中学习了绝大多数功能，例如，创建新字符（参见上图中的`ii)`部分），将对象/字符分解为各个部分和关系（请参见`iii)`部分），并根据有关现有概念的现有知识开发新的，有意义的概念/字符（请参见上图中的`iv)`部分）。 相反，深度学习模型针对每个任务都需要特殊的损失函数和架构，由于该任务可用的标记数据非常有限，因此通常不切实际。
 
@@ -122,7 +122,7 @@
 
 使用随机渲染功能生成原始二进制字符图像`I[m]`，该函数将笔划轨迹与灰度墨水映射。 这是通过为每个像素分配独立的伯努利概率来实现的。
 
-BPL 是一种高度直观的模型，可以在贝叶斯框架下使用简单的程序为概念建模。 从训练数据中学习概率分布的参数。 在分类和生成的单次计算机视觉任务上，该模型的性能与人类水平的性能相当，其数据需求远低于某些最新的深度学习模型。 这里研究的概率程序非常基础，适合于相当容易的字符识别任务。 BPL 框架支持设计更复杂的程序，这些程序可以对各种对象的复杂表示进行建模。 例如，可以使用此框架对在零件和关系方面具有清晰直观描述的对象（例如车辆，食品，动物，甚至人脸）进行建模。 为此，BPL 框架甚至支持建模抽象知识，例如自然语言语义和物理理论。 然而，这些概率程序需要对数据及其部分，子部分和关系进行手动标记，这是一个耗时的过程，而深度学习方法则是自己学习这些人类直观特征和深层抽象特征。
+BPL 是一种高度直观的模型，可以在贝叶斯框架下使用简单的程序为概念建模。 从训练数据中学习概率分布的参数。 在分类和生成的单次计算机视觉任务上，该模型的表现与人类水平的表现相当，其数据需求远低于某些最新的深度学习模型。 这里研究的概率程序非常基础，适合于相当容易的字符识别任务。 BPL 框架支持设计更复杂的程序，这些程序可以对各种对象的复杂表示进行建模。 例如，可以使用此框架对在零件和关系方面具有清晰直观描述的对象（例如车辆，食品，动物，甚至人脸）进行建模。 为此，BPL 框架甚至支持建模抽象知识，例如自然语言语义和物理理论。 然而，这些概率程序需要对数据及其部分，子部分和关系进行手动标记，这是一个耗时的过程，而深度学习方法则是自己学习这些人类直观特征和深层抽象特征。
 
 # 判别式 K 次学习
 
@@ -218,7 +218,7 @@ K 次测试时间`P(y*, x*, D, W_tilde_MAP) = ∫p(y* | x*, W)P(W | D, W_tilde_M
 
 # 总结
 
-在本章中，我们学习了在贝叶斯框架内开发概率模型的方法，该模型可以极大地减少数据需求并达到人类水平的性能。 从前面讨论的手写字符的示例中，我们还观察到概率模型不仅可以学习如何对字符进行分类，还可以学习基本概念，即以新的方式应用获得的知识，例如从集合中仅有的几个字符生成全新的字符，以及将字符解析为部分和关系。
+在本章中，我们学习了在贝叶斯框架内开发概率模型的方法，该模型可以极大地减少数据需求并达到人类水平的表现。 从前面讨论的手写字符的示例中，我们还观察到概率模型不仅可以学习如何对字符进行分类，还可以学习基本概念，即以新的方式应用获得的知识，例如从集合中仅有的几个字符生成全新的字符，以及将字符解析为部分和关系。
 
 但是，人类学习器需要从具有丰富重叠结构的许多经验中获得的广泛的先前经验来完成新的学习任务。 为了模仿人类学习，图形结构需要具有更多的依赖性，并且需要在模型中内置丰富的归纳偏差。 还应注意，人类在很小的时候就对物体的物理特性（形状，运动和其他力学）有很好的认识。 学习模型不会隐式地捕获对象的直观物理特性，也不会显式地将其嵌入对象中。 直观物理（类似于游戏引擎中嵌入的物理）与概率模型和深度学习的集成，是朝着更健壮的单发学习迈出的重要一步。 最后，由于先验知识以强先验和图形结构的形式嵌入到概率模型中，因此与必须从头学习任务的深度学习模型相比，它们的数据消耗更少。 但这是以在概率模型中进行有效推理的计算挑战为代价的。 在推断时，这些模型必须搜索巨大的概率空间，这对于现代计算机而言是不实际的。 相反，深度学习模型具有精确且计算上便宜的推断。 最近的工作通过使用前馈映射对*摊销*概率推理计算来解决图形模型中的这一推理挑战，可以使用成对的生成/识别网络来学习。 这提供了另一条有希望的研究领域，使深度学习和概率模型更加接近。
 
diff --git a/new/handson-nlp-pt-1x/1.md b/new/handson-nlp-pt-1x/1.md
index 8e55da815e5512957d5bc2714ed28510b9fc3379..26f9693740fddb0644d05f9341e3c20ababd0bf2 100644
--- a/new/handson-nlp-pt-1x/1.md
+++ b/new/handson-nlp-pt-1x/1.md
@@ -80,7 +80,7 @@
 
 ## 模型如何学习？
 
-为了学习模型，我们需要某种评估模型性能的方法。 为此，我们使用称为损失的概念。 **损失**是衡量如何根据其真实值接近模型预测的一种度量。 对于我们数据集中的给定房屋，损失的一种度量可能是真实价格（`y`）与我们的模型预测的价格（`y_hat`）之间的差。 我们可以通过对数据集中所有房屋的平均损失进行评估，从而评估系统中的总损失。 但是，从理论上讲，正损失可以抵消负损失，因此，更常见的损失度量是**均方误差**：
+为了学习模型，我们需要某种评估模型表现的方法。 为此，我们使用称为损失的概念。 **损失**是衡量如何根据其真实值接近模型预测的一种度量。 对于我们数据集中的给定房屋，损失的一种度量可能是真实价格（`y`）与我们的模型预测的价格（`y_hat`）之间的差。 我们可以通过对数据集中所有房屋的平均损失进行评估，从而评估系统中的总损失。 但是，从理论上讲，正损失可以抵消负损失，因此，更常见的损失度量是**均方误差**：
 
 ![](img/Formula_01_005.png)
 
@@ -116,15 +116,15 @@
 
 图 1.8 –过拟合的样本输出
 
-我们现在有一个房子，其大小为 **110 平方米**，以预测价格。 根据我们的直觉，由于该房屋比 **100 平方米**房屋大，我们希望这所房屋的价格会更高，大约 **340,000 美元**。 使用我们的拟合多项式模型，我们可以看到预测的价格实际上低于小房子，约为 **320,000 美元**。 我们的模型适合我们训练过的数据，但不能很好地推广到一个新的，看不见的数据点。 这就是，称为**过拟合**。 由于过拟合，重要的是不要根据训练的数据评估模型的性能，因此我们需要生成单独的一组数据以评估我们的数据。
+我们现在有一个房子，其大小为 **110 平方米**，以预测价格。 根据我们的直觉，由于该房屋比 **100 平方米**房屋大，我们希望这所房屋的价格会更高，大约 **340,000 美元**。 使用我们的拟合多项式模型，我们可以看到预测的价格实际上低于小房子，约为 **320,000 美元**。 我们的模型适合我们训练过的数据，但不能很好地推广到一个新的，看不见的数据点。 这就是，称为**过拟合**。 由于过拟合，重要的是不要根据训练的数据评估模型的表现，因此我们需要生成单独的一组数据以评估我们的数据。
 
 ### 训练与测试
 
-通常，在训练模型时，我们将数据分为两部分：训练数据集和较小的测试数据集。 我们使用训练数据集训练模型，并在测试数据集上对其进行评估。 这样做是为了在看不见的数据集上衡量模型的性能。 如前所述，要使模型成为良好的预测指标，必须将其很好地推广到该模型之前从未见过的一组新数据，而这恰恰是对一组测试数据进行评估所得出的结果。
+通常，在训练模型时，我们将数据分为两部分：训练数据集和较小的测试数据集。 我们使用训练数据集训练模型，并在测试数据集上对其进行评估。 这样做是为了在看不见的数据集上衡量模型的表现。 如前所述，要使模型成为良好的预测指标，必须将其很好地推广到该模型之前从未见过的一组新数据，而这恰恰是对一组测试数据进行评估所得出的结果。
 
 ### 评估模型
 
-尽管我们试图将模型中的损失降到最低，但仅此一项并不能给我们太多有关模型在实际进行预测方面的优势的信息。 考虑一个反垃圾邮件模型，该模型可以预测收到的电子邮件是否为垃圾邮件，并自动将垃圾邮件发送到垃圾文件夹。 评估性能的一种简单方法是**准确率**：
+尽管我们试图将模型中的损失降到最低，但仅此一项并不能给我们太多有关模型在实际进行预测方面的优势的信息。 考虑一个反垃圾邮件模型，该模型可以预测收到的电子邮件是否为垃圾邮件，并自动将垃圾邮件发送到垃圾文件夹。 评估表现的一种简单方法是**准确率**：
 
 ![](img/Formula_01_016.png)
 
diff --git a/new/handson-nlp-pt-1x/2.md b/new/handson-nlp-pt-1x/2.md
index ee4699d37b729de8ec5285dee453d624f21ae50e..36cbe131cbd5e7353fa1d332d368496a23a5fff0 100644
--- a/new/handson-nlp-pt-1x/2.md
+++ b/new/handson-nlp-pt-1x/2.md
@@ -391,7 +391,7 @@ display(pred_table.head())
 
 ## 评估我们的模型
 
-既然我们已经从模型中获得了一些预测，我们就可以使用这些预测来评估模型的质量。 如上一章所述，评估模型性能的一种基本方法是**准确率**。 在这里，我们只是将正确的预测（预测的图像标签等于实际的图像标签）计算为模型做出的预测总数的百分比：
+既然我们已经从模型中获得了一些预测，我们就可以使用这些预测来评估模型的质量。 如上一章所述，评估模型表现的一种基本方法是**准确率**。 在这里，我们只是将正确的预测（预测的图像标签等于实际的图像标签）计算为模型做出的预测总数的百分比：
 
 ```py
 preds = len(predictionlabel)
@@ -405,7 +405,7 @@ print((correct/preds)*100)
 
 图 2.17 –准确率得分
 
-恭喜你！ 您的第一个神经网络能够正确识别近 90% 的看不见的数字图像。 随着我们的前进，我们将看到可能会带来更先进的性能。 但是，到目前为止，我们已经证明使用 PyTorch 创建简单的深度神经网络非常简单。 只需几行代码就可以编写代码，从而获得超越基本机器学习模型（例如回归）所能达到的性能。
+恭喜你！ 您的第一个神经网络能够正确识别近 90% 的看不见的数字图像。 随着我们的前进，我们将看到可能会带来更先进的表现。 但是，到目前为止，我们已经证明使用 PyTorch 创建简单的深度神经网络非常简单。 只需几行代码就可以编写代码，从而获得超越基本机器学习模型（例如回归）所能达到的表现。
 
 # 用于 PyTorch 的 NLP
 
@@ -415,7 +415,7 @@ print((correct/preds)*100)
 
 在此示例中，我们将选择西班牙语和英语的句子：
 
-1.  首先，我们将每个句子拆分成一个单词列表，并将每个句子的语言作为标签。我们取一部分句子来训练我们的模型，并在一边保留一小部分作为我们的测试集。我们这样做是为了在训练完模型后，可以评估模型的性能。
+1.  首先，我们将每个句子拆分成一个单词列表，并将每个句子的语言作为标签。我们取一部分句子来训练我们的模型，并在一边保留一小部分作为我们的测试集。我们这样做是为了在训练完模型后，可以评估模型的表现。
 
     ```py
     ("This is my favourite chapter".lower().split(),\
diff --git a/new/handson-nlp-pt-1x/5.md b/new/handson-nlp-pt-1x/5.md
index 72c9d2eb0e2bcd812e6d2a4b6a325eddda2906d2..361f7a9136514c07755cfdac6081537d7fd4ae7b 100644
--- a/new/handson-nlp-pt-1x/5.md
+++ b/new/handson-nlp-pt-1x/5.md
@@ -149,7 +149,7 @@ LSTM 与 RNN 的结构非常相似。 虽然 LSTM 的各个步骤之间存在一
 
 图 5.10 –双向 LSTM 过程
 
-在这里，我们可以看到我们在整个过程中都保持了这两个隐藏状态，并使用它们来计算最终的隐藏状态`h[t]`。 因此，如果我们希望计算时间步`t`的最终隐藏状态，则可以使用前向隐藏状态`f[t]`，该状态已看到所有单词，包括输入`x[t]`，以及反向隐藏状态`r[t]`，其中已经看到了`x[t]`之后的所有单词。 因此，我们最终的隐藏状态`h[t]`包含隐藏状态，这些状态已经看到了句子中的所有单词，而不仅仅是出现在时间步`t`之前的单词。 这意味着可以更好地捕获整个句子中任何给定单词的上下文。 事实证明，双向 LSTM 可以在多个 NLP 任务上提供比常规单向 LSTM 更高的性能。
+在这里，我们可以看到我们在整个过程中都保持了这两个隐藏状态，并使用它们来计算最终的隐藏状态`h[t]`。 因此，如果我们希望计算时间步`t`的最终隐藏状态，则可以使用前向隐藏状态`f[t]`，该状态已看到所有单词，包括输入`x[t]`，以及反向隐藏状态`r[t]`，其中已经看到了`x[t]`之后的所有单词。 因此，我们最终的隐藏状态`h[t]`包含隐藏状态，这些状态已经看到了句子中的所有单词，而不仅仅是出现在时间步`t`之前的单词。 这意味着可以更好地捕获整个句子中任何给定单词的上下文。 事实证明，双向 LSTM 可以在多个 NLP 任务上提供比常规单向 LSTM 更高的表现。
 
 # 使用 LSTM 构建情感分析器
 
@@ -230,7 +230,7 @@ print(np.mean([len(x) for x in reviews]))
 
 图 5.14 –长度值
 
-我们可以看到最长的句子是`70`个字长，平均句子长度是`11.78`。 为了捕获所有句子中的所有信息，我们希望填充所有句子，使它们的长度为 70。但是，使用更长的句子意味着更长的序列，这会使我们的 LSTM 层变得更深。 这意味着模型训练需要更长的时间，因为我们必须通过更多层反向传播梯度，但是这也意味着我们输入的很大一部分只是稀疏并且充满了空标记，这使得从数据中学习的效率大大降低 。 我们的最大句子长度远大于我们的平均句子长度，这说明了这一点。 为了捕获我们大部分的句子信息而不会不必要地填充我们的输入并使它们太稀疏，我们选择使用`50`的输入大小。 您可能希望尝试在`20`和`70`之间使用不同的输入大小，以了解这如何影响模型性能。
+我们可以看到最长的句子是`70`个字长，平均句子长度是`11.78`。 为了捕获所有句子中的所有信息，我们希望填充所有句子，使它们的长度为 70。但是，使用更长的句子意味着更长的序列，这会使我们的 LSTM 层变得更深。 这意味着模型训练需要更长的时间，因为我们必须通过更多层反向传播梯度，但是这也意味着我们输入的很大一部分只是稀疏并且充满了空标记，这使得从数据中学习的效率大大降低 。 我们的最大句子长度远大于我们的平均句子长度，这说明了这一点。 为了捕获我们大部分的句子信息而不会不必要地填充我们的输入并使它们太稀疏，我们选择使用`50`的输入大小。 您可能希望尝试在`20`和`70`之间使用不同的输入大小，以了解这如何影响模型表现。
 
 我们将创建一个函数，使我们能够填充句子，使它们的大小相同。 对于短于序列长度的评论，我们用空标记填充它们。 对于长度超过序列长度的评论，我们只需丢弃超过最大序列长度的所有标记：
 
@@ -366,7 +366,7 @@ net = SentimentLSTM(n_vocab, n_embed, n_hidden, n_output, n_layers)
 
 ## 训练模型
 
-要训​​练我们的模型，我们必须首先定义我们的数据集。 我们将使用训练数据集来训练模型，在验证集的每一步上评估训练后的模型，然后最后使用看不见的测试数据集来测量模型的最终性能。 我们使用与验证训练分开的测试集的原因是，我们可能希望基于针对验证集的损失来微调模型超参数。 如果这样做，我们可能最终会选择对于该特定验证数据而言性能最佳的超参数。 我们根据看不见的测试集评估最终时间，以确保我们的模型能够很好地推广到训练循环任何部分之前从未见过的数据。
+要训​​练我们的模型，我们必须首先定义我们的数据集。 我们将使用训练数据集来训练模型，在验证集的每一步上评估训练后的模型，然后最后使用看不见的测试数据集来测量模型的最终表现。 我们使用与验证训练分开的测试集的原因是，我们可能希望基于针对验证集的损失来微调模型超参数。 如果这样做，我们可能最终会选择对于该特定验证数据而言表现最佳的超参数。 我们根据看不见的测试集评估最终时间，以确保我们的模型能够很好地推广到训练循环任何部分之前从未见过的数据。
 
 我们已经将模型输入（`x`）定义为`encode_sentences`，但是我们还必须定义模型输出（`y`）。 我们这样做很简单，如下所示：
 
@@ -433,7 +433,7 @@ for epoch in range(n_epochs):
 
 在这里，我们只训练了多个时期的模型，对于每个时期，我们首先使用批量大小参数初始化隐藏层。 在这种情况下，我们设置`batch_size = 1`，因为我们一次只训练我们的模型一个句子。 对于训练装载机中的每批输入语句和标签，我们首先将梯度归零（以防止它们累积），并使用模型的当前状态使用数据的正向传播来计算模型输出。 然后使用此输出，使用模型的预测输出和正确的标签来计算损失。 然后，我们通过网络对该损失进行反向传递，以计算每个阶段的梯度。 接下来，我们使用`grad_clip_norm()`函数裁剪梯度，因为这将阻止梯度爆炸，如本章前面所述。 我们定义了`clip = 5`，这意味着任何给定节点的最大梯度为`5`。 最后，我们通过调用`optimizer.step()`，使用在反向传播中计算出的梯度来更新权重。
 
-如果我们自己运行此循环，我们将训练我们的模型。 但是，我们想在每个时期之后评估模型的性能，以便根据验证数据集确定模型的性能。 我们这样做如下：
+如果我们自己运行此循环，我们将训练我们的模型。 但是，我们想在每个时期之后评估模型的表现，以便根据验证数据集确定模型的表现。 我们这样做如下：
 
 ```py
 if (step % print_every) == 0:            
@@ -463,7 +463,7 @@ if (step % print_every) == 0:            
 torch.save(net.state_dict(), 'model.pkl')
 ```
 
-在为三个时期训练了我们的模型之后，我们注意到了两个主要方面。 我们将首先从好消息开始-我们的模型正在学习一些东西！ 我们的训练损失不仅下降了，而且在每个时期之后，我们在验证集上的损失也下降了。 这意味着我们的模型仅在三个时期后就可以更好地预测看不见的数据的情感！ 坏消息是，我们的模型过拟合。 我们的训练损失比验证损失要低得多，这表明虽然我们的模型已经学会了如何很好地预测训练数据集，但这并不能推广到看不见的数据集。 预期会发生这种情况，因为我们使用的训练数据非常少（仅 2,400 个训练语句）。 当我们训练整个嵌入层时，很可能许多单词在训练集中只出现一次，而在验证集中却没有出现，反之亦然，这使得该模型几乎不可能归纳出我们的语料库中所有不同的单词。 在实践中，我们希望在更大的数据集上训练我们的模型，以使我们的模型学习如何更好地归纳。 我们还在很短的时间内训练了该模型，并且没有执行超参数调整来确定模型的最佳迭代。 随意尝试更改模型中的某些参数（例如训练时间，隐藏状态大小，嵌入大小等），以提高模型的性能。
+在为三个时期训练了我们的模型之后，我们注意到了两个主要方面。 我们将首先从好消息开始-我们的模型正在学习一些东西！ 我们的训练损失不仅下降了，而且在每个时期之后，我们在验证集上的损失也下降了。 这意味着我们的模型仅在三个时期后就可以更好地预测看不见的数据的情感！ 坏消息是，我们的模型过拟合。 我们的训练损失比验证损失要低得多，这表明虽然我们的模型已经学会了如何很好地预测训练数据集，但这并不能推广到看不见的数据集。 预期会发生这种情况，因为我们使用的训练数据非常少（仅 2,400 个训练语句）。 当我们训练整个嵌入层时，很可能许多单词在训练集中只出现一次，而在验证集中却没有出现，反之亦然，这使得该模型几乎不可能归纳出我们的语料库中所有不同的单词。 在实践中，我们希望在更大的数据集上训练我们的模型，以使我们的模型学习如何更好地归纳。 我们还在很短的时间内训练了该模型，并且没有执行超参数调整来确定模型的最佳迭代。 随意尝试更改模型中的某些参数（例如训练时间，隐藏状态大小，嵌入大小等），以提高模型的表现。
 
 尽管我们的模型过拟合，但它仍然学到了一些东西。 现在，我们希望在最终的测试数据集上评估我们的模型。 我们使用之前定义的测试加载器对数据执行了最后一次传递。 在此过程中，我们遍历所有测试数据并使用最终模型进行预测：
 
diff --git a/new/handson-nlp-pt-1x/6.md b/new/handson-nlp-pt-1x/6.md
index 91dd32f3db973311d67e28a041760a708ae109f2..ab2596d81478029607226fb34f1dcd9851a9055a 100644
--- a/new/handson-nlp-pt-1x/6.md
+++ b/new/handson-nlp-pt-1x/6.md
@@ -105,7 +105,7 @@ CNN 背后的基本概念是卷积。 **卷积**本质上是一个滑动窗口
 
 # 构建用于文本分类的 CNN
 
-既然我们了解了 CNN 的基础知识，我们就可以从头开始构建。 在上一章中，我们建立了情感预测模型，其中情感是二分类器；`1`表示正，`0`表示负。 但是，在此示例中，我们的目标是为**多类文本分类**构建 CNN。 在多类别问题中，特定示例只能分类为几种类别之一。 如果一个示例可以分类为许多不同的类别，则这就是多标签分类。 由于我们的模型是多类的，因此这意味着我们的模型将旨在预测我们的输入句子被归为几类中的哪一类。 尽管此问题比二分类任务要困难得多（因为我们的句子现在可以属于许多类别之一，而不是两个类别之一），但我们将证明 CNN 可以在此任务上提供良好的性能。 首先，我们将定义数据。
+既然我们了解了 CNN 的基础知识，我们就可以从头开始构建。 在上一章中，我们建立了情感预测模型，其中情感是二分类器；`1`表示正，`0`表示负。 但是，在此示例中，我们的目标是为**多类文本分类**构建 CNN。 在多类别问题中，特定示例只能分类为几种类别之一。 如果一个示例可以分类为许多不同的类别，则这就是多标签分类。 由于我们的模型是多类的，因此这意味着我们的模型将旨在预测我们的输入句子被归为几类中的哪一类。 尽管此问题比二分类任务要困难得多（因为我们的句子现在可以属于许多类别之一，而不是两个类别之一），但我们将证明 CNN 可以在此任务上提供良好的表现。 首先，我们将定义数据。
 
 ## 定义多类分类数据集
 
@@ -380,7 +380,7 @@ model = model.to(device)
 
 ## 训练 CNN
 
-在定义训练过程之前，我们需要计算性能指标以说明模型的性能（希望！）如何随时间增加。 在我们的二分类任务中，准确率是我们用来衡量表现的简单指标。 对于我们的多分类任务，我们将再次使用准确率，但是计算准确率的过程稍微复杂些，因为我们现在必须确定模型预测的六个类别中的哪个类别以及六个类别中的哪个类别是正确的类别。
+在定义训练过程之前，我们需要计算表现指标以说明模型的表现（希望！）如何随时间增加。 在我们的二分类任务中，准确率是我们用来衡量表现的简单指标。 对于我们的多分类任务，我们将再次使用准确率，但是计算准确率的过程稍微复杂些，因为我们现在必须确定模型预测的六个类别中的哪个类别以及六个类别中的哪个类别是正确的类别。
 
 首先，我们定义一个称为`multi_accuracy`的函数来计算：
 
@@ -436,7 +436,7 @@ for batch in iterator:
     return total_epoch_loss, total_epoch_accuracy
 ```
 
-同样，我们可以定义一个称为`eval`的函数，该函数将在验证数据上调用，以根据尚未训练模型的一组数据来计算训练后的模型性能。 尽管此功能与我们之前定义的训练函数几乎相同，但是我们必须做两个关键的补充：
+同样，我们可以定义一个称为`eval`的函数，该函数将在验证数据上调用，以根据尚未训练模型的一组数据来计算训练后的模型表现。 尽管此功能与我们之前定义的训练函数几乎相同，但是我们必须做两个关键的补充：
 
 ```py
 model.eval()
@@ -444,9 +444,9 @@ model.eval()
 with torch.no_grad():
 ```
 
-这两个步骤将模型设置为评估模式，忽略任何遗漏函数，并确保未计算和更新梯度。 这是因为我们希望在评估性能时冻结模型中的权重，并确保不使用验证数据对模型进行训练，因为我们希望将其与用于训练模型的数据分开保存 。
+这两个步骤将模型设置为评估模式，忽略任何遗漏函数，并确保未计算和更新梯度。 这是因为我们希望在评估表现时冻结模型中的权重，并确保不使用验证数据对模型进行训练，因为我们希望将其与用于训练模型的数据分开保存 。
 
-现在，我们只需要与数据迭代器一起循环调用训练和评估函数，即可训练模型。 我们首先定义希望模型训练的时期数。 我们还定义了我们的模型迄今为止所实现的最低验证损失。 这是因为我们只希望使训练后的模型具有最低的验证损失（即性能最佳的模型）。 这意味着，如果我们的模型训练了多个时期并开始过拟合，那么只有这些模型的最佳性能将被保留，这意味着选择大量时期的后果会更少。
+现在，我们只需要与数据迭代器一起循环调用训练和评估函数，即可训练模型。 我们首先定义希望模型训练的时期数。 我们还定义了我们的模型迄今为止所实现的最低验证损失。 这是因为我们只希望使训练后的模型具有最低的验证损失（即表现最佳的模型）。 这意味着，如果我们的模型训练了多个时期并开始过拟合，那么只有这些模型的最佳表现将被保留，这意味着选择大量时期的后果会更少。
 
 我们将最低的验证损失初始化为无穷大，开始于：
 
diff --git a/new/handson-nlp-pt-1x/7.md b/new/handson-nlp-pt-1x/7.md
index 9296cf72b2392c0a8033cee0bb3cd99c657331d4..9db65819583ec40a0d6e3a4cb45383f03a2db033 100644
--- a/new/handson-nlp-pt-1x/7.md
+++ b/new/handson-nlp-pt-1x/7.md
@@ -400,7 +400,7 @@ def forward(self, input, h, cell):
     model = Seq2Seq(encod, decod, device).to(device)
     ```
 
-在此处尝试使用不同的参数进行试验，看看它如何影响模型的性能。 例如，尽管模型的整体最终性能可能会更好，但是在隐藏层中使用大量尺寸可能会使模型训练速度变慢。 或者，模型可能过拟合。 通常，需要进行实验才能找到性能最佳的模型。
+在此处尝试使用不同的参数进行试验，看看它如何影响模型的表现。 例如，尽管模型的整体最终表现可能会更好，但是在隐藏层中使用大量尺寸可能会使模型训练速度变慢。 或者，模型可能过拟合。 通常，需要进行实验才能找到表现最佳的模型。
 
 在完全定义了 Seq2Seq 模型之后，我们现在就可以开始对其进行训练了。
 
@@ -528,7 +528,7 @@ def forward(self, input, h, cell):
 
 图 7.17 –训练模型
 
-在这里，我们可以看到我们的训练和验证损失似乎都随着时间而下降。 我们可以继续训练模型很多时间，理想情况下，直到验证损失达到最低值为止。 现在，我们可以评估性能最佳的模型，以查看进行实际翻译时的性能。
+在这里，我们可以看到我们的训练和验证损失似乎都随着时间而下降。 我们可以继续训练模型很多时间，理想情况下，直到验证损失达到最低值为止。 现在，我们可以评估表现最佳的模型，以查看进行实际翻译时的表现。
 
 ## 评估模型
 
@@ -579,6 +579,6 @@ def forward(self, input, h, cell):
 
 在本章中，我们介绍了如何从头开始构建序列到序列模型。 我们学习了如何分别对编码器和解码器组件进行编码，以及如何将它们集成到一个模型中，该模型能够将句子从一种语言翻译成另一种语言。
 
-尽管我们的由编码器和解码器组成的序列到序列模型对于序列翻译很有用，但它已不再是最新技术。 在过去的几年中，已经完成了将序列到序列模型与注意力模型结合起来以实现最新性能的方法。
+尽管我们的由编码器和解码器组成的序列到序列模型对于序列翻译很有用，但它已不再是最新技术。 在过去的几年中，已经完成了将序列到序列模型与注意力模型结合起来以实现最新表现的方法。
 
 在下一章中，我们将讨论如何在序列到序列学习的上下文中使用注意力网络，并展示如何使用两种技术来构建聊天机器人。
\ No newline at end of file
diff --git a/new/handson-nlp-pt-1x/8.md b/new/handson-nlp-pt-1x/8.md
index 6be4158656733cee17650ae59be1f251cfb55399..815c9839cc8161e36c9706802a35d6f04d00de37 100644
--- a/new/handson-nlp-pt-1x/8.md
+++ b/new/handson-nlp-pt-1x/8.md
@@ -4,7 +4,7 @@
 
 在上一章中，我们研究了如何构建序列到序列模型以将句子从一种语言翻译成另一种语言。 能够进行基本交互的对话型聊天机器人的工作方式几乎相同。 当我们与聊天机器人交谈时，我们的句子将成为模型的输入。 输出是聊天机器人选择回复的内容。 因此，我们正在训练它如何响应，而不是训练我们的聊天机器人来学习如何解释输入的句子。
 
-我们将在上一章中扩展序列到序列模型，在模型中增加**注意力**。 对序列到序列模型的这种改进意味着我们的模型可以学习输入句子中要查找的位置以获得所需信息的方式，而不是使用整个输入句子决策。 这项改进使我们能够创建具有最先进性能的效率更高的序列到序列模型。
+我们将在上一章中扩展序列到序列模型，在模型中增加**注意力**。 对序列到序列模型的这种改进意味着我们的模型可以学习输入句子中要查找的位置以获得所需信息的方式，而不是使用整个输入句子决策。 这项改进使我们能够创建具有最先进表现的效率更高的序列到序列模型。
 
 在本章中，我们将研究以下主题：
 
@@ -474,7 +474,7 @@ for line in lines[:3]:
 
     a）由于需要学习的参数较少，因此 GRU 已被证明具有更高的计算效率。 这意味着我们的模型使用 GRU 进行训练要比使用 LSTM 进行训练更快。
 
-    b）已证明 GRU 在短数据序列上具有与 LSTM 相似的性能水平。 当学习更长的数据序列时，LSTM 更有用。 在这种情况下，我们仅使用 10 个单词或更少的输入句子，因此 GRU 应该产生相似的结果。
+    b）已证明 GRU 在短数据序列上具有与 LSTM 相似的表现水平。 当学习更长的数据序列时，LSTM 更有用。 在这种情况下，我们仅使用 10 个单词或更少的输入句子，因此 GRU 应该产生相似的结果。
 
     c）事实证明，GRU 在学习小型数据集方面比 LSTM 更有效。 由于我们的训练数据的规模相对于我们要学习的任务的复杂性而言较小，因此我们应该选择使用 GRU。
 
@@ -778,7 +778,7 @@ for line in lines[:3]:
                 }, os.path.join(directory, '{}_{}.tar'.format(iteration, 'checkpoint')))
     ```
 
-现在已经完成了开始训练模型的所有必要步骤，我们需要创建函数以允许我们评估模型的性能。
+现在已经完成了开始训练模型的所有必要步骤，我们需要创建函数以允许我们评估模型的表现。
 
 ## 定义评估过程
 
@@ -987,7 +987,7 @@ print('Response:', ' '.join(output_words))
     decoder.train()
     ```
 
-8.  接下来，我们为编码器和解码器创建优化器。我们将这些优化器初始化为 Adam 优化器，但其他优化器也同样适用。用不同的优化器进行实验可能会产生不同级别的模型性能。如果你之前已经训练过一个模型，如果需要的话，你也可以加载优化器的状态。
+8.  接下来，我们为编码器和解码器创建优化器。我们将这些优化器初始化为 Adam 优化器，但其他优化器也同样适用。用不同的优化器进行实验可能会产生不同级别的模型表现。如果你之前已经训练过一个模型，如果需要的话，你也可以加载优化器的状态。
 
     ```py
     print('Building optimizers ...')
@@ -1043,7 +1043,7 @@ print('Response:', ' '.join(output_words))
 
 ### 评估模型
 
-既然我们已经成功创建并训练了我们的模型，那么现在该评估其性能了。 我们将通过以下步骤进行操作：
+既然我们已经成功创建并训练了我们的模型，那么现在该评估其表现了。 我们将通过以下步骤进行操作：
 
 1.  为了开始评估，我们首先将模型切换到评估模式。与所有其他 PyTorch 模型一样，这样做是为了防止在评估过程中发生任何进一步的参数更新。
 
diff --git a/new/handson-nlp-pt-1x/9.md b/new/handson-nlp-pt-1x/9.md
index 62adbb6adba88124faedb85a612751e1e6ac1ed5..9b54e76284746b6eaf94fb98032b4b3be9e9b9a1 100644
--- a/new/handson-nlp-pt-1x/9.md
+++ b/new/handson-nlp-pt-1x/9.md
@@ -1,10 +1,10 @@
 # “第 9 章”：前方的路
 
-机器学习领域正在迅速扩展，几乎每年都有新的发现。 NLP 的机器学习领域也不例外，其发展迅速，并且在 NLP 任务上的机器学习模型的性能也逐渐提高。
+机器学习领域正在迅速扩展，几乎每年都有新的发现。 NLP 的机器学习领域也不例外，其发展迅速，并且在 NLP 任务上的机器学习模型的表现也逐渐提高。
 
-到目前为止，在本书中，我们已经讨论了许多机器学习方法，这些方法使我们能够构建模型来执行 NLP 任务，例如分类，翻译和通过聊天机器人进行近似对话。 但是，到目前为止，我们的模型的性能相对于人类而言一直较差。 即使使用到目前为止我们已经研究过的技术，包括具有注意力机制的序列到序列网络，我们也不大可能训练一个匹配或胜过真实人的聊天机器人模型。 但是，我们将在本章中看到 NLP 领域的最新发展使我们更加接近创建与人类没有区别的聊天机器人的目标。
+到目前为止，在本书中，我们已经讨论了许多机器学习方法，这些方法使我们能够构建模型来执行 NLP 任务，例如分类，翻译和通过聊天机器人进行近似对话。 但是，到目前为止，我们的模型的表现相对于人类而言一直较差。 即使使用到目前为止我们已经研究过的技术，包括具有注意力机制的序列到序列网络，我们也不大可能训练一个匹配或胜过真实人的聊天机器人模型。 但是，我们将在本章中看到 NLP 领域的最新发展使我们更加接近创建与人类没有区别的聊天机器人的目标。
 
-在本章中，我们将探索 NLP 的两个最先进的机器学习模型，并研究一些可带来卓越性能的功能。 然后，我们将转向研究其他许多当前关注的 NLP 任务，以及如何使用机器学习技术来解决它们。
+在本章中，我们将探索 NLP 的两个最先进的机器学习模型，并研究一些可带来卓越表现的功能。 然后，我们将转向研究其他许多当前关注的 NLP 任务，以及如何使用机器学习技术来解决它们。
 
 在本章中，我们将介绍以下主题：
 
@@ -19,13 +19,13 @@
 
 到目前为止，虽然我们在本书中学到的技术对于从头开始训练我们自己的机器学习模型都是非常有用的方法，但与全球正在开发的最复杂的模型相距甚远。 公司和研究团队一直在努力创建最先进的机器学习模型，这些模型将在许多 NLP 任务上达到最高性能。
 
-当前，有两种具有最佳性能并且可以被认为是最新技术的 NLP 模型： **BERT** 和 **GPT-2** 。 两种模型都是**通用语言模型**的形式。 我们将在接下来的部分中详细讨论这些内容。
+当前，有两种具有最佳表现并且可以被认为是最新技术的 NLP 模型： **BERT** 和 **GPT-2** 。 两种模型都是**通用语言模型**的形式。 我们将在接下来的部分中详细讨论这些内容。
 
 ## BERT
 
-**BERT** 代表**转换器**的双向编码器表示形式，由 Google 于 2018 年开发，被广泛认为是 NLP 领域的领先模型，在自然语言的语言推理和问答任务中已取得领先的性能。 幸运的是，它已作为开源模型发布，因此可以下载并用于您自己的 NLP 任务。
+**BERT** 代表**转换器**的双向编码器表示形式，由 Google 于 2018 年开发，被广泛认为是 NLP 领域的领先模型，在自然语言的语言推理和问答任务中已取得领先的表现。 幸运的是，它已作为开源模型发布，因此可以下载并用于您自己的 NLP 任务。
 
-BERT 是作为预训练的模型发布的，这意味着用户可以下载和实现 BERT，而无需每次都从头开始重新训练模型。 预先训练的模型在几个语料库上进行了训练，包括整个 Wikipedia（由 25 亿个单词组成）和另一个图书集（其中还包括 8 亿个单词）。 但是，BERT 与其他类似模型不同的主要因素是它提供了一种深度，双向，无监督的语言表示形式，该语言表示形式提供了更复杂，更详细的表示形式，从而提高了 NLP 任务的性能。 。
+BERT 是作为预训练的模型发布的，这意味着用户可以下载和实现 BERT，而无需每次都从头开始重新训练模型。 预先训练的模型在几个语料库上进行了训练，包括整个 Wikipedia（由 25 亿个单词组成）和另一个图书集（其中还包括 8 亿个单词）。 但是，BERT 与其他类似模型不同的主要因素是它提供了一种深度，双向，无监督的语言表示形式，该语言表示形式提供了更复杂，更详细的表示形式，从而提高了 NLP 任务的表现。 。
 
 ### 嵌入
 
@@ -252,12 +252,12 @@ x0 + t0 = E0
 
 我们仍处于聊天机器人无法与真实人类进行对话的阶段，并且 BERT 从其知识库中提取信息的能力非常有限。 但是，BERT 所取得的一些结果是有希望的，并且考虑到 NLP 机器学习领域的发展速度，这表明这可能很快就会成为现实。
 
-当前，由于 BERT 的训练方式，它只能解决非常狭窄的 NLP 任务。 但是，BERT 的许多变体已经以微妙的方式进行了更改，以在特定任务上实现更高的性能。 这些包括但不限于以下内容：
+当前，由于 BERT 的训练方式，它只能解决非常狭窄的 NLP 任务。 但是，BERT 的许多变体已经以微妙的方式进行了更改，以在特定任务上实现更高的表现。 这些包括但不限于以下内容：
 
 *   **roBERTa**：由 Facebook 构建的 BERT 的变体。 删除 BERT 的下一个句子预测元素，但通过实现动态屏蔽来增强单词屏蔽策略。
-*   **xlm**/**BERT**：也是由 Facebook 构建的，该模型对 BERT 应用了双语言训练机制，从而使它能够学习不同语言的单词之间的关系。 这使 BERT 可以有效地用于机器翻译任务，与基本的序列到序列模型相比，表现出更高的性能。
+*   **xlm**/**BERT**：也是由 Facebook 构建的，该模型对 BERT 应用了双语言训练机制，从而使它能够学习不同语言的单词之间的关系。 这使 BERT 可以有效地用于机器翻译任务，与基本的序列到序列模型相比，表现出更高的表现。
 *   **distilBERT**：BERT 的更紧凑版本，保留了原始版本的 95%，但将学习到的参数数量减半，从而减少了模型的总大小和训练时间。
-*   **ALBERT**：此经过 Google 训练的模型使用了自己独特的训练方法，称为句子顺序预测。 BERT 的这种变体在许多任务上均表现出优于标准 BERT 的性能，现在被认为是 BERT 之前的最先进技术（说明了事物可以快速改变的速度！）。
+*   **ALBERT**：此经过 Google 训练的模型使用了自己独特的训练方法，称为句子顺序预测。 BERT 的这种变体在许多任务上均表现出优于标准 BERT 的表现，现在被认为是 BERT 之前的最先进技术（说明了事物可以快速改变的速度！）。
 
 虽然 BERT 可能是最著名的，但也有其他基于转换器的模型被认为是最新技术。 通常被认为与 BERT 竞争的主要竞争对手是 GPT-2。
 
@@ -295,7 +295,7 @@ GPT-2 与 BERT 类似，但在一些细微的方面有所不同。 虽然这两
 
 **输出**：`blue`
 
-就 BERT 和 GPT-2 之间的性能而言，这是关键的权衡之一。 BERT 被双向训练的事实意味着这种单标记生成是不可能的。 但是，GPT-2 不是双向的，因此在进行预测时只考虑句子中的先前单词，这就是为什么 BERT 在预测句子中缺少的单词时胜过 GPT-2 的原因。
+就 BERT 和 GPT-2 之间的表现而言，这是关键的权衡之一。 BERT 被双向训练的事实意味着这种单标记生成是不可能的。 但是，GPT-2 不是双向的，因此在进行预测时只考虑句子中的先前单词，这就是为什么 BERT 在预测句子中缺少的单词时胜过 GPT-2 的原因。
 
 ## 比较自我注意和遮罩的自我注意
 
@@ -333,7 +333,7 @@ Dr. Jorge Pérez, an evolutionary biologist from the University of La Paz, and s
 
 这只是模型从很少的输入中生成的更大的九段响应的前三段。 值得注意的是，这些句子都非常合理（不管不可能的主题是什么！），各段以逻辑顺序排列在一起，并且该模型能够从很小的输入中产生所有这些。
 
-尽管这在性能以及通过构建深层 NLP 模型可以实现的功能方面给人留下深刻的印象，但确实引起了人们对此类模型的道德规范以及如何使用（和滥用它们）的担忧。
+尽管这在表现以及通过构建深层 NLP 模型可以实现的功能方面给人留下深刻的印象，但确实引起了人们对此类模型的道德规范以及如何使用（和滥用它们）的担忧。
 
 随着“假新闻”的兴起和使用互联网的错误信息的传播，类似的示例说明了使用这些模型生成逼真的文本是多么简单。 让我们考虑一个示例，其中智能体希望在线上生成有关多个主题的虚假新闻。 现在，他们甚至不需要自己编写虚假信息。 从理论上讲，他们可以训练 NLP 模型为他们执行此操作，然后再在互联网上散布这些虚假信息。 GPT-2 的作者在训练并将模型发布给公众时特别注意这一点，并指出该模型有可能被滥用和滥用，因此只有在他们看不到证据的情况下才向公众发布更大更复杂的模型。 较小型号的误用。
 
@@ -468,9 +468,9 @@ The apple was sold by the shop to the man
 
 与任何分类任务一样，这是一个有监督的学习问题，需要完整注释的句子才能训练模型，该模型将识别以前未见过的句子的语义角色。 但是，这样带注释的句子的可用性非常稀缺。 我们在本章前面看到的巨大的语言模型（例如 BERT）是在原始句子上训练的，不需要带标签的示例。 但是，在语义角色标记的情况下，我们的模型需要使用正确标记的句子才能执行此任务。 尽管确实存在用于此目的的数据集，但它们的大小和通用性不足以训练完全综合，准确的模型，该模型在各种句子上均能很好地表现。
 
-您可能会想到，解决语义角色标记任务的最新技术都是基于神经网络的。 初始模型使用 LSTM 和双向 LSTM 结合 GLoVe 嵌入，以便对句子进行分类。 这些模型还包含了卷积层，也表现出良好的性能。
+您可能会想到，解决语义角色标记任务的最新技术都是基于神经网络的。 初始模型使用 LSTM 和双向 LSTM 结合 GLoVe 嵌入，以便对句子进行分类。 这些模型还包含了卷积层，也表现出良好的表现。
 
-但是，得知这些最新模型是基于 BERT 的也就不足为奇了。 使用 BERT 已在各种与 NLP 相关的任务中显示了出色的性能，并且语义角色标记也不例外。 集成了 BERT 的模型已经过全面训练，可以预测词性标签，执行语法分析并同时执行语义角色标记，并显示出良好的效果。
+但是，得知这些最新模型是基于 BERT 的也就不足为奇了。 使用 BERT 已在各种与 NLP 相关的任务中显示了出色的表现，并且语义角色标记也不例外。 集成了 BERT 的模型已经过全面训练，可以预测词性标签，执行语法分析并同时执行语义角色标记，并显示出良好的效果。
 
 其他研究也表明，图卷积网络在语义标记方面是有效的。 图由节点和边构成，其中图内的节点代表语义成分，边代表父子部分之间的关​​系。
 
diff --git a/new/pt-ai-fund/1.md b/new/pt-ai-fund/1.md
index b6999527507ebf51a1b6a139e181797988c1c295..e87e8083652a0cdde4f1a0974670c6301f6ad4fc 100644
--- a/new/pt-ai-fund/1.md
+++ b/new/pt-ai-fund/1.md
@@ -314,7 +314,7 @@ tensor([[3, 3],
 
 # 工作原理
 
-在本秘籍中，我们介绍了从各种数据源创建张量的各种方法。 在我们开始探索使用 PyTorch 进行深度学习的概念及其原理之前，必须了解一些最常用的功能来处理数据的基本单位张量。 我们可以使用`torch.tensor()`方法创建具有各种值和形状的张量。 我们甚至可以从均匀分布或标准正态分布中得出张量，这对于初始化神经网络以获得最佳性能和训练时间至关重要，所有这些张量都具有默认的`torch.FloatTensor` 数据类型，并使用`dtype`更新数据类型。 参数。
+在本秘籍中，我们介绍了从各种数据源创建张量的各种方法。 在我们开始探索使用 PyTorch 进行深度学习的概念及其原理之前，必须了解一些最常用的功能来处理数据的基本单位张量。 我们可以使用`torch.tensor()`方法创建具有各种值和形状的张量。 我们甚至可以从均匀分布或标准正态分布中得出张量，这对于初始化神经网络以获得最佳表现和训练时间至关重要，所有这些张量都具有默认的`torch.FloatTensor` 数据类型，并使用`dtype`更新数据类型。 参数。
 
 `.ones()`方法创建一个包含给定形状的张量的张量，`.zeros()`用所有零填充该张量，`full()`方法将给定形状的张量填充。 `.empty()`方法创建一个空张量，`.rand()`从`[0, 1]`的均匀分布中绘制一个具有随机值的张量，`.randn()`从正态分布中绘制均值为 0 和方差 1 的一个具有随机值的张量 ，也称为标准正态分布。
 
diff --git a/new/pt-ai-fund/2.md b/new/pt-ai-fund/2.md
index f34a19ae505a127f669166d21a9ae756bafe1a51..0ad1c3fce81c6cc5e66afba2608eabc31e7e4778 100644
--- a/new/pt-ai-fund/2.md
+++ b/new/pt-ai-fund/2.md
@@ -6,7 +6,7 @@
 
 ![](img/d6e62091-b4e4-489a-b2e8-926df04945ed.png)
 
-神经网络所看到的只是数字集，它试图识别数据中的模式。 通过训练，神经网络学会识别输入中的模式。 但是，某些特定的架构在应用于特定类别的问题时比其他结构具有更好的性能。 一个简单的神经网络架构由三种层组成：**输入**层，**输出**层和**隐藏**层。 当隐藏层不止一个时，它称为**深度神经网络**。
+神经网络所看到的只是数字集，它试图识别数据中的模式。 通过训练，神经网络学会识别输入中的模式。 但是，某些特定的架构在应用于特定类别的问题时比其他结构具有更好的表现。 一个简单的神经网络架构由三种层组成：**输入**层，**输出**层和**隐藏**层。 当隐藏层不止一个时，它称为**深度神经网络**。
 
 以下是深度神经网络的表示：
 
@@ -309,7 +309,7 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机
 
 # 工作原理
 
-在此秘籍中，我们用对数 softmax 替换了 softmax，以便随后可以使用概率对数而不是概率的对数，这具有很好的理论解释。 这样做有多种原因，包括改进的数值性能和梯度优化。 在训练可能具有计算挑战性和昂贵成本的模型时，这些优势非常重要。 此外，当它没有预测正确的类别时，它具有很高的惩罚作用。
+在此秘籍中，我们用对数 softmax 替换了 softmax，以便随后可以使用概率对数而不是概率的对数，这具有很好的理论解释。 这样做有多种原因，包括改进的数值表现和梯度优化。 在训练可能具有计算挑战性和昂贵成本的模型时，这些优势非常重要。 此外，当它没有预测正确的类别时，它具有很高的惩罚作用。
 
 因此，在处理对数 softmax 时，我们会使用负对数似然率，因为 softmax 不兼容。 在`n`类数之间的分类中很有用。 该对数将确保我们不会处理 0 到 1 之间的非常小的值，而负值将确保小于 1 的概率的对数非零。 我们的目标是减少这种负的对数丢失误差函数。 在 PyTorch 中，损失函数称为**标准**，因此我们将损失函数命名为`criterion`。
 
@@ -481,7 +481,7 @@ Training loss: 0.2596
 
 丢弃可以直观地理解为创建大量集成模型，学习在一个模型的大定义下捕获各种功能。
 
-在本秘籍中，我们将研究如何在模型定义中添加缺失，以通过防止过拟合来改善整体模型性能。 应当记住，丢弃仅在训练时才适用； 但是，在测试和实际预测期间，我们希望所有神经元都做出贡献。
+在本秘籍中，我们将研究如何在模型定义中添加缺失，以通过防止过拟合来改善整体模型表现。 应当记住，丢弃仅在训练时才适用； 但是，在测试和实际预测期间，我们希望所有神经元都做出贡献。
 
 # 操作步骤
 
diff --git a/new/pt-ai-fund/3.md b/new/pt-ai-fund/3.md
index 2c305e0f47aea7a627d9c65c273c62e560126d04..43e0b4841584521a6c80a94cea9064764bdf73ba 100644
--- a/new/pt-ai-fund/3.md
+++ b/new/pt-ai-fund/3.md
@@ -146,7 +146,7 @@ Conv2d(3, 16, kernel_size=(3, 4), stride=(3, 3), padding=(1, 2))
 
 这是使用池化层的主要原因：
 
-*   **减少计算数量**：通过减少输入的空间尺寸而不会损失滤波器，我们可以获得更好的计算性能，因此我们减少了训练所需的时间以及计算资源。
+*   **减少计算数量**：通过减少输入的空间尺寸而不会损失滤波器，我们可以获得更好的计算表现，因此我们减少了训练所需的时间以及计算资源。
 *   **防止过拟合**：随着空间尺寸的减小，我们减少了模型具有的参数数量，从而降低了模型的复杂性并有助于我们更好地概括。
 *   **位置不变性**：这使 CNN 可以捕获图像中的特征，而不管特征在给定图像中的位置。 假设我们正在尝试建立一个分类器来检测芒果。 芒果位于图像的中心，左上角，右下角还是图像中的任何位置都没关系-需要对其进行检测。 池化层可以帮助我们。
 
@@ -369,9 +369,9 @@ PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为
 
 # 执行数据扩充
 
-在本秘籍中，我们将学习有关使用火炬进行数据扩充的知识。 数据扩充是深度学习和计算机视觉中的一项重要技术。 对于任何涉及深度学习或计算机视觉的模型，可用的数据量对于查看模型的性能至关重要。 数据扩充可防止模型记住有限数量的数据，而不是对观察到的数据进行概括。 数据扩充通过从原始图像创建变量而不实际收集新数据来增加用于训练模型的数据的多样性。
+在本秘籍中，我们将学习有关使用火炬进行数据扩充的知识。 数据扩充是深度学习和计算机视觉中的一项重要技术。 对于任何涉及深度学习或计算机视觉的模型，可用的数据量对于查看模型的表现至关重要。 数据扩充可防止模型记住有限数量的数据，而不是对观察到的数据进行概括。 数据扩充通过从原始图像创建变量而不实际收集新数据来增加用于训练模型的数据的多样性。
 
-通常，光量，亮度，方向或颜色变化不会影响模型所做的推断。 但是，当模型在现实世界中部署时，输入数据可能会有这些变化。 对于模型来说，知道其做出的决定必须相对于输入中的这些变化是不变的，这很有用，因此数据扩充可以提高模型的性能。 在本秘籍中，我们将使用 PyTorch 的`transform`模块执行数据扩充。
+通常，光量，亮度，方向或颜色变化不会影响模型所做的推断。 但是，当模型在现实世界中部署时，输入数据可能会有这些变化。 对于模型来说，知道其做出的决定必须相对于输入中的这些变化是不变的，这很有用，因此数据扩充可以提高模型的表现。 在本秘籍中，我们将使用 PyTorch 的`transform`模块执行数据扩充。
 
 # 操作步骤
 
@@ -815,7 +815,7 @@ train_loss = train_loss/len(train_loader.sampler)
 valid_loss = valid_loss/len(valid_loader.sampler)
 ```
 
-18.最后，我们在每个时期打印模型性能：
+18.最后，我们在每个时期打印模型表现：
 
 ```py
     print(f'| Epoch: {epoch:02} | Train Loss: {train_loss:.3f} | Val. Loss: {valid_loss:.3f} |')
@@ -865,11 +865,11 @@ valid_loss = valid_loss/len(valid_loader.sampler)
 
 然后，我们定义了损失函数，也称为`criterion`。 由于这是一个分类问题，因此我们使用了交叉熵损失。 然后，我们选择 SGD 优化器在反向传播时更新模型权重，学习速率为 0.01，并使用`model.parameters()`传入模型参数。 然后，我们将模型运行了 30 个周期，尽管我们可以选择任何合理的数目来执行此操作。 在循环中，我们将训练和验证损失重置为 0，并将模型设置为训练模式，然后遍历训练数据集中的每个批量。 我们首先将批量移至设备，这样，如果我们的 GPU 内存有限，则并非所有数据都不会完全加载到 GPU 内存中。 然后，我们将输入张量传递到模型中，并获取输出，并将其传递到损失函数中，以评估预测标签和真实标签之间的差异。
 
-此后，我们使用`loss.backward()`进行了反向传播，并使用`optimizer.step()`步骤更新了模型权重。 然后，我们使用总历时损失来汇总批量中的损失。 然后，我们使用`model.eval()`将模型转换为评估模型，因为该模型的性能需要在验证集上进行评估，并且该模型在此阶段中不会学习，因此我们也需要关闭退出项。 遍历验证批量，我们获得了模型输出，并在整个时期累积了验证批量之间的损失。 此后，我们格式化了模型性能，以查看每个时期模型的变化。 我们注意到，模型训练和验证损失随时间的推移而减少，这表明模型正在学习。
+此后，我们使用`loss.backward()`进行了反向传播，并使用`optimizer.step()`步骤更新了模型权重。 然后，我们使用总历时损失来汇总批量中的损失。 然后，我们使用`model.eval()`将模型转换为评估模型，因为该模型的表现需要在验证集上进行评估，并且该模型在此阶段中不会学习，因此我们也需要关闭退出项。 遍历验证批量，我们获得了模型输出，并在整个时期累积了验证批量之间的损失。 此后，我们格式化了模型表现，以查看每个时期模型的变化。 我们注意到，模型训练和验证损失随时间的推移而减少，这表明模型正在学习。
 
 # 更多
 
-我们已经运行了训练过的模型，我们需要根据保持数据或测试数据（即该模型尚未看到的数据）评估模型。 通过这样做，我们可以评估模型的真实性能。 为此，您将必须进入模型测试批量，并且对于每个批量，必须执行`_, prediction = torch.max(output, 1)`将 softmax 概率转换为实际预测，并使用`prediction.eq(target.data.view_as(prediction))`将预测与真实输出标签进行比较，其中我们确保预测张量和输出张量的尺寸相同。 这将返回一个张量，其中匹配的张量为 1，不匹配的张量为 0。 我们可以使用它来计算每个批量中模型的准确率，并将其汇总到整个测试数据集中。
+我们已经运行了训练过的模型，我们需要根据保持数据或测试数据（即该模型尚未看到的数据）评估模型。 通过这样做，我们可以评估模型的真实表现。 为此，您将必须进入模型测试批量，并且对于每个批量，必须执行`_, prediction = torch.max(output, 1)`将 softmax 概率转换为实际预测，并使用`prediction.eq(target.data.view_as(prediction))`将预测与真实输出标签进行比较，其中我们确保预测张量和输出张量的尺寸相同。 这将返回一个张量，其中匹配的张量为 1，不匹配的张量为 0。 我们可以使用它来计算每个批量中模型的准确率，并将其汇总到整个测试数据集中。
 
 # 另见
 
diff --git a/new/pt-ai-fund/4.md b/new/pt-ai-fund/4.md
index 09973a744c8109867fc7bca4cd3536ad8aca9b5f..c4c189d95efa969424b3cd7a321235586e681fae 100644
--- a/new/pt-ai-fund/4.md
+++ b/new/pt-ai-fund/4.md
@@ -547,7 +547,7 @@ class MultiLSTMClassifier(nn.Module):
 
 # 双向 LSTM
 
-该秘籍以多层 LSTM 秘籍为基础。 在正常的 LSTM 中，LSTM 会从头到尾读取输入序列。 但是，在双向 LSTM 中，有第二个 LSTM 从最后到第一个读取序列，即反向 RNN。 当当前时间戳的预测取决于序列中进一步输入时，这种类型的 LSTM 可以提高模型性能。 考虑示例“我看过漫画”和“我昨天看过漫画”。 在这种情况下，基于将来出现的标记，相同的标记（即`read`）具有不同的含义。 我们将在本秘籍中探讨其实现。
+该秘籍以多层 LSTM 秘籍为基础。 在正常的 LSTM 中，LSTM 会从头到尾读取输入序列。 但是，在双向 LSTM 中，有第二个 LSTM 从最后到第一个读取序列，即反向 RNN。 当当前时间戳的预测取决于序列中进一步输入时，这种类型的 LSTM 可以提高模型表现。 考虑示例“我看过漫画”和“我昨天看过漫画”。 在这种情况下，基于将来出现的标记，相同的标记（即`read`）具有不同的含义。 我们将在本秘籍中探讨其实现。
 
 # 准备
 
diff --git a/new/pt-ai-fund/5.md b/new/pt-ai-fund/5.md
index 0d1666af0abbf597abb70bd0e3d2a2d9b8fb15bf..80d07b358f39ac2d4346f4b6c9c4219d492a5237 100644
--- a/new/pt-ai-fund/5.md
+++ b/new/pt-ai-fund/5.md
@@ -565,9 +565,9 @@ Epoch |        Training Loss |            Test Loss |  Accuracy  |
 
 在此秘籍中，我们创建了模型并将其移至可用设备，并分别使用负对数损失和 Adam 作为我们的标准和优化器。 `train_epochs()`方法用于在定义的时期范围内训练模型。 在每个时期结束时，我们使用`writer.flush()`方法来确保所有未决事件已写入磁盘。 最后，我们使用`writer.close()`刷新关闭编写器。 我们还在此功能中保存了最佳模型，以供日后重新加载。
 
-然后，我们从到目前为止的训练中重新加载了最佳模型，并对其进行了冻结以进行微调。 解冻后，所有模型参数均可用于训练。 我们将优化器设置为较低的学习率，对该未冻结的模型进行了更多的训练，并记录了模型的性能。 我们看到，通过微调，我们的模型表现更好。
+然后，我们从到目前为止的训练中重新加载了最佳模型，并对其进行了冻结以进行微调。 解冻后，所有模型参数均可用于训练。 我们将优化器设置为较低的学习率，对该未冻结的模型进行了更多的训练，并记录了模型的表现。 我们看到，通过微调，我们的模型表现更好。
 
-从 TensorBoard 图中，我们看到冻结模型中的指标为橙色，解冻后的指标为蓝色，这表明模型解冻后的性能有所提高。 然后，我们从训练数据中采样了图像网格图，并从各个时期对分类错误的示例进行了采样。
+从 TensorBoard 图中，我们看到冻结模型中的指标为橙色，解冻后的指标为蓝色，这表明模型解冻后的表现有所提高。 然后，我们从训练数据中采样了图像网格图，并从各个时期对分类错误的示例进行了采样。
 
 我们看到训练和测试损失在各个时期都减少了，准确率提高了。
 
diff --git a/new/pt-ai-fund/6.md b/new/pt-ai-fund/6.md
index d1b01f6026bd363ca85893e44086dc5d8ca6475e..e27cb63337f202719b0c48263f8bc9e646dbeeee 100644
--- a/new/pt-ai-fund/6.md
+++ b/new/pt-ai-fund/6.md
@@ -551,7 +551,7 @@ Epoch : | 005 / 050 |
 
 然后，我们开始训练生成器，并且生成器应该能够欺骗判别器。 生成器必须纠正鉴别者正确预测生成的图像为假的情况。 因此，只要来自判别器的预测将生成的图像标记为伪造，就会增加生成器损失`gerror`。 然后，我们计算梯度并更新发生器权重。
 
-然后，我们定期显示模型指标，并保存固定噪声生成器生成的图像，以可视化模型在各个时期的性能。
+然后，我们定期显示模型指标，并保存固定噪声生成器生成的图像，以可视化模型在各个时期的表现。
 
 # 更多
 
@@ -565,7 +565,7 @@ Epoch : | 005 / 050 |
 
 以前我们已经看到，使用 GAN，生成器和判别器相互竞争，并且这样做可以产生越来越好的图像。 但是，从理论上讲，它们达到了生成器已捕获真实图像的所有特征的程度，并且生成器无法学习。 同样，鉴别者只能猜测给定图像是真实的还是伪造的，成功机会为 50/50。 在这一点上，据说 GAN 已经收敛。
 
-现在，任何方面的改善都会导致另一面的结果降低，这是**零和**状态或**纳什平衡**； 但是在实践中很难实现，因为生成器和判别器都在不断变化，因此检查 GAN 性能的最佳方法是通过图形和图表。 在本秘籍中，我们将快速了解可视化。
+现在，任何方面的改善都会导致另一面的结果降低，这是**零和**状态或**纳什平衡**； 但是在实践中很难实现，因为生成器和判别器都在不断变化，因此检查 GAN 表现的最佳方法是通过图形和图表。 在本秘籍中，我们将快速了解可视化。
 
 # 准备好
 
@@ -671,7 +671,7 @@ PGGAN 的关键创新可以总结如下：
 *   **均衡的学习率**：所有权重（`w`）被归一化（`w'`）在某个范围内，以便`w' = w / c`的常数`c`对于每一层来说都是不同的，具体取决于重量矩阵的形状。
 *   **逐像素特征归一化**：对每个像素中的特征向量进行归一化，因为批量规范最适合大型微型批量，并且占用大量内存。
 
-Nvidia 最初执行 PGGAN 的过程要花一到两个月的时间。 但是，为了让我们看到 PGGAN 的性能，我们将使用 PyTorch Hub，它是使用 PyTorch 构建的预训练模型的存储库。
+Nvidia 最初执行 PGGAN 的过程要花一到两个月的时间。 但是，为了让我们看到 PGGAN 的表现，我们将使用 PyTorch Hub，它是使用 PyTorch 构建的预训练模型的存储库。
 
 # 准备
 
diff --git a/new/pt-ai-fund/7.md b/new/pt-ai-fund/7.md
index 377be4ac4a44138d02a4fa5e79ccd2b0ae6de217..9e5dcd4725a0bde53121c89eecce7d42809ce082 100644
--- a/new/pt-ai-fund/7.md
+++ b/new/pt-ai-fund/7.md
@@ -437,7 +437,7 @@ if steps%UPDATE_FREQ == 0:
 .
 ```
 
-0.  现在，我们将定义一个函数，该函数将可视化小车的性能：
+0.  现在，我们将定义一个函数，该函数将可视化小车的表现：
 
 ```py
 >>def play_agent(dqn, env):
@@ -487,7 +487,7 @@ Rewards: 160.0
 
 # 更多
 
-您可以编写一个函数来绘制算法的性能，并且仅在模型的得分始终在 450-500 之间时才停止训练过程。
+您可以编写一个函数来绘制算法的表现，并且仅在模型的得分始终在 450-500 之间时才停止训练过程。
 
 # 另见
 
@@ -497,7 +497,7 @@ Rewards: 160.0
 
 # Deep GA 简介
 
-在本秘籍中，我们将探讨**深层遗传算法**（**Deep GA**），并向您展示当将其应用于 RL 时，它是基于梯度方法的竞争替代品。 我们将使用一组随机生成的网络，而不是使用梯度下降来修改其权重的随机生成的网络，而是创建一个一代，然后对其在给定环境中的性能进行评估。 请注意，一代人中的某些网络将比其他人表现更好。 我们将选择性能最佳的网络，并将其保留给下一代网络。 然后，我们将通过复制它们来创建下一代并对其权重进行随机修改。 由于我们将选择权重较小的最佳网络，因此网络的整体性能将不断提高。
+在本秘籍中，我们将探讨**深层遗传算法**（**Deep GA**），并向您展示当将其应用于 RL 时，它是基于梯度方法的竞争替代品。 我们将使用一组随机生成的网络，而不是使用梯度下降来修改其权重的随机生成的网络，而是创建一个一代，然后对其在给定环境中的表现进行评估。 请注意，一代人中的某些网络将比其他人表现更好。 我们将选择表现最佳的网络，并将其保留给下一代网络。 然后，我们将通过复制它们来创建下一代并对其权重进行随机修改。 由于我们将选择权重较小的最佳网络，因此网络的整体表现将不断提高。
 
 在本秘籍中，我们将定义模型的网络维度，该网络维度将用于预测给定状态时应采取的措施。
 
@@ -540,7 +540,7 @@ Rewards: 160.0
 
 # 生成智能体
 
-在本秘籍中，我们将着眼于创建一组智能体以开始我们的进化过程，然后初始化这些智能体的权重。 我们将使用这些智能体来评估模型的性能并生成下一代智能体。
+在本秘籍中，我们将着眼于创建一组智能体以开始我们的进化过程，然后初始化这些智能体的权重。 我们将使用这些智能体来评估模型的表现并生成下一代智能体。
 
 # 操作步骤
 
@@ -610,7 +610,7 @@ agents.append(agent)
 >>import numpy as np
 ```
 
-2.  接下来，我们需要定义一个函数来评估智能体的性能：
+2.  接下来，我们需要定义一个函数来评估智能体的表现：
 
 ```py
 >>def eval_agent(agent, env):
@@ -662,11 +662,11 @@ return total_reward
 
 在本秘籍中，我们完成了深度遗传算法的一些关键功能。 我们研究了三个不同的功能-第一个功能`eval_agent()`与我们在“训练 DQN”秘籍中看到的功能非常相似，其中我们使用了智能体，该智能体是一种神经网络模型，它预测要采取的动作，并执行到`MAX_STEP`（对于`cartpole-v1`为 500）或终端为`True`并返回分数的动作。
 
-然后，我们使用第二个函数`agent_score()`返回指定数量`runs`之上的平均分数，并返回该平均分数，以确保模型的随机性能不佳。 最后一个函数`all_agent_score()`仅循环遍历一代中的所有智能体，并获得一代中所有智能体的平均分数。
+然后，我们使用第二个函数`agent_score()`返回指定数量`runs`之上的平均分数，并返回该平均分数，以确保模型的随机表现不佳。 最后一个函数`all_agent_score()`仅循环遍历一代中的所有智能体，并获得一代中所有智能体的平均分数。
 
 # 使智能体突变
 
-在本秘籍中，我们将介绍使智能体突变。 在从给定的一代中选择性能最佳的模型之后，然后再创建下一代智能体，我们将对这些选定智能体的权重进行轻微的随机变化，这使智能体可以探索更多区域以获得更好的回报，就像生物进化的工作原理一样。
+在本秘籍中，我们将介绍使智能体突变。 在从给定的一代中选择表现最佳的模型之后，然后再创建下一代智能体，我们将对这些选定智能体的权重进行轻微的随机变化，这使智能体可以探索更多区域以获得更好的回报，就像生物进化的工作原理一样。
 
 # 操作步骤
 
@@ -752,15 +752,15 @@ return copy.deepcopy(agents[top_id])
 
 # 工作原理
 
-在本秘籍中，我们研究了四个不同的函数-`mutation`函数为一个智能体创建一个重复项，并为每个参数附加一个受`MUTATION_POWER`限制的小的随机值。 `rand_like`方法从间隔`[0, 1)`上以与`param`相同的大小从均匀分布返回具有随机值的张量。 最后，该函数返回突变的子智能体。 接下来，我们看到`elite`函数返回性能最佳的智能体中最佳智能体的副本。 在`elite`函数中，我们重新评估智能体以确保得分最高的智能体被选为精英，并作为子智能体传递给下一代。
+在本秘籍中，我们研究了四个不同的函数-`mutation`函数为一个智能体创建一个重复项，并为每个参数附加一个受`MUTATION_POWER`限制的小的随机值。 `rand_like`方法从间隔`[0, 1)`上以与`param`相同的大小从均匀分布返回具有随机值的张量。 最后，该函数返回突变的子智能体。 接下来，我们看到`elite`函数返回表现最佳的智能体中最佳智能体的副本。 在`elite`函数中，我们重新评估智能体以确保得分最高的智能体被选为精英，并作为子智能体传递给下一代。
 
 `child_agent`函数生成的子智能体数量与上一代相同，其中一个子智能体是`elite`函数的精英智能体，其余子智能体则使用`np.random.choice`随机选择。 `selected_agents`保留了表现最佳的选定智能体的列表。 在`[mutate(agent) for agent in selected_agents]`步骤中，使用`mutation`函数对得分最高的智能体进行突变。
 
-然后，我们将精英智能体附加到下一代智能体。 最后，`top_parent`函数返回一代中性能最高的智能体的索引。
+然后，我们将精英智能体附加到下一代智能体。 最后，`top_parent`函数返回一代中表现最高的智能体的索引。
 
 # 训练深度 GA
 
-在本秘籍中，我们将完成深度遗传算法的演化，并可视化执行平衡操作的关键。 我们将使用在本章的秘籍中了解到的所有功能，并针对给定的代数运行这些功能。 这将创建智能体，获取他们的分数，选择性能最佳的智能体，并将其突变为下一代。 在几代人中，我们将看到智能体的分数增加。
+在本秘籍中，我们将完成深度遗传算法的演化，并可视化执行平衡操作的关键。 我们将使用在本章的秘籍中了解到的所有功能，并针对给定的代数运行这些功能。 这将创建智能体，获取他们的分数，选择表现最佳的智能体，并将其突变为下一代。 在几代人中，我们将看到智能体的分数增加。
 
 # 操作步骤
 
@@ -889,11 +889,11 @@ Rewards: 350.0
 
 然后，我们创建了一些智能体，以开始我们的进化，并通过遍历`generations`将它们运行了预定的代数，在其中我们获得了每一代所有智能体的奖励。 然后，我们选择了得分最高的父母，并通过`child_agent`函数传递这些父母指数以获得下一代。 之后，我们打印出前 5 个得分的平均值。
 
-最后，我们使用了与“训练 DQN”秘籍中相同的`play_agent`函数，并进行了较小的修改，以补偿模型预测值的差异。 在这里，我们使用精英模型来显示卡特彼勒的性能，每一代之后。 位于智能体列表的末尾。 这是使用`play_agent`函数完成的。
+最后，我们使用了与“训练 DQN”秘籍中相同的`play_agent`函数，并进行了较小的修改，以补偿模型预测值的差异。 在这里，我们使用精英模型来显示卡特彼勒的表现，每一代之后。 位于智能体列表的末尾。 这是使用`play_agent`函数完成的。
 
 # 更多
 
-您可以控制深度遗传算法的各种超参数，以查看性能差异并将分数存储到图表中。
+您可以控制深度遗传算法的各种超参数，以查看表现差异并将分数存储到图表中。
 
 # 另见
 
diff --git a/new/pt-dl-handson/1.md b/new/pt-dl-handson/1.md
index 1f7e0266a2e2484f725f2ca9d9baa5ed7fc09c70..7fde2dc9d520f96cf21715f5caef3d39336f9306 100644
--- a/new/pt-dl-handson/1.md
+++ b/new/pt-dl-handson/1.md
@@ -52,7 +52,7 @@ PyTorch 核心社区不仅为 Torch 的 C 二进制文件构建了 Python 包装
 
 ### 是什么让 PyTorch 受欢迎？
 
-在可靠的深度学习框架的众多中，由于速度和效率的原因，几乎每个人都在使用静态图或基于符号图的方法。 动态网络的内在问题（例如性能问题）使开发人员无法花费大量时间来实现它。 但是，静态图的限制使研究人员无法思考解决问题的多种不同方法，因为思维过程必须限制在静态计算图的框内。
+在可靠的深度学习框架的众多中，由于速度和效率的原因，几乎每个人都在使用静态图或基于符号图的方法。 动态网络的内在问题（例如表现问题）使开发人员无法花费大量时间来实现它。 但是，静态图的限制使研究人员无法思考解决问题的多种不同方法，因为思维过程必须限制在静态计算图的框内。
 
 如前所述，哈佛大学的 Autograd 软件包最初是作为解决此问题的方法，然后 Torch 社区从 Python 采纳了这个想法并实现了 torch-autograd。 Chainer 和 CMU 的 DyNet 可能是接下来的两个基于动态图的框架，得到了社区的大力支持。 尽管所有这些框架都可以解决借助强制方法创建的静态图所产生的问题，但它们没有其他流行的静态图框架所具有的动力。 PyTorch 绝对是答案。 PyTorch 团队采用了经过良好测试的著名 Torch 框架的后端，并将其与 Chainer 的前端合并以得到最佳组合。 团队优化了内核，添加了更多的 Pythonic API，并正确设置了抽象，因此 PyTorch 不需要像 Keras 这样的抽象库即可让初学者入门。
 
@@ -242,7 +242,7 @@ for epoch in range(epochs):
 
 #### 循环神经网络
 
-RNN 是最常见的深度学习算法之一，它们席卷全球。 我们现在在自然语言处理或理解中几乎拥有所有最先进的性能，这是由于 RNN 的变体。 在循环网络中，您尝试识别数据中的最小单位，并使数据成为这些单位的组。 在自然语言的示例中，最常见的方法是使一个单词成为一个单元，并在处理该句子时将其视为一组单词。 您展开整个句子的 RNN，然后一次处理一个单词。 RNN 具有适用于不同数据集的变体，有时，选择变体时可以考虑效率。 **长短期记忆**（**LSTM**）和**门控循环单元**（**GRU**）细胞是最常见的 RNN 单元。
+RNN 是最常见的深度学习算法之一，它们席卷全球。 我们现在在自然语言处理或理解中几乎拥有所有最先进的表现，这是由于 RNN 的变体。 在循环网络中，您尝试识别数据中的最小单位，并使数据成为这些单位的组。 在自然语言的示例中，最常见的方法是使一个单词成为一个单元，并在处理该句子时将其视为一组单词。 您展开整个句子的 RNN，然后一次处理一个单词。 RNN 具有适用于不同数据集的变体，有时，选择变体时可以考虑效率。 **长短期记忆**（**LSTM**）和**门控循环单元**（**GRU**）细胞是最常见的 RNN 单元。
 
 ![Recurrent neural networks](img/B09475_01_13.jpg)
 
@@ -260,7 +260,7 @@ RNN 是最常见的深度学习算法之一，它们席卷全球。 我们现在
 
 #### 卷积神经网络
 
-**卷积神经网络**（**CNN**）使我们能够在计算机视觉中获得超人的性能。 在的早期，我们达到了的人类准确率，并且我们仍在逐年提高准确率。
+**卷积神经网络**（**CNN**）使我们能够在计算机视觉中获得超人的表现。 在的早期，我们达到了的人类准确率，并且我们仍在逐年提高准确率。
 
 卷积网络是最易理解的网络，因为我们有可视化工具可以显示每一层的功能。 **Facebook AI Research**（**FAIR**）负责人 Yann LeCun 于 1990 年代发明了 CNN。 那时我们无法使用它们，因为我们没有足够的数据集和计算能力。 CNN 基本上像滑动窗口一样扫描您的输入并进行中间表示，然后在最终到达全连接层之前对其进行逐层抽象。 CNN 也成功地用于非图像数据集中。
 
diff --git a/new/pt-dl-handson/2.md b/new/pt-dl-handson/2.md
index 17e8948e0b9ee31b95b836ce5be9de41bc2dda21..7f23e780984e276a4991f80d5e4dafc4ba3c0a1e 100644
--- a/new/pt-dl-handson/2.md
+++ b/new/pt-dl-handson/2.md
@@ -290,7 +290,7 @@ print(a2.grad, a2.grad_fn, a2)
 
 所有用户创建的张量都要求梯度在`gradient`属性中具有值，并且我们需要更新参数。 所有参数张量都具有`.data`属性和`.grad`属性，它们分别具有张量值和梯度。 显然，我们需要做的是获取梯度并将其从数据中减去。 但是，事实证明，从参数减小整个梯度并不是一个好主意。 其背后的想法是，参数更新的数量决定了网络从每个示例（每次迭代）中学到的知识，并且如果我们给出的特定示例是一个异常值，我们不希望我们的网络学习虚假信息。
 
-我们希望我们的网络得到推广，从所有示例中学习一些，并最终变得擅长于推广任何新示例。 因此，我们不是从数据中减少整个梯度，而是使用学习率来决定在特定更新中应使用多少梯度。 找到最佳学习率始终是一个重要的决定，因为这会影响模型的整体性能。 基本的经验法则是找到一个学习率，该学习率应足够小以使模型最终能够学习，而又要足够高以至于不会永远收敛。
+我们希望我们的网络得到推广，从所有示例中学习一些，并最终变得擅长于推广任何新示例。 因此，我们不是从数据中减少整个梯度，而是使用学习率来决定在特定更新中应使用多少梯度。 找到最佳学习率始终是一个重要的决定，因为这会影响模型的整体表现。 基本的经验法则是找到一个学习率，该学习率应足够小以使模型最终能够学习，而又要足够高以至于不会永远收敛。
 
 前面描述的训练策略称为梯度下降。 诸如亚当之类的更复杂的训练策略将在下一章中讨论。 梯度下降本身已从其他两个变体演变而来。 梯度下降的最原始版本是 SGD，如前所述。 使用 SGD，每个网络执行都在单个样本上运行，并使用从一个样本获得的梯度更新模型，然后继续进行下一个样本。
 
diff --git a/new/pt-dl-handson/3.md b/new/pt-dl-handson/3.md
index 814653a4dedd2da07bfe08ebc05a341f7507b85e..77b35b039caae5f2ea27a7f3e47f1edc4fe0c483 100644
--- a/new/pt-dl-handson/3.md
+++ b/new/pt-dl-handson/3.md
@@ -380,7 +380,7 @@ transform = transforms.Compose(
 
 训练器网络并不是真正必需的组件，但它是一个很好的帮助程序工具，可以节省大量时间来编写样板文件和修复错误。 有时，它可以将程序的行数减少一半，这也有助于提高可读性。
 
-#### 瓶颈和表现分析
+#### 瓶颈和性能分析
 
 PyTorch 的 Python 优先方法阻止核心团队在的第一年建立一个单独的探查器，但是当模块开始转向 C/C++ 内核时，就很明显需要在 Python 的 cProfiler 上安装一个独立的探查器，这就是 `autograd.profiler`故事的开始。
 
@@ -549,7 +549,7 @@ def _fire_event(self, event_name, *event_args):
 
 #### 指标
 
-就像`Engine`一样，指标也是 Ignite 源代码的重要组成部分，源代码正在不断发展。 度量将用于分析神经网络的性能和效率的几种常用度量包装为`Engine`可以理解的简单可配置类。 接下来给出当前构建的指标。 我们将使用其中一些来构建前面的事件处理程序：
+就像`Engine`一样，指标也是 Ignite 源代码的重要组成部分，源代码正在不断发展。 度量将用于分析神经网络的表现和效率的几种常用度量包装为`Engine`可以理解的简单可配置类。 接下来给出当前构建的指标。 我们将使用其中一些来构建前面的事件处理程序：
 
 *   `Accuracy`
 *   `Loss`
diff --git a/new/pt-dl-handson/4.md b/new/pt-dl-handson/4.md
index e758054e07fa94fbd898bb78894513fa707fc203..1be46b446f5058d6b8d47d45cdb68b063307f683 100644
--- a/new/pt-dl-handson/4.md
+++ b/new/pt-dl-handson/4.md
@@ -318,7 +318,7 @@ LinkNet 由一个初始块，一个最终块，一个带有四个卷积模块的
 
 然后，解码器模块的输出通过最终模块，该模块将上采样两次，就像初始模块下采样两次一样。 还有更多：与其他语义分割模型相比，LinkNet 通过使用跳跃连接的思想可以减少架构中的参数数量。
 
-在每个卷积块之后，编码器块与解码器块进行通信，这使编码器块在正向传播之后会忘记某些信息。 由于编码器模块的输出不必保留该信息，因此参数的数量可能比其他现有架构的数量少得多。 实际上，该论文的作者使用 ResNet18 作为编码器，并且仍然能够以惊人的性能获得最新的结果。 下面是 LinkNet 的架构：
+在每个卷积块之后，编码器块与解码器块进行通信，这使编码器块在正向传播之后会忘记某些信息。 由于编码器模块的输出不必保留该信息，因此参数的数量可能比其他现有架构的数量少得多。 实际上，该论文的作者使用 ResNet18 作为编码器，并且仍然能够以惊人的表现获得最新的结果。 下面是 LinkNet 的架构：
 
 ![LinkNet](img/B09475_04_11.jpg)
 
diff --git a/new/pt-dl-handson/5.md b/new/pt-dl-handson/5.md
index d46284b3805c6ba0cfbbadb887133fd9f610f816..e41aa1cd3b70af334bf365dc0fc25bb54735a699 100644
--- a/new/pt-dl-handson/5.md
+++ b/new/pt-dl-handson/5.md
@@ -14,7 +14,7 @@
 
 注意是下一个重大发明，它可以帮助网络将注意力集中在输入的重要部分上，而不是搜索整个输入并试图找到答案。 实际上，来自 Google Brain 和多伦多大学的一个团队证明，注意力可以击败 LSTM 和 GRU 网络[1]。 但是，大多数实现都同时使用 LSTM/GRU 和注意力。
 
-嵌入是通过比较单词在单词簇中的分布来找到单词的概念含义的另一种革命性思想。 嵌入保持单词之间的关系，并将这种关系（它从单词簇中的单词分布中找到）转换为一组浮点数。 嵌入大大减少了输入大小，并极大地提高了性能和准确率。 我们将使用 word2vec 进行实验。
+嵌入是通过比较单词在单词簇中的分布来找到单词的概念含义的另一种革命性思想。 嵌入保持单词之间的关系，并将这种关系（它从单词簇中的单词分布中找到）转换为一组浮点数。 嵌入大大减少了输入大小，并极大地提高了表现和准确率。 我们将使用 word2vec 进行实验。
 
 数据处理是序列数据（尤其是自然语言）的主要挑战之一。 PyTorch 提供了一些工具包来处理该问题。 我们将使用预处理后的数据来简化实现，但是我们将遍历工具包以了解它们的工作原理。 与这些工具包一起，我们将使用`torchtext`，它消除了处理输入数据时将面临的许多困难。
 
@@ -376,7 +376,7 @@ LSTM 主要由遗忘门，更新门和单元状态组成，这使得 LSTM 与常
 
 #### GRU
 
-GRU 是一个相对较新的设计，与 LSTM 相比，它效率高且复杂度低。 简而言之，GRU 将遗忘门和更新门合并在一起，并且只对单元状态进行一次一次性更新。 实际上，GRU 没有单独的单元状态和隐藏状态，两者都合并在一起以创建一个状态。 这些简化在不影响网络准确率的前提下，极大地降低了 GRU 的复杂性。 由于 GRU 比 LSTM 具有更高的性能，因此 GRU 如今已被广泛使用。
+GRU 是一个相对较新的设计，与 LSTM 相比，它效率高且复杂度低。 简而言之，GRU 将遗忘门和更新门合并在一起，并且只对单元状态进行一次一次性更新。 实际上，GRU 没有单独的单元状态和隐藏状态，两者都合并在一起以创建一个状态。 这些简化在不影响网络准确率的前提下，极大地降低了 GRU 的复杂性。 由于 GRU 比 LSTM 具有更高的表现，因此 GRU 如今已被广泛使用。
 
 ![GRUs](img/B09475_05_07.jpg)
 
@@ -411,7 +411,7 @@ class Encoder(nn.Module):
 
 #### LSTM 和 GRU
 
-虽然 PyTorch 允许访问粒度`LSTMCell`和`GRUCell` API，但它也可以处理用户不需要粒度的情况。 这在用户不需要更改 LSTM 工作原理的内部但性能最为重要的情况下特别有用，因为 Python 循环的速度很慢。 `torch.nn`模块具有用于 LSTM 和 GRU 网络的高级 API，这些 API 封装了`LSTMCell`和`GRUCell`，并使用 **cuDNN**（**CUDA 深度神经网络**）实现了有效执行。 LSTM 和 cuDNN GRU。
+虽然 PyTorch 允许访问粒度`LSTMCell`和`GRUCell` API，但它也可以处理用户不需要粒度的情况。 这在用户不需要更改 LSTM 工作原理的内部但表现最为重要的情况下特别有用，因为 Python 循环的速度很慢。 `torch.nn`模块具有用于 LSTM 和 GRU 网络的高级 API，这些 API 封装了`LSTMCell`和`GRUCell`，并使用 **cuDNN**（**CUDA 深度神经网络**）实现了有效执行。 LSTM 和 cuDNN GRU。
 
 ```py
 class Encoder(nn.Module):
@@ -447,13 +447,13 @@ class Encoder(nn.Module):
 
 RNN 中的层数在语义上类似于任何类型的神经网络中层数的增加。 由于它可以保存有关数据集的更多信息，因此增加了网络的学习能力。
 
-在 PyTorch 中的 LSTM 中，添加多个层只是对象初始化的一个参数：`num_layers`。 但这要求单元状态和隐藏状态的形状为`[num_layers * num_directions, batch, hidden_size]`，其中`num_layers`是层数，`num_directions`对于单向是`1`，对于双向是`2`（尝试通过使用更多数量的层和双向 RNN 来保留示例的性能）。
+在 PyTorch 中的 LSTM 中，添加多个层只是对象初始化的一个参数：`num_layers`。 但这要求单元状态和隐藏状态的形状为`[num_layers * num_directions, batch, hidden_size]`，其中`num_layers`是层数，`num_directions`对于单向是`1`，对于双向是`2`（尝试通过使用更多数量的层和双向 RNN 来保留示例的表现）。
 
 ##### 双向 RNN
 
 RNN 实现通常是单向的，这就是到目前为止我们已经实现的。 单向和双向 RNN 之间的区别在于，在双向 RNN 中，后向通过等效于在相反方向上的正向传播。 因此，反向传递的输入是相同的序列，但是是反向的。
 
-事实证明，双向 RNN 的性能要优于单方向的 RNN，并且很容易理解原因，尤其是对于 NLP。 但这不能一概而论，并非在所有情况下都是如此。 从理论上讲，如果手头的任务需要过去和将来的信息，则双向 RNN 往往会工作得更好。 例如，预测单词填补空白需要上一个序列和下一个序列。
+事实证明，双向 RNN 的表现要优于单方向的 RNN，并且很容易理解原因，尤其是对于 NLP。 但这不能一概而论，并非在所有情况下都是如此。 从理论上讲，如果手头的任务需要过去和将来的信息，则双向 RNN 往往会工作得更好。 例如，预测单词填补空白需要上一个序列和下一个序列。
 
 在我们的分类任务中，双向 RNN 效果更好，因为当 RNN 使序列具有上下文的含义时，它会在两侧使用序列流。 PyTorch 的 LSTM 或 GRU 接受参数`bidirectional`的布尔值，该值确定网络是否应该是双向的。
 
@@ -465,7 +465,7 @@ RNN 实现通常是单向的，这就是到目前为止我们已经实现的。
 
 #### 分类器
 
-高级`RNNClassifier`与简单`RNNClassifier`完全相同，唯一的例外是 RNN 编码器已被 LSTM 或 GRU 编码器替代。 但是，高级分类器由于使用了高度优化的 cuDNN 后端，因此可以显着提高网络性能，尤其是在 GPU 上。
+高级`RNNClassifier`与简单`RNNClassifier`完全相同，唯一的例外是 RNN 编码器已被 LSTM 或 GRU 编码器替代。 但是，高级分类器由于使用了高度优化的 cuDNN 后端，因此可以显着提高网络表现，尤其是在 GPU 上。
 
 我们为高级 RNN 开发的模型是多层双向 LSTM/GRU 网络。 增加对秘籍的关注可大大提高性能。 但这不会改变分类器，因为所有这些组件都将使用`Encoder`方法包装，并且分类器仅担心`Encoder`的功能 API 不会改变。
 
diff --git a/new/pt-dl-handson/6.md b/new/pt-dl-handson/6.md
index b57a612463d85e31aa091660e28a75edd2cfcfa5..b79b0dff3319fa9f81e30db7c32687c1a347bf7d 100644
--- a/new/pt-dl-handson/6.md
+++ b/new/pt-dl-handson/6.md
@@ -165,7 +165,7 @@ for epoch in range(25):
 
 ##### 门控 PixelCNN
 
-DeepMind 在 PixelCNN 的一篇迭代论文中成功地使用了门控 PixelCNN ，该方法通过用 Sigmoid 和 tanh 构建的门代替 ReLU 激活函数。 PixelCNN [1]的介绍性论文提供了三种用于解决同一代网络的不同方法，其中具有 RNN 的模型优于其他两种。 DeepMind 仍引入了基于 CNN 的模型来显示与 PixelRNN 相比的速度增益。 但是，随着 PixelCNN 中门控激活的引入，作者能够将性能与 RNN 变体相匹配，从而获得更大的性能增益。 同一篇论文介绍了一种避免盲点并在生成时增加全局和局部条件的机制，这超出了本书的范围，因为对于 WaveNet 模型而言这不是必需的。
+DeepMind 在 PixelCNN 的一篇迭代论文中成功地使用了门控 PixelCNN ，该方法通过用 Sigmoid 和 tanh 构建的门代替 ReLU 激活函数。 PixelCNN [1]的介绍性论文提供了三种用于解决同一代网络的不同方法，其中具有 RNN 的模型优于其他两种。 DeepMind 仍引入了基于 CNN 的模型来显示与 PixelRNN 相比的速度增益。 但是，随着 PixelCNN 中门控激活的引入，作者能够将表现与 RNN 变体相匹配，从而获得更大的表现增益。 同一篇论文介绍了一种避免盲点并在生成时增加全局和局部条件的机制，这超出了本书的范围，因为对于 WaveNet 模型而言这不是必需的。
 
 ### WaveNet
 
diff --git a/new/pt-tut-17/04.md b/new/pt-tut-17/04.md
index 3122f2836ac0c9660b793f0d125dbb04ef592623..0aa6c4e755e083b29d0cbdb4b22b0c84911a4c75 100644
--- a/new/pt-tut-17/04.md
+++ b/new/pt-tut-17/04.md
@@ -184,7 +184,7 @@ Does `b` require gradients?: True
 
 ```
 
-在 NN 中，不计算梯度的参数通常称为**冻结参数**。 如果事先知道您不需要这些参数的梯度，则“冻结”模型的一部分很有用（通过减少自动梯度计算，这会带来一些性能优势）。
+在 NN 中，不计算梯度的参数通常称为**冻结参数**。 如果事先知道您不需要这些参数的梯度，则“冻结”模型的一部分很有用（通过减少自动梯度计算，这会带来一些表现优势）。
 
 从 DAG 中排除很重要的另一个常见用例是[调整预训练网络](https://pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html)
 
diff --git a/new/pt-tut-17/17.md b/new/pt-tut-17/17.md
index d2f779383600165f9269aa520fe04101fc4277de..5989bb30ced45ac3aeeecaf285b4ce88659f82d0 100644
--- a/new/pt-tut-17/17.md
+++ b/new/pt-tut-17/17.md
@@ -15,8 +15,8 @@
 具体来说，在第 5 点，我们将看到：
 
 > *   有两种方法可以检查我们的训练数据
-> *   在训练模型时如何跟踪其性能
-> *   在训练后如何评估模型的性能。
+> *   在训练模型时如何跟踪其表现
+> *   在训练后如何评估模型的表现。
 
 我们将从 [CIFAR-10 教程](https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html)中类似的样板代码开始：
 
diff --git a/new/pt-tut-17/21.md b/new/pt-tut-17/21.md
index 367498ab6f8e20c1d0c67c72cc96b685d67ec19a..9a56cff7d7891c0abed83eecb0d1be0b13f7740e 100644
--- a/new/pt-tut-17/21.md
+++ b/new/pt-tut-17/21.md
@@ -46,7 +46,7 @@ import matplotlib.pyplot as plt
 
 本教程只有三个输入，定义如下：
 
-*   `epsilons`-用于运行的`ε`值列表。 在列表中保留 0 很重要，因为它表示原始测试集上的模型性能。 同样，从直觉上讲，我们期望`ε`越大，扰动越明显，但是从降低模型准确率的角度来看，攻击越有效。 由于此处的数据范围为`[0,1]`，因此`ε`值不得超过 1。
+*   `epsilons`-用于运行的`ε`值列表。 在列表中保留 0 很重要，因为它表示原始测试集上的模型表现。 同样，从直觉上讲，我们期望`ε`越大，扰动越明显，但是从降低模型准确率的角度来看，攻击越有效。 由于此处的数据范围为`[0,1]`，因此`ε`值不得超过 1。
 *   `pretrained_model`-使用[`pytorch/examples/mnist`](https://github.com/pytorch/examples/tree/master/mnist)训练的 MNIST 模型的路径。 为简单起见，[请在此处下载预训练模型](https://drive.google.com/drive/folders/1fn83DF14tWmit0RTKWRhPq5uVXt73e0h?usp=sharing)。
 *   `use_cuda`-布尔标志，如果需要和可用，则使用 CUDA。 请注意，具有 CUDA 的 GPU 在本教程中并不重要，因为 CPU 不会花费很多时间。
 
diff --git a/new/pt-tut-17/22.md b/new/pt-tut-17/22.md
index 7a5cb2db7acfabb35e07187a252826c09bfacaed..0feb1054df2c6bf4fef40ddce57909584fe49a98 100644
--- a/new/pt-tut-17/22.md
+++ b/new/pt-tut-17/22.md
@@ -12,7 +12,7 @@
 
 ### 什么是 GAN？
 
-GAN 是用于教授 DL 模型以捕获训练数据分布的框架，因此我们可以从同一分布中生成新数据。 GAN 由 Ian Goodfellow 于 2014 年发明，并在论文[《生成对抗网络》](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)中首次进行了描述。 它们由两个不同的模型组成：*生成器*和*判别器*。 生成器的工作是生成看起来像训练图像的“假”图像。 判别器的工作是查看图像并从生成器输出它是真实的训练图像还是伪图像。 在训练过程中，生成器不断尝试通过生成越来越好的伪造品而使判别器的性能超过智者，而判别器正在努力成为更好的侦探并正确地对真实和伪造图像进行分类。 博弈的平衡点是当生成器生成的伪造品看起来像直接来自训练数据时，而判别器则总是猜测生成器输出是真实还是伪造品的 50% 置信度。
+GAN 是用于教授 DL 模型以捕获训练数据分布的框架，因此我们可以从同一分布中生成新数据。 GAN 由 Ian Goodfellow 于 2014 年发明，并在论文[《生成对抗网络》](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)中首次进行了描述。 它们由两个不同的模型组成：*生成器*和*判别器*。 生成器的工作是生成看起来像训练图像的“假”图像。 判别器的工作是查看图像并从生成器输出它是真实的训练图像还是伪图像。 在训练过程中，生成器不断尝试通过生成越来越好的伪造品而使判别器的表现超过智者，而判别器正在努力成为更好的侦探并正确地对真实和伪造图像进行分类。 博弈的平衡点是当生成器生成的伪造品看起来像直接来自训练数据时，而判别器则总是猜测生成器输出是真实还是伪造品的 50% 置信度。
 
 现在，让我们从判别器开始定义一些在整个教程中使用的符号。 令`x`为代表图像的数据。 `D(x)`是判别器网络，其输出`x`来自训练数据而不是生成器的（标量）概率。 在这里，由于我们要处理图像，因此`D(x)`的输入是 CHW 大小为`3x64x64`的图像。 直观地，当`x`来自训练数据时，`D(x)`应该为高，而当`x`来自发生器时，它应该为低。 `D(x)`也可以被认为是传统的二分类器。
 
diff --git a/new/pt-tut-17/32.md b/new/pt-tut-17/32.md
index 14939def057172b8c5f7f7bdd30f9940a5d5dd47..17ae80afdbcfe1f189f3b8db642a05fe655c3ab1 100644
--- a/new/pt-tut-17/32.md
+++ b/new/pt-tut-17/32.md
@@ -346,7 +346,7 @@ The model has 3,491,552 trainable parameters
 
 ```
 
-注意：特别是对语言翻译模型的性能进行评分时，我们必须告诉`nn.CrossEntropyLoss`函数忽略仅填充目标的索引。
+注意：特别是对语言翻译模型的表现进行评分时，我们必须告诉`nn.CrossEntropyLoss`函数忽略仅填充目标的索引。
 
 ```py
 PAD_IDX = en_vocab.stoi['<pad>']
diff --git a/new/pt-tut-17/34.md b/new/pt-tut-17/34.md
index ab87a8266cb033e8c3a74b34ef08c9205ea2219e..0c232c19cedd5921b0cca4d89f185282a4031f9b 100644
--- a/new/pt-tut-17/34.md
+++ b/new/pt-tut-17/34.md
@@ -14,7 +14,7 @@
 
 卡特波尔
 
-当智能体观察环境的当前状态并选择一个动作时，环境*会转换为*到新状态，并且还会返回表示该动作后果的奖励。 在此任务中，每增加一个时间步长，奖励为 +1，并且如果杆子掉落得太远或手推车离中心的距离超过 2.4 个单位，则环境终止。 这意味着性能更好的方案将持续更长的时间，从而积累更大的回报。
+当智能体观察环境的当前状态并选择一个动作时，环境*会转换为*到新状态，并且还会返回表示该动作后果的奖励。 在此任务中，每增加一个时间步长，奖励为 +1，并且如果杆子掉落得太远或手推车离中心的距离超过 2.4 个单位，则环境终止。 这意味着表现更好的方案将持续更长的时间，从而积累更大的回报。
 
 对 CartPole 任务进行了设计，以使对智能体的输入是代表环境状态（位置，速度等）的 4 个实际值。 但是，神经网络可以完全通过查看场景来解决任务，因此我们将以推车为中心的一部分屏幕作为输入。 因此，我们的结果无法直接与官方排行榜上的结果进行比较-我们的任务更加艰巨。 不幸的是，这确实减慢了训练速度，因为我们必须渲染所有帧。
 
diff --git a/new/pt-tut-17/45.md b/new/pt-tut-17/45.md
index 1a90513381026bdc99602f48617b36edeff63f58..1a9f05eb7e631d63345250a503c61875fbbcdcc5 100644
--- a/new/pt-tut-17/45.md
+++ b/new/pt-tut-17/45.md
@@ -14,7 +14,7 @@ C++ 扩展是我们开发的一种机制，允许用户（您）创建源外定
 
 本说明的其余部分将逐步介绍编写和使用 C++（和 CUDA）扩展的实际示例。 如果您被追捕，或者在一天结束前仍未完成该操作，就会有人开除您，则可以跳过本节，直接进入下一部分的实现细节。
 
-假设您想出了一种新型的循环装置，发现与现有技术相比，它具有更好的性能。 该循环单元类似于 LSTM，但不同之处在于它缺少*遗忘门*，并使用*指数线性单元*（ELU）作为其内部激活函数。 由于此设备永远不会忘记，因此我们将其称为 *LLTM* 或*长期记忆*单元。
+假设您想出了一种新型的循环装置，发现与现有技术相比，它具有更好的表现。 该循环单元类似于 LSTM，但不同之处在于它缺少*遗忘门*，并使用*指数线性单元*（ELU）作为其内部激活函数。 由于此设备永远不会忘记，因此我们将其称为 *LLTM* 或*长期记忆*单元。
 
 LLTM 与普通 LSTM 的两种区别非常重要，以至于我们无法为自己的目的配置 PyTorch 的`LSTMCell`，因此我们必须创建一个自定义单元。 这样做的第一个也是最简单的方法，并且在所有情况下都可能是一个好的第一步，是使用 Python 在纯 PyTorch 中实现我们所需的功能。 为此，我们需要子类`torch.nn.Module`并实现 LLTM 的正向传播。 看起来像这样：
 
diff --git a/new/pt-tut-17/53.md b/new/pt-tut-17/53.md
index ed7e1c417cfe6640b3d6780a65437920f5069484..82962328a51b691bbeb2e256031006aeee95b90b 100644
--- a/new/pt-tut-17/53.md
+++ b/new/pt-tut-17/53.md
@@ -2,7 +2,7 @@
 
 > 原文：<https://pytorch.org/tutorials/beginner/hyperparameter_tuning_tutorial.html>
 
-超参数调整可以使平均模型与高精度模型有所不同。 通常，选择不同的学习率或更改网络层大小等简单的事情可能会对模型性能产生巨大影响。
+超参数调整可以使平均模型与高精度模型有所不同。 通常，选择不同的学习率或更改网络层大小等简单的事情可能会对模型表现产生巨大影响。
 
 幸运的是，有一些工具可以帮助您找到最佳的参数组合。 [Ray Tune](https://docs.ray.io/en/latest/tune.html) 是用于分布式超参数调整的行业标准工具。 Ray Tune 包含最新的超参数搜索算法，与 TensorBoard 和其他分析库集成，并通过 [Ray 的分布式机器学习引擎](https://ray.io/)本地支持分布式训练。
 
@@ -256,7 +256,7 @@ def train_cifar(config, checkpoint_dir=None, data_dir=None):
 
 ## 测试集准确率
 
-通常，机器学习模型的性能是在保持测试集上使用尚未用于训练模型的数据进行测试的。 我们还将其包装在一个函数中：
+通常，机器学习模型的表现是在保持测试集上使用尚未用于训练模型的数据进行测试的。 我们还将其包装在一个函数中：
 
 ```py
 def test_accuracy(net, device="cpu"):
@@ -298,7 +298,7 @@ config = {
 
 `tune.sample_from()`函数使您可以定义自己的采样方法以获得超参数。 在此示例中，`l1`和`l2`参数应为 4 到 256 之间的 2 的幂，因此应为 4、8、16、32、64、128 或 256。`lr`（学习率）应在 0.0001 和 0.1 之间均匀采样。 最后，批量大小可以在 2、4、8 和 16 之间选择。
 
-现在，在每次试用中，Ray Tune 都会从这些搜索空间中随机抽取参数组合。 然后它将并行训练许多模型，并在其中找到性能最佳的模型。 我们还使用`ASHAScheduler`，它将尽早终止效果不佳的测试。
+现在，在每次试用中，Ray Tune 都会从这些搜索空间中随机抽取参数组合。 然后它将并行训练许多模型，并在其中找到表现最佳的模型。 我们还使用`ASHAScheduler`，它将尽早终止效果不佳的测试。
 
 我们用`functools.partial`包装`train_cifar`函数以设置常量`data_dir`参数。 我们还可以告诉 Ray Tune 每个审判应提供哪些资源：
 
@@ -320,7 +320,7 @@ result = tune.run(
 
 在这里，我们还可以指定分数 GPU，因此`gpus_per_trial=0.5`之类的东西完全有效。 然后，试用版将彼此共享 GPU。 您只需要确保模型仍然适合 GPU 内存即可。
 
-训练完模型后，我们将找到性能最好的模型，并从检查点文件中加载训练后的网络。 然后，我们获得测试仪的准确率，并通过打印报告一切。
+训练完模型后，我们将找到表现最好的模型，并从检查点文件中加载训练后的网络。 然后，我们获得测试仪的准确率，并通过打印报告一切。
 
 完整的主要功能如下：
 
diff --git a/new/pt-tut-17/56.md b/new/pt-tut-17/56.md
index 3f9070c3abee903a112e06b1b71ff597e8c6e3ce..a6aa23bce34e76df1ae41773a70b1de39f5692e0 100644
--- a/new/pt-tut-17/56.md
+++ b/new/pt-tut-17/56.md
@@ -18,7 +18,7 @@
 
 *   BERT，或者说转换器的双向嵌入表示，是一种预训练语言表示的新方法，它可以在许多常见的自然语言处理（NLP）任务（例如问题解答，文本分类， 和别的。 [可以在此处找到](https://arxiv.org/pdf/1810.04805.pdf)。
 *   PyTorch 中的动态量化支持将浮点模型转换为具有静态`int8`或`float16`数据类型的权重和动态量化激活的量化模型。 当权重量化为`int8`时，激活（每批）动态量化为`int8`。 在 PyTorch 中，我们有[`torch.quantization.quantize_dynamic` API](https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic)，该 API 用仅动态权重的量化版本替换了指定的模块，并输出了量化模型。
-*   我们在[通用语言理解评估基准（GLUE）](https://gluebenchmark.com/)中演示了 [Microsoft Research Paraphrase 语料库（MRPC）任务](https://www.microsoft.com/en-us/download/details.aspx?id=52398)的准确率和推理性能结果。 MRPC（Dolan 和 Brockett，2005 年）是从在线新闻源中自动提取的句子对的语料库，带有人工注释，说明句子中的句子在语义上是否等效。 由于班级不平衡（正向为 68%，负向为 32%），我们遵循常规做法并报告 [F1 得分](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html)。 MRPC 是用于语言对分类的常见 NLP 任务，如下所示。
+*   我们在[通用语言理解评估基准（GLUE）](https://gluebenchmark.com/)中演示了 [Microsoft Research Paraphrase 语料库（MRPC）任务](https://www.microsoft.com/en-us/download/details.aspx?id=52398)的准确率和推理表现结果。 MRPC（Dolan 和 Brockett，2005 年）是从在线新闻源中自动提取的句子对的语料库，带有人工注释，说明句子中的句子在语义上是否等效。 由于班级不平衡（正向为 68%，负向为 32%），我们遵循常规做法并报告 [F1 得分](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html)。 MRPC 是用于语言对分类的常见 NLP 任务，如下所示。
 
 ![../_img/bert.png](img/b43b70d8a6eef9ea4f75867b5e83b483.png)
 
diff --git a/new/rl-tf/01.md b/new/rl-tf/01.md
index 5511f29d3c344de3289531ff617582df4df4373f..7f965562f37ccac9ad4b2d9bb61cfa227b8137ba 100644
--- a/new/rl-tf/01.md
+++ b/new/rl-tf/01.md
@@ -1,8 +1,8 @@
 # 深度学习–架构和框架
 
-人工神经网络是一种计算系统，为我们提供了解决诸如图像识别到语音翻译等具有挑战性的机器学习任务的重要工具。 最近的突破，例如 Google DeepMind 的 AlphaGo 击败了最好的围棋玩家，或者卡内基梅隆大学的 Libratus 击败了世界上最好的职业扑克玩家，都证明了算法的进步。 这些算法像人类一样学习狭窄的智能，并达到超人水平的性能。 用通俗易懂的话说，人工神经网络是我们可以在计算机上编程的人脑的松散表示。 确切地说，这是受我们对人脑功能知识的启发而产生的一种方法。 神经网络的一个关键概念是创建输入数据的表示空间，然后在该空间中解决问题。 也就是说，从数据的当前状态开始扭曲数据，以便可以以不同的状态表示数据，从而可以解决有关的问题陈述（例如分类或回归）。 深度学习意味着多个隐藏的表示，即具有许多层的神经网络，可以创建更有效的数据表示。 每一层都会细化从上一层收到的信息。
+人工神经网络是一种计算系统，为我们提供了解决诸如图像识别到语音翻译等具有挑战性的机器学习任务的重要工具。 最近的突破，例如 Google DeepMind 的 AlphaGo 击败了最好的围棋玩家，或者卡内基梅隆大学的 Libratus 击败了世界上最好的职业扑克玩家，都证明了算法的进步。 这些算法像人类一样学习狭窄的智能，并达到超人水平的表现。 用通俗易懂的话说，人工神经网络是我们可以在计算机上编程的人脑的松散表示。 确切地说，这是受我们对人脑功能知识的启发而产生的一种方法。 神经网络的一个关键概念是创建输入数据的表示空间，然后在该空间中解决问题。 也就是说，从数据的当前状态开始扭曲数据，以便可以以不同的状态表示数据，从而可以解决有关的问题陈述（例如分类或回归）。 深度学习意味着多个隐藏的表示，即具有许多层的神经网络，可以创建更有效的数据表示。 每一层都会细化从上一层收到的信息。
 
-另一方面，强化学习是机器学习的另一个方面，它是一种学习遵循一系列动作的任何类型的活动的技术。 强化学习智能体从环境中收集信息并创建状态表示； 然后执行一个导致新状态和报酬的动作（即来自环境的可量化反馈，告诉我们该动作是好是坏）。 这种现象一直持续到智能体能够将性能提高到超过特定阈值（即最大化奖励的期望值）为止。 在每个步骤中，可以随机选择这些动作，将其固定或使用神经网络进行监督。 使用深度神经网络对动作预测进行监督将打开一个新领域，称为**深度强化学习**。 这构成了 AlphaGo，Libratus 和人工智能领域中许多其他突破性研究的基础。
+另一方面，强化学习是机器学习的另一个方面，它是一种学习遵循一系列动作的任何类型的活动的技术。 强化学习智能体从环境中收集信息并创建状态表示； 然后执行一个导致新状态和报酬的动作（即来自环境的可量化反馈，告诉我们该动作是好是坏）。 这种现象一直持续到智能体能够将表现提高到超过特定阈值（即最大化奖励的期望值）为止。 在每个步骤中，可以随机选择这些动作，将其固定或使用神经网络进行监督。 使用深度神经网络对动作预测进行监督将打开一个新领域，称为**深度强化学习**。 这构成了 AlphaGo，Libratus 和人工智能领域中许多其他突破性研究的基础。
 
 我们将在本章介绍以下主题：
 
@@ -46,11 +46,11 @@
 
 ![](img/ee3226e9-923f-4bd2-97b7-0b4035267f13.png)
 
-请参考以下数据的图形表示与不同机器学习算法的性能的比较：
+请参考以下数据的图形表示与不同机器学习算法的表现的比较：
 
-1.  我们看到传统的机器学习算法的性能在一定时间后收敛，因为它们无法吸收超过阈值的数据量的不同表示形式。
+1.  我们看到传统的机器学习算法的表现在一定时间后收敛，因为它们无法吸收超过阈值的数据量的不同表示形式。
 
-2.  检查图的左下角，靠近原点。 这是算法的相对顺序没有很好定义的区域。 由于数据量小，内部表示形式并没有那么明显。 结果，所有算法的性能指标都一致。 在此级别上，性能与更好的要素工程成正比。 但是这些手工设计的功能随着数据大小的增加而失败。 这就是深度神经网络的来历，因为它们能够从大量数据中捕获更好的表示。
+2.  检查图的左下角，靠近原点。 这是算法的相对顺序没有很好定义的区域。 由于数据量小，内部表示形式并没有那么明显。 结果，所有算法的表现指标都一致。 在此级别上，表现与更好的要素工程成正比。 但是这些手工设计的功能随着数据大小的增加而失败。 这就是深度神经网络的来历，因为它们能够从大量数据中捕获更好的表示。
 
 因此，我们可以得出结论，不应该将深度学习架构应用于任何遇到的数据。 所获得数据的数量和种类表明要应用哪种算法。 有时，小数据通过传统的机器学习算法比深度神经网络更有效。
 
@@ -68,9 +68,9 @@
 
 人类水平的表现是必要的，并且通常应用于深度学习。 在一段时间内收敛到最高点之后，人员水平的准确率变得恒定。 这一点称为最佳错误率（也称为贝叶斯错误率，即对于任何随机结果分类器而言，最低的错误率）。
 
-其背后的原因是由于数据中的噪声，许多问题在性能上都有理论上的限制。 因此，人员级别的准确率是通过进行错误分析来改进模型的好方法。 这是通过合并人为误差，训练集误差和验证集误差来估计偏差方差影响（即欠拟合和过拟合条件）来完成的。
+其背后的原因是由于数据中的噪声，许多问题在表现上都有理论上的限制。 因此，人员级别的准确率是通过进行错误分析来改进模型的好方法。 这是通过合并人为误差，训练集误差和验证集误差来估计偏差方差影响（即欠拟合和过拟合条件）来完成的。
 
-数据规模，算法类型和性能指标是一组方法，可以帮助我们针对不同的机器学习算法确定改进水平。 因此，决定是否投资深度学习或采用传统机器学习方法的关键决策。
+数据规模，算法类型和表现指标是一组方法，可以帮助我们针对不同的机器学习算法确定改进水平。 因此，决定是否投资深度学习或采用传统机器学习方法的关键决策。
 
 具有一些输入功能（下图中的三个）的基本感知器如下所示：
 
diff --git a/new/rl-tf/02.md b/new/rl-tf/02.md
index 7bf03601eb1d33061eb4e009bc147b4b1780646b..7663a8c13e62d59644071f3feee28808f2154e29 100644
--- a/new/rl-tf/02.md
+++ b/new/rl-tf/02.md
@@ -565,7 +565,7 @@ HFFG
 
 Q 学习和 Q 网络都需要付出一定的稳定性。 在某些情况下，如果给定的 Q 值超参数集未收敛，但具有相同的超参数，则有时会出现收敛。 这是由于这些学习方法的不稳定。 为了解决这个问题，如果状态空间较小，则应定义更好的初始策略（此处为给定状态的最大 Q 值）。 此外，超参数，尤其是学习率，折扣因子和ε值，起着重要的作用。 因此，必须正确初始化这些值。
 
-由于增加了状态空间，因此与 Q 学习相比，Q 网络具有更大的灵活性。 Q 网络中的深度神经网络可能会导致更好的学习和性能。 就使用深度状态 Q 网络玩 Atari 而言，有许多调整，我们将在接下来的章节中进行讨论。
+由于增加了状态空间，因此与 Q 学习相比，Q 网络具有更大的灵活性。 Q 网络中的深度神经网络可能会导致更好的学习和表现。 就使用深度状态 Q 网络玩 Atari 而言，有许多调整，我们将在接下来的章节中进行讨论。
 
 # 总结
 
diff --git a/new/rl-tf/04.md b/new/rl-tf/04.md
index c0a9be86283cacc51982de463d9778e7b7a6e08c..b95dd2100fc15e5d34f78ebac9aacee86c833f7e 100644
--- a/new/rl-tf/04.md
+++ b/new/rl-tf/04.md
@@ -373,7 +373,7 @@ end for
 
 ![](img/297c6703-97ca-4ba2-8e19-70dabec7b4a1.png)
 
-但是，实际上我们没有标签。 因此，我们将实现强化学习，在其中我们将尝试许多任务并记下观察结果。 然后，更频繁地执行性能更好的任务。
+但是，实际上我们没有标签。 因此，我们将实现强化学习，在其中我们将尝试许多任务并记下观察结果。 然后，更频繁地执行表现更好的任务。
 
 在输入 Python 代码之前，让我们放下步骤。 它们如下：
 
diff --git a/new/rl-tf/05.md b/new/rl-tf/05.md
index fc9ce87f750654fe8fcddd990ab8487456aac512..4f50c5b132f689e1e51d1cea53c486195c78c544 100644
--- a/new/rl-tf/05.md
+++ b/new/rl-tf/05.md
@@ -15,7 +15,7 @@
 
 2014 年，Google 以高达 5 亿美元的价格收购了伦敦一家名为 DeepMind 的创业公司。 在新闻中，我们了解到他们创建了一个 AI 智能体来击败任何 Atari 游戏，但是 Google 付出如此高的价格收购它的主要原因是因为这一突破向**通用人工智能**靠近了一步。 通用人工智能被称为 AI 智能体。 它能够完成各种任务并像人类一样泛化。 当它超过这一点时，该点称为人工超级智能。 目前，AI 社区所做的工作就是我们所说的人工智能，即人工智能，其中 AI 智能体能够执行多个任务，但不能概括各种任务。
 
-DeepMind 在研究期刊 **Nature** 上发表了他们的论文[《通过深度强化学习进行人类水平控制》](http://www.davidqiu.com:8888/research/nature14236.pdf)，这表明，他们的深度强化学习算法可成功应用于 50 种不同的 Atari 游戏，并在其中 30 种游戏中达到高于人类水平的性能。 他们的 AI 智能体称为**深度 Q 学习器**。 在详细深入学习强化学习之前，让我们回顾一下强化学习的基础知识。
+DeepMind 在研究期刊 **Nature** 上发表了他们的论文[《通过深度强化学习进行人类水平控制》](http://www.davidqiu.com:8888/research/nature14236.pdf)，这表明，他们的深度强化学习算法可成功应用于 50 种不同的 Atari 游戏，并在其中 30 种游戏中达到高于人类水平的表现。 他们的 AI 智能体称为**深度 Q 学习器**。 在详细深入学习强化学习之前，让我们回顾一下强化学习的基础知识。
 
 有监督和无监督的学习是 AI 应用社区众所周知的。 **监督学习**处理包含输入特征和目标标签（连续或离散）的标记数据集，并创建将这些输入特征映射到目标标签的模型。 另一方面，**无监督学习**处理仅包含输入特征但不包含目标标签的未标记数据集，其目的是发现基础模式，以将数据分类到不同集群中，并分别定义其效用。 不同集群中特定类型的数据。
 
@@ -351,7 +351,7 @@ Episode 10 completed with total reward 222.356805259 in 843 steps
 
 我们的游戏环境是视频，而卷积神经网络在计算机视觉方面已经显示了最新的成果。 而且，游戏框架中物体检测的水平应该接近人类水平的能力，并且卷积神经网络从图像中学习表示，类似于人类原始视觉皮层的行为。
 
-DeepMind 在其 DQN 网络中使用了三个卷积层和两个全连接层，从而在 Atari 游戏中实现了超人水平的性能，如以下流程图所示：
+DeepMind 在其 DQN 网络中使用了三个卷积层和两个全连接层，从而在 Atari 游戏中实现了超人水平的表现，如以下流程图所示：
 
 ![](img/373d89a3-057c-444c-91b2-bbe4eeb5e1b4.png)
 
@@ -401,7 +401,7 @@ end
 
 # 深度 Q 网络以及其他方面的进步
 
-随着更多的研究和更多的时间，深度 Q 网络已经进行了许多改进，从而获得了更好的架构，从而提供了更高的性能和稳定性。 在本节中，我们将仅讨论两种著名的架构，即**双重 DQN** 和**决斗 DQN**。
+随着更多的研究和更多的时间，深度 Q 网络已经进行了许多改进，从而获得了更好的架构，从而提供了更高的表现和稳定性。 在本节中，我们将仅讨论两种著名的架构，即**双重 DQN** 和**决斗 DQN**。
 
 # 双 DQN
 
diff --git a/new/rl-tf/06.md b/new/rl-tf/06.md
index f25bbb698cc06d1e4900bb95cb90057b59e87b09..6bc53e2dfa2990675122e877a4f8335ffce9fe72 100644
--- a/new/rl-tf/06.md
+++ b/new/rl-tf/06.md
@@ -13,7 +13,7 @@
 
 换句话说，演员的行为像孩子，而评论家的行为像父母，孩子探索多种行为，父母批评不良行为并补充良好行为。 因此，行动者批判算法既学习了策略功能，又学习了状态作用值函数。 像策略梯度一样，参与者评论算法也通过梯度上升来更新其参数。 在高维连续状态和动作空间的情况下，演员评论家方法非常有效。
 
-因此，让我们从 Google DeepMind 发布的深度强化学习中的异步方法开始，该方法在性能和计算效率方面都超过了 DQN。
+因此，让我们从 Google DeepMind 发布的深度强化学习中的异步方法开始，该方法在表现和计算效率方面都超过了 DQN。
 
 我们将在本章介绍以下主题：
 
@@ -60,7 +60,7 @@ Google DeepMind 和 MILA 的联合团队于 2016 年 6 月发布了用于深度
 
 异步单步 Q 学习中的区别在于，有多个此类学习智能体，例如，学习器并行运行并计算此损失。 因此，梯度计算也并行发生在不同的线程中，其中每个学习智能体都与自己的环境副本进行交互。 这些梯度在多个时间步长上在不同线程中的累积用于在固定时间步长后或情节结束后更新策略网络参数。 梯度的累积优于策略网络参数更新，因为这样可以避免覆盖每个学习器智能体执行的更改。
 
-此外，将不同的探索策略添加到不同的线程可以使学习变得多样化且稳定。 由于更好的探索，因此提高了性能，因为不同线程中的每个学习智能体都受到不同的探索策略。 尽管有许多方法可以执行此操作，但一种简单的方法是在使用 ε 贪婪的同时为不同的线程使用不同的`ε`示例。
+此外，将不同的探索策略添加到不同的线程可以使学习变得多样化且稳定。 由于更好的探索，因此提高了表现，因为不同线程中的每个学习智能体都受到不同的探索策略。 尽管有许多方法可以执行此操作，但一种简单的方法是在使用 ε 贪婪的同时为不同的线程使用不同的`ε`示例。
 
 异步单步 Q 学习的伪代码如下所示。 这里，以下是全局参数：
 
diff --git a/new/rl-tf/07.md b/new/rl-tf/07.md
index 75927adf9930255015a6b146755bca22a74af44c..26ef592cb1176809b3654b7dc1286d4d466b7202 100644
--- a/new/rl-tf/07.md
+++ b/new/rl-tf/07.md
@@ -2,7 +2,7 @@
 
 近年来，视频游戏行业以惊人的速度增长。 根据 SuperData 的 2017 年度回顾报告，全球游戏行业创造了 1084 亿美元的收入。 全球游戏市场研究机构 Newzoo 预测，到 2020 年，视频游戏行业的收入将超过 1400 亿美元。
 
-实时策略游戏构成策略视频游戏类型的子类别，并且相对于回合制策略游戏而言，实时策略游戏现在变得越来越重要。 在本章中，我们将讨论 AI 社区为何无法解决实时策略游戏，以及与其他算法相比，强化学习在学习和性能方面如何更好地解决该问题陈述。
+实时策略游戏构成策略视频游戏类型的子类别，并且相对于回合制策略游戏而言，实时策略游戏现在变得越来越重要。 在本章中，我们将讨论 AI 社区为何无法解决实时策略游戏，以及与其他算法相比，强化学习在学习和表现方面如何更好地解决该问题陈述。
 
 我们将在本章介绍以下主题：
 
diff --git a/new/rl-tf/08.md b/new/rl-tf/08.md
index 9f89377a0df6926b0948e41f448547f7c0cdcb5b..b6336c6017e2e416b42354ef8aa5422753884d4c 100644
--- a/new/rl-tf/08.md
+++ b/new/rl-tf/08.md
@@ -21,11 +21,11 @@
 
 如前所述，游戏是测试这些 AI 算法的最佳测试平台。 除了具有成本效益之外，没有两个游戏是相同的，因此能够使用从一个游戏中学到的知识并将其应用于另一个游戏，这是一般智慧的标志。 单个算法可以应用的游戏越多，它变得越通用。
 
-我们第一次看到向**人工智能**（**AGI**）迈出了巨大的一步，当时 DeepMind 证明了他们的 AI 可以击败许多 Atari 游戏，使其成为现存最通用的 AI 系统 。 DeepMind 在研究期刊 **Nature** 上发表了他们的论文[《通过深度强化学习进行人类级别控制》](http://www.davidqiu.com:8888/research/nature14236.pdf)，由 Silver 等展示了他们的 AI 智能体**深度 Q 学习器**，使用了深度强化学习算法，已成功应用于 50 种不同的 Atari 游戏，并在以下截图中显示了其中的 30 种，其性能均达到人类水平。 通用人工智能的发展方向是 Google 购买 DeepMind 的原因：
+我们第一次看到向**人工智能**（**AGI**）迈出了巨大的一步，当时 DeepMind 证明了他们的 AI 可以击败许多 Atari 游戏，使其成为现存最通用的 AI 系统 。 DeepMind 在研究期刊 **Nature** 上发表了他们的论文[《通过深度强化学习进行人类级别控制》](http://www.davidqiu.com:8888/research/nature14236.pdf)，由 Silver 等展示了他们的 AI 智能体**深度 Q 学习器**，使用了深度强化学习算法，已成功应用于 50 种不同的 Atari 游戏，并在以下截图中显示了其中的 30 种，其表现均达到人类水平。 通用人工智能的发展方向是 Google 购买 DeepMind 的原因：
 
 ![](img/1ee7ccc9-af7f-42c3-85ed-94293d4cb9e2.jpg)
 
-比较 50 种不同的 Atari 游戏的性能：DQN 的性能根据专业人类玩家测试员规范化，[《通过深度强化学习的人类水平控制》](http://www.davidqiu.com:8888/research/nature14236.pdf)。
+比较 50 种不同的 Atari 游戏的表现：DQN 的表现根据专业人类玩家测试员规范化，[《通过深度强化学习的人类水平控制》](http://www.davidqiu.com:8888/research/nature14236.pdf)。
 
 2016 年 3 月 9 日，我们见证了 Google DeepMind 的 AlphaGo 在古代中国游戏围棋中击败 18 届世界冠军 Lee Sedol 的历史。 对于整个 AI 社区来说，这是一个伟大的里程碑。 这是因为人们投入了毕生精力来掌握围棋游戏。 由于其复杂性，围棋游戏具有很高的挑战性。 根据 1997 年[《纽约时报》的文章](http://www.nytimes.com/1997/07/29/science/to-test-a-powerful-computer-play-an-ancient-game.html)，科学家说，围棋是智力水平最高的游戏，要在围棋上击败人类至少要花一个世纪的时间。 但是，由于有了 Google DeepMind，我们得以在不到二十年的时间内实现了这一壮举。 以下是本章将涉及的主题：
 
@@ -166,7 +166,7 @@ Silver 等人
 
 # AlphaGo Zero
 
-第一代 AlphaGo 能够击败专业的围棋玩家。 2017 年 10 月，Google DeepMind 在 Nature 上发表了有关[《AlphaGo Zero》](https://www.nature.com/articles/nature24270)的论文。 AlphaGo Zero 是 AlphaGo 的最新版本。 早期版本的 AlphaGo 在接受过数以千计的从业余到专业游戏的人类游戏训练后，学会了玩游戏。 但是 AlphaGo 的最终版本（即 AlphaGo Zero）从零开始学到了一切，这是从第一个基本原理开始的，既没有使用任何人工数据也没有任何人工干预，并且能够实现最高水平的性能。 因此，AlphaGo Zero 通过与自己对战来学习玩围棋。 最大的壮举之一是，AlphaGo Zero 在 19 小时内就能够学习更高级的围棋策略的基础知识，包括生与死，影响力和领土。 在短短的三天内，AlphaGo Zero 击败了所有先前的 AlphaGo 版本，并在 40 天内超过了人类对围棋的一千年了解。
+第一代 AlphaGo 能够击败专业的围棋玩家。 2017 年 10 月，Google DeepMind 在 Nature 上发表了有关[《AlphaGo Zero》](https://www.nature.com/articles/nature24270)的论文。 AlphaGo Zero 是 AlphaGo 的最新版本。 早期版本的 AlphaGo 在接受过数以千计的从业余到专业游戏的人类游戏训练后，学会了玩游戏。 但是 AlphaGo 的最终版本（即 AlphaGo Zero）从零开始学到了一切，这是从第一个基本原理开始的，既没有使用任何人工数据也没有任何人工干预，并且能够实现最高水平的表现。 因此，AlphaGo Zero 通过与自己对战来学习玩围棋。 最大的壮举之一是，AlphaGo Zero 在 19 小时内就能够学习更高级的围棋策略的基础知识，包括生与死，影响力和领土。 在短短的三天内，AlphaGo Zero 击败了所有先前的 AlphaGo 版本，并在 40 天内超过了人类对围棋的一千年了解。
 
 AlphaGo Zero 背后最重要的想法是，它完全从空白状态（即清晰的围棋棋盘）中学习，并通过自己的玩法自行弄清楚，而无需任何人类知识，没有任何人类游戏示例和数据，甚至没有任何人为干预。 它从最初的基本原理中发现并发展了学习围棋游戏的直觉。 这种从头开始的学习称为**表格学习**或**白板学习**。
 
diff --git a/new/rl-tf/09.md b/new/rl-tf/09.md
index 3bd7fee282231d71b45e61cfbb36cb9a71d14778..06854feb6d10c0d5d2e6d263b9ca33173813d2b5 100644
--- a/new/rl-tf/09.md
+++ b/new/rl-tf/09.md
@@ -175,7 +175,7 @@ DeepTraffic 由一条高速公路带组成，该高速公路带显示了同时
 *   减速
 *   没做什么
 
-对于其他汽车，将按照现实的模式随机选择动作，例如，由于随机选择动作，不会太频繁地改变车道。 以红色（深灰色）显示的汽车由深度强化学习智能体控制。 竞争对手获得以 DQN 实现的预定义神经网络。 任务是配置不同的超参数并获得最佳性能，即最高平均速度。
+对于其他汽车，将按照现实的模式随机选择动作，例如，由于随机选择动作，不会太频繁地改变车道。 以红色（深灰色）显示的汽车由深度强化学习智能体控制。 竞争对手获得以 DQN 实现的预定义神经网络。 任务是配置不同的超参数并获得最佳表现，即最高平均速度。
 
 # 总结
 
diff --git a/new/rl-tf/10.md b/new/rl-tf/10.md
index 20a66f84e30f3c646fecf6caf29214b565a42990..8748530ff9097c4ba9151f1d8d9a6c4ca66ef712 100644
--- a/new/rl-tf/10.md
+++ b/new/rl-tf/10.md
@@ -36,11 +36,11 @@
 
 跟随获胜者和跟随失败者是基于先前构建的财务模型，该模型可能会或可能不会在上表中提及的相应算法中使用机器学习技术。 这些方法在不同金融市场中的有效性可以判断其效果。
 
-模式匹配模型将历史数据样本作为输入，根据样本分布优化投资组合，并预测下一个时期的市场分布。 元学习聚合了不同类别的多种策略，以实现稳定的性能。
+模式匹配模型将历史数据样本作为输入，根据样本分布优化投资组合，并预测下一个时期的市场分布。 元学习聚合了不同类别的多种策略，以实现稳定的表现。
 
 当前，存在用于金融市场交易的深度学习方法，这些方法可以预测价格走势和趋势，但不能在不同的金融产品之间执行自动的资金分配和重新分配。 由于我们拥有所有资产的历史价格，因此我们可以将包含它们的输入数据准备到循环神经网络中，该网络将预测下一时期的资产价格作为输出。 这是机器学习中的监督回归问题。
 
-这些模型的性能完全取决于未来资产价格的预测准确率，而不仅是在下一个时期。 但是，未来的市场价格极难预测，因为它们不仅取决于历史价格，而且只能反映波动和流动，不包括也会驱动金融市场的情感因素。
+这些模型的表现完全取决于未来资产价格的预测准确率，而不仅是在下一个时期。 但是，未来的市场价格极难预测，因为它们不仅取决于历史价格，而且只能反映波动和流动，不包括也会驱动金融市场的情感因素。
 
 需要注意的另一个重要点是，预测市场价格并不意味着预测市场行为。 因此，需要领域知识和逻辑将预测价格转换为行动。 结合深度强化学习，可根据最大化回报的目标使此逻辑转换自动化。
 
@@ -66,7 +66,7 @@
 
 EIIE 通过**在线随机批量学习**（**OSBL**）进行训练，其中强化学习框架的奖励函数是该时期的平均对数回报。 由于奖励功能是动态的，因此，随着训练是通过梯度上升进行的，EIIE 也在不断发展。 如前所述，EIIE 由一个神经网络组成，因此，对于当前框架，使用不同类型的神经网络测试了三种不同类型的 EIIE，即**卷积神经网络**（**CNN**），**循环神经网络**（**RNN**）和**长短期记忆网络**（**LSTM**），这是 RNN 单元。 这种类型的框架可以轻松扩展到不同的市场，而不仅限于一个。
 
-该提议框架的测试平台是一个名为 Poloniex 的加密货币交易市场。 实验之前，通过在一定时间间隔内的交易量排名来选择硬币。 实验在 30 分钟的交易时间内进行，并将 EIIE 的性能与前面提到的在线投资组合选择方法进行了比较。 EIIE 能够击败所有这些方法。
+该提议框架的测试平台是一个名为 Poloniex 的加密货币交易市场。 实验之前，通过在一定时间间隔内的交易量排名来选择硬币。 实验在 30 分钟的交易时间内进行，并将 EIIE 的表现与前面提到的在线投资组合选择方法进行了比较。 EIIE 能够击败所有这些方法。
 
 由于该框架不是在现实世界的金融市场中而是在加密货币市场中进行测试的，因此我们必须知道加密货币与传统金融资产之间的差异，以及为什么加密货币市场事先是算法投资组合管理实验的更好测试平台。 它们如下：
 
@@ -205,13 +205,13 @@ PVM 是按时间步长顺序（即时间顺序）收集投资组合向量的集
 
 因此，提出了 OSBL，其中在时段`t`结束时，时段的价格变动将添加到训练集中。 在完成时间段`t + 1`的订单后，使用从该组中随机选择的小批量对策略网络进行训练。 有关 OSBL 的完整详细研究超出了本书的范围，但是为了进一步探索，请阅读[《金融组合管理问题的深层强化学习框架》](https://arxiv.org/pdf/1706.10059.pdf)中的 5.3 节 。
 
-使用所有三个不同的策略网络（即 CNN，RNN 和 LSTM）在加密货币交易所 Poloniex 上对该框架进行了测试。 用于检查框架性能的投资组合的财务指标为：
+使用所有三个不同的策略网络（即 CNN，RNN 和 LSTM）在加密货币交易所 Poloniex 上对该框架进行了测试。 用于检查框架表现的投资组合的财务指标为：
 
 *   **投资组合价值**：最终投资组合的价值
 *   **最大跌幅**：在达到新峰值之前，从一个峰值（最高点）到波谷（最低点）的最大损失
 *   **夏普比率**：风险收益率（可变性）比率
 
-在前面提到的指标的基础上，将提出的框架的性能与现有的在线投资组合管理方法进行了比较，它能够成功击败现有的在线投资组合管理方法。 因此，提出的强化学习框架能够解决一般的金融投资组合管理问题。
+在前面提到的指标的基础上，将提出的框架的表现与现有的在线投资组合管理方法进行了比较，它能够成功击败现有的在线投资组合管理方法。 因此，提出的强化学习框架能够解决一般的金融投资组合管理问题。
 
 拟议框架的主要特点是：
 
diff --git a/new/rl-tf/11.md b/new/rl-tf/11.md
index 0c659b24a772e8160c9c29862484fb9de216d60c..325713e0a2b21a0bfc457d807d9a580e8ff8ccf2 100644
--- a/new/rl-tf/11.md
+++ b/new/rl-tf/11.md
@@ -4,7 +4,7 @@
 
 与认知科学的紧密比较将是动态机器人系统和自动驾驶中强化学习的许多成功实现。 他们证明了将强化学习算法用于物理系统实时控制的理论。
 
-在深度 Q 网络和策略梯度中使用神经网络可消除对人工设计的策略和状态表示的使用。 在深度强化学习中直接使用 CNN 并使用图像像素代替手工设计的功能作为状态已成为广泛接受的实践。 小型批量训练以及单独的主要网络和目标网络的概念为深度强化学习算法带来了成功。 在以像素为输入的 50 场 Atari 2600 游戏中，DeepMind 和深度强化学习的成功实现了超人的性能水平，这是强化学习研究的转折点。
+在深度 Q 网络和策略梯度中使用神经网络可消除对人工设计的策略和状态表示的使用。 在深度强化学习中直接使用 CNN 并使用图像像素代替手工设计的功能作为状态已成为广泛接受的实践。 小型批量训练以及单独的主要网络和目标网络的概念为深度强化学习算法带来了成功。 在以像素为输入的 50 场 Atari 2600 游戏中，DeepMind 和深度强化学习的成功实现了超人的表现水平，这是强化学习研究的转折点。
 
 研究人员试图在机器人技术中实现深层 Q 网络，但并未取得重大成功。 其背后的主要原因是机器人领域中的高维连续动作空间。 为了在连续的动作空间中实现 DQN，必须离散化它们，但是这种离散化会导致信息丢失，这对于诸如机器人之类的领域可能是非常危险的。
 
@@ -35,7 +35,7 @@
 
 在本书中，我们涵盖了从基础到高级的强化学习领域中的大多数算法。 因此，这些章节是理解机器人领域中不同算法所面临的应用和挑战的前提。 早期强化学习算法通过首先获取状态动作值，然后从中得出策略来处理获取最佳策略的问题。 然后，策略迭代方法出现了，直接用于输出优化的策略。 探索利用技术有助于完善现有策略，探索新措施并更新现有策略。 强化学习方法，例如 MDP（在第 3 章，“马尔可夫决策过程”中），其中需要采用转移模型的值迭代方法称为**基于模型的学习器**。 另一方面，诸如 Q 学习（在第 5 章，“Q 学习和深度 Q 网络”中）的算法不需要这种转移模型，因此也不需要任何预定义的策略。 他们被称为**无模型的脱离策略学习器**。
 
-在深度强化学习领域，行动值函数逼近器和策略函数逼近器在制定最先进的学习算法集方面发挥着关键作用。 策略搜索算法（例如策略梯度）旨在通过最大化期望的奖励总和来找到最佳策略，而使用行动值函数近似器（例如深度 Q 网络）的算法旨在通过最大化期望的总和，来找到给定状态和行动值的奖励。 但是，在处理由高维和连续状态动作空间构成的环境时，性能上的差异在于，这最能描述机器人在其中运行的真实环境。 在这种情况下，策略搜索算法的性能会更好，因为它们在连续状态操作空间域中可以更好地工作：
+在深度强化学习领域，行动值函数逼近器和策略函数逼近器在制定最先进的学习算法集方面发挥着关键作用。 策略搜索算法（例如策略梯度）旨在通过最大化期望的奖励总和来找到最佳策略，而使用行动值函数近似器（例如深度 Q 网络）的算法旨在通过最大化期望的总和，来找到给定状态和行动值的奖励。 但是，在处理由高维和连续状态动作空间构成的环境时，表现上的差异在于，这最能描述机器人在其中运行的真实环境。 在这种情况下，策略搜索算法的表现会更好，因为它们在连续状态操作空间域中可以更好地工作：
 
 ![](img/dbe76734-7904-4c3f-b486-17840eae3d22.png)
 
@@ -110,7 +110,7 @@ Perkins 和 Barto（2002）提出了一种基于 Lyapunov 函数构造强化学
 
 在现实世界中，设计好的奖励功能是一个巨大的挑战。 因此，代表或指定目标是现实世界中的挑战。 现实世界中充满不确定性，因此，奖励函数应能够捕获与此类不确定性相关的积极状态。
 
-一些领域在任务完成后获得奖励，不确定性较小，但在某些情况下，导致更好的最终结果的每个动作都具有不同的奖励。 这是由于每个状态的重要性，因为每个状态都像在现实情况中那样采取了行动。 因此，任务完成奖励机制不能在现实世界中实现，因为它不会捕获不确定性，也不会导致学习趋同，从而导致性能下降。
+一些领域在任务完成后获得奖励，不确定性较小，但在某些情况下，导致更好的最终结果的每个动作都具有不同的奖励。 这是由于每个状态的重要性，因为每个状态都像在现实情况中那样采取了行动。 因此，任务完成奖励机制不能在现实世界中实现，因为它不会捕获不确定性，也不会导致学习趋同，从而导致表现下降。
 
 在我们遇到的大多数现有模拟中，我们看到了一种二元奖励机制，该机制仅捕获了学习智能体的成功和失败。 将中间奖励包含为奖励功能的一部分，将比二元奖励方法更好，从而导致更好的解决方案。 包括中间奖励在内，将捕获现实系统中从状态到状态转换的不确定性。
 
diff --git a/new/rl-tf/13.md b/new/rl-tf/13.md
index 11fedef17140a19aab8b036959303c18ed7166ef..4fc2cd6a25f5fad4cece9a5eaba5518a8786200f 100644
--- a/new/rl-tf/13.md
+++ b/new/rl-tf/13.md
@@ -92,7 +92,7 @@ YOLO 还可以预测训练中所有班级每个盒子的班级得分。 因此
 
 **单发检测器**（**SSD**）以其在速度和准确率之间的平衡而著称。 就像 YOLO 一样，SSD 仅在输入图像上运行一次 CNN 即可学习表示形式。 在此表示形式上运行一个小的`3x3`卷积核，以预测边界框和类概率。 为了处理比例，SSD 会在多个卷积层之后预测边界框。 由于每个卷积层以不同的比例运行，因此它能够检测各种比例的对象。
 
-下图显示了 Fast R-CNN，Faster R-CNN，YOLO 和 SSD 的性能指标：
+下图显示了 Fast R-CNN，Faster R-CNN，YOLO 和 SSD 的表现指标：
 
 ![](img/f32fc789-7256-486f-a907-7820f5bc1461.png)
 
diff --git a/new/rl-tf/14.md b/new/rl-tf/14.md
index 6295836101a13de5e7b6a4dd5d9ea18e295079a2..e3133f1f0ab85669d161065d9b76c84ad94fe1d7 100644
--- a/new/rl-tf/14.md
+++ b/new/rl-tf/14.md
@@ -31,7 +31,7 @@
 *   **提取式摘要**：通过复制输入文本中的部分文本来创建摘要
 *   **抽象式摘要**：通过改写文本或使用输入文本中未包含的新词来生成新文本
 
-为机器翻译创建的基于注意力的编码器解码器模型（Bahdanau 等，2014）是一个序列到序列模型，能够通过获得良好的 ROUGE 得分来生成具有良好性能的抽象摘要（请参见附录 A，“强化学习中的其他主题”）。 在短输入序列上的性能很好，并且随着输入文本序列长度的增加而降低。
+为机器翻译创建的基于注意力的编码器解码器模型（Bahdanau 等，2014）是一个序列到序列模型，能够通过获得良好的 ROUGE 得分来生成具有良好表现的抽象摘要（请参见附录 A，“强化学习中的其他主题”）。 在短输入序列上的表现很好，并且随着输入文本序列长度的增加而降低。
 
 在 CNN /每日邮件数据集的更大输入序列和输出摘要数据集上（Hermann 等，2015），Nallapati 等人（2016）提出了抽象摘要模型的应用，其中输入序列最多为 800 个标记，而摘要最多为 100 个标记。 对本实验的分析表明，与较大输入序列的基于注意力的编码器-解码器模型相关的问题是，它们通常会生成异常摘要，这些摘要通常由重复的短语组成。 这是因为仅通过监督学习方法进行训练的编码器解码器模型通常会遭受曝光偏差，即在训练过程中的每个时间步骤都提供了地面真相（实际文本）的假设。
 
diff --git a/new/rl-tf/15.md b/new/rl-tf/15.md
index a2f4a2aca7b0821b3132b3fb5059fc4f236dfaa5..8dcda0379ffb5ef4ee971c07ff2634e7087b863f 100644
--- a/new/rl-tf/15.md
+++ b/new/rl-tf/15.md
@@ -15,7 +15,7 @@
 
 **信任区域策略优化**（**TRPO**）是一种用于优化策略的迭代方法。 TRPO 优化了大型非线性策略。 TRPO 通过对输出策略分布施加约束来限制策略搜索空间。 为此，对策略网络参数使用 KL 散度损失函数（`D_max[KL](θ_old, θ)`）来惩罚这些参数。 新策略和旧策略之间的 KL 差异约束称为信任区域约束。 由于此约束，策略分布中不会发生大规模更改，从而导致策略网络尽早收敛。
 
-TRPO 由 Schulman 等（2017）发布在名为[《信任区域策略优化》](https://arxiv.org/pdf/1502.05477.pdf)的研究出版物中。 在这里，他们提到了一些实验，这些实验证明了 TRPO 在不同任务上的强大性能，例如学习模拟机器人游泳，玩 Atari 游戏等等。 [为了详细研究 TRPO，请访问出版物的 arXiv 链接](https://arxiv.org/pdf/1502.05477.pdf)。
+TRPO 由 Schulman 等（2017）发布在名为[《信任区域策略优化》](https://arxiv.org/pdf/1502.05477.pdf)的研究出版物中。 在这里，他们提到了一些实验，这些实验证明了 TRPO 在不同任务上的强大表现，例如学习模拟机器人游泳，玩 Atari 游戏等等。 [为了详细研究 TRPO，请访问出版物的 arXiv 链接](https://arxiv.org/pdf/1502.05477.pdf)。
 
 # 确定性策略梯度