2021-01-24 22:37:37

new/dl-pt-workshop/3.md

@@ -586,11 +586,11 @@ batch_size = 100
 
 误差分析是指对训练和验证数据集上的错误率进行的初始分析。 然后，使用此分析来确定改善模型表现的最佳措施。
 
-为了执行误差分析，有必要确定贝叶斯误差（也称为不可约误差），它是可实现的最小误差。 几十年前，贝叶斯错误等同于人为错误，这意味着专家认为可以达到的最低错误级别。
+为了执行误差分析，有必要确定贝叶斯误差（也称为不可约误差），它是可实现的最小误差。 几十年前，贝叶斯误差等同于人为误差，这意味着专家认为可以达到的最低误差级别。
 
 如今，随着技术和算法的改进，由于机器具有超越人类表现的能力，因此难以估计此值。 没有办法衡量他们与人类相比能做的更好，因为我们只能了解我们的能力。
 
-为了执行误差分析，通常首先将贝叶斯错误设置为等于人为错误。 然而，这种局限性并非一成不变，研究人员认为，超越人类的表现也应是最终目标。
+为了执行误差分析，通常首先将贝叶斯误差设置为等于人为误差。 然而，这种局限性并非一成不变，研究人员认为，超越人类的表现也应是最终目标。
 
 执行误差分析的过程如下：
 
@@ -602,7 +602,7 @@ batch_size = 100
     图 3.9：用于在训练集上计算模型错误率的方程式
 
 3.  从训练集误差`A)`中减去贝叶斯误差。 保存差异，将用于进一步分析。
-4.  从验证集错误`B)`中减去训练集错误，并保存差值。
+4.  从验证集误差`B)`中减去训练集误差，并保存差值。
 5.  取步骤 3 和步骤 4 中计算出的差值，并使用以下一组规则。
 
     如果在“步骤 3”中计算出的差大于在“步骤 4”中计算出的差，则该模型不适合，也称为遭受高偏差。

new/dl-pt-workshop/6.md

@@ -302,7 +302,7 @@ for i in range(1, epochs+1):
 
 到目前为止，已经明确了 LSTM 网络与传统 RNN 的区别在于它们具有长期记忆的能力。 但是，必须指出的是，随着时间的流逝，非常古老的信息不太可能影响下一个输出。 考虑到这一点，LSTM 网络还具有考虑数据位与底层上下文之间距离的能力，以便也可以决定忘记一些不再相关的信息。
 
-那么，LSTM 网络如何决定何时记住和何时忘记？ 与传统的 RNN 不同，LSTM 网络在每个节点中仅执行一次计算，而 LSTM 网络执行四种不同的计算，从而允许网络的不同输入（即当前事件，短期记忆和长期事件）之间进行交互。 术语记忆）以得出结果。
+那么，LSTM 网络如何决定何时记住和何时忘记？ 与传统的 RNN 不同，LSTM 网络在每个节点中仅执行一次计算，而 LSTM 网络执行四种不同的计算，从而允许网络的不同输入（即当前事件，短期记忆和长期记忆项）之间进行交互，以得出结果。
 
 要了解 LSTM 网络背后的过程，请考虑用于管理网络中信息的四个门，如下图所示：
 

new/dl-pt-workshop/7.md

@@ -602,7 +602,7 @@
 
     注意
 
-    可以在以前共享的 GitHub 存储库中找到此活动随附的 Jupyter 笔记本。 在那里，您会发现对模型进行微调的各种尝试及其结果。 表现最佳的型号可以在笔记本电脑的末尾找到。
+    可以在以前共享的 GitHub 存储库中找到此活动随附的 Jupyter 笔记本。 在那里，您会发现对模型进行微调的各种尝试及其结果。 表现最佳的模型可以在笔记本电脑的末尾找到。
 
 4.  绘制两组数据的损失和准确率。
 
@@ -1807,7 +1807,7 @@
     x = np.array(x).reshape((n_seq,-1))
     ```
 
-8.  通过使用`256`作为共两个递归层的隐藏单元数来实例化你的模型。
+8.  通过使用`256`作为共两个循环层的隐藏单元数来实例化你的模型。
 
     ```py
     model = LSTM(len(chars), 256, 2)

new/handson-1shot-learn-py/1.md

@@ -74,7 +74,7 @@
 
 # 一次学习概述
 
-一次学习可以看作是一种类似于人类学习方式的机器训练方法。 一次学习是一种在有限的监督数据的帮助下，借助强大的先验知识来学习新任务的方法。 李菲菲博士最早发表的导致图像分类问题精度高的著作可以追溯到 2000 年代-尽管近年来，研究人员在通过不同的深度学习架构和优化算法（例如， 匹配网络，不可知论元学习模型和记忆增强神经网络。 一次学习在多个行业中都有很多应用，尤其是在医疗和制造业中。 在医学上，当可用数据有限时，例如在治疗罕见疾病时，我们可以使用一次学习。 而在制造中，我们可以减少人为错误，例如表壳制造中的缺陷。
+一次学习可以看作是一种类似于人类学习方式的机器训练方法。 一次学习是一种在有限的监督数据的帮助下，借助强大的先验知识来学习新任务的方法。 李菲菲博士最早发表的导致图像分类问题精度高的著作可以追溯到 2000 年代-尽管近年来，研究人员在通过不同的深度学习架构和优化算法（例如， 匹配网络，不可知论元学习模型和记忆增强神经网络。 一次学习在多个行业中都有很多应用，尤其是在医疗和制造业中。 在医学上，当可用数据有限时，例如在治疗罕见疾病时，我们可以使用一次学习。 而在制造中，我们可以减少人为误差，例如表壳制造中的缺陷。
 
 # 一次学习的先决条件
 

new/handson-1shot-learn-py/2.md

@@ -137,7 +137,7 @@
 
 ![](img/73760b22-b575-40f1-85be-396c6822a5d5.png)
 
-用距离函数的术语，我们可以说以下几点：
+用距离函数项，我们可以说以下几点：
 
 ![](img/e89f8c0f-2387-40bf-9cd0-b346ff3fdc52.png)
 
@@ -187,7 +187,7 @@
 
 # 训练器
 
-在训练架构方面，匹配网络遵循某种技术：它们尝试在训练阶段复制测试条件。 简而言之，正如我们在上一节中所了解的那样，匹配网络从训练数据中采样标签集，然后它们从同一标签集生成支持集和批量集。 数据预处理之后，匹配网络通过训练模型以将支持集作为训练集，并将批量集作为测试集来最小化错误，从而学习其参数。 通过将支持集作为训练集，将批量集作为测试集的训练过程，可使匹配的网络复制测试条件。
+在训练架构方面，匹配网络遵循某种技术：它们尝试在训练阶段复制测试条件。 简而言之，正如我们在上一节中所了解的那样，匹配网络从训练数据中采样标签集，然后它们从同一标签集生成支持集和批量集。 数据预处理之后，匹配网络通过训练模型以将支持集作为训练集，并将批量集作为测试集来最小化误差，从而学习其参数。 通过将支持集作为训练集，将批量集作为测试集的训练过程，可使匹配的网络复制测试条件。
 
 在下一部分中，我们将介绍匹配网络的架构和算法，并学习如何在模型的训练阶段使用批量集（即测试集）。
 

new/handson-1shot-learn-py/3.md

@@ -127,7 +127,7 @@ MANN 的读取操作与 NTM 的读取操作非常相似，唯一的区别是此
 
 # 元网络算法
 
-要开始学习元网络，我们首先需要定义以下术语：
+要开始学习元网络，我们首先需要定义以下项：
 
 *   **支持集**：训练集中的采样输入数据点（`x`，`y`）。
 *   **测试集**：来自训练集的采样数据点（`x`，*和*）。

new/handson-1shot-learn-py/4.md

@@ -44,7 +44,7 @@ MAML 的目的是为模型的参数提供良好的初始化，从而以较少的
 
 # 算法
 
-要了解 MAML 的一次学习/小样本学习，首先，我们需要学习某些术语。 这些类似于我们在匹配网络时学到的知识：
+要了解 MAML 的一次学习/小样本学习，首先，我们需要学习某些项。 这些类似于我们在匹配网络时学到的知识：
 
 *  `T`：这表示各种任务-例如，我们希望我们的模型学习识别猫，狗，马等，以及`T[i]`代表一种识别猫的训练模型。 在此，`T[i] ∈ T`。
 *  `P(T)`：这表示所有任务之间的概率分布。 我们的目标是通过 MAML 学习`P(T)`。
@@ -93,7 +93,7 @@ LSTM 元学习器是一种元学习。 LSTM 元学习器分为两个阶段：
 *   **元学习器**：在此阶段，模型着重于学习跨各种任务的常识。
 *   **基础学习器**：在基础学习器中，模型尝试优化以学习任务特定目标的参数。
 
-LSTM 元学习器的关键思想是训练 LSTM 单元以*学习我们原始任务的更新规则*。 用元学习框架的术语来说， **LSTM 细胞**将用作元学习器，而*特定于任务的目标*（例如狗的品种分类）将被用作*基础学习器*。
+LSTM 元学习器的关键思想是训练 LSTM 单元以*学习我们原始任务的更新规则*。 用元学习框架的术语来说， **LSTM 单元**将用作元学习器，而*特定于任务的目标*（例如狗的品种分类）将被用作*基础学习器*。
 
 现在，问题来了，为什么我们要使用 LSTM 单元？ LSTM 元学习器的作者做出了一个关键的观察，即 LSTM 中的单元状态更新与反向传播中的基于梯度的更新相似，可用于学习基本学习器目标的更新规则：
 
@@ -143,7 +143,7 @@ LSTM 在各种门的帮助下存储信息历史记录，如上图所示。 我
 
 要训​​练一个一次学习模型，您需要匹配训练条件以测试时间条件，例如，像在匹配网络中一样，在较少的数据上进行训练，但要进行多个批量。 LSTM 元学习器也遵循与匹配网络相同的概念，并已被证明在特定任务目标上确实表现出色。
 
-要开始理解 LSTM 元学习器，首先，我们需要了解某些术语：
+要开始理解 LSTM 元学习器，首先，我们需要了解某些项：
 
 *   **基础学习器**（`M`）：具有特定任务的主要目标，带有参数`θ`-例如，用于识别猫的分类器
 *   **元学习器**（`R`）：LSTM 单元，带有参数，`θ`
@@ -541,7 +541,7 @@ plt.savefig('daml-sine.png')
 
 要求解任何方程，通常我们可以使用很多方法。 同样，为了进行优化（学习神经网络的参数），许多研究人员也公开了许多方法，但是事实证明梯度下降是一种适用于每种情况的通用方法。 如果我们希望处理特定类型的神经网络问题，那么最好探索可能适合我们任务的不同优化技术。
 
-在这一章中，我们研究了两种最著名的一次学习优化方法：MAML 和 LSTM 元学习器。 我们了解了 MAML 如何通过优化我们的初始参数设置来解决一次学习问题，从而在几个数据点上进行一个或几个梯度下降步骤可以导致更好的概括。 我们还探讨了 LSTM 元学习器对如何训练 LSTM 细胞作为元学习器以预测基础学习器体重更新的见解。
+在这一章中，我们研究了两种最著名的一次学习优化方法：MAML 和 LSTM 元学习器。 我们了解了 MAML 如何通过优化我们的初始参数设置来解决一次学习问题，从而在几个数据点上进行一个或几个梯度下降步骤可以导致更好的概括。 我们还探讨了 LSTM 元学习器对如何训练 LSTM 单元作为元学习器以预测基础学习器体重更新的见解。
 
 在下一章中，我们将探讨一种著名的 ML 方法贝叶斯学习。 我们将通过用概率模型表示对象类别来观察几个贝叶斯学习框架的发展。 我们将对判别式`K`-次学习和贝叶斯程序学习及其在现实世界中的应用进行恰当的解释。
 

new/handson-1shot-learn-py/5.md

@@ -36,7 +36,7 @@
 
 ![](img/d5a1d317-b037-40b4-b612-10d2e168e328.png)
 
-在非概率视图（也称为**期望最大化框架**）中，右侧等式中的术语`p(Data | θ)`和`P(θ)`，分别成为损失函数和正则化。 在给定的概率设置中，相同的术语称为（给定`θ`的数据的）**似然**和**先验**（在参数空间中的先验信念）。 这种概率优化称为**最大后验**（**MAP**）估计，因为我们正在从数据中最大化模型参数的后验分布。 但是，贝叶斯统计不相信 MAP 估计，因为它可能给我们有关最终学习参数的错误结果。 一个不同的数据集很有可能会给我们完全不同的学习参数，这些参数在参数空间中与从原始数据集中学习的参数相距甚远。 这就是贝叶斯学习试图解决的问题。 它显式地模拟参数空间中的不确定性。
+在非概率视图（也称为**期望最大化框架**）中，右侧等式中的项`p(Data | θ)`和`P(θ)`，分别成为损失函数和正则化。 在给定的概率设置中，相同的项称为（给定`θ`的数据的）**似然**和**先验**（在参数空间中的先验信念）。 这种概率优化称为**最大后验**（**MAP**）估计，因为我们正在从数据中最大化模型参数的后验分布。 但是，贝叶斯统计不相信 MAP 估计，因为它可能给我们有关最终学习参数的错误结果。 一个不同的数据集很有可能会给我们完全不同的学习参数，这些参数在参数空间中与从原始数据集中学习的参数相距甚远。 这就是贝叶斯学习试图解决的问题。 它显式地模拟参数空间中的不确定性。
 
 考虑给定左撇子和右撇子人数据集的参数分布示例。 下图显示了分布：
 
@@ -163,7 +163,7 @@ K 次学习的一种非常常见的方法是训练具有相关任务的大型模
 
 ![](img/be56381d-889a-404b-95e6-1ebe2a7002bc.png)
 
-3.  我们可以将术语`P(D_tilde)`吸收到比例常数中，从而使前面的方程式变为：
+3.  我们可以将项`P(D_tilde)`吸收到比例常数中，从而使前面的方程式变为：
 
 ![](img/a32d4c87-1014-4d11-b7c1-563e0c5bfd97.png)
 

new/handson-nlp-pt-1x/1.md

@@ -134,7 +134,7 @@
 
 图 1.9 –该表显示了被预测为垃圾邮件/非垃圾邮件的数据
 
-在这里，我们可以看到，尽管我们的模型正确地预测了 990 封电子邮件不是垃圾邮件（称为真实否定邮件），但它也预测了 10 封属于垃圾邮件的邮件被视为非垃圾邮件（称为错误否定邮件）。 我们的模型仅假设所有电子邮件都不是垃圾邮件，这根本不是一个很好的反垃圾邮件过滤器！ 我们不仅应该使用准确率，还应该使用**精度和召回**评估模型。 在这种情况下，我们的模型的召回率为零（意味着未返回正结果）将立即成为危险信号：
+在这里，我们可以看到，尽管我们的模型正确地预测了 990 封电子邮件不是垃圾邮件（称为真实否定邮件），但它也预测了 10 封属于垃圾邮件的邮件被视为非垃圾邮件（称为错误负面邮件）。 我们的模型仅假设所有电子邮件都不是垃圾邮件，这根本不是一个很好的反垃圾邮件过滤器！ 我们不仅应该使用准确率，还应该使用**精度和召回**评估模型。 在这种情况下，我们的模型的召回率为零（意味着未返回正结果）将立即成为危险信号：
 
 ![](img/Formula_01_017.jpg)
 

new/handson-nlp-pt-1x/3.md

@@ -600,11 +600,11 @@ This is a small giraffe
 
 图 3.28 –单词嵌入
 
-但是，此方法为句子中的所有单词分配相等的权重。 您是否认为所有单词都对句子的含义有同等的贡献？ `This`和`a`是英语中非常常见的单词，但是`giraffe`很少见。 因此，我们可能希望为稀有词分配更多权重。 这种方法被称为**术语频率-反向文档频率**（**TD-IDF**）。 现在，我们将演示如何计算文档的 TF-IDF 权重。
+但是，此方法为句子中的所有单词分配相等的权重。 您是否认为所有单词都对句子的含义有同等的贡献？ `This`和`a`是英语中非常常见的单词，但是`giraffe`很少见。 因此，我们可能希望为稀有词分配更多权重。 这种方法被称为**词频-反向文档频率**（**TD-IDF**）。 现在，我们将演示如何计算文档的 TF-IDF 权重。
 
 ## 计算 TF-IDF
 
-顾名思义，TF-IDF 由两个分开的部分组成：术语频率和文档反向频率。 术语频率是一种特定于文档的度量，用于计算要分析的文档中给定单词的频率：
+顾名思义，TF-IDF 由两个分开的部分组成：词频和文档反向频率。 词频是一种特定于文档的度量，用于计算要分析的文档中给定单词的频率：
 
 ![](img/Formula_03_003.png)
 
@@ -647,7 +647,7 @@ This is a small giraffe
     emma_word_set = set(emma_word_set)
     ```
 
-2.  接下来，我们创建一个函数，将返回给定文档中某个词的术语频率。我们以文档的长度来给出我们的词数，并计算这个词在文档中的出现次数，然后再返回比率。在这里，我们可以看到`ago`这个词在句子中出现了一次，而这个句子的长度是 41 个字，我们得到的词频是 0.024。
+2.  接下来，我们创建一个函数，将返回给定文档中某个词的词频。我们以文档的长度来给出我们的词数，并计算这个词在文档中的出现次数，然后再返回比率。在这里，我们可以看到`ago`这个词在句子中出现了一次，而这个句子的长度是 41 个字，我们得到的词频是 0.024。
 
     ```py
     def TermFreq(document, word):

new/handson-nlp-pt-1x/5.md

@@ -17,7 +17,7 @@
 
 # 构建 RNN
 
-RNN 由循环层组成。 尽管它们在许多方面类似于标准前馈神经网络中的全连接层，但这些递归层由隐藏状态组成，该隐藏状态在顺序输入的每个步骤中进行更新。 这意味着对于任何给定的序列，模型都使用隐藏状态初始化，该状态通常表示为一维向量。 然后，将序列的第一步输入模型，并根据一些学习到的参数更新隐藏状态。 然后将第二个单词馈入网络，并根据其他一些学习到的参数再次更新隐藏状态。 重复这些步骤，直到处理完整个序列，并且使我们处于最终的隐藏状态。 该计算使用从先前的计算中继承并更新的隐藏状态来循环执行，这就是为什么我们将这些网络称为循环的原因。 然后，将这个最终的隐藏状态连接到另一个全连接层，并预测最终的分类。
+RNN 由循环层组成。 尽管它们在许多方面类似于标准前馈神经网络中的全连接层，但这些循环层由隐藏状态组成，该隐藏状态在顺序输入的每个步骤中进行更新。 这意味着对于任何给定的序列，模型都使用隐藏状态初始化，该状态通常表示为一维向量。 然后，将序列的第一步输入模型，并根据一些学习到的参数更新隐藏状态。 然后将第二个单词馈入网络，并根据其他一些学习到的参数再次更新隐藏状态。 重复这些步骤，直到处理完整个序列，并且使我们处于最终的隐藏状态。 该计算使用从先前的计算中继承并更新的隐藏状态来循环执行，这就是为什么我们将这些网络称为循环的原因。 然后，将这个最终的隐藏状态连接到另一个全连接层，并预测最终的分类。
 
 我们的循环层如下所示，其中`h`是隐藏状态，而`x`是我们在序列中各个时间步的输入。 对于每次迭代，我们都会在每个时间步`x`中更新隐藏状态：
 
@@ -53,7 +53,7 @@ RNN 由循环层组成。 尽管它们在许多方面类似于标准前馈神经
 
 ## 梯度爆炸和收缩
 
-RNN 中我们经常面临的一个问题是**梯度爆炸或收缩**。 我们可以将递归层视为一个非常深的网络。 在计算梯度时，我们在隐藏状态的每次迭代中都这样做。 如果在给定位置的损失相对于权重的梯度变得很大，则在递归层的所有迭代中前馈时，这将产生乘法效果。 这会导致梯度爆炸，因为它们会很快变得非常大。 如果我们的梯度较大，则可能导致网络不稳定。 另一方面，如果隐藏状态下的梯度非常小，这将再次产生乘法效果，并且梯度将接近 0。这意味着梯度可能变得太小而无法通过梯度下降准确地更新参数， 表示我们的模型无法学习。
+RNN 中我们经常面临的一个问题是**梯度爆炸或收缩**。 我们可以将循环层视为一个非常深的网络。 在计算梯度时，我们在隐藏状态的每次迭代中都这样做。 如果在给定位置的损失相对于权重的梯度变得很大，则在循环层的所有迭代中前馈时，这将产生乘法效果。 这会导致梯度爆炸，因为它们会很快变得非常大。 如果我们的梯度较大，则可能导致网络不稳定。 另一方面，如果隐藏状态下的梯度非常小，这将再次产生乘法效果，并且梯度将接近 0。这意味着梯度可能变得太小而无法通过梯度下降准确地更新参数， 表示我们的模型无法学习。
 
 我们可以用来防止的梯度爆炸的一种技术是使用**梯度剪切**。 此技术限制了我们的梯度，以防止它们变得太大。 我们只需选择一个超参数`C`，就可以计算出裁剪的梯度，如下所示：
 
@@ -117,7 +117,7 @@ LSTM 与 RNN 的结构非常相似。 虽然 LSTM 的各个步骤之间存在一
 
 图 5.7 –遗忘门
 
-遗忘门本质上是学习要忘记序列中的哪些元素。 先前的隐藏状态`h[t-1]`和最新的输入步骤`x1`被连接在一起，并通过了在遗忘门上习得的权重矩阵，以及 Sigmoid 函数，它将值压缩为 0 到 1 之间。将得到的矩阵`f[t]`逐点乘以上一步`c[t-1]`单元状态。 这有效地将掩码应用于先前的小区状态，使得仅来自先前的小区状态的相关信息被提出。
+遗忘门本质上是学习要忘记序列中的哪些元素。 先前的隐藏状态`h[t-1]`和最新的输入步骤`x1`被连接在一起，并通过了在遗忘门上习得的权重矩阵，以及 Sigmoid 函数，它将值压缩为 0 到 1 之间。将得到的矩阵`f[t]`逐点乘以上一步`c[t-1]`单元状态。 这有效地将掩码应用于先前的单元状态，使得仅来自先前的单元状态的相关信息被提出。
 
 接下来，我们将查看**输入门**：
 
@@ -125,7 +125,7 @@ LSTM 与 RNN 的结构非常相似。 虽然 LSTM 的各个步骤之间存在一
 
 图 5.8 –输入门
 
-输入门再次采用连接的先前隐藏状态`h[t-1]`和当前序列输入`x[t]`，并将其通过具有学习参数的 Sigmoid 函数，从而输出另一个矩阵`i[t]`，它由 0 到 1 之间的值组成。连接的隐藏状态和序列输入也通过 tanh 函数，该函数将输出压缩在 -1 和 1 之间。 通过`i[t]`矩阵。 这意味着生成`i[t]`所需的学习参数可以有效地了解应从当前时间步长将哪些元素保留在我们的细胞状态中。 然后将其添加到当前单元状态以获得最终单元状态，该状态将继续进行到下一个时间步骤。
+输入门再次采用连接的先前隐藏状态`h[t-1]`和当前序列输入`x[t]`，并将其通过具有学习参数的 Sigmoid 函数，从而输出另一个矩阵`i[t]`，它由 0 到 1 之间的值组成。连接的隐藏状态和序列输入也通过 tanh 函数，该函数将输出压缩在 -1 和 1 之间。 通过`i[t]`矩阵。 这意味着生成`i[t]`所需的学习参数可以有效地了解应从当前时间步长将哪些元素保留在我们的单元状态中。 然后将其添加到当前单元状态以获得最终单元状态，该状态将继续进行到下一个时间步骤。
 
 最后，我们有是 LSTM 单元的最后一个元素-**输出门**：
 

new/handson-nlp-pt-1x/8.md

@@ -1100,6 +1100,6 @@ print('Response:', ' '.join(output_words))
 
 # 总结
 
-在本章中，我们运用了从递归模型和序列到序列模型中学到的所有知识，并将它们与注意力机制结合起来，构建了一个可以正常工作的聊天机器人。 尽管与聊天机器人进行对话与与真实的人交谈并不太容易，但是我们可能希望通过一个更大的数据集来实现一个更加现实的聊天机器人。
+在本章中，我们运用了从循环模型和序列到序列模型中学到的所有知识，并将它们与注意力机制结合起来，构建了一个可以正常工作的聊天机器人。 尽管与聊天机器人进行对话与与真实的人交谈并不太容易，但是我们可能希望通过一个更大的数据集来实现一个更加现实的聊天机器人。
 
 尽管 2017 年备受关注的序列到序列模型是最新技术，但机器学习是一个快速发展的领域，自那时以来，对这些模型进行了多次改进。 在最后一章中，我们将更详细地讨论其中一些最先进的模型，并涵盖用于 NLP 的机器学习中的其他几种当代技术，其中许多仍在开发中。
\ No newline at end of file

new/handson-nlp-pt-1x/9.md

@@ -335,7 +335,7 @@ Dr. Jorge Pérez, an evolutionary biologist from the University of La Paz, and s
 
 尽管这在表现以及通过构建深层 NLP 模型可以实现的功能方面给人留下深刻的印象，但确实引起了人们对此类模型的道德规范以及如何使用（和滥用它们）的担忧。
 
-随着“假新闻”的兴起和使用互联网的错误信息的传播，类似的示例说明了使用这些模型生成逼真的文本是多么简单。 让我们考虑一个示例，其中智能体希望在线上生成有关多个主题的虚假新闻。 现在，他们甚至不需要自己编写虚假信息。 从理论上讲，他们可以训练 NLP 模型为他们执行此操作，然后再在互联网上散布这些虚假信息。 GPT-2 的作者在训练并将模型发布给公众时特别注意这一点，并指出该模型有可能被滥用和滥用，因此只有在他们看不到证据的情况下才向公众发布更大更复杂的模型。 较小型号的误用。
+随着“假新闻”的兴起和使用互联网的错误信息的传播，类似的示例说明了使用这些模型生成逼真的文本是多么简单。 让我们考虑一个示例，其中智能体希望在线上生成有关多个主题的虚假新闻。 现在，他们甚至不需要自己编写虚假信息。 从理论上讲，他们可以训练 NLP 模型为他们执行此操作，然后再在互联网上散布这些虚假信息。 GPT-2 的作者在训练并将模型发布给公众时特别注意这一点，并指出该模型有可能被滥用和滥用，因此只有在他们看不到证据的情况下才向公众发布更大更复杂的模型。 较小模型的误用。
 
 这可能成为 NLP 深度学习向前发展的重点。 当我们使用可以接近人类复杂程度的聊天机器人和文本生成器（例如 GPT-2）时，需要充分了解对这些模型的使用和误用。 研究表明，GPT-2 生成的文本被认为与《纽约时报》的真实人类书面文章（83%）几乎一样可信（72%）。 随着将来我们继续开发更复杂的深层 NLP 模型，随着模型生成的文本变得越来越现实，这些数字可能会收敛。
 

new/pt-ai-fund/2.md

@@ -323,7 +323,7 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机
 
 # 实现优化器
 
-在本秘籍中，我们将学习优化器。 在先前的秘籍“定义损失函数”中，我们谈到了误差和误差函数，并了解到，为了获得一个好的模型，我们需要最小化计算出的误差。 **反向传播**是神经网络从错误中学习的一种方法。 错误用于修改权重，以使错误最小化。 优化函数负责修改权重以减少误差。 优化函数计算相对于权重的误差的偏导数。 导数显示正斜率的方向，因此我们需要反转梯度的方向。 **优化器**函数将模型参数和损失函数结合在一起，以迭代方式修改模型参数以减少模型误差。 可以考虑将优化器摆在模型权重的基础上，根据模型与实际输出的预测差异来获得最佳模型，而损失函数则通过指示优化器是对还是错来充当指导。
+在本秘籍中，我们将学习优化器。 在先前的秘籍“定义损失函数”中，我们谈到了误差和误差函数，并了解到，为了获得一个好的模型，我们需要最小化计算出的误差。 **反向传播**是神经网络从误差中学习的一种方法。 误差用于修改权重，以使误差最小化。 优化函数负责修改权重以减少误差。 优化函数计算相对于权重的误差的偏导数。 导数显示正斜率的方向，因此我们需要反转梯度的方向。 **优化器**函数将模型参数和损失函数结合在一起，以迭代方式修改模型参数以减少模型误差。 可以考虑将优化器摆在模型权重的基础上，根据模型与实际输出的预测差异来获得最佳模型，而损失函数则通过指示优化器是对还是错来充当指导。
 
 学习速率是优化器的超参数，它控制权重的更新量。 学习速度确保了权重不会大量更新，从而使算法根本无法收敛，并且误差越来越大。 然而，与此同时，权重的更新不应太低，以至于永远需要花费成本函数/误差函数的最小值。
 
@@ -409,7 +409,7 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机
 >>pred = model(image)
 ```
 
-12.然后我们计算损失/错误：
+12.然后我们计算损失/误差：
 
 ```py
 >>loss = criterion(pred, label)

new/pt-dl-handson/0.md

@@ -16,7 +16,7 @@
 
 第 4 章，“计算机视觉”是迄今为止深度学习最成功的结果，它讨论了成功背后的关键思想，并贯穿了使用最广泛的视觉算法– **卷积神经网络（CNN）**。 我们将逐步实现 CNN 以了解其工作原理，然后使用 PyTorch 的`nn`包中预定义的 CNN。 本章可帮助您制作简单的 CNN 和基于高级 CNN 的视觉算法，称为语义分割。
 
-第 5 章，“序列数据处理”着眼于循环神经网络，它是目前最成功的序列数据处理算法。 本章向您介绍主要的 RNN 组件，例如**长短期记忆**（**LSTM**）网络和**门控循环单元**（**GRU**）。 然后，在探索循环神经网络之前，我们将经历 RNN 实现中的算法更改，例如双向 RNN，并增加层数。 为了理解递归网络，我们将使用斯坦福大学 NLP 小组的著名示例（栈增强的解析器-解释器神经网络（SPINN）），并将其在 PyTorch 中实现。
+第 5 章，“序列数据处理”着眼于循环神经网络，它是目前最成功的序列数据处理算法。 本章向您介绍主要的 RNN 组件，例如**长短期记忆**（**LSTM**）网络和**门控循环单元**（**GRU**）。 然后，在探索循环神经网络之前，我们将经历 RNN 实现中的算法更改，例如双向 RNN，并增加层数。 为了理解循环网络，我们将使用斯坦福大学 NLP 小组的著名示例（栈增强的解析器-解释器神经网络（SPINN）），并将其在 PyTorch 中实现。
 
 第 6 章，“生成网络”，简要讨论了生成网络的历史，然后解释了各种生成网络。 在这些不同的类别中，本章向我们介绍了自回归模型和 GAN。 我们将研究作为自动回归模型一部分的 PixelCNN 和 WaveNet 的实现细节，然后详细研究 GAN。
 

new/pt-dl-handson/1.md

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

new/pt-dl-handson/2.md

@@ -67,7 +67,7 @@ def get_numpy_data(input_size=10, limit=1000):
 *   我们将输入转换为 10 位二进制数，因此我们的第一个输入层需要 10 个神经元才能接受这 10 位数字。
 *   由于我们的输出始终是大小为 4 的向量，因此我们需要有四个输出神经元。
 *   看来我们要解决的问题很简单：比较深度学习在当今世界中产生的虚构冲动。 首先，我们可以有一个大小为 100 的隐藏层。
-*   由于在处理之前批量数据总是更好，为了获得良好的结果，我们将对输入的批量添加 64 个数据点。 请查看本章末尾的“查找错误”部分，以了解批量为什么更好。
+*   由于在处理之前批量数据总是更好，为了获得良好的结果，我们将对输入的批量添加 64 个数据点。 请查看本章末尾的“查找误差”部分，以了解批量为什么更好。
 
 让我们定义超参数并调用我们先前定义的函数以获取训练和测试数据。 我们将为各种神经网络模型定义五个典型的超参数：
 
@@ -87,7 +87,7 @@ for i in epoch:
     network_execution_over_whole_dataset()
 ```
 
-**学习率**决定了我们希望我们的网络从每次迭代的错误中获取反馈的速度。 它通过忘记网络从所有先前迭代中学到的知识来决定从当前迭代中学到的知识。 将学习率保持为 1 可使网络考虑完全错误，并根据完全错误调整权重。 学习速率为零意味着向网络传递的信息为零。 学习率将是神经网络中梯度更新方程式中的选择因子。 对于每个神经元，我们运行以下公式来更新神经元的权重：
+**学习率**决定了我们希望我们的网络从每次迭代的误差中获取反馈的速度。 它通过忘记网络从所有先前迭代中学到的知识来决定从当前迭代中学到的知识。 将学习率保持为 1 可使网络考虑完全误差，并根据完全误差调整权重。 学习速率为零意味着向网络传递的信息为零。 学习率将是神经网络中梯度更新方程式中的选择因子。 对于每个神经元，我们运行以下公式来更新神经元的权重：
 
 ```py
 weight -= lr * loss
@@ -265,7 +265,7 @@ print(a2.grad, a2.grad_fn, a2)
 
 在拥有框架之前，这不是一个容易的过程。 实际上，找到每个参数的导数并进行更新是一项繁琐且容易出错的任务。 在 PyTorch 中，您要做的就是在最后一个节点上调用`backward`，它将反向传播并更新它。 具有梯度的`grad`属性。
 
-PyTorch 的`backward`函数进行反向传播，并找到每个神经元的错误。 但是，我们需要基于此误差因子来更新神经元的权重。 更新发现的错误的过程通常称为优化，并且有不同的优化策略。 PyTorch 为我们提供了另一个名为`optim`的模块，用于实现不同的优化算法。 在先前的实现中，我们使用了基本且最受欢迎的优化算法，称为**随机梯度下降**（**SGD**）。 当我们使用复杂的神经网络时，我们将在后面的章节中看到不同的优化算法。
+PyTorch 的`backward`函数进行反向传播，并找到每个神经元的误差。 但是，我们需要基于此误差因子来更新神经元的权重。 更新发现的误差的过程通常称为优化，并且有不同的优化策略。 PyTorch 为我们提供了另一个名为`optim`的模块，用于实现不同的优化算法。 在先前的实现中，我们使用了基本且最受欢迎的优化算法，称为**随机梯度下降**（**SGD**）。 当我们使用复杂的神经网络时，我们将在后面的章节中看到不同的优化算法。
 
 PyTorch 还通过将反向传播和优化分为不同的步骤，为我们提供了更大的灵活性。 请记住，反向传播会在`.grad`属性中累积梯度。 这是有帮助的，特别是在我们的项目更注重研究，或者想要深入研究权重-梯度关系，或者想要了解梯度的变化方式时。 有时，我们希望更新除特定神经元之外的所有参数，或者有时我们可能认为不需要更新特定层。 在需要对参数更新进行更多控制的情况下，具有显式的参数更新步骤会带来很大的好处。
 
@@ -316,7 +316,7 @@ print(output.grad_fn.next_functions[0][0].next_functions[0][0])
 # <PowBackward0 object at 0x7eff017b4128>
 ```
 
-训练显示出其创建者之后，立即在输出张量上打印`grad_fn`，在`output`的情况下，是除法运算符执行最后的二分运算。 然后，对任何梯度函数（或向后函数）的`next_functions`调用都会向我们展示返回输入节点的方式。 在该示例中，除法运算符遵循求和函数，该函数将一批中所有数据点的平方误差相加。 下一个运算符是幂运算符，该运算符用于平方各个错误。 下图显示了使用函数链接张量的想法：
+训练显示出其创建者之后，立即在输出张量上打印`grad_fn`，在`output`的情况下，是除法运算符执行最后的二分运算。 然后，对任何梯度函数（或向后函数）的`next_functions`调用都会向我们展示返回输入节点的方式。 在该示例中，除法运算符遵循求和函数，该函数将一批中所有数据点的平方误差相加。 下一个运算符是幂运算符，该运算符用于平方各个误差。 下图显示了使用函数链接张量的想法：
 
 ![Parameter update](img/B09475_02_08.jpg)
 
@@ -525,7 +525,7 @@ tensor([[1]], dtype=torch.uint8)
 
 ### 损失函数
 
-现在我们有了`FizBuzNet`返回的预测，我们需要找出模型预测的水平，然后反向传播该错误。 我们调用损失函数来查找错误。 社区中普遍存在不同的损失函数。 PyTorch 带有`nn`模块中内置的所有流行损失函数。 损失函数接受对数和实际值，并在其上应用损失函数以查找损失得分。 此过程给出了错误率，该错误率代表了模型预测的好坏。 在新手模型中，我们使用了基本的 MSE 损失，已在`nn`模块中将其定义为`MSELoss()`。
+现在我们有了`FizBuzNet`返回的预测，我们需要找出模型预测的水平，然后反向传播该误差。 我们调用损失函数来查找误差。 社区中普遍存在不同的损失函数。 PyTorch 带有`nn`模块中内置的所有流行损失函数。 损失函数接受对数和实际值，并在其上应用损失函数以查找损失得分。 此过程给出了错误率，该错误率代表了模型预测的好坏。 在新手模型中，我们使用了基本的 MSE 损失，已在`nn`模块中将其定义为`MSELoss()`。
 
 ```py
 loss = nn.MSELoss()
@@ -588,7 +588,7 @@ for epoch in range(epochs):
         optimizer.step()
 ```
 
-这是循环遍历批量并使用输入批量调用`net`的代码。 然后，将`net(x_)`返回的`hyp`与实际值`y_`一起传递给损失函数。 损失函数返回的错误用作叶子节点来调用`backward()`。 然后，我们调用`optimizer`的`step()`函数，该函数将更新参数。 更新之后，用户负责将梯度归零，这现在可以通过`optimizer.zero_grad()`实现。
+这是循环遍历批量并使用输入批量调用`net`的代码。 然后，将`net(x_)`返回的`hyp`与实际值`y_`一起传递给损失函数。 损失函数返回的误差用作叶子节点来调用`backward()`。 然后，我们调用`optimizer`的`step()`函数，该函数将更新参数。 更新之后，用户负责将梯度归零，这现在可以通过`optimizer.zero_grad()`实现。
 
 ## 总结
 

new/pt-dl-handson/3.md

@@ -166,7 +166,7 @@ Dataset MNIST
 
 ```
 
-`torchvision`的`models`模块包装有几种常用的型号，可以直接使用。 由于当今大多数高级模型都使用迁移学习来获得其他架构学习的权重（例如，第三章中的语义分段模型使用经过训练的 resnet18 网络），因此这是模型最常用的`torchvision`功能之一。 以下代码段显示了如何从`torchvision.models`下载 resnet18 模型。 标志`pretrained`告诉`torchvision`仅使用模型或获取从 PyTorch 服务器下载的预训练模型。
+`torchvision`的`models`模块包装有几种常用的模型，可以直接使用。 由于当今大多数高级模型都使用迁移学习来获得其他架构学习的权重（例如，第三章中的语义分段模型使用经过训练的 resnet18 网络），因此这是模型最常用的`torchvision`功能之一。 以下代码段显示了如何从`torchvision.models`下载 resnet18 模型。 标志`pretrained`告诉`torchvision`仅使用模型或获取从 PyTorch 服务器下载的预训练模型。
 
 ```py
 >>> resnet18 = torchvision.models.resnet18(pretrained=False)

new/pt-dl-handson/5.md

@@ -44,11 +44,11 @@
 
 ### 简单 RNN
 
-RNN 已被用作理解数据含义的 NLP 技术，并且我们可以根据从中发现的顺序关系来完成许多任务。 我们将使用这个简单的 RNN 来展示递归如何有效地积累单词的含义并根据单词所处的上下文来理解单词的含义。
+RNN 已被用作理解数据含义的 NLP 技术，并且我们可以根据从中发现的顺序关系来完成许多任务。 我们将使用这个简单的 RNN 来展示循环如何有效地积累单词的含义并根据单词所处的上下文来理解单词的含义。
 
 在开始构建网络的任何核心模块之前，我们必须处理数据集并对其进行修改以供使用。 我们将使用来自 Stanford 的 SNLI 数据集（包含标记为包含，矛盾和中立的句子对的数据集），该数据集已经过预处理并保存在`torchtext`中。
 
-加载的数据集包含数据实例，这些实例是标记为蕴含，矛盾和中立的句子对。 每个句子与一组将与递归网络一起使用的转换相关联。 在以下代码块中显示了从`BucketIterator`加载的数据集。 我们可以通过调用`batch.premise`和`.hypothesis`访问一对句子（`get_data()`函数是伪代码，以避免显示长行；获取数据的实际代码可在 GitHub 存储库中找到）：
+加载的数据集包含数据实例，这些实例是标记为蕴含，矛盾和中立的句子对。 每个句子与一组将与循环网络一起使用的转换相关联。 在以下代码块中显示了从`BucketIterator`加载的数据集。 我们可以通过调用`batch.premise`和`.hypothesis`访问一对句子（`get_data()`函数是伪代码，以避免显示长行；获取数据的实际代码可在 GitHub 存储库中找到）：
 
 ```py
 >>> train_iter, dev_iter, test_iter = get_data()
@@ -435,7 +435,7 @@ class Encoder(nn.Module):
             return ht[-2:].transpose(0, 1).contiguous().view(batch_size, -1)
 ```
 
-与`LSTMCell`和`GRUCell`相似，LSTM 和 GRU 具有相似的函数式 API，以使它们彼此兼容。 此外，与细胞对应物相比，LSTM 和 GRU 接受更多的参数，其中`num_layers`，`dropout`和`bidirectional`很重要。
+与`LSTMCell`和`GRUCell`相似，LSTM 和 GRU 具有相似的函数式 API，以使它们彼此兼容。 此外，与单元对应物相比，LSTM 和 GRU 接受更多的参数，其中`num_layers`，`dropout`和`bidirectional`很重要。
 
 如果将`True`作为参数，则`dropout`参数将为网络实现添加一个丢弃层，这有助于避免过拟合和规范化网络。 使用 LSTM 之类的高级 API 消除了对 Python 循环的需要，并一次接受了完整的序列作为输入。 尽管可以接受常规序列作为输入，但始终建议传递打包（掩码）输入，这样可以提高性能，因为 cuDNN 后端希望输入如此。
 

new/pt-dl-handson/6.md

@@ -439,7 +439,7 @@ def train_discriminator(optimizer, real_data, fake_data):
     return error_real + error_fake, prediction_real, prediction_fake
 ```
 
-在前面的代码块中定义的函数`train_generator`接受`optimizer`对象，伪数据和实数据，然后将它们传递给判别器。 函数`fake_data_target`（在下面的代码块中提供）创建一个零张量，该张量的大小与预测大小相同，其中预测是从判别器返回的值。 判别器的训练策略是使任何真实数据被归类为真实分布的概率最大化，并使任何数据点被归类为真实分布的概率最小化。 在实践中，使用了来自判别器或生成器的结果的日志，因为这会严重损害网络的分类错误。 然后在应用`optimizer.step`函数之前将错误反向传播，该函数将通过学习速率以梯度更新权重。
+在前面的代码块中定义的函数`train_generator`接受`optimizer`对象，伪数据和实数据，然后将它们传递给判别器。 函数`fake_data_target`（在下面的代码块中提供）创建一个零张量，该张量的大小与预测大小相同，其中预测是从判别器返回的值。 判别器的训练策略是使任何真实数据被归类为真实分布的概率最大化，并使任何数据点被归类为真实分布的概率最小化。 在实践中，使用了来自判别器或生成器的结果的日志，因为这会严重损害网络的分类错误。 然后在应用`optimizer.step`函数之前将误差反向传播，该函数将通过学习速率以梯度更新权重。
 
 接下来给出用于获得真实数据目标和伪数据目标的函数，这与前面讨论的最小化或最大化概率的概念基本一致。 实际数据生成器返回一个张量为 1s 的张量，该张量是我们作为输入传递的形状。 在训练生成器时，我们正在尝试通过生成图像来最大程度地提高其概率，该图像看起来应该是从真实数据分布中获取的。 这意味着判别器应将 1 预测为图像来自真实分布的置信度分数。
 

new/pt-dl-handson/7.md

@@ -441,9 +441,9 @@ def optimize_model():
 
 ![Gym](img/B09475_07_10.jpg)
 
-最后，我们计算期望的 Q 函数。 根据我们先前的讨论，它将是`R + Gamma`（下一个状态值）。 然后，我们根据实际 Q 函数和预期 Q 函数计算损失，然后将错误反向传播到策略网络（请记住`target_net`处于`eval`模式）。 我们还使用梯度钳制来确保梯度较小且不会转移得太远。
+最后，我们计算期望的 Q 函数。 根据我们先前的讨论，它将是`R + Gamma`（下一个状态值）。 然后，我们根据实际 Q 函数和预期 Q 函数计算损失，然后将误差反向传播到策略网络（请记住`target_net`处于`eval`模式）。 我们还使用梯度钳制来确保梯度较小且不会转移得太远。
 
-训练神经网络将花费一些时间，因为该过程将渲染每个帧并计算该错误。 我们本可以使用一种更简单的方法，直接获取速度和位置来表示损失函数，并且由于不需要渲染每一帧，因此可以花费更少的时间进行训练。 它只会直接从`env.state`接受输入。
+训练神经网络将花费一些时间，因为该过程将渲染每个帧并计算该误差。 我们本可以使用一种更简单的方法，直接获取速度和位置来表示损失函数，并且由于不需要渲染每一帧，因此可以花费更少的时间进行训练。 它只会直接从`env.state`接受输入。
 
 此算法有许多改进，例如为智能体增加了想象力，以便可以更好地探索和想象其脑海中的动作，并做出更好的预测。
 

new/pt-tut-17/04.md

@@ -12,7 +12,7 @@
 
 **正向传播**：在正向传播中，NN 对正确的输出进行最佳猜测。 它通过其每个函数运行输入数据以进行猜测。
 
-**反向传播**：在反向传播中，NN 根据其猜测中的错误调整其参数。 它通过从输出向后遍历，收集有关函数参数（*梯度*）的误差导数并使用梯度下降来优化参数来实现。 有关反向传播的更详细的演练，请查看 3Blue1Brown 的[视频](https://www.youtube.com/watch?v=tIeHLnjs5U8)。
+**反向传播**：在反向传播中，NN 根据其猜测中的误差调整其参数。 它通过从输出向后遍历，收集有关函数参数（*梯度*）的误差导数并使用梯度下降来优化参数来实现。 有关反向传播的更详细的演练，请查看 3Blue1Brown 的[视频](https://www.youtube.com/watch?v=tIeHLnjs5U8)。
 
 ## 在 PyTorch 中的用法
 
@@ -33,7 +33,7 @@ prediction = model(data) # forward pass
 
 ```
 
-我们使用模型的预测和相应的标签来计算误差（`loss`）。 下一步是通过网络反向传播此错误。 当我们在误差张量上调用`.backward()`时，开始反向传播。 然后，Autograd 会为每个模型参数计算梯度并将其存储在参数的`.grad`属性中。
+我们使用模型的预测和相应的标签来计算误差（`loss`）。 下一步是通过网络反向传播此误差。 当我们在误差张量上调用`.backward()`时，开始反向传播。 然后，Autograd 会为每个模型参数计算梯度并将其存储在参数的`.grad`属性中。
 
 ```py
 loss = (prediction - labels).sum()
@@ -80,7 +80,7 @@ Q = 3`a`3 - b**2
 
 ```
 
-假设`a`和`b`是神经网络的参数，`Q`是错误。 在 NN 训练中，我们想要相对于参数的误差，即
+假设`a`和`b`是神经网络的参数，`Q`是误差。 在 NN 训练中，我们想要相对于参数的误差，即
 
 ![](img/tex4-2.gif)
 

new/pt-tut-17/05.md

@@ -210,7 +210,7 @@ print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU
 
 ## 反向传播
 
-要反向传播错误，我们要做的只是对`loss.backward()`。 不过，您需要清除现有的梯度，否则梯度将累积到现有的梯度中。
+要反向传播误差，我们要做的只是对`loss.backward()`。 不过，您需要清除现有的梯度，否则梯度将累积到现有的梯度中。
 
 现在，我们将其称为`loss.backward()`，然后看一下向后前后`conv1`的偏差梯度。
 

new/pt-tut-17/34.md

@@ -117,7 +117,7 @@ Q 学习的主要思想是，如果我们有一个函数`Q*：State x Action =>
 
 ![](img/tex34-3.gif)
 
-为了最小化此错误，我们将使用 [Huber 损失](https://en.wikipedia.org/wiki/Huber_loss)。 当误差较小时，Huber 损失的作用类似于均方误差，而当误差较大时，则表现为平均绝对误差-当`Q`的估计值非常嘈杂时，这使它对异常值的鲁棒性更高。 我们通过从重播内存中采样的一批过渡`B`来计算：
+为了最小化此误差，我们将使用 [Huber 损失](https://en.wikipedia.org/wiki/Huber_loss)。 当误差较小时，Huber 损失的作用类似于均方误差，而当误差较大时，则表现为平均绝对误差-当`Q`的估计值非常嘈杂时，这使它对异常值的鲁棒性更高。 我们通过从重播内存中采样的一批过渡`B`来计算：
 
 ![](img/tex34-4.gif)
 

new/pt-tut-17/43.md

@@ -288,7 +288,7 @@ True
 
 ```
 
-以下型号列表完全支持通道在最后，并在 Volta 设备上显示了 8%-35% 的表现增益：`alexnet`，`mnasnet0_5`，`mnasnet0_75`，`mnasnet1_0`，`mnasnet1_3`，`mobilenet_v2`，`resnet101`，`resnet152`，`resnet18`，`resnet34`，`resnet50`，`resnext50_32x4d`，`shufflenet_v2_x0_5`，`shufflenet_v2_x1_0`，`shufflenet_v2_x1_5`，`shufflenet_v2_x2_0`，`squeezenet1_0`，`squeezenet1_1`，`vgg11` ，`vgg11_bn`，`vgg13`，`vgg13_bn`，`vgg16`，`vgg16_bn`，`vgg19`，`vgg19_bn`，`wide_resnet101_2`，`wide_resnet50_2`
+以下模型列表完全支持通道在最后，并在 Volta 设备上显示了 8%-35% 的表现增益：`alexnet`，`mnasnet0_5`，`mnasnet0_75`，`mnasnet1_0`，`mnasnet1_3`，`mobilenet_v2`，`resnet101`，`resnet152`，`resnet18`，`resnet34`，`resnet50`，`resnext50_32x4d`，`shufflenet_v2_x0_5`，`shufflenet_v2_x1_0`，`shufflenet_v2_x1_5`，`shufflenet_v2_x2_0`，`squeezenet1_0`，`squeezenet1_1`，`vgg11` ，`vgg11_bn`，`vgg13`，`vgg13_bn`，`vgg16`，`vgg16_bn`，`vgg19`，`vgg19_bn`，`wide_resnet101_2`，`wide_resnet50_2`
 
 ## 转换现有模型
 

new/rl-tf/01.md

@@ -58,7 +58,7 @@
 
 *   **通用深度学习**：密集连接的层或全连接网络
 
-*   **序列模型**：循环神经网络，长短期记忆网络，门控递归单元等
+*   **序列模型**：循环神经网络，长短期记忆网络，门控循环单元等
 
 *   **空间数据模型**（例如，图像）：卷积神经网络，生成对抗网络
 
@@ -66,9 +66,9 @@
 
 当前，该行业主要由前三个部分驱动，但是人工智能的未来取决于第四部分的发展。 沿着机器学习的发展历程，我们可以看到直到现在，这些学习模型都将实数作为输出，例如电影评论（情感评分）和图像分类（类对象）。 但是现在，以及其他类型的输出也正在生成，例如，图像字幕（输入：图像，输出：文本），机器翻译（输入：文本，输出：文本）和语音识别（输入：音频， 输出：文本）。
 
-人类水平的表现是必要的，并且通常应用于深度学习。 在一段时间内收敛到最高点之后，人员水平的准确率变得恒定。 这一点称为最佳错误率（也称为贝叶斯错误率，即对于任何随机结果分类器而言，最低的错误率）。
+人类水平的表现是必要的，并且通常应用于深度学习。 在一段时间内收敛到最高点之后，人员水平的准确率变得恒定。 这一点称为最佳错误率（也称为贝叶斯误差率，即对于任何随机结果分类器而言，最低的错误率）。
 
-其背后的原因是由于数据中的噪声，许多问题在表现上都有理论上的限制。 因此，人员级别的准确率是通过进行错误分析来改进模型的好方法。 这是通过合并人为误差，训练集误差和验证集误差来估计偏差方差影响（即欠拟合和过拟合条件）来完成的。
+其背后的原因是由于数据中的噪声，许多问题在表现上都有理论上的限制。 因此，人员级别的准确率是通过进行误差分析来改进模型的好方法。 这是通过合并人为误差，训练集误差和验证集误差来估计偏差方差影响（即欠拟合和过拟合条件）来完成的。
 
 数据规模，算法类型和表现指标是一组方法，可以帮助我们针对不同的机器学习算法确定改进水平。 因此，决定是否投资深度学习或采用传统机器学习方法的关键决策。
 

new/rl-tf/04.md

@@ -485,7 +485,7 @@ def policy_forward(x):
     return p,h #probability of action 2(that is UP) and hidden layer state that is hidden state
 ```
 
-*   **反向传播**：`policy_backward(arr_hidden_state, gradient_logp, observation_values)`函数采用隐藏状态值，错误`gradient_logp`和观测值来针对不同权重参数计算导数，如以下代码所示：
+*   **反向传播**：`policy_backward(arr_hidden_state, gradient_logp, observation_values)`函数采用隐藏状态值，误差`gradient_logp`和观测值来针对不同权重参数计算导数，如以下代码所示：
 
 ```py
 def policy_backward(arr_hidden_state,gradient_logp,observation_values):