2021-01-21 20:51:34

new/dl-pt-workshop/7.md

@@ -1536,7 +1536,7 @@
 
     图 6.26：显示索引 1 到 52 列的数据集
 
-3.  绘制从整个数据集中随机选择的五种产品的每周销售交易情况。在进行随机抽样时，使用随机种子`0`，以达到与当前活动相同的结果。
+3.  绘制从整个数据集中随机选择的五种产品的每周销售交易情况。在进行随机采样时，使用随机种子`0`，以达到与当前活动相同的结果。
 
     ```py
     plot_data = data.sample(5, random_state=0)

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

@@ -328,7 +328,7 @@ plt.savefig('maml_output.png')
 
 让我们开始！
 
-元学习算法优化了模型快速学习新任务的能力。 为此，他们使用跨各种任务收集的数据，并根据其学习新的元测试任务的能力进行评估。 此过程可以形式化为学习数据（一系列任务）的先验知识（即提取重要信息），并且微调过程成为在学习到的先验知识下的推论：
+元学习算法优化了模型快速学习新任务的能力。 为此，他们使用跨各种任务收集的数据，并根据其学习新的元测试任务的能力进行评估。 此过程可以形式化为学习数据（一系列任务）的先验知识（即提取重要信息），并且微调过程成为在学习到的先验知识下的推断：
 
 1.  导入所有库：
 

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

@@ -149,7 +149,7 @@ K 次学习的一种非常常见的方法是训练具有相关任务的大型模
 
 # 权重的概率模型
 
-假设由于最大数据集 <sub>![](img/403250cc-771e-4aee-a332-d513338fbc0e.png)</sub> 而在第一阶段获知的 softmax 权重 <sub>![](img/daa1d70f-57d4-454b-a485-a90bcffda0f7.png)</sub> 的不确定性很小。 将此近似值与上图中的图形模型结构结合起来，我们可以摆脱原始数据集 <sub>![](img/68914ee7-4e63-4366-829d-00766394cd7a.png)</sub> ，并使用 <sub>![](img/78fc4afd-1c3e-4ddc-a0d3-b0c3204109fc.png)</sub> 的 MAP 估算值（ <sub>![](img/9eb067e3-a492-42d9-ad39-01cc56e6c75e.png)</sub> ）处于概念学习和 K 次学习阶段。 完整的概率模型遵循以下步骤：
+假设由于最大数据集 <sub>![](img/403250cc-771e-4aee-a332-d513338fbc0e.png)</sub> 而在第一阶段获知的 softmax 权重 <sub>![](img/daa1d70f-57d4-454b-a485-a90bcffda0f7.png)</sub> 的不确定性很小。 将此近似值与上图中的图形模型结构结合起来，我们可以摆脱原始数据集 <sub>![](img/68914ee7-4e63-4366-829d-00766394cd7a.png)</sub> ，并使用 <sub>![](img/78fc4afd-1c3e-4ddc-a0d3-b0c3204109fc.png)</sub> 的 MAP 估计值（ <sub>![](img/9eb067e3-a492-42d9-ad39-01cc56e6c75e.png)</sub> ）处于概念学习和 K 次学习阶段。 完整的概率模型遵循以下步骤：
 
 1.  K 次学习过程将信息合并到两个数据集 <sub>![](img/5bc40cb8-9d4b-48dd-a0b6-ec3398c621b5.png)</sub> 和 <sub>![](img/e7a90ae4-002f-42a9-8f17-5a5eee3be91b.png)</sub> 中，以在 <sub>![](img/bbb34fd1-52d7-4366-abe5-16af10f325df.png)</sub> 上生成后验分布：
 
@@ -204,7 +204,7 @@ K 次学习（等式 2）期间新权重![](img/211df3d3-5161-4ea1-9817-744ffa03
 
 # 第二阶段–概念学习
 
-概率模型直接适合于 MAP 权重 <sub>![](img/01b11f3a-0686-4edc-b119-3eccb26d356b.png)</sub> 。 对于共轭模型，后验分布是通过解析获得的。 否则，将使用 <sub>![](img/520f8b84-704b-4501-b74d-294304b03b84.png)</sub> 的 MAP 估算值。
+概率模型直接适合于 MAP 权重 <sub>![](img/01b11f3a-0686-4edc-b119-3eccb26d356b.png)</sub> 。 对于共轭模型，后验分布是通过解析获得的。 否则，将使用 <sub>![](img/520f8b84-704b-4501-b74d-294304b03b84.png)</sub> 的 MAP 估计值。
 
 # 第三阶段– K 次学习
 
@@ -212,7 +212,7 @@ K 次学习（等式 2）期间新权重![](img/211df3d3-5161-4ea1-9817-744ffa03
 
 # 第四阶段 – K 次测试
 
-K 次测试时间 <sub>![](img/c3734ba9-5a51-47ff-84f2-54c038662868.png)</sub> 的推论是难以理解的，因此此处使用近似值。 如果从阶段 3 开始使用 <sub>![](img/8ad46a3a-039b-4f21-9049-c640cc90b96b.png)</sub> （ <sub>![](img/e631a1e5-efaa-41e0-b3af-d080d5df4b7a.png)</sub> ）的 MAP 估计值，则 <sub>![](img/52f71d1d-16a5-446e-9276-d0e2faedd10c.png)</sub> 。 如果在阶段 3 中重新采样，则使用 <sub>![](img/858ad399-04bb-4869-aa0e-88ba105b2300.png)</sub> 。
+K 次测试时间 <sub>![](img/c3734ba9-5a51-47ff-84f2-54c038662868.png)</sub> 的推断是难以理解的，因此此处使用近似值。 如果从阶段 3 开始使用 <sub>![](img/8ad46a3a-039b-4f21-9049-c640cc90b96b.png)</sub> （ <sub>![](img/e631a1e5-efaa-41e0-b3af-d080d5df4b7a.png)</sub> ）的 MAP 估计值，则 <sub>![](img/52f71d1d-16a5-446e-9276-d0e2faedd10c.png)</sub> 。 如果在阶段 3 中重新采样，则使用 <sub>![](img/858ad399-04bb-4869-aa0e-88ba105b2300.png)</sub> 。
 
 在 miniImageNet 数据集（由 100 个类组成，每个类中包含 600 个图像）上，此方法可以一次学习一次和五次学习获得最先进的结果。 离统一概率模型和深度学习的领域又迈进了一步，将两者结合起来，可以开发出真正强大的模型，从而利用概率领域的强大数学保证和深度学习模型的强大健壮功能。 判别式 K 次学习方法仍然需要大量带标签的训练数据来训练基于深度学习的特征提取器。 另一方面，贝叶斯程序学习方法利用模型中的归纳偏差和手工设计的特征，因此需要较少的标注训练数据。
 
@@ -220,7 +220,7 @@ K 次测试时间 <sub>![](img/c3734ba9-5a51-47ff-84f2-54c038662868.png)</sub>
 
 在本章中，我们学习了在贝叶斯框架内开发概率模型的方法，该模型可以极大地减少数据需求并达到人类水平的性能。 从前面讨论的手写字符的示例中，我们还观察到概率模型不仅可以学习如何对字符进行分类，还可以学习基本概念，即以新的方式应用获得的知识，例如生成相似的字符并生成全新的 集合中只有几个字符的字符，以及将字符解析为部分和关系。
 
-但是，人类学习器需要从具有丰富重叠结构的许多经验中获得的广泛的先前经验来完成新的学习任务。 为了模仿人类学习，图形结构需要具有更多的依赖性，并且需要在模型中内置丰富的归纳偏差。 还应注意，人类在很小的时候就对物体的物理特性（形状，运动和其他力学）有很好的认识。 学习模型不会隐式地捕获对象的直观物理特性，也不会显式地将其嵌入对象中。 直观物理（类似于游戏引擎中嵌入的物理）与概率模型和深度学习的集成，是朝着更健壮的单发学习迈出的重要一步。 最后，由于先验知识以强先验和图形结构的形式嵌入到概率模型中，因此与必须从头学习任务的深度学习模型相比，它们的数据消耗更少。 但这是以在概率模型中进行有效推理的计算挑战为代价的。 在推论时，这些模型必须搜索巨大的概率空间，这对于现代计算机而言是不实际的。 相反，深度学习模型具有精确且计算上便宜的推断。 最近的工作通过使用前馈映射对*摊销*概率推理计算来解决图形模型中的这一推理挑战，可以使用成对的生成/识别网络来学习。 这提供了另一条有希望的研究领域，使深度学习和概率模型更加接近。
+但是，人类学习器需要从具有丰富重叠结构的许多经验中获得的广泛的先前经验来完成新的学习任务。 为了模仿人类学习，图形结构需要具有更多的依赖性，并且需要在模型中内置丰富的归纳偏差。 还应注意，人类在很小的时候就对物体的物理特性（形状，运动和其他力学）有很好的认识。 学习模型不会隐式地捕获对象的直观物理特性，也不会显式地将其嵌入对象中。 直观物理（类似于游戏引擎中嵌入的物理）与概率模型和深度学习的集成，是朝着更健壮的单发学习迈出的重要一步。 最后，由于先验知识以强先验和图形结构的形式嵌入到概率模型中，因此与必须从头学习任务的深度学习模型相比，它们的数据消耗更少。 但这是以在概率模型中进行有效推理的计算挑战为代价的。 在推断时，这些模型必须搜索巨大的概率空间，这对于现代计算机而言是不实际的。 相反，深度学习模型具有精确且计算上便宜的推断。 最近的工作通过使用前馈映射对*摊销*概率推理计算来解决图形模型中的这一推理挑战，可以使用成对的生成/识别网络来学习。 这提供了另一条有希望的研究领域，使深度学习和概率模型更加接近。
 
 # 进一步阅读
 

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

@@ -26,13 +26,13 @@
 
 图 1.1 –显示住房数据的表格
 
-在这里，我们已经得到的信息，包括最近出售的四栋房屋的大小，以及他们出售的的价格。 根据这四所房屋的数据，我们能否使用此信息对市场上的新房屋做出预测？ 一个简单的称为**回归**的机器学习模型可以估算以下两个因素之间的关系：
+在这里，我们已经得到的信息，包括最近出售的四栋房屋的大小，以及他们出售的的价格。 根据这四所房屋的数据，我们能否使用此信息对市场上的新房屋做出预测？ 一个简单的称为**回归**的机器学习模型可以估计以下两个因素之间的关系：
 
 ![Figure 1.2 – Output of the housing data ](img/B12365_01_2.jpg)
 
 图 1.2 –外壳数据输出
 
-给定此历史数据，我们可以使用此数据来估计**大小**（`X`）和**价格**（`Y`）之间的关系。 现在我们已经估算了大小和价格之间的关系，如果给了我们只知道房子大小的新房子，我们可以使用学习的函数使用它来预测价格：
+给定此历史数据，我们可以使用此数据来估计**大小**（`X`）和**价格**（`Y`）之间的关系。 现在我们已经估计了大小和价格之间的关系，如果给了我们只知道房子大小的新房子，我们可以使用学习的函数使用它来预测价格：
 
 ![Figure 1.3 – Predicting house prices ](img/B12365_01_3.jpg)
 

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

@@ -510,7 +510,7 @@ Figure 9.20 – Bi-directional LSTM (SLING)
 
 从 NLP 的角度来看，自然语言的歧义使其成为一项有趣的任务。 两个句子可以具有不同的句法结构，不同的语义结构，并且由完全不同的单词组成，但含义仍然非常相似。 同样，两个句子可以由相同的词和实体组成，但含义却大不相同。
 
-在这里，使用模型来量化文本的含义特别有用。 文本蕴含也是一个独特的问题，因为两个句子可能没有完全相同的含义，但是仍然可以从另一个推断出一个句子。 这需要在大多数语言模型中不存在的语言推论元素。 通过将语言推论的元素纳入我们未来的模型中，我们可以更好地捕获文本的含义，并且能够确定两个文本是否包含相同的信息，而无论它们的表示形式是否相似。
+在这里，使用模型来量化文本的含义特别有用。 文本蕴含也是一个独特的问题，因为两个句子可能没有完全相同的含义，但是仍然可以从另一个推断出一个句子。 这需要在大多数语言模型中不存在的语言推断元素。 通过将语言推断的元素纳入我们未来的模型中，我们可以更好地捕获文本的含义，并且能够确定两个文本是否包含相同的信息，而无论它们的表示形式是否相似。
 
 幸运的是，创建简单的文本包含模型并不困难，并且已证明基于 LSTM 的模型是有效的。 可能证明有效的一种设置是连体 LSTM 网络的设置。
 

new/pt-ai-fund/3.md

@@ -371,7 +371,7 @@ PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为
 
 在本秘籍中，我们将学习有关使用火炬进行数据扩充的知识。 数据扩充是深度学习和计算机视觉中的一项重要技术。 对于任何涉及深度学习或计算机视觉的模型，可用的数据量对于查看模型的性能至关重要。 数据扩充可防止模型记住有限数量的数据，而不是对观察到的数据进行概括。 数据扩充通过从原始图像创建变量而不实际收集新数据来增加用于训练模型的数据的多样性。
 
-通常，光量，亮度，方向或颜色变化不会影响模型所做的推论。 但是，当模型在现实世界中部署时，输入数据可能会有这些变化。 对于模型来说，知道其做出的决定必须相对于输入中的这些变化是不变的，这很有用，因此数据扩充可以提高模型的性能。 在本秘籍中，我们将使用 PyTorch 的`transform`模块执行数据扩充。
+通常，光量，亮度，方向或颜色变化不会影响模型所做的推断。 但是，当模型在现实世界中部署时，输入数据可能会有这些变化。 对于模型来说，知道其做出的决定必须相对于输入中的这些变化是不变的，这很有用，因此数据扩充可以提高模型的性能。 在本秘籍中，我们将使用 PyTorch 的`transform`模块执行数据扩充。
 
 # 操作步骤
 

new/pt-ai-fund/7.md

@@ -147,7 +147,7 @@ Q 值可以更新如下：
 
 新的 Q 值是两个部分的总和。 第一部分是`(1 - 学习率) * 旧 Q 值`，它是多少旧值将被记住。 学习率为 0 时，不会学习任何新内容，学习率为 1 时，所有旧值都将被忘记。
 
-第二部分是**学习率*（即时行动奖励+最优未来价值的折算估算）**，其中学习值是即时奖励加上最优未来价值的折算估算。 未来奖励的重要性由折扣系数决定。
+第二部分是**学习率*（即时行动奖励+最优未来价值的折算估计）**，其中学习值是即时奖励加上最优未来价值的折算估计。 未来奖励的重要性由折扣系数决定。
 
 通过深度 Q 学习，我们可以使用深度神经网络来预测动作的 Q 值，并使用深度神经网络来选择动作，而不是使用 Q 表查找给定状态下具有最大可能 Q 值的动作。 给定动作的最大 Q 值。
 
@@ -314,11 +314,11 @@ if not self.explore_limit:
 
 # 工作原理
 
-在本秘籍中，我们完成了 DQN 类，并添加了所有必需的功能来训练 DQN。 在构造函数中，我们初始化了探索的初始状态，观察空间和动作空间，然后定义了一个存储单元来保存 DQN 的经验。 我们创建了称为`policy_net`和`target_net`的软骨模型的两个实例。 我们需要两个网络，因为在训练的每个步骤中，Q 网络的值都会移动，并且如果我们使用不断变化的目标值来调整我们的网络，则该网络可能会由于陷入此变化的目标与估计的 Q 值之间的反馈回路而变得不稳定。 网络值。 如果发生这种情况，价值估算将失去控制。 因此，我们使用了两个网络并将`target_net`保持在`eval`模式。 然后，我们使用`MSELoss()`作为损失函数以及`Adam`优化器来更新权重。
+在本秘籍中，我们完成了 DQN 类，并添加了所有必需的功能来训练 DQN。 在构造函数中，我们初始化了探索的初始状态，观察空间和动作空间，然后定义了一个存储单元来保存 DQN 的经验。 我们创建了称为`policy_net`和`target_net`的软骨模型的两个实例。 我们需要两个网络，因为在训练的每个步骤中，Q 网络的值都会移动，并且如果我们使用不断变化的目标值来调整我们的网络，则该网络可能会由于陷入此变化的目标与估计的 Q 值之间的反馈回路而变得不稳定。 网络值。 如果发生这种情况，价值估计将失去控制。 因此，我们使用了两个网络并将`target_net`保持在`eval`模式。 然后，我们使用`MSELoss()`作为损失函数以及`Adam`优化器来更新权重。
 
 在`load_memory()`方法中，我们从环境中存储了状态，操作，奖励，下一个状态和终端，以用于训练网络。 我们使用的下一个方法是`predict_action`。 在此方法中，我们使用`np.random.rand()`选择了`random_number`，这为我们提供了`[0,1)`的值。 如果此`random_number`小于当前的`exploration_rate`，则我们选择一个随机动作，该动作由`exploration_rate`控制。 这就是我们合并探索的方式。 但是，如果`random_number`大于`exploration_rate`，则`target_net`会预测`q_values`并选择具有最大 Q 值的动作。
 
-最后，我们实现了`experience_replay`方法。 在这里，我们等待数据点的数量至少为`BATCH_SIZE`，然后从内存中随机抽样一批。 这使它可以从一系列不同的观察中学习，而不是从一系列紧密相关的观察中学习。 遍历批量时，我们使用`target_net`根据 Q 值更新公式更新了 Q 值。 然后，我们根据新 Q 值与`policy_net`预测的 Q 值之间的误差训练了`policy_net`。 之后，通过将其乘以探索衰减量逐渐降低探索速率，直到获得最低探索速率。 我们这样做是因为，在训练的初始阶段，我们希望代理人进行更多探索； 但是，随着训练的进行，我们希望算法能够收敛。 至此，我们已经完成了 DQN 类的所有功能。
+最后，我们实现了`experience_replay`方法。 在这里，我们等待数据点的数量至少为`BATCH_SIZE`，然后从内存中随机采样一批。 这使它可以从一系列不同的观察中学习，而不是从一系列紧密相关的观察中学习。 遍历批量时，我们使用`target_net`根据 Q 值更新公式更新了 Q 值。 然后，我们根据新 Q 值与`policy_net`预测的 Q 值之间的误差训练了`policy_net`。 之后，通过将其乘以探索衰减量逐渐降低探索速率，直到获得最低探索速率。 我们这样做是因为，在训练的初始阶段，我们希望代理人进行更多探索； 但是，随着训练的进行，我们希望算法能够收敛。 至此，我们已经完成了 DQN 类的所有功能。
 
 # 更多
 

new/pt-dl-handson/7.md

@@ -196,7 +196,7 @@ Q 学习是一种非策略算法，因此，在 Q 学习中，我们将有两个
 Transition = namedtuple('Transition', ('state', 'action', 'next_state', 'reward'))
 ```
 
-我们将随机抽样一些经验或交易，并在优化模型时向他们学习。
+我们将随机采样一些经验或交易，并在优化模型时向他们学习。
 
 ```py
 class ReplayMemory(object):

new/pt-tut-17/28.md

-# 从零开始的 NLP：使用字符级 RNN 的名称分类
+# 从零开始的 NLP：使用字符级 RNN 分类名称
 
 > 原文：<https://pytorch.org/tutorials/intermediate/char_rnn_classification_tutorial.html>
 

new/pt-tut-17/29.md

@@ -331,7 +331,7 @@ plt.plot(all_losses)
 
 ![../_img/sphx_glr_char_rnn_generation_tutorial_001.png](img/5ad82e2b23a82287af2caa2fe4b316b3.png)
 
-## 网络抽样
+## 网络采样
 
 为了示例，我们给网络一个字母，询问下一个字母是什么，将其作为下一个字母输入，并重复直到 EOS 令牌。
 

new/pt-tut-17/30.md

-# 从零开始的 NLP：从序列到序列网络的翻译和注意
+# 从零开始的 NLP：使用序列到序列网络的翻译和注意力
 
 > 原文：<https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html>
 
@@ -319,7 +319,7 @@ class DecoderRNN(nn.Module):
 
 我鼓励您训练并观察该模型的结果，但是为了节省空间，我们将直接努力并引入注意力机制。
 
-#### 注意解码器
+#### 注意力解码器
 
 如果仅上下文向量在编码器和解码器之间传递，则该单个向量承担对整个句子进行编码的负担。
 
@@ -529,7 +529,7 @@ def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, lear
 
 ```
 
-### 绘图结果
+### 绘制结果
 
 使用训练时保存的损失值数组`plot_losses`，使用 matplotlib 进行绘制。
 
@@ -699,7 +699,7 @@ evaluateRandomly(encoder1, attn_decoder1)
 
 ```
 
-### 可视化注意
+### 可视化注意力
 
 注意力机制的一个有用特性是其高度可解释的输出。 因为它用于加权输入序列的特定编码器输出，所以我们可以想象一下在每个时间步长上网络最关注的位置。
 

new/pt-tut-17/31.md

@@ -119,7 +119,7 @@ def generate_batch(batch):
 
 ```
 
-## 定义函数以训练模型并评估结果。
+## 定义函数来训练模型并评估结果
 
 建议 PyTorch 用户使用[`torch.utils.data.DataLoader`](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader)，它可以轻松地并行加载数据（[教程在这里](https://pytorch.org/tutorials/beginner/data_loading_tutorial.html)）。 我们在此处使用`DataLoader`加载`AG_NEWS`数据集，并将其发送到模型以进行训练/验证。
 

new/pt-tut-17/34.md

@@ -60,9 +60,9 @@ device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 ```
 
-## 重播内存
+## 回放记忆
 
-我们将使用经验回放记忆来训练我们的 DQN。 它存储代理观察到的转换，使我们以后可以重用此数据。 通过从中随机抽样，可以构建批量的转换相关。 已经表明，这极大地稳定和改善了 DQN 训练程序。
+我们将使用经验回放记忆来训练我们的 DQN。 它存储代理观察到的转换，使我们以后可以重用此数据。 通过从中随机采样，可以构建批量的转换相关。 已经表明，这极大地稳定和改善了 DQN 训练程序。
 
 为此，我们将需要两个类：
 
@@ -121,7 +121,7 @@ Q 学习的主要思想是，如果我们有一个函数`Q*：State x Action =>
 
 ![](img/tex34-4.gif)
 
-### Q-network
+### Q 网络
 
 我们的模型将是一个卷积神经网络，该卷积神经网络将吸收当前屏幕补丁和先前屏幕补丁之间的差异。 它有两个输出，分别代表`Q(s, left)`和`Q(s, right)`（其中`s`是网络的输入）。 实际上，网络正在尝试预测在给定当前输入的情况下执行每个操作的*预期收益*。
 

new/pt-tut-17/35.md

@@ -161,7 +161,7 @@ env = FrameStack(env, num_stack=4)
 
 ![picture](img/ad48ffbd1cfc0475d744b8b89a0d962a.png)
 
-## 代理
+## 智能体
 
 我们创建一个类`Mario`来表示我们的代理在游戏中。 马里奥应该能够：
 
@@ -194,7 +194,7 @@ class Mario:
 
 在以下各节中，我们将填充马里奥的参数并定义其功能。
 
-### 法案
+### 行动
 
 对于任何给定状态，代理都可以选择执行最佳操作（**利用**）或执行随机操作（**探索**）。
 
@@ -255,7 +255,7 @@ class Mario:
 
 ```
 
-### 缓存和调用
+### 缓存和回忆
 
 这两个功能是马里奥的“记忆”过程。
 
@@ -359,7 +359,7 @@ class MarioNet(nn.Module):
 
 ```
 
-#### TD 估算和 TD 目标
+#### TD 估计和 TD 目标
 
 学习涉及两个值：
 

new/pt-tut-17/37.md

-# 通过带有 Flask 的 REST API 在 Python 中部署 PyTorch
+# 通过使用 Flask 的 REST API 在 Python 中部署 PyTorch
 
 > 原文：<https://pytorch.org/tutorials/intermediate/flask_rest_api_tutorial.html>
 
@@ -77,7 +77,7 @@ def predict():
 
 ```
 
-## 推论
+## 推断
 
 在下一部分中，我们将重点介绍编写推理代码。 这将涉及两部分，第一部分是准备图像，以便可以将其馈送到 DenseNet；第二部分，我们将编写代码以从模型中获取实际的预测。
 

new/pt-tut-17/38.md

@@ -36,7 +36,7 @@ print(torch.__version__)
 
 ```
 
-## PyTorch 模型创作基础
+## PyTorch 模型创建基础
 
 首先定义一个简单的`Module`。 `Module`是 PyTorch 中组成的基本单位。 它包含：
 

new/pt-tut-17/39.md

@@ -42,9 +42,9 @@ Out[2]: tensor([-0.2698, -0.0381,  0.4023, -0.3010, -0.0448], grad_fn=<SliceBack
 
 ```
 
-### 通过注释转换为 Torch 脚本
+### 通过注解转换为 Torch 脚本
 
-在某些情况下，例如，如果模型采用特定形式的控制流，则可能需要直接在 Torch 脚本中编写模型并相应地注释模型。 例如，假设您具有以下原始 Pytorch 模型：
+在某些情况下，例如，如果模型采用特定形式的控制流，则可能需要直接在 Torch 脚本中编写模型并相应地注解模型。 例如，假设您具有以下原始 Pytorch 模型：
 
 ```py
 import torch
@@ -83,13 +83,13 @@ sm = torch.jit.script(my_module)
 
 ```
 
-如果您需要在`nn.Module`中排除某些方法，因为它们使用的是 TorchScript 不支持的 Python 功能，则可以使用`@torch.jit.ignore`来注释这些方法
+如果您需要在`nn.Module`中排除某些方法，因为它们使用的是 TorchScript 不支持的 Python 功能，则可以使用`@torch.jit.ignore`来注解这些方法
 
 `my_module`是已准备好进行序列化的`ScriptModule`的实例。
 
 ## 第 2 步：将脚本模块序列化为文件
 
-跟踪或注释 PyTorch 模型后，一旦有了`ScriptModule`，就可以将其序列化为文件了。 稍后，您将能够使用 C++ 从此文件加载模块并执行它，而无需依赖 Python。 假设我们要序列化先前在跟踪示例中显示的`ResNet18`模型。 要执行此序列化，只需在模块上调用[`save`](https://pytorch.org/docs/master/jit.html#torch.jit.ScriptModule.save)并为其传递文件名：
+跟踪或注解 PyTorch 模型后，一旦有了`ScriptModule`，就可以将其序列化为文件了。 稍后，您将能够使用 C++ 从此文件加载模块并执行它，而无需依赖 Python。 假设我们要序列化先前在跟踪示例中显示的`ResNet18`模型。 要执行此序列化，只需在模块上调用[`save`](https://pytorch.org/docs/master/jit.html#torch.jit.ScriptModule.save)并为其传递文件名：
 
 ```py
 traced_script_module.save("traced_resnet_model.pt")
@@ -135,7 +135,7 @@ int main(int argc, const char* argv[]) {
 
 `<torch/script.h>`标头包含了运行示例所需的 LibTorch 库中的所有相关包含。 我们的应用接受序列化的 PyTorch `ScriptModule`的文件路径作为其唯一的命令行参数，然后继续使用`torch::jit::load()`函数对该模块进行反序列化，该函数将该文件路径作为输入。 作为回报，我们收到一个`torch::jit::script::Module`对象。 我们将稍后讨论如何执行它。
 
-### 取决于 LibTorch 和构建应用
+### 依赖 LibTorch 并构建应用
 
 假设我们将以上代码存储到名为`example-app.cpp`的文件中。 最小的`CMakeLists.txt`构建起来看起来很简单：
 

new/pt-tut-17/40.md

-# （可选）将模型从 PyTorch 导出到 ONNX 并使用 ONNX 运行时运行它
+# 将模型从 PyTorch 导出到 ONNX 并使用 ONNX 运行时运行它（可选）
 
 > 原文：<https://pytorch.org/tutorials/advanced/super_resolution_with_onnxruntime.html>
 

new/rl-tf/01.md

@@ -176,7 +176,7 @@ ReLU 的导数图，对于`x <= 0`，`f'(x) = 1`，对于`x > 0`，`f'(x) = 0`
 
 # 如何选择正确的激活函数
 
-激活函数取决于问题陈述的目的和所关注的属性。 一些推论如下：
+激活函数取决于问题陈述的目的和所关注的属性。 一些推断如下：
 
 *   Sigmoid 函数在浅层网络和二分类器的情况下效果很好。 较深的网络可能会导致梯度消失。
 

new/rl-tf/04.md

@@ -190,7 +190,7 @@ Episode T
 
 由于这些更新针对所有状态独立发生，因此可以针对所有状态并行执行这些操作。
 
-在完成情节的最后一步之后扩展每个州的计算值估计值时，我们发现基于值的更新与基于结果的更新相同，例如在蒙特卡洛方法中，我们会进行全面的展望，直到 剧集的结尾。 因此，我们需要一种更好的方法来更新我们的值函数估算值，而无需多做一步。 通过合并`TD(0)`规则，我们可以解决此问题。
+在完成情节的最后一步之后扩展每个州的计算值估计值时，我们发现基于值的更新与基于结果的更新相同，例如在蒙特卡洛方法中，我们会进行全面的展望，直到 剧集的结尾。 因此，我们需要一种更好的方法来更新我们的值函数估计值，而无需多做一步。 通过合并`TD(0)`规则，我们可以解决此问题。
 
 # `TD(0)`规则
 

new/rl-tf/05.md

@@ -59,7 +59,7 @@ DeepMind 在研究期刊 **Nature** 上发表了他们的论文[《通过深度
 
 # 蒙特卡洛学习
 
-蒙特卡洛（Monte Carlo）是用于模型免费学习的最简单方法，在该方法中，代理会观察情节中前进的所有步骤（即前瞻）的回报。 因此，在时间`t`时的总估算报酬为![](img/3dc9f398-49e4-4d6c-9ad4-35090d9306ff.png)：
+蒙特卡洛（Monte Carlo）是用于模型免费学习的最简单方法，在该方法中，代理会观察情节中前进的所有步骤（即前瞻）的回报。 因此，在时间`t`时的总估计报酬为![](img/3dc9f398-49e4-4d6c-9ad4-35090d9306ff.png)：
 
 ![](img/142010fa-0c37-4b54-b47d-e27ca48bd3d6.png)
 
@@ -91,7 +91,7 @@ Repeat forever:
 
 时间差异学习是一种用于学习价值和策略迭代方法中的值函数以及 Q 学习中的 Q 函数的方法。
 
-如果我们希望我们的 AI 代理始终选择最大化折扣未来奖励的行动，那么我们需要某种时间差异学习。 为此，我们需要定义一个函数 Q，该函数表示当我们在状态`s`上执行动作`a`时最大的未来折扣。 因此，Q 函数表示给定状态下的动作质量。 使用它，我们可以通过仅了解当前状态和操作来估算最终得分，而在此之后无需进行任何操作。 因此，目标将是对具有最高 Q 值的状态采取该措施。 因此，我们必须通过称为 Q 学习的过程来学习此 Q 函数。
+如果我们希望我们的 AI 代理始终选择最大化折扣未来奖励的行动，那么我们需要某种时间差异学习。 为此，我们需要定义一个函数 Q，该函数表示当我们在状态`s`上执行动作`a`时最大的未来折扣。 因此，Q 函数表示给定状态下的动作质量。 使用它，我们可以通过仅了解当前状态和操作来估计最终得分，而在此之后无需进行任何操作。 因此，目标将是对具有最高 Q 值的状态采取该措施。 因此，我们必须通过称为 Q 学习的过程来学习此 Q 函数。
 
 # 策略内和策略外学习
 
@@ -405,7 +405,7 @@ end
 
 # 双 DQN
 
-使用**双重 DQN（DDQN）**的原因是常规 DQN 高估了在给定状态下可能采取的措施的 Q 值。 在常规 DQN 中，所有动作之间的高估都不相等。 因此，问题仍然存在：否则，所有行动之间的均等估算就不会成为问题。 结果，某些次优的行为获得了更高的价值，因此学习最佳策略的时间增加了。 这导致我们对常规 DQN 架构进行了少量修改，并导致了所谓的 DDQN，即双深度 Q 网络。
+使用**双重 DQN（DDQN）**的原因是常规 DQN 高估了在给定状态下可能采取的措施的 Q 值。 在常规 DQN 中，所有动作之间的高估都不相等。 因此，问题仍然存在：否则，所有行动之间的均等估计就不会成为问题。 结果，某些次优的行为获得了更高的价值，因此学习最佳策略的时间增加了。 这导致我们对常规 DQN 架构进行了少量修改，并导致了所谓的 DDQN，即双深度 Q 网络。
 
 在 DDQN 中，我们不是在训练过程中计算目标 Q 值时取最大 Q 值，而是使用主要网络选择操作，并使用目标网络为该操作生成目标 Q 值。 这使动作脱钩。 从目标 Q 网络中进行选择，生成目标 Q 值，从而减少高估，并有助于更快地进行训练。 DDQN 中的目标 Q 值通过以下公式更新：
 

new/rl-tf/06.md

@@ -152,7 +152,7 @@ repeat until  :
 
 # 异步 N 步 Q 学习
 
-异步 N 步 Q 学习的架构在某种程度上类似于异步单步 Q 学习的架构。 区别在于，使用探索策略最多选择![](img/934eccea-ab73-4d16-8dd9-6ae2bef78aa9.png)步骤或直到达到终端状态，才能选择学习代理动作，以便计算策略网络参数的单个更新。 此过程列出了自上次更新以来![](img/55e36559-5c3e-4598-b8a3-954b2a844161.png)来自环境的奖励。 然后，对于每个时间步长，将损失计算为该时间步长的折现未来奖励与估算 Q 值之间的差。 对于每个时间步长，此损耗相对于特定于线程的网络参数的梯度将被计算和累积。 有多个这样的学习代理并行运行和累积梯度。 这些累积的梯度用于执行策略网络参数的异步更新。
+异步 N 步 Q 学习的架构在某种程度上类似于异步单步 Q 学习的架构。 区别在于，使用探索策略最多选择![](img/934eccea-ab73-4d16-8dd9-6ae2bef78aa9.png)步骤或直到达到终端状态，才能选择学习代理动作，以便计算策略网络参数的单个更新。 此过程列出了自上次更新以来![](img/55e36559-5c3e-4598-b8a3-954b2a844161.png)来自环境的奖励。 然后，对于每个时间步长，将损失计算为该时间步长的折现未来奖励与估计 Q 值之间的差。 对于每个时间步长，此损耗相对于特定于线程的网络参数的梯度将被计算和累积。 有多个这样的学习代理并行运行和累积梯度。 这些累积的梯度用于执行策略网络参数的异步更新。
 
 异步 N 步 Q 学习的伪代码如下所示。 这里，以下是全局参数：