2021-01-21 16:10:34

new/dl-pt-workshop/1.md

@@ -240,7 +240,7 @@ PyTorch 已被许多研究人员和人工智能开发人员采用，这使其成
 
 尽管优点很多，但仍然存在一些要考虑的缺点，在这里进行了说明：
 
-*   **小型社区**：与其他库（例如 TensorFlow）相比，该库的适配器社区很小。 但是，它仅对公众开放了三年，今天，它已成为实施深度学习解决方案的最受欢迎的前五名图书馆之一，并且它的社区每天都在增长。
+*   **小型社区**：与其他库（例如 TensorFlow）相比，该库的适配器社区很小。 但是，它仅对公众开放了三年，今天，它已成为实现深度学习解决方案的最受欢迎的前五名图书馆之一，并且它的社区每天都在增长。
 *   **参差不齐的文档**：与其他深度学习库相比，该库是一个相当新的文档，因此该文档并不完整。 但是，由于库的特性和功能正在增加，因此文档正在扩展。 此外，随着社区的不断发展，互联网上将提供更多信息。
 *   **有关生产准备就绪的问题**：尽管有关该库的许多投诉都集中在无法将其部署到生产中，但在发布 1.0 版之后，该库包含了可以导出最终版本的生产能力 进行建模并在生产环境中使用它们。
 

new/dl-pt-workshop/2.md

@@ -430,7 +430,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
 
 对于本章中的练习和活动，您将需要在本地计算机上安装 Python 3.7，Jupyter 6.0，NumPy 1.17 和 Pandas 0.25。
 
-1.  打开 Jupyter 笔记本以实施此练习。
+1.  打开 Jupyter 笔记本以实现此练习。
 2.  导入 Pandas 库：
 
     ```py

new/dl-pt-workshop/3.md

@@ -666,7 +666,7 @@ batch_size = 100
 
 ## 练习 3 .02：提高模型的性能
 
-对于此活动，我们将实施在练习中定义的操作，以减少影响模型性能的高偏差。 请考虑以下情形：团队成员对您所做的工作和代码的组织印象深刻，但是考虑到他们对客户的承诺，他们却要求您尝试将性能提高到 80%。 请按照以下步骤完成此活动：
+对于此活动，我们将实现在练习中定义的操作，以减少影响模型性能的高偏差。 请考虑以下情形：团队成员对您所做的工作和代码的组织印象深刻，但是考虑到他们对客户的承诺，他们却要求您尝试将性能提高到 80%。 请按照以下步骤完成此活动：
 
 注意
 

new/dl-pt-workshop/4.md

@@ -2,7 +2,7 @@
 
 总览
 
-本章介绍了训练**卷积神经网络**（**CNN**）的过程-也就是说，发生在不同层的计算通常可以在 CNN 架构中找到，其目的 训练过程。 您将学习如何通过对模型应用数据扩充和批量规范化来改善计算机视觉模型的性能。 到本章末，您将能够使用 CNN 通过 PyTorch 解决图像分类问题。 这将是在计算机视觉领域实施其他解决方案的起点。
+本章介绍了训练**卷积神经网络**（**CNN**）的过程-也就是说，发生在不同层的计算通常可以在 CNN 架构中找到，其目的 训练过程。 您将学习如何通过对模型应用数据扩充和批量规范化来改善计算机视觉模型的性能。 到本章末，您将能够使用 CNN 通过 PyTorch 解决图像分类问题。 这将是在计算机视觉领域实现其他解决方案的起点。
 
 # 简介
 
@@ -790,7 +790,7 @@ class CNN(nn.Module):
 
 接下来，数据扩充被引入为一种工具，它通过增加训练示例的数量来提高网络性能，而无需收集更多图像。 该技术专注于创建现有图像的变体，以创建要馈送到模型的“新”图像。
 
-通过实施数据扩充，本章的第二个活动旨在解决相同的图像分类问题，目的是比较结果。
+通过实现数据扩充，本章的第二个活动旨在解决相同的图像分类问题，目的是比较结果。
 
 最后，本章介绍了批量规范化的概念。 这包括标准化每个隐藏层的输出，以加快学习速度。 在解释了在 PyTorch 中应用批量归一化的过程之后，本章的最后一个活动旨在使用批量归一化解决相同的图像分类问题。
 

new/dl-pt-workshop/6.md

@@ -821,7 +821,7 @@ class LSTM(nn.Module):
 
 注意
 
-值得一提的是，此活动中的数据并未分为不同的数据集，以使模型可以进行微调和测试。 这是因为此活动的主要重点是实施创建能够执行情感分析的模型的过程。
+值得一提的是，此活动中的数据并未分为不同的数据集，以使模型可以进行微调和测试。 这是因为此活动的主要重点是实现创建能够执行情感分析的模型的过程。
 
 1.  导入所需的库。
 2.  加载包含来自亚马逊的 1,000 条产品评论的数据集，并与标签 0（对于负面评论）或 1（对于正面评论）配对。 将数据分成两个变量-一个包含评论，另一个包含标签。

new/dl-pt-workshop/7.md

@@ -1136,7 +1136,7 @@
 
     要访问此源代码的 GPU 版本，请参考[这里](https://packt.live/2BUGjGF)。 此版本的源代码无法作为在线交互示例使用，需要通过 GPU 设置在本地运行。
 
-## 活动 4.02：实施数据扩充
+## 活动 4.02：实现数据扩充
 
 ### 解决方案
 

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

@@ -24,7 +24,7 @@
 
 [您可以在该书的 GitHub 存储库中找到该章的代码文件](https://github.com/PacktPublishing/Hands-On-One-shot-Learning-with-Python)。
 
-# 参数方法–概述
+# 参数方法概述
 
 在上一章中，我们简要讨论了非参数机器学习方法。 本节将主要关注机器学习的参数方法是什么，以及它们实际学习了什么。
 
@@ -36,7 +36,7 @@
 
 在这里，`P(Y | X)`是分类分布，这意味着我们正在尝试学习可能类别上的分布。 简单来说：给定`X`，我们将学习`Y`可以具有的所有可能类别。 由于数据的缘故，这都是可能的-随着数据量的增加，我们对`Y`的近似值也随之增加。 在下一节中，我们将学习神经网络的学习过程，并了解哪些属性在逼近`Y`标签中起着重要的作用。
 
-# 神经网络–学习程序
+# 神经网络学习器
 
 众所周知，神经网络通过使用随机梯度下降优化方法使损失函数（或目标函数）最小化来学习。 因此，损失函数是决定神经网络架构目标的主要因素之一。 例如，如果要分类数据点，我们将选择损失函数，例如**类别交叉熵**，**0-1 损失**和**铰链损失**； 相反，如果我们的目标是回归，我们将选择损失函数，例如**均方误差**，**均方根误差**和 **Huber 损失**。 一些常见的方程式如下：
 
@@ -69,7 +69,7 @@
 
 关键思想听起来可能类似于转学，但有所不同。 连体网络使用对比损失函数来学习这些功能。 其次，连体网络方法仅适用于相似的域，因为它还需要注意域的适应性，也就是说，它需要尝试确保我们的训练和测试数据集在域方面是紧密的。 例如，如果您要创建一个系统来测试两个手写示例是否属于同一个人，则可以在 MNIST 数据集上训练一个连体网络架构，通过该架构，可以学习特定于手写体的特征（例如曲线） 和给定字符的笔划。 在下一节中，我们将研究连体网络的架构并了解其优化。
 
-# 建筑
+# 构建
 
 连体网络由两个相同的神经网络组成，它们共享相似的参数，每个磁头获取一个输入数据点。 在中间层，由于权重和偏差相同，因此我们提取了相似的特征。 这些网络的最后一层被馈送到**对比损失函数层**，，该层计算两个输入之间的相似度。
 
@@ -185,7 +185,7 @@
 
 匹配网络的关键思想是将图像映射到嵌入空间，该空间也封装了标签分布，然后使用不同的架构在相同的嵌入空间中投影测试图像。 然后，我们以后用余弦相似度来衡量相似度。 让我们看一下匹配网络如何创建其嵌入空间。
 
-# 训练程序
+# 训练器
 
 在训练架构方面，匹配网络遵循某种技术：它们尝试在训练阶段复制测试条件。 简而言之，正如我们在上一节中所了解的那样，匹配网络从训练数据中采样标签集，然后它们从同一标签集生成支持集和批量集。 数据预处理之后，匹配网络通过训练模型以将支持集作为训练集，并将批量集作为测试集来最小化错误，从而学习其参数。 通过将支持集作为训练集，将批量集作为测试集的训练过程，可使匹配的网络复制测试条件。
 
@@ -580,7 +580,7 @@ Omniglot 数据集旨在开发更多类似于人类的学习算法。 它包含
 *   注意模型，`softmax(c)`
 *   损失函数，交叉熵损失
 
-现在，我们将遍历匹配网络的每个部分并实施它：
+现在，我们将遍历匹配网络的每个部分并实现它：
 
 1.  导入所有库：
 

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

@@ -34,21 +34,21 @@
 
 在下一节中，我们将讨论如何产生这些权重以及如何执行读写操作。
 
-# 造型
+# 建模
 
 在时间步`t`（`M[t]`）的存储矩阵具有`R`行和`C`列。 有一种注意力机制，用于指定注意头应该读取/写入的内存位置。 控制器生成的注意力向量是长度`R`的向量，称为**权重向量**（`w[t]`），其中 向量`w[t](i)`的条目是存储库第`i`行的权重。 权重向量已标准化，这意味着它满足以下条件：*
 
 ![](img/eed93f02-4abc-465e-b009-2912f63ccb39.png)
 
-# 阅读
+# 读取
 
 读取头将返回长度为`C`的向量， `r[t]`，它是存储器行`M[t](i)`由权重向量缩放：
 
 ![](img/7b4dda93-17d9-4c36-ab06-7af57479b100.png)
 
-# 写作
+# 写入
 
-写作是两个步骤的结合：擦除和添加。 为了擦除旧数据，写头使用附加长度`C`擦除向量`e[t]`以及权重向量。 以下方程式定义了擦除行的中间步骤：
+写入是两个步骤的结合：擦除和添加。 为了擦除旧数据，写头使用附加长度`C`擦除向量`e[t]`以及权重向量。 以下方程式定义了擦除行的中间步骤：
 
 ![](img/cb6720e7-9a40-4e30-b015-966dd1074fb0.png)
 
@@ -56,7 +56,7 @@
 
 ![](img/6d9c4431-8618-4953-a442-b2320bd662fb.png)
 
-# 编址
+# 寻址
 
 读取和写入操作的关键是权重向量，该权重向量指示要从中读取/写入的行。 控制器分四个阶段生成此权重向量。 每个阶段都会产生一个中间向量，该向量将传递到下一个阶段：
 
@@ -88,7 +88,7 @@
 
 MANN 的目标是在一次学习任务中表现出色。 正如我们之前阅读的，NMT 控制器同时使用基于内容的寻址和基于位置的寻址。 另一方面，MANN 控制器仅使用基于内容的寻址。 有两个原因。 原因之一是一次学习任务不需要基于位置的寻址。 在此任务中，对于给定的输入，控制器可能只需要执行两个操作，并且这两个操作都与内容有关，而与位置无关。 当输入与先前看到的输入非常相似时，将采取一种措施，在这种情况下，我们可以更新内存的当前内容。 当当前输入与以前看到的输入不相似时，将采取另一种操作，在这种情况下，我们不想覆盖最近的信息。 相反，我们写到使用最少的内存位置。 在这种情况下，该存储模块称为**最久未使用的访问**（**LRUA**）模块。
 
-# 阅读
+# 读取
 
 MANN 的读取操作与 NTM 的读取操作非常相似，唯一的区别是此处的权重向量仅使用基于内容的寻址（NMT 寻址的阶段 -1）。 更准确地说，控制器使用标准化的读取权重向量 <sub>![](img/e4dcb67f-bd46-4c65-acff-e7326482cfbd.png)</sub> ，将其与`M[t]`的行一起使用以生成读取向量，`r[t]`：
 
@@ -100,7 +100,7 @@ MANN 的读取操作与 NTM 的读取操作非常相似，唯一的区别是此
 
 在此，运算`K()`是余弦相似度，类似于为 NMT 定义的余弦相似度。
 
-# 写作
+# 写入
 
 为了写入存储器，控制器在写入最近读取的存储器行和写入最近读取的存储器行之间进行插值。
 
@@ -214,7 +214,7 @@ MANN 的读取操作与 NTM 的读取操作非常相似，唯一的区别是此
 
 本练习不包括代码的某些部分。 如果希望获得可运行的代码，请在[这个页面](https://github.com/PacktPublishing/Hands-On-One-shot-Learning-with-Python)中查看本书的 GitHub 存储库。
 
-# NTM 的实施
+# NTM 的实现
 
 如上所述，NTM 由两个重要组成部分组成：
 
@@ -576,7 +576,7 @@ plt.imshow(grid_img_pred.data.permute(2, 1, 0))
 
 在这里，我们创建了一个 300 个时间步长的随机信号，并观察了模型复制该信号的程度。 在此步骤中，您观察了复制任务输出。 这两个信号应该非常接近。 如果不是，我们建议您更多地训练模型。
 
-# MAAN 的实施
+# MAAN 的实现
 
 正如我们在上一节中展示的那样，NTM 的控制器能够使用基于内容的寻址，基于位置的寻址或同时使用这两种，而 MANN 则使用纯基于内容的内存写入器来工作。
 

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

@@ -240,7 +240,7 @@ class MNISTClassifier(nn.Module):
 
 在这里，我们可以看到我们的最后一层输出了`10`个单位。 这是因为我们希望预测每个图像是否为 0 到 9 之间的数字，总共是 10 种不同的可能分类。 我们的输出是长度为`10`的向量，并且包含图像的 10 种可能值中的每一个的预测。 在进行最终分类时，我们将数值最高的数字分类作为模型的最终预测。 例如，对于给定的预测，我们的模型可能会预测图像类型为 1 的概率为 10%，类型 2 的概率为 10%，类型 3 的概率为 80%。 因此，我们将类型 3 作为预测，因为它以最高概率被预测。
 
-## 实施辍学
+## 实现辍学
 
 在我们的`MNISTClassifier`类的`__init__`方法中，我们还定义了一种丢弃方法，以帮助规范网络：
 

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

@@ -626,9 +626,9 @@ This is a small giraffe
 
 现在，我们可以演示如何在 Python 中实现此功能并将 TF-IDF 权重应用于我们的嵌入。
 
-## 实施 TF-IDF
+## 实现 TF-IDF
 
-在这里，我们将使用 NLTK 数据集中的 Emma 语料对数据集实施 TF-IDF。 该数据集由 Jane Austen 的书《Emma》中的句子组成，我们希望为这些句子中的每一个计算一个嵌入式向量表示：
+在这里，我们将使用 NLTK 数据集中的 Emma 语料对数据集实现 TF-IDF。 该数据集由 Jane Austen 的书《Emma》中的句子组成，我们希望为这些句子中的每一个计算一个嵌入式向量表示：
 
 1.  我们首先导入我们的数据集，并循环处理每一个句子，删除所有标点符号和非字母数字字符（如星号）。我们选择在我们的数据集中留下停顿词，以展示 TF-IDF 如何处理这些词，因为这些词出现在许多文档中，因此具有非常低的 IDF。我们在语料库中创建了一个解析句子的列表和一组不同的词。
 

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

@@ -660,7 +660,7 @@ for line in lines[:3]:
     decoder_hidden = encoder_hidden[:decoder.n_layers]
     ```
 
-    接下来，我们实施教师强迫。 如果您从上一章的老师强迫中回想起，当以给定的概率生成输出序列时，我们将使用真正的上一个输出标记而不是预测的上一个输出标记来生成输出序列中的下一个单词。 使用教师强制可以帮助我们的模型更快收敛。 但是，我们必须小心，不要使教师强迫率过高，否则我们的模型将过于依赖教师强迫，并且不会学会独立产生正确的输出。
+    接下来，我们实现教师强迫。 如果您从上一章的老师强迫中回想起，当以给定的概率生成输出序列时，我们将使用真正的上一个输出标记而不是预测的上一个输出标记来生成输出序列中的下一个单词。 使用教师强制可以帮助我们的模型更快收敛。 但是，我们必须小心，不要使教师强迫率过高，否则我们的模型将过于依赖教师强迫，并且不会学会独立产生正确的输出。
 
 5.  确定我们是否应该对当前步骤使用教师强制。
 
@@ -682,7 +682,7 @@ for line in lines[:3]:
     n_totals += nTotal
     ```
 
-7.  如果我们不对给定的批次实施教师强迫，程序几乎是相同的。但是，我们不使用真实输出作为序列的下一个输入，而是使用模型生成的输出。
+7.  如果我们不对给定的批次实现教师强迫，程序几乎是相同的。但是，我们不使用真实输出作为序列的下一个输入，而是使用模型生成的输出。
 
     ```py
     _, topi = decoder_output.topk(1)

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

@@ -25,7 +25,7 @@
 
 **BERT** 代表**转换器**的双向编码器表示形式，由 Google 于 2018 年开发，被广泛认为是 NLP 领域的领先模型，在自然语言中已取得领先的性能 语言推理和问答任务。 幸运的是，它已作为开源模型发布，因此可以下载并用于您自己的 NLP 任务。
 
-BERT 是作为预训练的模型发布的，这意味着用户可以下载和实施 BERT，而无需每次都从头开始重新训练模型。 预先训练的模型在几个语料库上进行了训练，包括整个 Wikipedia（由 25 亿个单词组成）和另一个图书集（其中还包括 8 亿个单词）。 但是，BERT 与其他类似模型不同的主要因素是它提供了一种深度，双向，无监督的语言表示形式，该语言表示形式提供了更复杂，更详细的表示形式，从而提高了 NLP 任务的性能。 。
+BERT 是作为预训练的模型发布的，这意味着用户可以下载和实现 BERT，而无需每次都从头开始重新训练模型。 预先训练的模型在几个语料库上进行了训练，包括整个 Wikipedia（由 25 亿个单词组成）和另一个图书集（其中还包括 8 亿个单词）。 但是，BERT 与其他类似模型不同的主要因素是它提供了一种深度，双向，无监督的语言表示形式，该语言表示形式提供了更复杂，更详细的表示形式，从而提高了 NLP 任务的性能。 。
 
 ### 嵌入
 
@@ -615,7 +615,7 @@ What day is it today?
 *   我们的**编码器**由 LSTM 组成，需要引起注意。
 *   我们的**输出**也是基于 RNN 的，并且一次将我们的输出解码一个单词，以产生最终的问题和答案。
 
-尽管存在经过预训练的问答网络，但是您可以练习实施新获得的 PyTorch 技能，并尝试自己构建和训练这样的模型。
+尽管存在经过预训练的问答网络，但是您可以练习实现新获得的 PyTorch 技能，并尝试自己构建和训练这样的模型。
 
 诸如此类的语言理解模型可能会成为 NLP 未来几年研究的主要重点之一，新论文的发布频率可能会越来越高。
 

new/pt-ai-fund/2.md

@@ -19,9 +19,9 @@
 *   定义神经网络类
 *   创建一个全连接网络
 *   定义损失函数
-*   实施优化器
-*   实施辍学
-*   实施函数式 API
+*   实现优化器
+*   实现辍学
+*   实现函数式 API
 
 # 技术要求
 
@@ -321,7 +321,7 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机
 
 您可以在[这个页面](https://pytorch.org/docs/master/nn.html#loss-functions)上查看更多损失函数的官方文档。
 
-# 实施优化器
+# 实现优化器
 
 在本秘籍中，我们将学习优化器。 在先前的秘籍“定义损失函数”中，我们谈到了误差和误差函数，并了解到，为了获得一个好的模型，我们需要最小化计算出的误差。 **反向传播**是神经网络从错误中学习的一种方法。 错误用于修改权重，以使错误最小化。 优化功能负责修改权重以减少误差。 优化函数计算相对于权重的误差的偏导数。 导数显示正斜率的方向，因此我们需要反转梯度的方向。 **优化器**函数将模型参数和损失函数结合在一起，以迭代方式修改模型参数以减少模型误差。 可以考虑将优化器摆在模型权重的基础上，根据模型与实际输出的预测差异来获得最佳模型，而损失函数则通过指示优化器是对还是错来充当指导。
 
@@ -473,7 +473,7 @@ Training loss: 0.2596
 
 您可以在[这个页面](https://pytorch.org/docs/stable/optim.html#torch.optim.Optimizer)上了解有关优化程序的更多信息。
 
-# 实施辍学
+# 实现辍学
 
 在本秘籍中，我们将研究实现辍学。 在训练神经网络模型或一般任何机器学习模型时，我们可能会遇到的一种较常见的现象是过拟合。 当模型学习提供给训练的数据而不是在求解空间上进行泛化时，就会发生过拟合，也就是说，模型学习的是训练数据的细微细节和噪声，而不是掌握全局，因此在效果上表现不佳。 新数据。 正则化是防止模型过拟合的过程。
 
@@ -556,7 +556,7 @@ Training loss: 0.2596
 
 您可以在[这个页面](https://arxiv.org/abs/1207.0580)上了解有关辍学的更多信息。
 
-# 实施函数式 API
+# 实现函数式 API
 
 在本秘籍中，我们将探索 PyTorch 中的函数式 API。 这样做将使我们能够编写更简洁的网络架构和组件。 我们将研究函数式 API，并使用函数式 API 定义模型或模型的一部分。
 

new/pt-ai-fund/5.md

@@ -15,8 +15,8 @@
 在本章中，我们将介绍以下秘籍：
 
 *   调整预训练模型
-*   实施模型训练
-*   实施模型测试
+*   实现模型训练
+*   实现模型测试
 *   加载数据集
 *   定义 TensorBoard 作者
 *   训练模型和解冻层
@@ -104,7 +104,7 @@ return model
 
 然后，我们定义了`get_model()`函数，该函数首先下载 ResNet-50 模型（本地不可用）并冻结该模型的权重。 通过冻结权重，较低的卷积层不会更新。 然后，我们用`AdaptiveConcatPool2d`层替换了平均池化层，并为两个可用的类添加了具有两个输出单元的全连接分类器。 我们最终返回了带有冻结的 ResNet 层的模型。
 
-# 实施模型训练
+# 实现模型训练
 
 在本秘籍中，我们将实现一个在单个时期内训练模型的功能。 此功能进一步记录模型的训练指标并将其绘制到 TensorBoard 上。 我们将传入模型，训练数据，优化器和模型训练准则，并将返回训练损失。
 
@@ -157,7 +157,7 @@ return model
 
 最后，我们使用 TensorBoard 中`SummaryWriter`对象中的`SummaryWriter`对象中的`add_scalar()`方法在 TensorBoard 中记录了训练指标-我们在其中传递了一个标签，一个标量值和一个计数器，在本例中为历元数 。
 
-# 实施模型测试
+# 实现模型测试
 
 在此秘籍中，我们将定义一个函数以在一个时期内根据验证数据测试模型。 此功能还将测试指标记录到 TensorBoard 上。 我们还将添加实用程序功能，通过绘制图像并以可读的方式标记这些图像来记录模型中的一些错误分类。
 
@@ -353,7 +353,7 @@ return model
 pip install tb-nightly
 ```
 
-这样，我们准备实施该秘籍。
+这样，我们准备实现该秘籍。
 
 # 怎么做...
 

new/pt-ai-fund/7.md

@@ -8,7 +8,7 @@ RL 是**人工智能**（**AI**）的领域，与我们在前面各章中介绍
 
 *   OpenAI 体育馆简介– CartPole
 *   引入 DQN
-*   实施 DQN 类
+*   实现 DQN 类
 *   训练 DQN
 *   引入深度 GA
 *   生成代理
@@ -189,7 +189,7 @@ def cartpole_model(observation_space, action_space):
 
 您可以在[这个页面](https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html#q-network)上查看替代架构。
 
-# 实施 DQN 类
+# 实现 DQN 类
 
 在本秘籍中，我们将使用神经网络完成 DQN。 为此，我们将执行一些关键任务，包括创建目标和策略网络，损失函数和网络优化器，存储学习过程的状态和奖励，预测行为，经验回放以及控制学习过程。 探索率。
 

new/pt-dl-handson/1.md

@@ -18,7 +18,7 @@
 
 Python 在深度学习社区中的广泛接受使一些研究人员和开发人员重新考虑了核心作者做出的选择 Lua 而不是 Python 的决定。 这不仅仅是语言：缺少具有易于调试功能的命令式框架也触发了 PyTorch 的构想。
 
-深度学习的前端开发人员发现符号图的概念很困难。 不幸的是，几乎所有的深度学习框架都是在此基础上构建的。 实际上，一些开发人员小组试图通过动态图来改变这种方法。 哈佛智能概率系统集团的 Autograd 是第一个这样做的流行框架。 然后，Twitter 上的 Torch 社区采纳了这个想法，并实施了 torch-autograd。
+深度学习的前端开发人员发现符号图的概念很困难。 不幸的是，几乎所有的深度学习框架都是在此基础上构建的。 实际上，一些开发人员小组试图通过动态图来改变这种方法。 哈佛智能概率系统集团的 Autograd 是第一个这样做的流行框架。 然后，Twitter 上的 Torch 社区采纳了这个想法，并实现了 torch-autograd。
 
 接下来，来自**卡内基梅隆大学**（**CMU**）的研究小组提出了 DyNet，然后 Chainer 提出了动态图表的功能和可解释的开发环境。
 
@@ -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 这样的抽象库即可让初学者入门。
 

new/pt-dl-handson/3.md

@@ -4,7 +4,7 @@
 
 PyTorch 最初是由 Facebook 实习生作为研究框架开始的，现已发展到由超级优化的 Caffe2 核心支持后端的阶段。 因此，简而言之，PyTorch 可以用作研究或原型框架，同时可以用来编写带有服务模块的有效模型，并且还可以部署到单板计算机和移动设备上。
 
-典型的深度学习工作流程始于围绕问题陈述的构想和研究，这是架构设计和模型决策发挥作用的地方。 然后使用原型对理论模型进行实验。 这包括尝试不同的模型或技术（例如跳过连接），或决定不尝试什么。 同样，选择合适的数据集进行原型设计并将数据集的无缝集成添加到管道中对于此阶段至关重要。 一旦实施了模型并通过训练和验证集对其进行了验证，则可以针对生产服务优化该模型。 下图描述了一个五阶段的深度学习工作流程：
+典型的深度学习工作流程始于围绕问题陈述的构想和研究，这是架构设计和模型决策发挥作用的地方。 然后使用原型对理论模型进行实验。 这包括尝试不同的模型或技术（例如跳过连接），或决定不尝试什么。 同样，选择合适的数据集进行原型设计并将数据集的无缝集成添加到管道中对于此阶段至关重要。 一旦实现了模型并通过训练和验证集对其进行了验证，则可以针对生产服务优化该模型。 下图描述了一个五阶段的深度学习工作流程：
 
 ![Deep Learning Workflow](img/B09475_03_01.jpg)
 

new/pt-dl-handson/5.md

@@ -16,7 +16,7 @@
 
 嵌入是通过比较单词在单词簇中的分布来找到单词的概念含义的另一种革命性思想。 嵌入保持单词之间的关系，并将这种关系（它从单词簇中的单词分布中找到）转换为一组浮点数。 嵌入大大减少了输入大小，并极大地提高了性能和准确率。 我们将使用 word2vec 进行实验。
 
-数据处理是序列数据（尤其是自然语言）的主要挑战之一。 PyTorch 提供了一些实用程序包来处理该问题。 我们将使用预处理后的数据来简化实施，但是我们将遍历实用程序包以了解它们的工作原理。 与这些实用程序包一起，我们将使用`torchtext`，它消除了处理输入数据时将面临的许多困难。
+数据处理是序列数据（尤其是自然语言）的主要挑战之一。 PyTorch 提供了一些实用程序包来处理该问题。 我们将使用预处理后的数据来简化实现，但是我们将遍历实用程序包以了解它们的工作原理。 与这些实用程序包一起，我们将使用`torchtext`，它消除了处理输入数据时将面临的许多困难。
 
 尽管本章全都是关于顺序数据的，但我们将专注于顺序数据的一个子集，这是自然语言。 特定于自然语言的一些研究人员认为，我们使用 LSTM 或 GRU 处理输入的方式不是应该如何处理自然语言。 自然语言在单词之间保持树状的层次关系，我们应该加以利用。 **栈式增强型解析器-解释器神经网络**（**SPINN**）[2]是来自 Stanford NLP 组的一种此类实现。 这种处理树状结构序列数据的特殊类型的网络是*递归神经网络*（与循环神经网络不同）。 在本章的最后一部分中，我们将详细介绍 SPINN。
 
@@ -96,7 +96,7 @@ array([[O., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
 
 使用自然语言（或由离散的单个单元组成的任何序列）的标准方法是将每个单词转换为一个热编码向量，并将其用于网络的后期。 这种方法的明显缺点是，随着词汇量的增加，输入层的大小也会增加。
 
-词嵌入是减少阵列或张量维数的数十年历史的想法。 **潜在迪利克雷分配**（**LDA**）和**潜在语义分析**（**LSA**）是我们用来进行嵌入的两个此类示例。 但是，在 Facebook 研究科学家 Tomas Mikolov 和他的团队于 2013 年实施 word2vec 之后，就开始将嵌入视为前提。
+词嵌入是减少阵列或张量维数的数十年历史的想法。 **潜在迪利克雷分配**（**LDA**）和**潜在语义分析**（**LSA**）是我们用来进行嵌入的两个此类示例。 但是，在 Facebook 研究科学家 Tomas Mikolov 和他的团队于 2013 年实现 word2vec 之后，就开始将嵌入视为前提。
 
 Word2vec 是一种无监督的学习算法，在这种算法中，网络未经训练就进行嵌入。 这意味着您可以在一个英语数据集上训练 word2vec 模型，并使用它为另一模型生成嵌入。
 
@@ -471,7 +471,7 @@ RNN 实现通常是单向的，这就是到目前为止我们已经实现的。
 
 ##### 注意
 
-如前所述，注意力是与正常神经网络过程一起集中在重要区域上的过程。 注意不是我们现有实施的一部分； 而是充当另一个模块，该模块始终查看输入，并作为额外输入传递到当前网络。
+如前所述，注意力是与正常神经网络过程一起集中在重要区域上的过程。 注意不是我们现有实现的一部分； 而是充当另一个模块，该模块始终查看输入，并作为额外输入传递到当前网络。
 
 注意背后的想法是，当我们阅读句子时，我们专注于句子的重要部分。 例如，将一个句子从一种语言翻译成另一种语言，我们将更专注于上下文信息，而不是构成句子的文章或其他单词。
 

new/pt-dl-handson/6.md

@@ -356,7 +356,7 @@ return torch.stack(skip_connections)
 
 这种监督学习算法本质上是判别式的，这意味着它学会对条件概率分布函数进行建模，在此条件函数中，它说明了某事物的概率被赋予了另一事物的状态。 例如，如果购买房屋的价格为 100,000 美元，那么房屋位置的概率是多少？ GAN 从随机分布生成输出，因此随机输入的变化使输出不同。
 
-GAN 从随机分布中获取样本，然后由网络将其转换为输出。 GAN 在学习输入分布的模式时不受监督，并且与其他生成网络不同，GAN 不会尝试明确地学习密度分布。 相反，他们使用博弈论方法来找到两个参与者之间的纳什均衡。 GAN 实施将始终拥有一个生成网络和一个对抗网络，这被视为两个试图击败的参与者。 GAN 的核心思想在于从统一或高斯等数据分布中采样，然后让网络将采样转换为真正的数据分布样。 我们将实现一个简单的 GAN，以了解 GAN 的工作原理，然后转向名为 CycleGAN 的高级 GAN 实现。
+GAN 从随机分布中获取样本，然后由网络将其转换为输出。 GAN 在学习输入分布的模式时不受监督，并且与其他生成网络不同，GAN 不会尝试明确地学习密度分布。 相反，他们使用博弈论方法来找到两个参与者之间的纳什均衡。 GAN 实现将始终拥有一个生成网络和一个对抗网络，这被视为两个试图击败的参与者。 GAN 的核心思想在于从统一或高斯等数据分布中采样，然后让网络将采样转换为真正的数据分布样。 我们将实现一个简单的 GAN，以了解 GAN 的工作原理，然后转向名为 CycleGAN 的高级 GAN 实现。
 
 ### Simple GAN
 

new/pt-dl-handson/7.md

@@ -132,7 +132,7 @@ MDP 定义有五件事：
 
 让我们举个例子。 让我们考虑通用状态`S0`。 现在我们需要预测在`a1`，`a2`和`a3`之间要采取什么行动才能获得最大的回报（累积折扣奖励）。 我们将此函数命名为`Q`。 我们的函数`Q`，将预测每个操作的预期收益（值（`V`））。 此`Q`函数也称为动作值函数，因为它考虑了状态和动作，并预测了它们各自的组合的预期收益。
 
-我们通常会选择最大值。 因此，这些最高限额将指导代理商到最后，这将是我们的策略。 请注意，我大部分时间都在说。 通常，在选择非最大动作值对时，我们会保持很小的随机机会。 我们这样做是为了提高模型的可探索性。 该随机探索机会的百分比称为`ε`，该策略称为 ε 贪婪策略。 这是人们用来解决强化学习问题的最常见策略。 如果我们一直都只选择最大值，而不进行任何探索，则该策略简称为贪婪策略。 我们将在实施过程中同时使用这两种策略。
+我们通常会选择最大值。 因此，这些最高限额将指导代理商到最后，这将是我们的策略。 请注意，我大部分时间都在说。 通常，在选择非最大动作值对时，我们会保持很小的随机机会。 我们这样做是为了提高模型的可探索性。 该随机探索机会的百分比称为`ε`，该策略称为 ε 贪婪策略。 这是人们用来解决强化学习问题的最常见策略。 如果我们一直都只选择最大值，而不进行任何探索，则该策略简称为贪婪策略。 我们将在实现过程中同时使用这两种策略。
 
 但是起初，我们可能不知道最佳作用值函数。 因此，由此产生的策略也将不是最佳策略。 我们将需要遍历动作值函数，并找到提供最佳回报的函数。 一旦找到它，我们将获得最优的`Q`。 最佳`Q`也称为`Q*`。 因此，我们将能够找到最优的`Pi`，也称为`Pi*`。
 

new/pt-tut-17/07.md

@@ -129,7 +129,7 @@ print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3'
 
 ### PyTorch：张量和 Autograd
 
-在上述示例中，我们必须手动实现神经网络的前向和后向传递。 对于小型的两层网络，手动实施反向传递并不是什么大问题，但是对于大型的复杂网络来说，可以很快变得非常麻烦。
+在上述示例中，我们必须手动实现神经网络的前向和后向传递。 对于小型的两层网络，手动实现反向传递并不是什么大问题，但是对于大型的复杂网络来说，可以很快变得非常麻烦。
 
 幸运的是，我们可以使用[自动微分](https://en.wikipedia.org/wiki/Automatic_differentiation)来自动计算神经网络中的反向传递。 PyTorch 中的 **Autograd** 软件包正是提供了此功能。 使用 Autograd 时，网络的正向传播将定义**计算图**； 图中的节点为张量，边为从输入张量产生输出张量的函数。 然后通过该图进行反向传播，可以轻松计算梯度。
 

new/pt-tut-17/19.md

@@ -34,7 +34,7 @@
 
 关于`labels`的注释。 该模型将`0`类作为背景。 如果您的数据集不包含背景类，则`labels`中不应包含`0`。 例如，假设您只有*猫*和*狗*两类，则可以定义`1`来表示*猫*和`0`代表*狗*。 因此，例如，如果其中一个图像同时具有两个类，则您的`labels`张量应类似于`[1,2]`。
 
-此外，如果要在训练过程中使用宽高比分组（以便每个批量仅包含具有相似长宽比的图像），则建议您还实施`get_height_and_width`方法，该方法返回图像的高度和宽度。 如果未提供此方法，我们将通过`__getitem__`查询数据集的所有元素，这会将图像加载到内存中，并且比提供自定义方法慢。
+此外，如果要在训练过程中使用宽高比分组（以便每个批量仅包含具有相似长宽比的图像），则建议您还实现`get_height_and_width`方法，该方法返回图像的高度和宽度。 如果未提供此方法，我们将通过`__getitem__`查询数据集的所有元素，这会将图像加载到内存中，并且比提供自定义方法慢。
 
 ### 为 PennFudan 编写自定义数据集
 

new/pt-tut-17/21.md

@@ -24,7 +24,7 @@
 
 从图中，`x`是正确分类为“熊猫”的原始输入图像，`y`是`x`的输出，`θ`表示模型参数，而`J(θ, x, y)`是用于训练网络的损耗。 攻击会将梯度反向传播回输入数据，以计算`ᐁ[x] J(θ, x, y)`。 然后，它会沿方向（即`ᐁ[x] J(θ)`）沿一小步（图片中的`ε`或`0.007`）调整输入数据，`(x, y)`，这将使损失最大化。 然后，当目标图像仍明显是“熊猫”时，目标网络将它们误分类为“长臂猿”。
 
-希望本教程的动机已经明确，所以让我们跳入实施过程。
+希望本教程的动机已经明确，所以让我们跳入实现过程。
 
 ```py
 from __future__ import print_function
@@ -290,7 +290,7 @@ plt.show()
 
 希望本教程对对抗性机器学习主题有所了解。 从这里可以找到许多潜在的方向。 这种攻击代表了对抗性攻击研究的最开始，并且由于随后有许多关于如何攻击和防御来自对手的 ML 模型的想法。 实际上，在 NIPS 2017 上有一个对抗性的攻击和防御竞赛，并且本文描述了该竞赛中使用的许多方法：[《对抗性的攻击与防御竞赛》](https://arxiv.org/pdf/1804.00097.pdf)。 防御方面的工作还引发了使机器学习模型总体上更*健壮*的想法，以适应自然扰动和对抗性输入。
 
-另一个方向是不同领域的对抗性攻击和防御。 对抗性研究不仅限于图像领域，请查看[对语音到文本模型的这种攻击](https://arxiv.org/pdf/1801.01944.pdf)。 但是，也许更多地了解对抗性机器学习的最好方法是动手。 尝试实施与 NIPS 2017 竞赛不同的攻击，并查看它与 FGSM 有何不同。 然后，尝试保护模型免受自己的攻击。
+另一个方向是不同领域的对抗性攻击和防御。 对抗性研究不仅限于图像领域，请查看[对语音到文本模型的这种攻击](https://arxiv.org/pdf/1801.01944.pdf)。 但是，也许更多地了解对抗性机器学习的最好方法是动手。 尝试实现与 NIPS 2017 竞赛不同的攻击，并查看它与 FGSM 有何不同。 然后，尝试保护模型免受自己的攻击。
 
 **脚本的总运行时间**：（4 分钟 22.519 秒）
 

new/pt-tut-17/42.md

@@ -175,7 +175,7 @@ print(named_imgs.abs().names)
 
 ### 访问器和约简
 
-可以使用尺寸名称来引用尺寸而不是位置尺寸。 这些操作还传播名称。 索引（基本索引和高级索引）尚未实施，但仍在规划中。 使用上面的`named_imgs`张量，我们可以执行以下操作：
+可以使用尺寸名称来引用尺寸而不是位置尺寸。 这些操作还传播名称。 索引（基本索引和高级索引）尚未实现，但仍在规划中。 使用上面的`named_imgs`张量，我们可以执行以下操作：
 
 ```py
 output = named_imgs.sum('C')  # Perform a sum over the channel dimension

new/pt-tut-17/45.md

@@ -12,7 +12,7 @@ C++ 扩展是我们开发的一种机制，允许用户（您）创建源外定
 
 ## 动机和示例
 
-本说明的其余部分将逐步介绍编写和使用 C++（和 CUDA）扩展的实际示例。 如果您被追捕，或者在一天结束前仍未完成该操作，就会有人开除您，则可以跳过本节，直接进入下一部分的实施细节。
+本说明的其余部分将逐步介绍编写和使用 C++（和 CUDA）扩展的实际示例。 如果您被追捕，或者在一天结束前仍未完成该操作，就会有人开除您，则可以跳过本节，直接进入下一部分的实现细节。
 
 假设您想出了一种新型的循环装置，发现与现有技术相比，它具有更好的性能。 该循环单元类似于 LSTM，但不同之处在于它缺少*遗忘门*，并使用*指数线性单元*（ELU）作为其内部激活函数。 由于此设备永远不会忘记，因此我们将其称为 *LLTM* 或*长期记忆*单元。
 

new/pt-tut-17/47.md

@@ -520,7 +520,7 @@ class TryCustomOp(torch.nn.Module):
 
 注意
 
-注册使用 C++ 类作为参数的运算符时，要求已注册自定义类。 您可以通过确保自定义类注册和您的自由函数定义在同一`TORCH_LIBRARY`块中，并确保自定义类注册位于第一位来强制实施此操作。 将来，我们可能会放宽此要求，以便可以按任何顺序进行注册。
+注册使用 C++ 类作为参数的运算符时，要求已注册自定义类。 您可以通过确保自定义类注册和您的自由函数定义在同一`TORCH_LIBRARY`块中，并确保自定义类注册位于第一位来强制实现此操作。 将来，我们可能会放宽此要求，以便可以按任何顺序进行注册。
 
 ## 结论
 

new/pt-tut-17/54.md

@@ -708,7 +708,7 @@ Global sparsity: 20.00%
 
 要实现自己的修剪功能，可以通过继承`BasePruningMethod`基类的子类来扩展`nn.utils.prune`模块，这与所有其他修剪方法一样。 基类为您实现以下方法：`__call__`，`apply_mask`，`apply`，`prune`和`remove`。 除了一些特殊情况外，您无需为新的修剪技术重新实现这些方法。 但是，您将必须实现`__init__`（构造函数）和`compute_mask`（有关如何根据修剪技术的逻辑为给定张量计算掩码的说明）。 另外，您将必须指定此技术实现的修剪类型（支持的选项为`global`，`structured`和`unstructured`）。 需要确定在迭代应用修剪的情况下如何组合蒙版。 换句话说，当修剪预修剪的参数时，当前的修剪技术应作用于参数的未修剪部分。 指定`PRUNING_TYPE`将使`PruningContainer`（处理修剪掩码的迭代应用）正确识别要修剪的参数。
 
-例如，假设您要实施一种修剪技术，以修剪张量中的所有其他条目（或者-如果先前已修剪过张量，则修剪张量的其余未修剪部分）。 这将是`PRUNING_TYPE='unstructured'`，因为它作用于层中的单个连接，而不作用于整个单元/通道（`'structured'`），或作用于不同的参数（`'global'`）。
+例如，假设您要实现一种修剪技术，以修剪张量中的所有其他条目（或者-如果先前已修剪过张量，则修剪张量的其余未修剪部分）。 这将是`PRUNING_TYPE='unstructured'`，因为它作用于层中的单个连接，而不作用于整个单元/通道（`'structured'`），或作用于不同的参数（`'global'`）。
 
 ```py
 class FooBarPruningMethod(prune.BasePruningMethod):

new/pt-tut-17/64.md

@@ -336,7 +336,7 @@ class Decoder(nn.Module):
 
 ```
 
-使用上述子模块，我们现在可以使用 RPC 将它们组合在一起以创建 RNN 模型。 在下面的代码中，`ps`代表参数服务器，该服务器托管嵌入表和解码器的参数。 构造函数使用[远程](https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.remote) API 在参数服务器上创建`EmbeddingTable`对象和`Decoder`对象，并在本地创建`LSTM`子模块。 在前进过程中，训练器使用`EmbeddingTable` `RRef`查找远程子模块，然后使用 RPC 将输入数据传递到`EmbeddingTable`，并获取查找结果。 然后，它通过本地`LSTM`层运行嵌入，最后使用另一个 RPC 将输出发送到`Decoder`子模块。 通常，要实施分布式模型并行训练，开发人员可以将模型分为多个子模块，调用 RPC 远程创建子模块实例，并在必要时使用`RRef`查找它们。 正如您在下面的代码中看到的那样，它看起来与单机模型并行训练非常相似。 主要区别是用 RPC 功能替换了`Tensor.to(device)`。
+使用上述子模块，我们现在可以使用 RPC 将它们组合在一起以创建 RNN 模型。 在下面的代码中，`ps`代表参数服务器，该服务器托管嵌入表和解码器的参数。 构造函数使用[远程](https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.remote) API 在参数服务器上创建`EmbeddingTable`对象和`Decoder`对象，并在本地创建`LSTM`子模块。 在前进过程中，训练器使用`EmbeddingTable` `RRef`查找远程子模块，然后使用 RPC 将输入数据传递到`EmbeddingTable`，并获取查找结果。 然后，它通过本地`LSTM`层运行嵌入，最后使用另一个 RPC 将输出发送到`Decoder`子模块。 通常，要实现分布式模型并行训练，开发人员可以将模型分为多个子模块，调用 RPC 远程创建子模块实例，并在必要时使用`RRef`查找它们。 正如您在下面的代码中看到的那样，它看起来与单机模型并行训练非常相似。 主要区别是用 RPC 功能替换了`Tensor.to(device)`。
 
 ```py
 class RNNModel(nn.Module):
@@ -388,7 +388,7 @@ class RNNModel(nn.Module):
 
 ```
 
-现在，我们准备实施训练循环。 初始化模型参数后，我们创建`RNNModel`和`DistributedOptimizer`。 分布式优化器将采用参数`RRefs`的列表，查找所有不同的所有者工作器，并在每个所有者工作器上创建给定的本地优化器（即，在这种情况下，您也可以使用其他本地优化器`SGD`） 使用给定的参数（即`lr=0.05`）。
+现在，我们准备实现训练循环。 初始化模型参数后，我们创建`RNNModel`和`DistributedOptimizer`。 分布式优化器将采用参数`RRefs`的列表，查找所有不同的所有者工作器，并在每个所有者工作器上创建给定的本地优化器（即，在这种情况下，您也可以使用其他本地优化器`SGD`） 使用给定的参数（即`lr=0.05`）。
 
 在训练循环中，它首先创建一个分布式 Autograd 上下文，这将帮助分布式 Autograd 引擎查找梯度和涉及的 RPC 发送/接收功能。 分布式 Autograd 引擎的设计详细信息可以在其[设计说明](https://pytorch.org/docs/master/notes/distributed_autograd.html)中找到。 然后，它像本地模型一样开始前向传递，并运行分布式后向传递。 对于后向分布，您只需要指定一个根列表，在这种情况下，就是损失`Tensor`。 分布式 Autograd 引擎将自动遍历分布式图形并正确编写梯度。 接下来，它在分布式优化器上运行`step`功能，该功能将与所有涉及的本地优化器联系以更新模型参数。 与本地训练相比，一个较小的差异是您不需要运行`zero_grad()`，因为每个 Autograd 上下文都有专用的空间来存储梯度，并且在每次迭代创建上下文时，来自不同迭代的那些梯度不会累积到 同一组`Tensors`。
 

new/pt-tut-17/66.md

@@ -183,7 +183,7 @@ class DistResNet50(nn.Module):
 
 ## 步骤 3：定义训练循环
 
-定义模型后，让我们实施训练循环。 我们使用专门的“主”工作人员来准备随机输入和标签，并控制分布式反向传递和分布式优化器步骤。 它首先创建`DistResNet50`模块的实例。 它指定每个批量的微批数量，并提供两个 RPC 工作程序的名称（即`worker1`和`worker2`）。 然后，它定义损失函数，并使用`parameter_rrefs()`帮助器创建`DistributedOptimizer`以获取参数`RRefs`的列表。 然后，主训练循环与常规本地训练非常相似，除了它使用`dist_autograd`向后启动并为反向和优化器`step()`提供`context_id`之外。
+定义模型后，让我们实现训练循环。 我们使用专门的“主”工作人员来准备随机输入和标签，并控制分布式反向传递和分布式优化器步骤。 它首先创建`DistResNet50`模块的实例。 它指定每个批量的微批数量，并提供两个 RPC 工作程序的名称（即`worker1`和`worker2`）。 然后，它定义损失函数，并使用`parameter_rrefs()`帮助器创建`DistributedOptimizer`以获取参数`RRefs`的列表。 然后，主训练循环与常规本地训练非常相似，除了它使用`dist_autograd`向后启动并为反向和优化器`step()`提供`context_id`之外。
 
 ```py
 import torch.distributed.autograd as dist_autograd

new/pt-tut-17/67.md

@@ -8,7 +8,7 @@
 
 *   [PyTorch 分布式概述](../beginner/dist_overview.html)
 *   [分布式 RPC 框架](rpc_tutorial.html)入门
-*   [使用分布式 RPC 框架](rpc_param_server_tutorial.html)实施参数服务器
+*   [使用分布式 RPC 框架](rpc_param_server_tutorial.html)实现参数服务器
 *   [RPC 异步执行装饰器](https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution)
 
 本教程演示了如何使用[`@rpc.functions.async_execution`](https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution)装饰器来构建批量 RPC 应用程序，该装饰器通过减少阻止的 RPC 线程数和合并被调用方上的 CUDA 操作来帮助加快训练速度。 这使用 TorchServer 的相同想法进行[批量推断](https://pytorch.org/serve/batch_inference_with_ts.html)。
@@ -90,7 +90,7 @@ class BatchUpdateParameterServer(object):
 
 ```
 
-对于训练器，它们都使用来自 PS 的相同参数集进行初始化。 在每次迭代中，每位训练器首先进行前进和后退操作，以局部生成梯度。 然后，每个训练器都使用 RPC 向 PS 报告其梯度，并通过同一 RPC 请求的返回值取回更新的参数。 在训练器的实施中，目标功能是否标记有`@rpc.functions.async_execution`都没有关系。 训练器只需使用`rpc_sync`调用`update_and_fetch_model`，这会阻塞训练器，直到返回更新的模型。
+对于训练器，它们都使用来自 PS 的相同参数集进行初始化。 在每次迭代中，每位训练器首先进行前进和后退操作，以局部生成梯度。 然后，每个训练器都使用 RPC 向 PS 报告其梯度，并通过同一 RPC 请求的返回值取回更新的参数。 在训练器的实现中，目标功能是否标记有`@rpc.functions.async_execution`都没有关系。 训练器只需使用`rpc_sync`调用`update_and_fetch_model`，这会阻塞训练器，直到返回更新的模型。
 
 ```py
 batch_size, image_w, image_h  = 20, 64, 64

new/rl-tf/01.md

@@ -34,7 +34,7 @@
 
 首先，它是当前的规模，即数据，计算能力和新算法的规模，这正在推动深度学习的发展。 互联网已经过去了四十年，导致大量的数字足迹不断积累和增长。 在此期间，研究和技术发展帮助扩大了计算系统的存储和处理能力。 当前，由于这些繁重的计算系统和海量数据，我们能够验证过去三十年来在人工智能领域的发现。
 
-现在，我们需要什么来实施深度学习？
+现在，我们需要什么来实现深度学习？
 
 首先，我们需要大量数据。
 
@@ -976,7 +976,7 @@ OpenAI Gym 由两部分组成：
 
 有关安装和依赖项，[请参考以下链接](https://gym.openai.com/docs/)。
 
-在介绍了基础知识之后，现在我们将从下面的第 2 章“使用 OpenAI Gym 训练强化学习智能体”开始使用 OpenAI Gym 实施强化学习。
+在介绍了基础知识之后，现在我们将从下面的第 2 章“使用 OpenAI Gym 训练强化学习智能体”开始使用 OpenAI Gym 实现强化学习。
 
 # 强化学习的先驱与突破
 

new/rl-tf/03.md

@@ -430,7 +430,7 @@ POMDP 中的值迭代基本上是从信念 MDP 获得的无限状态空间上的
 
 # 使用 MDP 训练 FrozenLake-v0 环境
 
-这是关于 OpenAI 体育馆中名为 **FrozenLake-v0** 的网格世界环境，在第 2 章“使用 OpenAI 体育馆训练强化学习智能体”中讨论。 我们实施了 Q 学习和 Q 网络（我们将在以后的章节中进行讨论）以了解 OpenAI 体育馆的环境。
+这是关于 OpenAI 体育馆中名为 **FrozenLake-v0** 的网格世界环境，在第 2 章“使用 OpenAI 体育馆训练强化学习智能体”中讨论。 我们实现了 Q 学习和 Q 网络（我们将在以后的章节中进行讨论）以了解 OpenAI 体育馆的环境。
 
 现在，让我们尝试使用以下代码实现值迭代，以获取 FrozenLake-v0 环境中每个状态的效用值：
 

new/rl-tf/04.md

@@ -371,7 +371,7 @@ end for
 
 ![](img/297c6703-97ca-4ba2-8e19-70dabec7b4a1.png)
 
-但是，实际上我们没有标签。 因此，我们将实施强化学习，在其中我们将尝试许多任务并记下观察结果。 然后，更频繁地执行性能更好的任务。
+但是，实际上我们没有标签。 因此，我们将实现强化学习，在其中我们将尝试许多任务并记下观察结果。 然后，更频繁地执行性能更好的任务。
 
 在输入 Python 代码之前，让我们放下步骤。 它们如下：
 

new/rl-tf/05.md

@@ -266,7 +266,7 @@ def discretization(env, obs):
     return pos_scaled,vel_scaled
 ```
 
-现在，我们将通过初始化 Q 表并相应地更新 Q 值来开始实施 Q 学习算法。 在这里，我们将奖励值更新为当前位置与最低点（即起点）之间的绝对差值，以便它通过远离中心即最低点来最大化奖励。 这样做是为了实现更好的收敛：
+现在，我们将通过初始化 Q 表并相应地更新 Q 值来开始实现 Q 学习算法。 在这里，我们将奖励值更新为当前位置与最低点（即起点）之间的绝对差值，以便它通过远离中心即最低点来最大化奖励。 这样做是为了实现更好的收敛：
 
 ```py
 #Q table
@@ -306,7 +306,7 @@ while True: #to hold the render at the last step when Car passes the flag
       env.render() 
 ```
 
-根据学习情况，前面的 Q 学习程序将以以下方式打印输出：
+根据学习情况，前面的 Q 学习器将以以下方式打印输出：
 
 ```py
 Episode 1 completed with total reward 8433.30289388 in 26839 steps
@@ -427,7 +427,7 @@ end
 
 # 适用于 OpenAI 体育馆山地车问题的深度 Q 网络
 
-在针对山地车问题实施 Q 学习时，我们已经讨论了环境。 让我们直接深入实施一个深度 Q 网络来解决山地车问题。 首先，我们将使用以下代码导入所需的库：
+在针对山地车问题实现 Q 学习时，我们已经讨论了环境。 让我们直接深入实现一个深度 Q 网络来解决山地车问题。 首先，我们将使用以下代码导入所需的库：
 
 ```py
 #importing the dependencies
@@ -896,7 +896,7 @@ Type of actions : ['NOOP', 'FIRE', 'RIGHT', 'LEFT']
 
 因此，目标是通过摧毁所有积木而不让球进入桨下来赢得比赛。
 
-让我们开始实施一个深层的 Q 网络，以使我们的代理商学习 Atari Breakout 的游戏。 首先，我们将使用以下代码导入必要的库：
+让我们开始实现一个深层的 Q 网络，以使我们的代理商学习 Atari Breakout 的游戏。 首先，我们将使用以下代码导入必要的库：
 
 ```py
 #Importing the dependencies
@@ -1363,7 +1363,7 @@ end
 
 # 适用于 OpenAI 体育馆山地车问题的 SARSA 算法
 
-让我们尝试实现先前在山地车问题中解释过的 SARSA 算法。 该程序的初始部分与先前的 Q 学习程序具有相似之处。
+让我们尝试实现先前在山地车问题中解释过的 SARSA 算法。 该程序的初始部分与先前的 Q 学习器具有相似之处。
 
 首先，我们将使用以下代码导入依赖项并检查山地车环境：
 
@@ -1506,6 +1506,6 @@ Episode 10 completed with total reward 213.212231118 in 786 steps
 
 我们知道强化学习可以优化环境中智能体的回报，**马尔可夫决策过程**（**MDP**）是一种环境表示和数学框架，用于使用状态对决策进行建模 ，动作和奖励。 在本章中，我们了解到 Q 学习是一种无需任何过渡模型即可为任何 MDP 找到最佳动作选择策略的方法。 另一方面，如果给出了转换模型，则值迭代会为任何 MDP 找到最佳的动作选择策略。
 
-我们还学习了另一个重要的话题，称为深度 Q 网络，这是一种经过改进的 Q 学习方法，它采用深度神经网络作为函数逼近器来在不同环境中进行泛化，这与特定于环境的 Q 表不同。 此外，我们还学会了在 OpenAI 体育馆环境中实施 Q 学习，深度 Q 网络和 SARSA 算法。 先前显示的大多数实现可能在具有更好的超参数值和更多训练集的情况下效果更好。
+我们还学习了另一个重要的话题，称为深度 Q 网络，这是一种经过改进的 Q 学习方法，它采用深度神经网络作为函数逼近器来在不同环境中进行泛化，这与特定于环境的 Q 表不同。 此外，我们还学会了在 OpenAI 体育馆环境中实现 Q 学习，深度 Q 网络和 SARSA 算法。 先前显示的大多数实现可能在具有更好的超参数值和更多训练集的情况下效果更好。
 
 在下一章中，我们将详细介绍著名的异步优势参与者批评算法。
\ No newline at end of file

new/rl-tf/07.md

@@ -32,7 +32,7 @@ Brett Sperry 首先使用术语**实时策略**（**RTS**）作为宣传其游
 
 # 强化学习和其他方法
 
-已经设计出许多方法来解决实时策略游戏的问题。 强化学习之前的主要方法之一是**基于案例的在线规划**。 基于案例的在线计划涉及基于案例的实时推理。 在基于案例的推理中，使用了一组方法来学习计划。 基于案例的在线计划在实施计划获取和执行的同时也实时地实现了此属性。
+已经设计出许多方法来解决实时策略游戏的问题。 强化学习之前的主要方法之一是**基于案例的在线规划**。 基于案例的在线计划涉及基于案例的实时推理。 在基于案例的推理中，使用了一组方法来学习计划。 基于案例的在线计划在实现计划获取和执行的同时也实时地实现了此属性。
 
 # 基于案例的在线计划
 
@@ -60,7 +60,7 @@ Brett Sperry 首先使用术语**实时策略**（**RTS**）作为宣传其游
 
 基于案例的在线计划
 
-如图所示，基于案例的在线计划具有两个额外的流程，相对于基于案例的推理，这些流程有很小的变化，以实时实施计划和执行。 这两个过程如下：
+如图所示，基于案例的在线计划具有两个额外的流程，相对于基于案例的推理，这些流程有很小的变化，以实时实现计划和执行。 这两个过程如下：
 
 *   扩展：此过程将当前适应的解决方案作为输入，并找到未解决的子问题，即子目标，如果有任何可检索和可解决的未解决子目标。 如果世界状态发生的变化足以使当前解决方案发生变化，它还会监视世界状态并将信号发送到适配模块。 这称为**延迟自适应**，在运行期间执行。 该流程模块使在线基于案例的计划在动态环境中工作。
 *   执行：这将执行当前解决方案并根据执行结果更新其状态。 如果子问题失败，导致当前解决方案在执行时失败，则此过程通过将当前信息发送到扩展模块以查找替代解决方案来更新当前解决方案，以缓解此问题。
@@ -90,7 +90,7 @@ Brett Sperry 首先使用术语**实时策略**（**RTS**）作为宣传其游
 
 # RTS 游戏中的强化学习
 
-在这里，我们将讨论如何实施强化学习算法来解决实时策略游戏问题。 让我们再次回顾强化学习的基本组成部分，它们如下：
+在这里，我们将讨论如何实现强化学习算法来解决实时策略游戏问题。 让我们再次回顾强化学习的基本组成部分，它们如下：
 
 *   状态`S`
 *   动作`A`

new/rl-tf/08.md

@@ -232,4 +232,4 @@ AlphaGo Zero 进行的蒙特卡罗树搜索，摘录自 Google DeepMind 的 Silv
 
 在本章中，我们研究了目前最好的强化学习架构，即 AlphaGo。 我们了解了选择围棋的原因及其相对于象棋的复杂性。 我们还了解了 DeepBlue AI 架构的工作原理，以及围棋需要一种不同的更好的架构和训练过程。 我们研究了 AlphaGo 和 AlphaGo Zero 使用的架构和训练过程，还了解了版本之间的差异以及 AlphaGo Zero 如何超越其早期版本。
 
-在下一章中，我们将研究如何在自动驾驶和自动驾驶汽车中使用和实施强化学习。
\ No newline at end of file
+在下一章中，我们将研究如何在自动驾驶和自动驾驶汽车中使用和实现强化学习。
\ No newline at end of file

new/rl-tf/09.md

@@ -175,7 +175,7 @@ DeepTraffic 由一条高速公路带组成，该高速公路带显示了同时
 *   减速中
 *   没做什么
 
-对于其他汽车，将按照现实的模式随机选择动作，例如，由于随机选择动作，不会太频繁地改变车道。 以红色（深灰色）显示的汽车由深度强化学习代理控制。 竞争对手获得以 DQN 实施的预定义神经网络。 任务是配置不同的超参数并获得最佳性能，即最高平均速度。
+对于其他汽车，将按照现实的模式随机选择动作，例如，由于随机选择动作，不会太频繁地改变车道。 以红色（深灰色）显示的汽车由深度强化学习代理控制。 竞争对手获得以 DQN 实现的预定义神经网络。 任务是配置不同的超参数并获得最佳性能，即最高平均速度。
 
 # 总结
 

new/rl-tf/10.md

 # 金融投资组合管理
 
-金融投资组合是将资金分配到不同金融产品中的过程。 在项目组合管理中实施深度学习一直是人工智能界的一个研究部门。 随着强化学习的进步，在创建免费的无财务模型的强化学习框架以产生端到端的财务组合管理代理方面，人们进行了积极的研究。
+金融投资组合是将资金分配到不同金融产品中的过程。 在项目组合管理中实现深度学习一直是人工智能界的一个研究部门。 随着强化学习的进步，在创建免费的无财务模型的强化学习框架以产生端到端的财务组合管理代理方面，人们进行了积极的研究。
 
 投资组合管理是一个连续的决策过程，将资金重新分配到众多不同的金融产品中，以期获得最大的回报。
 

new/rl-tf/11.md

@@ -2,7 +2,7 @@
 
 到目前为止，我们已经看到了强化学习在 AlphaGo，自动驾驶，项目组合管理等方面的进步。 研究表明，强化学习可以提供认知特征，例如动物行为。
 
-与认知科学的紧密比较将是动态机器人系统和自动驾驶中强化学习的许多成功实施。 他们证明了将强化学习算法用于物理系统实时控制的理论。
+与认知科学的紧密比较将是动态机器人系统和自动驾驶中强化学习的许多成功实现。 他们证明了将强化学习算法用于物理系统实时控制的理论。
 
 在深度 Q 网络和策略梯度中使用神经网络可消除对人工设计的策略和状态表示的使用。 在深度强化学习中直接使用 CNN 并使用图像像素代替手工设计的功能作为状态已成为广泛接受的实践。 小型批量训练以及单独的主要网络和目标网络的概念为深度强化学习算法带来了成功。 在以像素为输入的 50 场 Atari 2600 游戏中，DeepMind 和深度强化学习的成功实现了超人的性能水平，这是强化学习研究的转折点。
 
@@ -12,7 +12,7 @@
 
 诸如处理连续动作空间域的策略梯度之类的算法归为**连续动作空间**（**CAS**）算法。 因此，在行动空间上提供随机表示的基于策略的方法解决了该问题，而不是 DAS 算法中的离散化。 CAS 算法最初是开发并用于低维状态空间，后来使用基于 CNN 的架构扩展到高维状态空间。 CAS 算法分为两个子类别：**随机连续动作空间**（**SCAS**）和**确定性连续动作空间**（**DCAS**）算法。 它们之间的主要区别在于复杂性，因为 SCAS 算法提供了更好的覆盖范围，因此需要大量的训练样本来学习更好的策略。 在现实世界的机器人应用中获取大量训练样本是非常不可行的，因此，仿真必须以尽可能最佳的方式表示现实世界，否则生成现实世界的数据将非常昂贵。
 
-确定性策略梯度的发现超过了随机策略算法，如 [Silver 等人](http://proceedings.mlr.press/v32/silver14.pdf)所述，该技术已包含在[附录 A](../Text/15.html) 中， “强化学习”中的其他主题。 在本章中，我们将介绍机器人强化学习背后的挑战以及当前如何实施机器人强化学习。
+确定性策略梯度的发现超过了随机策略算法，如 [Silver 等人](http://proceedings.mlr.press/v32/silver14.pdf)所述，该技术已包含在[附录 A](../Text/15.html) 中， “强化学习”中的其他主题。 在本章中，我们将介绍机器人强化学习背后的挑战以及当前如何实现机器人强化学习。
 
 本章将讨论的主题包括：
 
@@ -86,7 +86,7 @@ Perkins 和 Barto（2002）提出了一种基于 Lyapunov 函数构造强化学
 *   实时创建学习模型以输出要采取的最佳措施
 *   延迟接收动作信号和致动导致机器人中的机器运动
 
-由于这些延迟，动作无法立即实施，从而导致延迟效果。 在诸如**马尔科夫决策过程**（**MDP**）之类的强化学习算法中，假定动作会瞬间影响环境，而忽略了与现实世界相关的延迟。 可以通过汇总一些最近的操作并将其提供给州来解决此问题，但这也将导致尺寸的增加（在上一节中讨论的机器人强化学习中的挑战）。 解决该问题的另一种方法是增加时间步长，但这有两个缺点，一个缺点是妨碍了机器人的控制，第二个缺点是由于持续时间的变化而对系统的动态产生不利影响。
+由于这些延迟，动作无法立即实现，从而导致延迟效果。 在诸如**马尔科夫决策过程**（**MDP**）之类的强化学习算法中，假定动作会瞬间影响环境，而忽略了与现实世界相关的延迟。 可以通过汇总一些最近的操作并将其提供给州来解决此问题，但这也将导致尺寸的增加（在上一节中讨论的机器人强化学习中的挑战）。 解决该问题的另一种方法是增加时间步长，但这有两个缺点，一个缺点是妨碍了机器人的控制，第二个缺点是由于持续时间的变化而对系统的动态产生不利影响。
 
 因此，我们总结了如下讨论的实际挑战：
 

new/rl-tf/14.md

@@ -248,6 +248,6 @@ DCN 在答案的开始位置创建概率分布，并在答案的结束位置创
 
 # 总结
 
-在本章中，我们学习了强化学习如何破坏 NLP 的领域。 我们研究了在 NLP 中使用强化学习的原因。 我们涵盖了 NLP 中的两个主要应用领域，即文本摘要和问题回答，并了解了在现有模型中如何实施强化学习框架以获得最新结果的基础。 NLP 中还有其他实施了强化学习的应用程序领域，例如对话生成和机器翻译（讨论它们不在本书的范围之内）。
+在本章中，我们学习了强化学习如何破坏 NLP 的领域。 我们研究了在 NLP 中使用强化学习的原因。 我们涵盖了 NLP 中的两个主要应用领域，即文本摘要和问题回答，并了解了在现有模型中如何实现强化学习框架以获得最新结果的基础。 NLP 中还有其他实现了强化学习的应用程序领域，例如对话生成和机器翻译（讨论它们不在本书的范围之内）。
 
-这使我们结束了深度强化学习的惊人旅程。 我们通过了解概念开始了基础知识，然后使用 TensorFlow 和 OpenAI Gym 实施了这些概念，然后遍历了很酷的研究领域，在这些领域中正在实施核心强化学习。 我希望旅途很有趣，我们能够建立最好的基础。
\ No newline at end of file
+这使我们结束了深度强化学习的惊人旅程。 我们通过了解概念开始了基础知识，然后使用 TensorFlow 和 OpenAI Gym 实现了这些概念，然后遍历了很酷的研究领域，在这些领域中正在实现核心强化学习。 我希望旅途很有趣，我们能够建立最好的基础。
\ No newline at end of file