2021-01-24 15:09:36

new/dl-pt-workshop/1.md

@@ -348,7 +348,7 @@ loss_funct = nn.MSELoss()
     output_units = 1
     ```
 
-3.  使用`Sequential()`容器，定义单层网络体系结构并将其存储在名为`model`的变量中。 确保定义一层，然后定义`Sigmoid`激活函数：
+3.  使用`Sequential()`容器，定义单层网络架构并将其存储在名为`model`的变量中。 确保定义一层，然后定义`Sigmoid`激活函数：
 
     ```py
     model = nn.Sequential(nn.Linear(input_units, output_units), \
@@ -439,7 +439,7 @@ for i in range(100):
     optimizer.step()
 ```
 
-对于每次迭代，调用模型以获得预测（`y_pred`）。 该预测和地面真实值（`y`）被馈送到损失函数，以确定模型逼近地面真实的能力。
+对于每次迭代，调用模型以获得预测（`y_pred`）。 该预测和真实情况值（`y`）被馈送到损失函数，以确定模型逼近真实情况的能力。
 
 接下来，将梯度归零，并使用`backward()`函数计算损失函数的梯度。
 

new/dl-pt-workshop/2.md

@@ -170,13 +170,13 @@ Rosenblatt 还介绍了权重的概念（`w1`，`w2`，...，`wn`），这些数
 
 ### 损失函数的计算
 
-一旦正向传播完成，训练过程的下一步就是计算损失函数，以通过比较预测相对于地面真实值的好坏来估计模型的误差。 考虑到这一点，要达到的理想值为 0，这意味着两个值之间没有差异。
+一旦正向传播完成，训练过程的下一步就是计算损失函数，以通过比较预测相对于真实情况值的好坏来估计模型的误差。 考虑到这一点，要达到的理想值为 0，这意味着两个值之间没有差异。
 
 这意味着训练过程的每次迭代的目标是通过更改在正向传播过程中用于执行计算的参数（权重和偏差）来最小化损失函数。
 
 同样，有多种损失函数可供选择。 但是，用于回归和分类任务的最常用损失函数如下：
 
-*   **均方误差（MSE）**：MSE 函数广泛用于衡量回归模型的性能，它计算地面真实值与预测值之间的距离之和：
+*   **均方误差（MSE）**：MSE 函数广泛用于衡量回归模型的性能，它计算真实情况值与预测值之间的距离之和：
 
 ![Figure 2.14: MSE loss function ](img/B15778_02_14.jpg)
 
@@ -268,7 +268,7 @@ Rosenblatt 还介绍了权重的概念（`w1`，`w2`，...，`wn`），这些数
 
     对于监督学习问题，输入数据包含一对特征和目标。 网络的工作是发现功能与目标之间的相关性或依赖性。
 
-2.  **隐藏层**：接下来，可以找到隐藏层。 神经网络可以具有许多隐藏层，这意味着在输入层和输出层之间可以有任意数量的层。 它具有的层越多，可以解决的数据问题就越复杂，但培训时间也将更长。 还有一些神经网络体系结构根本不包含隐藏层，单层网络就是这种情况。
+2.  **隐藏层**：接下来，可以找到隐藏层。 神经网络可以具有许多隐藏层，这意味着在输入层和输出层之间可以有任意数量的层。 它具有的层越多，可以解决的数据问题就越复杂，但培训时间也将更长。 还有一些神经网络架构根本不包含隐藏层，单层网络就是这种情况。
 
     在每一层中，都会根据从上一层作为输入接收的信息执行计算，然后将其用于输出将成为下一层输入的值。
 
@@ -822,7 +822,7 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
     y_test = torch.tensor(y_test.values).float()
     ```
 
-3.  使用`sequential()`容器定义网络体系结构。 确保创建四层网络。 考虑到我们正在处理回归问题，请在前三层使用 ReLU 激活函数，而在最后一层不使用激活函数。
+3.  使用`sequential()`容器定义网络架构。 确保创建四层网络。 考虑到我们正在处理回归问题，请在前三层使用 ReLU 激活函数，而在最后一层不使用激活函数。
 
     每层的单位数应为 100、50、25 和 1：
 
@@ -889,7 +889,7 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
     Ground truth: 60.0 Prediction: 69.5818099975586
     ```
 
-    如您所见，地面真实值（`60`）非常接近预测值（`69.58`）。
+    如您所见，真实情况值（`60`）非常接近预测值（`69.58`）。
 
     注意
 

new/dl-pt-workshop/3.md

@@ -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）输出节点，而对于多类分类任务，输出层应等于类标签的数量。
 
@@ -394,7 +394,7 @@ class Classifier(torch.nn.Module):
     D_o = 2
     ```
 
-3.  使用 PyTorch 的自定义模块，创建一个名为`Classifier`的类并定义模型的体系结构，使其具有两个线性层-第一个层是 **ReLU** 激活函数，第二层是 **Softmax** 激活功能：
+3.  使用 PyTorch 的自定义模块，创建一个名为`Classifier`的类并定义模型的架构，使其具有两个线性层-第一个层是 **ReLU** 激活函数，第二层是 **Softmax** 激活功能：
 
     ```py
     class Classifier(torch.nn.Module):
@@ -707,7 +707,7 @@ batch_size = 100
 
 此处提供了有关如何保存和加载经过训练的模型的分步指南：
 
-1.  最初，模型的检查点将仅包含模型的参数。 但是，在加载模型时，这不是唯一需要的信息。 根据分类器采用的参数（即包含网络体系结构的类），可能有必要保存更多信息，例如** input **单元的数量。 考虑到这一点，第一步是定义要保存的信息：
+1.  最初，模型的检查点将仅包含模型的参数。 但是，在加载模型时，这不是唯一需要的信息。 根据分类器采用的参数（即包含网络架构的类），可能有必要保存更多信息，例如** input **单元的数量。 考虑到这一点，第一步是定义要保存的信息：
 
     ```py
     checkpoint = {"input": X_train.shape[1], \

new/dl-pt-workshop/5.md

@@ -367,7 +367,7 @@ for index, layer in model._modules.items():
 使用上一练习的网络架构和本章第一练习的图像，我们将创建几个函数，这些函数能够从输入图像中提取特征并为样式特征创建语法矩阵。
 
 1.  打开上一个练习中的笔记本。
-2.  打印我们在上一个练习中加载的模型的体系结构。 这将帮助我们识别相关层，以便我们可以执行样式迁移任务：
+2.  打印我们在上一个练习中加载的模型的架构。 这将帮助我们识别相关层，以便我们可以执行样式迁移任务：
 
     ```py
     print(model)

new/dl-pt-workshop/6.md

@@ -272,7 +272,7 @@ for i in range(1, epochs+1):
 7.  定义损失函数，优化算法和训练网络的时期数。 为此，请使用均方误差损失函数，Adam 优化器和 10,000 个周期。
 8.  使用`for`循环通过遍历所有时期来执行训练过程。 在每个时期，都必须进行预测，以及随后的损失函数计算和网络参数优化。 然后，保存每个时期的损失。
 9.  绘制所有时期的损失。
-0.  使用散点图，显示在训练过程的最后一个周期中获得的预测值与地面真实值（即上周的销售交易）的对比。
+0.  使用散点图，显示在训练过程的最后一个周期中获得的预测值与真实情况值（即上周的销售交易）的对比。
 
     注意
 

new/dl-pt-workshop/7.md

@@ -1666,7 +1666,7 @@
 
     图 6.28：显示所有时期的损失的图
 
-0.  使用散点图，显示在训练过程的最后一个周期中获得的预测值与地面真实值（即上周的销售交易）的对比。
+0.  使用散点图，显示在训练过程的最后一个周期中获得的预测值与真实情况值（即上周的销售交易）的对比。
 
     ```py
     x_range = range(len(data))

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

@@ -410,7 +410,7 @@ My favourite language is ___
 
 图 3.17 –概率的表格表示
 
-有了这个，我们可以计算出出现 Python 的概率，假设前一个单词*为*出现的概率仅为 20%，而*英语*出现的概率仅为 10%。 我们可以进一步扩展此模型，以使用我们认为适当的来表示单词的三元组或任何 N 元组。 我们已经证明，可以使用 N 元组语言建模将关于单词之间的相互关系的更多信息引入我们的模型，而不必天真地假设单词是独立分布的。
+有了这个，我们可以计算出出现 Python 的概率，假设前一个单词*为*出现的概率仅为 20%，而*英语*出现的概率仅为 10%。 我们可以进一步扩展此模型，以使用我们认为适当的来表示单词的三元组或任何 N 元组。 我们已经证明，可以使用 N 元组语言建模将关于单词之间的相互关系的更多信息引入我们的模型，而不必朴素地假设单词是独立分布的。
 
 # 分词
 

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

@@ -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 单元的最后一个元素-**输出门**：
 
@@ -133,7 +133,7 @@ LSTM 与 RNN 的结构非常相似。 虽然 LSTM 的各个步骤之间存在一
 
 图 5.9 –输出门
 
-输出门计算 LSTM 单元的最终输出-单元状态和隐藏状态，并继续进行下一步。 单元状态`c[t]`与前两个步骤相同，是遗忘门和输入门的乘积。 通过获取串联的先前隐藏状态`h[t-1]`和当前时间步输入`x[t]`，可以计算出最终隐藏状态`h[t]`，并通过具有一些学习参数的 Sigmoid 函数来获得输出门输出`o[t]`。 最终单元状态`c[t]`通过 tanh 函数并乘以输出门输出`o[t]`，以计算最终隐藏状态`h[t]`。 这意味着在输出门上学习到的参数可以有效地控制将先前隐藏状态和当前输出中的哪些元素与最终单元状态进行组合，以作为新的隐藏状态延续到下一个时间步长。
+输出门计算 LSTM 单元的最终输出-单元状态和隐藏状态，并继续进行下一步。 单元状态`c[t]`与前两个步骤相同，是遗忘门和输入门的乘积。 通过获取连接的先前隐藏状态`h[t-1]`和当前时间步输入`x[t]`，可以计算出最终隐藏状态`h[t]`，并通过具有一些学习参数的 Sigmoid 函数来获得输出门输出`o[t]`。 最终单元状态`c[t]`通过 tanh 函数并乘以输出门输出`o[t]`，以计算最终隐藏状态`h[t]`。 这意味着在输出门上学习到的参数可以有效地控制将先前隐藏状态和当前输出中的哪些元素与最终单元状态进行组合，以作为新的隐藏状态延续到下一个时间步长。
 
 在我们的前向遍历中，我们简单地遍历模型，初始化我们的隐藏状态和单元状态，并在每个时间步使用 LSTM 单元对其进行更新，直到剩下最终的隐藏状态为止，该状态将输出到网络下一层的神经元。 通过在 LSTM 的所有层中进行反向传播，我们可以计算相对于网络损失的梯度，因此我们知道通过梯度下降来更新参数的方向。 我们得到几种矩阵或参数-一种用于输入门，一种用于输出门，以及一种用于遗忘门。
 

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

@@ -329,15 +329,13 @@ The scientist named the population, after their distinctive horn, Ovid's Unicorn
 Now, after almost two centuries, the mystery of what sparked this odd phenomenon is finally solved.
 
 Dr. Jorge Pérez, an evolutionary biologist from the University of La Paz, and several companions, were exploring the Andes Mountains when they found a small valley, with no other animals or humans. Pérez noticed that the valley had what appeared to be a natural fountain, surrounded by two peaks of rock and silver snow.
-
-This is only the first th
 ```
 
 这只是模型从很少的输入中生成的更大的九段响应的前三段。 值得注意的是，这些句子都非常合理（不管不可能的主题是什么！），各段以逻辑顺序排列在一起，并且该模型能够从很小的输入中产生所有这些。
 
 尽管这在性能以及通过构建深层 NLP 模型可以实现的功能方面给人留下深刻的印象，但确实引起了人们对此类模型的道德规范以及如何使用（和滥用它们）的担忧。
 
-随着“假新闻”的兴起和使用互联网的错误信息的传播，类似的示例说明了使用这些模型生成逼真的文本是多么简单。 让我们考虑一个示例，其中代理希望在线上生成有关多个主题的虚假新闻。 现在，他们甚至不需要自己编写虚假信息。 从理论上讲，他们可以训练 NLP 模型为他们执行此操作，然后再在互联网上散布这些虚假信息。 GPT-2 的作者在训练并将模型发布给公众时特别注意这一点，并指出该模型有可能被滥用和滥用，因此只有在他们看不到证据的情况下才向公众发布更大更复杂的模型。 较小型号的误用。
+随着“假新闻”的兴起和使用互联网的错误信息的传播，类似的示例说明了使用这些模型生成逼真的文本是多么简单。 让我们考虑一个示例，其中智能体希望在线上生成有关多个主题的虚假新闻。 现在，他们甚至不需要自己编写虚假信息。 从理论上讲，他们可以训练 NLP 模型为他们执行此操作，然后再在互联网上散布这些虚假信息。 GPT-2 的作者在训练并将模型发布给公众时特别注意这一点，并指出该模型有可能被滥用和滥用，因此只有在他们看不到证据的情况下才向公众发布更大更复杂的模型。 较小型号的误用。
 
 这可能成为 NLP 深度学习向前发展的重点。 当我们使用可以接近人类复杂程度的聊天机器人和文本生成器（例如 GPT-2）时，需要充分了解对这些模型的使用和误用。 研究表明，GPT-2 生成的文本被认为与《纽约时报》的真实人类书面文章（83%）几乎一样可信（72%）。 随着将来我们继续开发更复杂的深层 NLP 模型，随着模型生成的文本变得越来越现实，这些数字可能会收敛。
 
@@ -428,7 +426,7 @@ Jeff the chef drinks…
 
 图 9.17 –将句子分为几个组成部分
 
-句子的这些部分具有特定的语义角色。 任何给定句子的**谓词**表示该句子内发生的事件，而该句子的所有其他部分都与给定谓词相关。 在这句话中，我们可以将“谁”标记为谓词的代理。 **代理**是导致事件的原因。 我们还可以将`Whom`标记为谓词的主题。 **主题**是我们句子中受相关事件影响最大的元素：
+句子的这些部分具有特定的语义角色。 任何给定句子的**谓词**表示该句子内发生的事件，而该句子的所有其他部分都与给定谓词相关。 在这句话中，我们可以将“谁”标记为谓词的智能体。 **智能体**是导致事件的原因。 我们还可以将`Whom`标记为谓词的主题。 **主题**是我们句子中受相关事件影响最大的元素：
 
 ![Figure 9.18 – Breaking down the roles ](img/B12365_09_18.jpg)
 
@@ -454,7 +452,7 @@ The apple was bought by the man from the shop
 The apple was sold by the shop to the man
 ```
 
-这些句子虽然没有明显地包含相同顺序的所有相同词，但它们实际上具有相同的含义。 通过对这些句子应用语义角色标签，我们可以确定谓词/代理/主题都相同。
+这些句子虽然没有明显地包含相同顺序的所有相同词，但它们实际上具有相同的含义。 通过对这些句子应用语义角色标签，我们可以确定谓词/智能体/主题都相同。
 
 先前我们看到了选区分析/句法分析如何用于识别句子的句法结构。 在这里，我们可以看到如何将简单的句子“我买了一只猫”分解为它的组成部分-代词，动词，行列式和名词：
 

new/pt-ai-fund/4.md

@@ -603,9 +603,9 @@ class BiLSTMClassifier(nn.Module):
 
 # 工作原理
 
-在此秘籍中，我们在 LSTM 定义中将`bidirectional`标志设置为`True`。 我们将前向和后向 LSTM 的隐藏状态串联起来，并将它们传递到全连接层中。 因此，全连接层的输入尺寸增加了一倍，以适应前向和后向隐藏状态张量。
+在此秘籍中，我们在 LSTM 定义中将`bidirectional`标志设置为`True`。 我们将前向和后向 LSTM 的隐藏状态连接起来，并将它们传递到全连接层中。 因此，全连接层的输入尺寸增加了一倍，以适应前向和后向隐藏状态张量。
 
-在`forward()`方法中，我们使用`torch.cat()`连接了向前和向后隐藏状态，并使用了向前和向后 LSTM 的最后一个隐藏状态。 在 PyTorch 中，隐藏状态堆叠为`[forward_layer_0, backward_layer_0, forward_layer_1, backward_layer_1, ..., forward_layer_n, backward_layer_n]`，因此所需的张量为`hidden[-2,:,:], hidden[-1,:,:]`。 串联后，在挤出额外的尺寸后，我们将隐藏的向量传递到全连接层中。
+在`forward()`方法中，我们使用`torch.cat()`连接了向前和向后隐藏状态，并使用了向前和向后 LSTM 的最后一个隐藏状态。 在 PyTorch 中，隐藏状态堆叠为`[forward_layer_0, backward_layer_0, forward_layer_1, backward_layer_1, ..., forward_layer_n, backward_layer_n]`，因此所需的张量为`hidden[-2,:,:], hidden[-1,:,:]`。 连接后，在挤出额外的尺寸后，我们将隐藏的向量传递到全连接层中。
 
 # 更多
 

new/pt-ai-fund/7.md

@@ -18,7 +18,7 @@ RL 是**人工智能**（**AI**）的领域，与我们在前面各章中介绍
 
 # 深入了解 RL
 
-**智能体**是任何 RL 问题的核心。 它是 RL 算法的一部分，它处理输入信息以执行操作。 它探索和利用重复试验中的知识，以学习如何最大化奖励。 代理必须处理的场景称为**环境**，而**动作**是代理可以在给定环境中进行的动作。 采取行动后从环境中获得的回报称为**奖励**，代理根据当前状态决定使用下一行动的行动过程称为**策略**。 相对于短期奖励，带有折扣的预期长期回报称为**值**。**Q 值**与该值相似，但具有附加的当前动作参数。
+**智能体**是任何 RL 问题的核心。 它是 RL 算法的一部分，它处理输入信息以执行操作。 它探索和利用重复试验中的知识，以学习如何最大化奖励。 智能体必须处理的场景称为**环境**，而**动作**是智能体可以在给定环境中进行的动作。 采取行动后从环境中获得的回报称为**奖励**，智能体根据当前状态决定使用下一行动的行动过程称为**策略**。 相对于短期奖励，带有折扣的预期长期回报称为**值**。**Q 值**与该值相似，但具有附加的当前动作参数。
 
 现在，我们已经了解了 RL 的上下文，让我们理解为什么我们应该使用**深度 RL**（**DRL**）而不是 RL。 DRL 将 RL 与深度学习相结合，后者使用 NN 解决 RL 问题。
 
@@ -318,7 +318,7 @@ if not self.explore_limit:
 
 在`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 类的所有功能。
 
 # 更多
 
@@ -540,13 +540,13 @@ Rewards: 160.0
 
 # 生成智能体
 
-在本秘籍中，我们将着眼于创建一组代理以开始我们的进化过程，然后初始化这些代理的权重。 我们将使用这些代理来评估模型的性能并生成下一代代理。
+在本秘籍中，我们将着眼于创建一组智能体以开始我们的进化过程，然后初始化这些智能体的权重。 我们将使用这些智能体来评估模型的性能并生成下一代智能体。
 
 # 操作步骤
 
-在此秘籍中，我们将创建给定数量的代理。 按着这些次序：
+在此秘籍中，我们将创建给定数量的智能体。 按着这些次序：
 
-1.  首先，我们将定义一个函数来初始化代理的权重：
+1.  首先，我们将定义一个函数来初始化智能体的权重：
 
 ```py
 >>def init_weight(module):
@@ -562,7 +562,7 @@ Rewards: 160.0
       agents = []
 ```
 
-3.  接下来，我们将创建`num_agents`个代理：
+3.  接下来，我们将创建`num_agents`个智能体：
 
 ```py
 for _ in range(num_agents):
@@ -586,11 +586,11 @@ agents.append(agent)
    return agents
 ```
 
-现在，我们的代理商已准备好进行评估。
+现在，我们的智能体已准备好进行评估。
 
 # 工作原理
 
-在此秘籍中，我们编写了两个函数-第一个函数初始化模型层的权重。 对于模型权重，我们使用`torch.nn.init`中的`xavier_uniform`并用`0`填充偏差。 第二个函数创建`num_agents`个代理，并使用`cartpole_model()`函数返回它们。 我们使用`init_weight`初始化权重。 然后，对于模型的参数，我们禁用梯度计算，将代理设置为`eval()`模式，然后返回所有代理。
+在此秘籍中，我们编写了两个函数-第一个函数初始化模型层的权重。 对于模型权重，我们使用`torch.nn.init`中的`xavier_uniform`并用`0`填充偏差。 第二个函数创建`num_agents`个智能体，并使用`cartpole_model()`函数返回它们。 我们使用`init_weight`初始化权重。 然后，对于模型的参数，我们禁用梯度计算，将智能体设置为`eval()`模式，然后返回所有智能体。
 
 # 另见
 
@@ -598,11 +598,11 @@ agents.append(agent)
 
 # 选择智能体
 
-在本秘籍中，我们将基于适应度函数着眼于代理商选择，在我们的案例中，这意味着在平衡卡特波勒方面得分很高。 这意味着我们将传播得分最高的代理，而忽略其余的代理。 我们将评估给定一代中的每个代理，并多次评估它们，以确保奖励不是偶然的。 最后，我们将使用每个代理商的平均分数来确定表现最佳的代理商。
+在本秘籍中，我们将基于适应度函数着眼于智能体选择，在我们的案例中，这意味着在平衡卡特波勒方面得分很高。 这意味着我们将传播得分最高的智能体，而忽略其余的智能体。 我们将评估给定一代中的每个智能体，并多次评估它们，以确保奖励不是偶然的。 最后，我们将使用每个智能体的平均分数来确定表现最佳的智能体。
 
 # 操作步骤
 
-在本秘籍中，我们将编写用于评估代理，多次评估以及按给定序列评估所有代理的功能。 按着这些次序：
+在本秘籍中，我们将编写用于评估智能体，多次评估以及按给定序列评估所有智能体的功能。 按着这些次序：
 
 1.  我们将从导入开始：
 
@@ -610,7 +610,7 @@ agents.append(agent)
 >>import numpy as np
 ```
 
-2.  接下来，我们需要定义一个函数来评估代理的性能：
+2.  接下来，我们需要定义一个函数来评估智能体的性能：
 
 ```py
 >>def eval_agent(agent, env):
@@ -660,17 +660,17 @@ return total_reward
 
 # 工作原理
 
-在本秘籍中，我们完成了深度遗传算法的一些关键功能。 我们研究了三个不同的功能-第一个功能`eval_agent()`与我们在“训练 DQN”秘籍中看到的功能非常相似，其中我们使用了代理，该代理是一种神经网络模型，它预测要采取的动作，并执行到`MAX_STEP`（对于`cartpole-v1`为 500）或终端为`True`并返回分数的动作。
+在本秘籍中，我们完成了深度遗传算法的一些关键功能。 我们研究了三个不同的功能-第一个功能`eval_agent()`与我们在“训练 DQN”秘籍中看到的功能非常相似，其中我们使用了智能体，该智能体是一种神经网络模型，它预测要采取的动作，并执行到`MAX_STEP`（对于`cartpole-v1`为 500）或终端为`True`并返回分数的动作。
 
-然后，我们使用第二个函数`agent_score()`返回指定数量`runs`之上的平均分数，并返回该平均分数，以确保模型的随机性能不佳。 最后一个函数`all_agent_score()`仅循环遍历一代中的所有代理，并获得一代中所有代理的平均分数。
+然后，我们使用第二个函数`agent_score()`返回指定数量`runs`之上的平均分数，并返回该平均分数，以确保模型的随机性能不佳。 最后一个函数`all_agent_score()`仅循环遍历一代中的所有智能体，并获得一代中所有智能体的平均分数。
 
 # 使智能体突变
 
-在本秘籍中，我们将介绍使智能体突变。 在从给定的一代中选择性能最佳的模型之后，然后再创建下一代代理，我们将对这些选定代理的权重进行轻微的随机变化，这使代理可以探索更多区域以获得更好的回报，就像生物进化的工作原理一样。
+在本秘籍中，我们将介绍使智能体突变。 在从给定的一代中选择性能最佳的模型之后，然后再创建下一代智能体，我们将对这些选定智能体的权重进行轻微的随机变化，这使智能体可以探索更多区域以获得更好的回报，就像生物进化的工作原理一样。
 
 # 操作步骤
 
-在此秘籍中，我们将识别精英特工并向这些特工添加突变。 按着这些次序：
+在此秘籍中，我们将识别精英智能体并向这些智能体添加突变。 按着这些次序：
 
 1.  首先，我们将导入`copy`和`numpy`模块：
 
@@ -748,19 +748,19 @@ return copy.deepcopy(agents[top_id])
     return np.argsort(rewards)[::-1][:num_top_parents]
 ```
 
-在这里，我们定义了识别精英特工的功能和为特工增加噪音的功能。
+在这里，我们定义了识别精英智能体的功能和为智能体增加噪音的功能。
 
 # 工作原理
 
-在本秘籍中，我们研究了四个不同的函数-`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`函数对得分最高的代理进行突变。
+`child_agent`函数生成的子智能体数量与上一代相同，其中一个子智能体是`elite`函数的精英智能体，其余子智能体则使用`np.random.choice`随机选择。 `selected_agents`保留了表现最佳的选定智能体的列表。 在`[mutate(agent) for agent in selected_agents]`步骤中，使用`mutation`函数对得分最高的智能体进行突变。
 
-然后，我们将精英代理附加到下一代代理。 最后，`top_parent`函数返回一代中性能最高的代理的索引。
+然后，我们将精英智能体附加到下一代智能体。 最后，`top_parent`函数返回一代中性能最高的智能体的索引。
 
 # 训练深度 GA
 
-在本秘籍中，我们将完成深度遗传算法的演化，并可视化执行平衡操作的关键。 我们将使用在本章的秘籍中了解到的所有功能，并针对给定的代数运行这些功能。 这将创建代理，获取他们的分数，选择性能最佳的代理，并将其突变为下一代。 在几代人中，我们将看到代理商的分数增加。
+在本秘籍中，我们将完成深度遗传算法的演化，并可视化执行平衡操作的关键。 我们将使用在本章的秘籍中了解到的所有功能，并针对给定的代数运行这些功能。 这将创建智能体，获取他们的分数，选择性能最佳的智能体，并将其突变为下一代。 在几代人中，我们将看到智能体的分数增加。
 
 # 操作步骤
 
@@ -804,13 +804,13 @@ return copy.deepcopy(agents[top_id])
 >>for gen in range(generations):
 ```
 
-现在，我们可以评估代理商：
+现在，我们可以评估智能体：
 
 ```py
       rewards = all_agent_score(agents, env, 3)
 ```
 
-通过这样做，我们得到了最好的代理商：
+通过这样做，我们得到了最好的智能体：
 
 ```py
       top_parents_id = top_parents(rewards, num_top_parents)
@@ -887,9 +887,9 @@ Rewards: 350.0
 
 在此秘籍中，我们改进了深度遗传算法。 根据论文《深度神经进化：遗传算法是用于训练深度神经网络以进行强化学习的一种竞争选择》，我们将超参数`MUTATION_POWER`设置为`0.02`。 我们不需要使用 PyTorch 来进行梯度计算，因为我们不需要依靠梯度下降来改善模型和创建环境。
 
-然后，我们创建了一些代理，以开始我们的进化，并通过遍历`generations`将它们运行了预定的代数，在其中我们获得了每一代所有代理的奖励。 然后，我们选择了得分最高的父母，并通过`child_agent`函数传递这些父母指数以获得下一代。 之后，我们打印出前 5 个得分的平均值。
+然后，我们创建了一些智能体，以开始我们的进化，并通过遍历`generations`将它们运行了预定的代数，在其中我们获得了每一代所有智能体的奖励。 然后，我们选择了得分最高的父母，并通过`child_agent`函数传递这些父母指数以获得下一代。 之后，我们打印出前 5 个得分的平均值。
 
-最后，我们使用了与“训练 DQN”秘籍中相同的`play_agent`函数，并进行了较小的修改，以补偿模型预测值的差异。 在这里，我们使用精英模型来显示卡特彼勒的性能，每一代之后。 位于代理商列表的末尾。 这是使用`play_agent`函数完成的。
+最后，我们使用了与“训练 DQN”秘籍中相同的`play_agent`函数，并进行了较小的修改，以补偿模型预测值的差异。 在这里，我们使用精英模型来显示卡特彼勒的性能，每一代之后。 位于智能体列表的末尾。 这是使用`play_agent`函数完成的。
 
 # 更多
 

new/pt-dl-handson/1.md

@@ -286,7 +286,7 @@ Figure 1.16: GAN setup
 
 现代强化学习使用深度网络进行学习，这与我们以前明确编码那些规则的旧方法不同。 我们将研究 Q 学习和深度 Q 学习，向您展示有无深度学习的强化学习之间的区别。
 
-强化学习被认为是通向一般智能的途径之一，在这种途径中，计算机或代理通过与现实世界，对象或实验的交互或从反馈中学习。 教一个强化学习智能体人相当于通过负面和正面奖励来训练狗。 当您给一块饼干拿起球时，或者当您对狗不捡球而大喊时，您会通过消极和积极的奖励来增强对狗大脑的了解。 我们对 AI 代理执行相同的操作，但是正数奖励将为正数，负数奖励将为负数。 即使我们不能将强化学习视为类似于 CNN/RNN 等的另一种架构，但我还是在这里将其作为使用深度神经网络解决实际问题的另一种方法：
+强化学习被认为是通向一般智能的途径之一，在这种途径中，计算机或智能体通过与现实世界，对象或实验的交互或从反馈中学习。 教一个强化学习智能体人相当于通过负面和正面奖励来训练狗。 当您给一块饼干拿起球时，或者当您对狗不捡球而大喊时，您会通过消极和积极的奖励来增强对狗大脑的了解。 我们对 AI 智能体执行相同的操作，但是正数奖励将为正数，负数奖励将为负数。 即使我们不能将强化学习视为类似于 CNN/RNN 等的另一种架构，但我还是在这里将其作为使用深度神经网络解决实际问题的另一种方法：
 
 ![Reinforcement learning](img/B09475_01_17.jpg)
 
@@ -419,7 +419,7 @@ tensor([[0.5594, 0.8875, 0.9234, 1.1294],
 
 索引张量就像索引普通的 Python 列表一样。 可以通过递归索引每个维度来索引多个维度。 索引从第一个可用维中选择索引。 索引时可以使用逗号分隔每个维度。 切片时可以使用此方法。 起始和结束索引可以使用完整的冒号分隔。 可以使用属性`t`访问矩阵的转置。 每个 PyTorch 张量对象都具有`t`属性。
 
-串联是工具箱中需要执行的另一项重要操作。 PyTorch 出于相同的目的制作了功能`cat`。 所有尺寸上的两个张量相同的张量（一个张量除外）可以根据需要使用`cat`进行连接。 例如，大小为`3 x 2 x 4`的张量可以与另一个大小为`3 x 2 x 4`的张量在第一维上级联，以获得大小为`3 x 2 x 4`的张量。`stack`操作看起来非常类似于串联，但这是完全不同的操作。 如果要向张量添加新尺寸，则可以使用`stack`。 与`cat`相似，您可以将轴传递到要添加新尺寸的位置。 但是，请确保两个张量的所有尺寸都与附着尺寸相同。
+连接是工具箱中需要执行的另一项重要操作。 PyTorch 出于相同的目的制作了功能`cat`。 所有尺寸上的两个张量相同的张量（一个张量除外）可以根据需要使用`cat`进行连接。 例如，大小为`3 x 2 x 4`的张量可以与另一个大小为`3 x 2 x 4`的张量在第一维上级联，以获得大小为`3 x 2 x 4`的张量。`stack`操作看起来非常类似于连接，但这是完全不同的操作。 如果要向张量添加新尺寸，则可以使用`stack`。 与`cat`相似，您可以将轴传递到要添加新尺寸的位置。 但是，请确保两个张量的所有尺寸都与附着尺寸相同。
 
 `split`和`chunk`是用于拆分张量的类似操作。 `split`接受每个输出张量要的大小。 例如，如果要在第 0 个维度上拆分大小为`3 x 2`的张量，尺寸为 1，则将得到三个大小均为`3 x 2`的张量。但是，如果在第 0 个维度上使用 2 作为大小，则会得到`3 x 2`的张量和另一个`3 x 2`的张量。
 

new/pt-dl-handson/4.md

@@ -304,7 +304,7 @@ running_loss += loss.item()
 
 语义分割为现实世界中的几个主要应用提供支持，从闭路电视摄像机和自动驾驶汽车到分割不同的对象。 在本章中，我们将实现一种称为 LinkNet [2][7]的最快的语义分割架构。
 
-在本章中，我们将 CamVid 数据集用于我们的 LinkNet 实现。 CamVid 是一个地面真实数据集，由高质量视频组成，这些高质量视频转换为手动分割和标记的帧。 手动标记的输出图像将颜色用作对象的标识。 例如，数据集输出目录中的所有图像都将洋红色用于道路。
+在本章中，我们将 CamVid 数据集用于我们的 LinkNet 实现。 CamVid 是一个真实情况数据集，由高质量视频组成，这些高质量视频转换为手动分割和标记的帧。 手动标记的输出图像将颜色用作对象的标识。 例如，数据集输出目录中的所有图像都将洋红色用于道路。
 
 #### LinkNet
 

new/pt-dl-handson/5.md

@@ -270,7 +270,7 @@ class Encoder(nn.Module):
 2.  如果存在矛盾，请将损失最小化为较大的负值。
 3.  如果它是中性的，则将损失保持在零附近（在两到三倍的范围内可行）。
 
-另一种方法可能是连接两个句子的隐藏状态并将它们传递到另一组层，并定义最终的分类器层，该层可以将连接的值分类为我们想要的三个类。 实际的 SPINN 实现使用后一种方法，但是合并机制比简单的串联更为复杂。
+另一种方法可能是连接两个句子的隐藏状态并将它们传递到另一组层，并定义最终的分类器层，该层可以将连接的值分类为我们想要的三个类。 实际的 SPINN 实现使用后一种方法，但是合并机制比简单的连接更为复杂。
 
 ```py
 class Merger(nn.Module):

new/pt-dl-handson/7.md

@@ -14,13 +14,13 @@
 
 这些现实问题似乎非常复杂。 我们将需要对所有这些事情进行数学公式化，以便计算机可以解决它们。 为此，我们需要简化环境和决策过程以实现特定目标。
 
-在强化学习的整个范式中，我们仅关注从交互中学习，而学习器或决策者则被视为代理。 在自动驾驶汽车中，代理人是汽车，而在乒乓球中，代理人是球拍。 当代理最初进入世界时，它将对世界一无所知。 代理将必须观察其环境并根据其做出决策或采取行动。 它从环境中返回的响应称为奖励，可以是肯定的也可以是否定的。 最初，代理将随机采取行动，直到获得正面奖励为止，并告诉他们这些决定可能对其有利。
+在强化学习的整个范式中，我们仅关注从交互中学习，而学习器或决策者则被视为智能体。 在自动驾驶汽车中，智能体是汽车，而在乒乓球中，智能体是球拍。 当智能体最初进入世界时，它将对世界一无所知。 智能体将必须观察其环境并根据其做出决策或采取行动。 它从环境中返回的响应称为奖励，可以是肯定的也可以是否定的。 最初，智能体将随机采取行动，直到获得正面奖励为止，并告诉他们这些决定可能对其有利。
 
-这似乎很简单，因为代理程序要做的就是考虑环境的当前状态进行决策，但是我们还想要更多。 通常，座席的目标是在其一生中最大化其累积奖励，重点是“累积”一词。 代理不仅关心在下一步中获得的报酬，而且还关心将来可能获得的报酬。 这需要有远见，并将使代理学习得更好。
+这似乎很简单，因为智能体程序要做的就是考虑环境的当前状态进行决策，但是我们还想要更多。 通常，座席的目标是在其一生中最大化其累积奖励，重点是“累积”一词。 智能体不仅关心在下一步中获得的报酬，而且还关心将来可能获得的报酬。 这需要有远见，并将使智能体学习得更好。
 
-这个元素使问题变得更加复杂，因为我们必须权衡两个因素：探索与利用。 探索将意味着做出随机决策并对其进行测试，而剥削则意味着做出代理商已经知道的决策将给其带来积极的结果，因此代理商现在需要找到一种方法来平衡这两个因素以获得最大的累积结果。 。 这是强化学习中非常重要的概念。 这个概念催生了各种算法来平衡这两个因素，并且是一个广泛的研究领域。
+这个元素使问题变得更加复杂，因为我们必须权衡两个因素：探索与利用。 探索将意味着做出随机决策并对其进行测试，而剥削则意味着做出智能体已经知道的决策将给其带来积极的结果，因此智能体现在需要找到一种方法来平衡这两个因素以获得最大的累积结果。 。 这是强化学习中非常重要的概念。 这个概念催生了各种算法来平衡这两个因素，并且是一个广泛的研究领域。
 
-在本章中，我们将使用 OpenAI 名为 Gym 的库。 这是一个开放源代码库，为强化学习算法的训练和基准测试设定了标准。 体育馆提供了许多研究人员用来训练强化学习算法的环境。 它包括许多 Atari 游戏，用于拾取物品的机器人仿真，用于步行和跑步的各种机器人仿真以及驾驶仿真。 该库提供了代理程序和环境之间相互交互所必需的参数。
+在本章中，我们将使用 OpenAI 名为 Gym 的库。 这是一个开放源代码库，为强化学习算法的训练和基准测试设定了标准。 体育馆提供了许多研究人员用来训练强化学习算法的环境。 它包括许多 Atari 游戏，用于拾取物品的机器人仿真，用于步行和跑步的各种机器人仿真以及驾驶仿真。 该库提供了智能体程序和环境之间相互交互所必需的参数。
 
 ## 问题
 
@@ -30,25 +30,25 @@
 
 图 7.1：强化学习框架
 
-在上图中，您可以看到任何强化学习问题的设置。 通常，强化学习问题的特征在于，代理人试图学习有关其环境的信息，如前所述。
+在上图中，您可以看到任何强化学习问题的设置。 通常，强化学习问题的特征在于，智能体试图学习有关其环境的信息，如前所述。
 
-假设时间以不连续的时间步长演化，则在时间步长 0 处，代理查看环境。 您可以将这种观察视为环境呈现给代理的情况。 这也称为观察环境状态。 然后，代理必须为该特定状态选择适当的操作。 接下来，环境根据代理采取的行动向代理提出了新的情况。 在同一时间步长中，环境会给代理提供奖励，从而可以指示代理是否做出了适当的响应。 然后该过程继续。 环境为坐席提供状态和奖励，然后坐席采取行动。
+假设时间以不连续的时间步长演化，则在时间步长 0 处，智能体查看环境。 您可以将这种观察视为环境呈现给智能体的情况。 这也称为观察环境状态。 然后，智能体必须为该特定状态选择适当的操作。 接下来，环境根据智能体采取的行动向智能体提出了新的情况。 在同一时间步长中，环境会给智能体提供奖励，从而可以指示智能体是否做出了适当的响应。 然后该过程继续。 环境为坐席提供状态和奖励，然后坐席采取行动。
 
 ![The problem](img/B09475_07_02.jpg)
 
 图 7.2：每个时间步骤都有一个状态，动作和奖励
 
-因此，状态，动作和奖励的顺序现在随着时间而流动，在这个过程中，对代理人而言最重要的是其奖励。 话虽如此，代理人的目标是使累积奖励最大化。 换句话说，代理商需要制定一项策略，以帮助其采取使累积奖励最大化的行动。 这只能通过与环境交互来完成。
+因此，状态，动作和奖励的顺序现在随着时间而流动，在这个过程中，对智能体而言最重要的是其奖励。 话虽如此，智能体的目标是使累积奖励最大化。 换句话说，智能体需要制定一项策略，以帮助其采取使累积奖励最大化的行动。 这只能通过与环境交互来完成。
 
-这是因为环境决定了对每个动作给予代理多少奖励。 为了用数学公式表述，我们需要指定状态，动作和奖励，以及环境规则。
+这是因为环境决定了对每个动作给予智能体多少奖励。 为了用数学公式表述，我们需要指定状态，动作和奖励，以及环境规则。
 
 ## 情景任务与连续任务
 
-在现实世界中，我们指定的许多任务都有明确定义的终点。 例如，如果特工正在玩游戏，则当特工获胜或失败或死亡时，情节或任务便会结束。
+在现实世界中，我们指定的许多任务都有明确定义的终点。 例如，如果智能体正在玩游戏，则当智能体获胜或失败或死亡时，情节或任务便会结束。
 
-在无人驾驶汽车的情况下，任务在汽车到达目的地或撞车时结束。 这些具有明确终点的任务称为情节任务。 代理在每个情节的结尾都会获得奖励，这是代理决定自己在环境中做得如何的时候。 然后，代理从头开始但继续拥有下一个情节的先验信息，然后继续执行下一个情节，因此效果更好。
+在无人驾驶汽车的情况下，任务在汽车到达目的地或撞车时结束。 这些具有明确终点的任务称为情节任务。 智能体在每个情节的结尾都会获得奖励，这是智能体决定自己在环境中做得如何的时候。 然后，智能体从头开始但继续拥有下一个情节的先验信息，然后继续执行下一个情节，因此效果更好。
 
-随着时间的流逝，在一段情节中，代理将学会玩游戏或将汽车开到特定的目的地，因此将受到训练。 您会记得，特工的目标是在剧集结束时最大限度地提高累积奖励。
+随着时间的流逝，在一段情节中，智能体将学会玩游戏或将汽车开到特定的目的地，因此将受到训练。 您会记得，智能体的目标是在剧集结束时最大限度地提高累积奖励。
 
 但是，有些任务可能永远持续下去。 例如，在股票市场上交易股票的机器人没有明确的终点，必须在每个时间步骤中学习和提高自己。 这些任务称为连续任务。 因此，在那种情况下，奖励是在特定的时间间隔提供给业务代表的，但任务没有尽头，因此业务代表必须从环境中学习并同时进行预测。
 
@@ -56,17 +56,17 @@
 
 ## 累积折扣奖励
 
-为了使代理人最大化累积奖励，可以考虑的一种方法是在每个时间步长上最大化奖励。 这样做可能会产生负面影响，因为在初始时间步长中最大化回报可能会导致代理在将来很快失败。 让我们以步行机器人为例。 假定机器人的速度是奖励的一个因素，如果机器人在每个时间步长上都最大化其速度，则可能会使其不稳定并使其更快落下。
+为了使智能体最大化累积奖励，可以考虑的一种方法是在每个时间步长上最大化奖励。 这样做可能会产生负面影响，因为在初始时间步长中最大化回报可能会导致智能体在将来很快失败。 让我们以步行机器人为例。 假定机器人的速度是奖励的一个因素，如果机器人在每个时间步长上都最大化其速度，则可能会使其不稳定并使其更快落下。
 
-我们正在训练机器人走路； 因此，我们可以得出结论，代理不能仅仅专注于当前时间步长来最大化报酬。 它需要考虑所有时间步骤。 所有强化学习问题都会是这种情况。 动作可能具有短期或长期影响，代理需要了解动作的复杂性以及环境带来的影响。
+我们正在训练机器人走路； 因此，我们可以得出结论，智能体不能仅仅专注于当前时间步长来最大化报酬。 它需要考虑所有时间步骤。 所有强化学习问题都会是这种情况。 动作可能具有短期或长期影响，智能体需要了解动作的复杂性以及环境带来的影响。
 
-在前述情况下，如果代理将了解到其移动速度不能超过某个可能会使它不稳定并对其产生长期影响的极限，则它将自行学习阈值速度。 因此，代理将在每个时间步长处获得较低的报酬，但会避免将来跌倒，从而使累积报酬最大化。
+在前述情况下，如果智能体将了解到其移动速度不能超过某个可能会使它不稳定并对其产生长期影响的极限，则它将自行学习阈值速度。 因此，智能体将在每个时间步长处获得较低的报酬，但会避免将来跌倒，从而使累积报酬最大化。
 
 假设在所有未来时间步长处的奖励都由`R[t]`，`R[t + 1]`，`R[t + 2]`表示，依此类推：
 
 ![Cumulative discounted rewards](img/B09475_07_002.jpg)
 
-由于这些时间步伐是在将来，代理人无法确定地知道将来的回报是什么。 它只能估计或预测它们。 未来奖励的总和也称为回报。 我们可以更明确地指定代理商的目标是使期望收益最大化。
+由于这些时间步伐是在将来，智能体无法确定地知道将来的回报是什么。 它只能估计或预测它们。 未来奖励的总和也称为回报。 我们可以更明确地指定智能体的目标是使期望收益最大化。
 
 让我们还考虑一下，未来回报中的所有回报并不那么重要。 为了说明这一点，假设您想训练一只狗。 您给它命令，如果它正确地遵循了它们，则给它一种奖赏。 您能期望狗像称重从现在起数年可能获得的奖励一样，来权衡明天可能获得的奖励吗？ 这似乎不可行。
 
@@ -76,7 +76,7 @@
 
 可以看到，我们在`Goal`方程中引入了可变伽玛。 接近 1 的`Gamma`表示您将来对每个奖励的重视程度相同。 接近 0 的`Gamma`表示只有最近的奖励才具有很高的权重。
 
-一个良好的做法是将`Gamma = 0.9`，因为您希望代理对未来有足够的关注，但又不是无限远。 您可以在训练时设置`Gamma`，并且`Gamma`会保持固定，直到实验结束。 重要的是要注意，折扣在连续任务中非常有用，因为它们没有尽头。 但是，继续执行的任务不在本章范围之内。
+一个良好的做法是将`Gamma = 0.9`，因为您希望智能体对未来有足够的关注，但又不是无限远。 您可以在训练时设置`Gamma`，并且`Gamma`会保持固定，直到实验结束。 重要的是要注意，折扣在连续任务中非常有用，因为它们没有尽头。 但是，继续执行的任务不在本章范围之内。
 
 ## 马尔可夫决策过程
 
@@ -102,19 +102,19 @@ MDP 定义有五件事：
 
 同样，如果电池处于高电量状态，则决定在其当前位置等待，电池处于高电量状态的可能性为 100%，但是获得的奖励也很低。
 
-花一点时间浏览所有动作和状态，以更好地了解它们。 通过详细说明代理可以处于的所有状态以及代理在其所有状态下可以执行的所有操作，并确定每个操作的概率，可以指定环境。 一旦指定了所有这些，就可以指定环境的一站式动态。
+花一点时间浏览所有动作和状态，以更好地了解它们。 通过详细说明智能体可以处于的所有状态以及智能体在其所有状态下可以执行的所有操作，并确定每个操作的概率，可以指定环境。 一旦指定了所有这些，就可以指定环境的一站式动态。
 
-在任何 MDP 中，代理都会知道状态，操作和折扣率，而不会知道环境的回报和一步动态。
+在任何 MDP 中，智能体都会知道状态，操作和折扣率，而不会知道环境的回报和一步动态。
 
 现在，您了解了制定任何实际问题（通过强化学习解决）的所有知识。
 
 ## 解决方案
 
-既然我们已经学习了如何使用 MDP 来指定问题，那么代理需要制定解决方案。 此策略也可以称为策略。
+既然我们已经学习了如何使用 MDP 来指定问题，那么智能体需要制定解决方案。 此策略也可以称为策略。
 
 ### 策略和值函数
 
-策略定义学习代理在给定时间的行为方式。 保单用希腊字母`Pi`表示。 该策略不能用公式定义； 它更多是基于直觉的概念。
+策略定义学习智能体在给定时间的行为方式。 保单用希腊字母`Pi`表示。 该策略不能用公式定义； 它更多是基于直觉的概念。
 
 让我们举个例子。 对于需要在房间外寻找出路的机器人，它可能具有以下策略：
 
@@ -132,11 +132,11 @@ MDP 定义有五件事：
 
 让我们举个例子。 让我们考虑通用状态`S0`。 现在我们需要预测在`a1`，`a2`和`a3`之间要采取什么行动才能获得最大的回报（累积折扣奖励）。 我们将此函数命名为`Q`。 我们的函数`Q`，将预测每个操作的预期收益（值（`V`））。 此`Q`函数也称为动作值函数，因为它考虑了状态和动作，并预测了它们各自的组合的预期收益。
 
-我们通常会选择最大值。 因此，这些最高限额将指导代理商到最后，这将是我们的策略。 请注意，我大部分时间都在说。 通常，在选择非最大动作值对时，我们会保持很小的随机机会。 我们这样做是为了提高模型的可探索性。 该随机探索机会的百分比称为`ε`，该策略称为 ε 贪婪策略。 这是人们用来解决强化学习问题的最常见策略。 如果我们一直都只选择最大值，而不进行任何探索，则该策略简称为贪婪策略。 我们将在实现过程中同时使用这两种策略。
+我们通常会选择最大值。 因此，这些最高限额将指导智能体到最后，这将是我们的策略。 请注意，我大部分时间都在说。 通常，在选择非最大动作值对时，我们会保持很小的随机机会。 我们这样做是为了提高模型的可探索性。 该随机探索机会的百分比称为`ε`，该策略称为 ε 贪婪策略。 这是人们用来解决强化学习问题的最常见策略。 如果我们一直都只选择最大值，而不进行任何探索，则该策略简称为贪婪策略。 我们将在实现过程中同时使用这两种策略。
 
 但是起初，我们可能不知道最佳作用值函数。 因此，由此产生的策略也将不是最佳策略。 我们将需要遍历动作值函数，并找到提供最佳回报的函数。 一旦找到它，我们将获得最优的`Q`。 最佳`Q`也称为`Q*`。 因此，我们将能够找到最优的`Pi`，也称为`Pi*`。
 
-此`Q`函数是代理必须学习的功能。 我们将使用神经网络来学习此功能，因为神经网络也是通用函数逼近器。 一旦有了行动值函数，座席就可以了解问题的最佳策略，我们就可以完成目标。
+此`Q`函数是智能体必须学习的功能。 我们将使用神经网络来学习此功能，因为神经网络也是通用函数逼近器。 一旦有了行动值函数，座席就可以了解问题的最佳策略，我们就可以完成目标。
 
 ### 贝尔曼方程
 
@@ -223,7 +223,7 @@ memory = ReplayMemory(10000)
 
 ### Gym
 
-我们将使用 OpenAI 的 Gym 从环境`env`中获取参数。 环境变量很多，例如代理的速度和位置。 我们将训练一个平衡点来平衡自己。
+我们将使用 OpenAI 的 Gym 从环境`env`中获取参数。 环境变量很多，例如智能体的速度和位置。 我们将训练一个平衡点来平衡自己。
 
 ![Gym](img/B09475_07_05.jpg)
 
@@ -437,7 +437,7 @@ def optimize_model():
 
 ![Gym](img/B09475_07_09.jpg)
 
-在那批状态中，置于 0 的 1 是终端状态。 所有其他均为非最终状态。 我们将所有非最终的下一个状态串联到`non_final_next_states`中。 之后，我们将`next_state_values`初始化为全 0。 然后，我们将`non_final_next_states`传递给`target_network`，从中获得最大值的操作值，并将其应用于`next_state_values[non_final_mask]`。 我们将从非最终状态预测的所有值都放入非最终`next_state_values`数组。 `next_state_values`的外观如下：
+在那批状态中，置于 0 的 1 是终端状态。 所有其他均为非最终状态。 我们将所有非最终的下一个状态连接到`non_final_next_states`中。 之后，我们将`next_state_values`初始化为全 0。 然后，我们将`non_final_next_states`传递给`target_network`，从中获得最大值的操作值，并将其应用于`next_state_values[non_final_mask]`。 我们将从非最终状态预测的所有值都放入非最终`next_state_values`数组。 `next_state_values`的外观如下：
 
 ![Gym](img/B09475_07_10.jpg)
 
@@ -445,7 +445,7 @@ def optimize_model():
 
 训练神经网络将花费一些时间，因为该过程将渲染每个帧并计算该错误。 我们本可以使用一种更简单的方法，直接获取速度和位置来表示损失函数，并且由于不需要渲染每一帧，因此可以花费更少的时间进行训练。 它只会直接从`env.state`接受输入。
 
-此算法有许多改进，例如为代理增加了想象力，以便可以更好地探索和想象其脑海中的动作，并做出更好的预测。
+此算法有许多改进，例如为智能体增加了想象力，以便可以更好地探索和想象其脑海中的动作，并做出更好的预测。
 
 ## 总结
 

new/pt-tut-17/29.md

@@ -112,7 +112,7 @@ O'Neal
 
 ## 创建网络
 
-该网络扩展[最后一个教程](#Creating-the-Network)的 RNN，并为类别张量附加了一个参数，该参数与其他张量串联在一起。 类别张量就像字母输入一样是一个单向向量。
+该网络扩展[最后一个教程](#Creating-the-Network)的 RNN，并为类别张量附加了一个参数，该参数与其他张量连接在一起。 类别张量就像字母输入一样是一个单向向量。
 
 我们将输出解释为下一个字母的概率。 采样时，最可能的输出字母用作下一个输入字母。
 

new/pt-tut-17/34.md

@@ -4,21 +4,21 @@
 
 **作者**： [Adam Paszke](https://github.com/apaszke)
 
-本教程说明如何使用 PyTorch 在 [OpenAI Gym](https://gym.openai.com/) 上的 CartPole-v0 任务上训练深度 Q 学习（DQN）代理。
+本教程说明如何使用 PyTorch 在 [OpenAI Gym](https://gym.openai.com/) 上的 CartPole-v0 任务上训练深度 Q 学习（DQN）智能体。
 
 **任务**
 
-代理商必须在两个动作之间做出决定-向左或向右移动推车-以便使与之相连的杆子保持直立。 您可以在 [Gym 网站](https://gym.openai.com/envs/CartPole-v0)上找到具有各种算法和可视化效果的官方排行榜。
+智能体必须在两个动作之间做出决定-向左或向右移动推车-以便使与之相连的杆子保持直立。 您可以在 [Gym 网站](https://gym.openai.com/envs/CartPole-v0)上找到具有各种算法和可视化效果的官方排行榜。
 
 ![cartpole](img/fed25c69a6015a90b6e9406e4ac6e01c.png)
 
 卡特波尔
 
-当代理观察环境的当前状态并选择一个动作时，环境*会转换为*到新状态，并且还会返回表示该动作后果的奖励。 在此任务中，每增加一个时间步长，奖励为 +1，并且如果杆子掉落得太远或手推车离中心的距离超过 2.4 个单位，则环境终止。 这意味着性能更好的方案将持续更长的时间，从而积累更大的回报。
+当智能体观察环境的当前状态并选择一个动作时，环境*会转换为*到新状态，并且还会返回表示该动作后果的奖励。 在此任务中，每增加一个时间步长，奖励为 +1，并且如果杆子掉落得太远或手推车离中心的距离超过 2.4 个单位，则环境终止。 这意味着性能更好的方案将持续更长的时间，从而积累更大的回报。
 
-对 CartPole 任务进行了设计，以使对代理的输入是代表环境状态（位置，速度等）的 4 个实际值。 但是，神经网络可以完全通过查看场景来解决任务，因此我们将以推车为中心的一部分屏幕作为输入。 因此，我们的结果无法直接与官方排行榜上的结果进行比较-我们的任务更加艰巨。 不幸的是，这确实减慢了训练速度，因为我们必须渲染所有帧。
+对 CartPole 任务进行了设计，以使对智能体的输入是代表环境状态（位置，速度等）的 4 个实际值。 但是，神经网络可以完全通过查看场景来解决任务，因此我们将以推车为中心的一部分屏幕作为输入。 因此，我们的结果无法直接与官方排行榜上的结果进行比较-我们的任务更加艰巨。 不幸的是，这确实减慢了训练速度，因为我们必须渲染所有帧。
 
-严格来说，我们将状态显示为当前屏幕补丁与前一个屏幕补丁之间的差异。 这将允许代理从一张图像中考虑极点的速度。
+严格来说，我们将状态显示为当前屏幕补丁与前一个屏幕补丁之间的差异。 这将允许智能体从一张图像中考虑极点的速度。
 
 **软件包**
 
@@ -62,7 +62,7 @@ device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 ## 回放记忆
 
-我们将使用经验回放记忆来训练我们的 DQN。 它存储代理观察到的转换，使我们以后可以重用此数据。 通过从中随机采样，可以构建批量的转换相关。 已经表明，这极大地稳定和改善了 DQN 训练程序。
+我们将使用经验回放记忆来训练我们的 DQN。 它存储智能体观察到的转换，使我们以后可以重用此数据。 通过从中随机采样，可以构建批量的转换相关。 已经表明，这极大地稳定和改善了 DQN 训练程序。
 
 为此，我们将需要两个类：
 
@@ -101,7 +101,7 @@ class ReplayMemory(object):
 
 我们的环境是确定性的，因此为简单起见，此处介绍的所有方程式也都确定性地制定。 在强化学习文献中，它们还将包含对环境中随机转变的期望。
 
-我们的目标是制定一种策略，尝试最大化折扣的累积奖励`R[t[0]] = Σ γ^(t - t[0]) r[t], t = t[0] -> ∞`，其中`R[t[0]]`也称为*回报*。 折扣`γ`应该是`0`和`1`之间的常数，以确保总和收敛。 这使得来自不确定的遥远未来的回报对我们的代理商而言不如可以对其充满信心的近期回报重要。
+我们的目标是制定一种策略，尝试最大化折扣的累积奖励`R[t[0]] = Σ γ^(t - t[0]) r[t], t = t[0] -> ∞`，其中`R[t[0]]`也称为*回报*。 折扣`γ`应该是`0`和`1`之间的常数，以确保总和收敛。 这使得来自不确定的遥远未来的回报对我们的智能体而言不如可以对其充满信心的近期回报重要。
 
 Q 学习的主要思想是，如果我们有一个函数`Q*：State x Action => R`，这可以告诉我们，如果我们在给定状态下采取行动，那么我们就可以轻松地制定出使我们的回报最大化的策略：
 

new/pt-tut-17/35.md

-# 训练玩马里奥的 RL 代理
+# 训练玩马里奥的 RL 智能体
 
 > 原文：<https://pytorch.org/tutorials/intermediate/mario_rl_tutorial.html>
 
@@ -37,13 +37,13 @@ import gym_super_mario_bros
 
 ## RL 定义
 
-**环境**：代理与之交互并学习的世界。
+**环境**：智能体与之交互并学习的世界。
 
-**操作**`a`：代理如何响应环境。 所有可能动作的集合称为*动作空间*。
+**操作**`a`：智能体如何响应环境。 所有可能动作的集合称为*动作空间*。
 
 **状态**`s`：环境的当前特征。 环境可以处于的所有可能状态的集合称为*状态空间*。
 
-**奖励**`r`：奖励是从环境到代理的关键反馈。 这是驱动代理学习并改变其未来行动的动力。 多个时间步长上的奖励汇总称为**回报**。
+**奖励**`r`：奖励是从环境到智能体的关键反馈。 这是驱动智能体学习并改变其未来行动的动力。 多个时间步长上的奖励汇总称为**回报**。
 
 **最佳操作的值函数**`Q*(s, a)`：如果您以状态`s`开始，执行任意操作`a`并给出期望的回报， 然后针对每个未来时间步长采取使收益最大化的行动。 可以说`Q`代表状态中动作的“质量”。 我们尝试近似该函数。
 
@@ -82,9 +82,9 @@ print(f"{next_state.shape},\n {reward},\n {done},\n {info}")
 
 ### 预处理环境
 
-环境数据在`next_state`中返回给代理。 正如您在上面看到的，每个状态都由`[3, 240, 256]`大小数组表示。 通常，这比我们的代理商需要的信息更多； 例如，马里奥的举动并不取决于管道或天空的颜色！
+环境数据在`next_state`中返回给智能体。 正如您在上面看到的，每个状态都由`[3, 240, 256]`大小数组表示。 通常，这比我们的智能体需要的信息更多； 例如，马里奥的举动并不取决于管道或天空的颜色！
 
-我们使用**包装程序**在将环境数据发送到代理之前对其进行预处理。
+我们使用**包装程序**在将环境数据发送到智能体之前对其进行预处理。
 
 `GrayScaleObservation`是将 RGB 图像转换为灰度的通用包装器； 这样做可以减少状态表示的大小，而不会丢失有用的信息。 现在每个状态的大小：`[1, 240, 256]`
 
@@ -163,7 +163,7 @@ env = FrameStack(env, num_stack=4)
 
 ## 智能体
 
-我们创建一个类`Mario`来表示我们的代理在游戏中。 马里奥应该能够：
+我们创建一个类`Mario`来表示我们的智能体在游戏中。 马里奥应该能够：
 
 *   **根据（环境的）当前状态，执行最佳操作策略**。
 *   **记住**经验。 经验为（当前状态，当前动作，奖励，下一个状态）。 马里奥*缓存*并且后来*回忆起*他的经验来更新其行动策略。
@@ -196,7 +196,7 @@ class Mario:
 
 ### 行动
 
-对于任何给定状态，代理都可以选择执行最佳操作（**利用**）或执行随机操作（**探索**）。
+对于任何给定状态，智能体都可以选择执行最佳操作（**利用**）或执行随机操作（**探索**）。
 
 马里奥随机发掘并发`self.exploration_rate` 当他选择利用时，他依靠`MarioNet`（在`Learn`部分中实现）提供最佳操作。
 

new/pt-tut-17/44.md

@@ -475,7 +475,7 @@ struct Net : torch::nn::Module {
 
 #### 什么是 GAN aGAN？
 
-GAN 由两个不同的神经网络模型组成：*生成器*和*判别器*。 生成器从噪声分布中接收样本，其目的是将每个噪声样本转换为类似于目标分布的图像（在我们的情况下为 MNIST 数据集）。 判别器又从 MNIST 数据集接收*实际*图像，或从生成器接收*假*图像。 要求发出一个概率来判断特定图像的真实程度（接近`1`）或伪造（接近`0`）。 来自判别器的关于由发生器产生的图像有多真实的反馈被用来训练发生器。 判别器对真实性有多好的反馈将用于优化判别器。 从理论上讲，生成器和判别器之间的微妙平衡使它们串联起来得到改善，从而导致生成器生成与目标分布无法区分的图像，从而使判别器（那时）的敏锐眼睛冒出了散发`0.5`的真实和真实可能性。 假图片。 对我们来说，最终结果是一台接收噪声作为输入并生成逼真的数字图像作为其输出的机器。
+GAN 由两个不同的神经网络模型组成：*生成器*和*判别器*。 生成器从噪声分布中接收样本，其目的是将每个噪声样本转换为类似于目标分布的图像（在我们的情况下为 MNIST 数据集）。 判别器又从 MNIST 数据集接收*实际*图像，或从生成器接收*假*图像。 要求发出一个概率来判断特定图像的真实程度（接近`1`）或伪造（接近`0`）。 来自判别器的关于由发生器产生的图像有多真实的反馈被用来训练发生器。 判别器对真实性有多好的反馈将用于优化判别器。 从理论上讲，生成器和判别器之间的微妙平衡使它们连接起来得到改善，从而导致生成器生成与目标分布无法区分的图像，从而使判别器（那时）的敏锐眼睛冒出了散发`0.5`的真实和真实可能性。 假图片。 对我们来说，最终结果是一台接收噪声作为输入并生成逼真的数字图像作为其输出的机器。
 
 #### 生成器模块
 

new/pt-tut-17/50.md

@@ -165,7 +165,7 @@ public:
 
 1.  它是分散的。 您可以组装运算符的所有部分（CPU，CUDA，Autograd），而不必编写引用所有元素的集中式`if`语句。 重要的是，第三方可以注册其他方面的额外实现，而不必修补运算符的原始定义。
 2.  它比 CPU，CUDA 和 Autograd 支持更多的调度键。 您可以在`c10/core/DispatchKey.h`中查看 PyTorch 中当前实现的调度密钥的完整列表。 这些分派密钥为运算符实现了多种可选功能，如果您决定希望自定义运算符支持该功能，则只需为相应的密钥注册内核即可。
-3.  调度程序实现对盒装后备功能的支持，后者是可以一次实现并应用于系统中所有运算符的功能。 盒装后备可用于提供调度键的默认行为。 如果您使用调度程序来实现您的运营商，那么您还可以选择所有这些操作的备用。
+3.  调度程序实现对盒装后备功能的支持，后者是可以一次实现并应用于系统中所有运算符的功能。 盒装后备可用于提供调度键的默认行为。 如果您使用调度程序来实现您的运算符，那么您还可以选择所有这些操作的备用。
 
 这是一些特定的调度键，您可能需要为其定义一个运算符。
 

new/pt-tut-17/54.md

@@ -348,7 +348,7 @@ OrderedDict([(0, <torch.nn.utils.prune.RandomUnstructured object at 0x7fda78275e
 
 ## 迭代式剪裁
 
-一个模块中的同一参数可以被多次剪裁，各种剪裁调用的效果等于串联应用的各种蒙版的组合。 `PruningContainer`的`compute_mask`方法可处理新遮罩与旧遮罩的组合。
+一个模块中的同一参数可以被多次剪裁，各种剪裁调用的效果等于连接应用的各种蒙版的组合。 `PruningContainer`的`compute_mask`方法可处理新遮罩与旧遮罩的组合。
 
 例如，假设我们现在想进一步剪裁`module.weight`，这一次是使用沿着张量的第 0 轴的结构化剪裁（第 0 轴对应于卷积层的输出通道，并且对于`conv1`具有 6 维） ，基于渠道的 L2 规范。 这可以通过`ln_structured`和`n=2`和`dim=0`函数来实现。
 
@@ -638,7 +638,7 @@ prune.global_unstructured(
 
 ```
 
-现在，我们可以检查每个剪裁参数中引起的稀疏性，该稀疏性将不等于每层中的 20%。 但是，全球稀疏度将（大约）为 20%。
+现在，我们可以检查每个剪裁参数中引起的稀疏性，该稀疏性将不等于每层中的 20%。 但是，全局稀疏度将（大约）为 20%。
 
 ```py
 print(

new/pt-tut-17/60.md

@@ -51,7 +51,7 @@ DDP 材料如下：
 
 ## 通用分布式训练
 
-许多训练范式不适合数据并行性，例如参数服务器范式，分布式管道并行性，具有多个观察者或代理的强化学习应用等。 [`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)旨在支持一般的分布式训练方案 。
+许多训练范式不适合数据并行性，例如参数服务器范式，分布式管道并行性，具有多个观察者或智能体的强化学习应用等。 [`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)旨在支持一般的分布式训练方案 。
 
 [`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)程序包具有四个主要支柱：
 

new/pt-tut-17/64.md

@@ -13,7 +13,7 @@
 
 先前的教程[分布式数据并行入门](ddp_tutorial.html)和[使用 PyTorch](dist_tuto.html) 编写分布式应用，描述了[`DistributedDataParallel`](https://pytorch.org/docs/stable/_modules/torch/nn/parallel/distributed.html)，该模型支持特定的训练范例，该模型可在多个进程之间复制，每个进程都处理输入数据的拆分。 有时，您可能会遇到需要不同训练范例的场景。 例如：
 
-1.  在强化学习中，从环境中获取训练数据可能相对昂贵，而模型本身可能很小。 在这种情况下，产生多个并行运行的观察者并共享一个代理可能会很有用。 在这种情况下，代理将在本地负责训练，但是应用仍将需要库在观察者和训练者之间发送和接收数据。
+1.  在强化学习中，从环境中获取训练数据可能相对昂贵，而模型本身可能很小。 在这种情况下，产生多个并行运行的观察者并共享一个智能体可能会很有用。 在这种情况下，智能体将在本地负责训练，但是应用仍将需要库在观察者和训练者之间发送和接收数据。
 2.  您的模型可能太大，无法容纳在一台计算机上的 GPU 中，因此需要一个库来帮助将模型拆分到多台计算机上。 或者，您可能正在实现[参数服务器](https://www.cs.cmu.edu/~muli/file/parameter_server_osdi14.pdf)训练框架，其中模型参数和训练器位于不同的机器上。
 
 [`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)程序包可以帮助解决上述情况。 在情况 1 中， [RPC](https://pytorch.org/docs/master/rpc.html#rpc) 和 [RRef](https://pytorch.org/docs/master/rpc.html#rref) 允许将数据从一个工作程序发送到另一个工作程序，同时轻松引用远程数据对象。 在情况 2 中，[分布式 Autograd](https://pytorch.org/docs/master/rpc.html#distributed-autograd-framework) 和[分布式优化器](https://pytorch.org/docs/master/rpc.html#module-torch.distributed.optim)使执行反向传递和优化器步骤就像本地训练一样。 在接下来的两节中，我们将使用强化学习示例和语言模型示例来演示[`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)的 API。 请注意，本教程并非旨在构建最准确或最有效的模型来解决给定的问题，相反，此处的主要目标是演示如何使用[`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)包来构建分布式训练应用。
@@ -63,7 +63,7 @@ def _remote_method(method, rref, *args, **kwargs):
 
 ```
 
-我们准备介绍观察员。 在此示例中，每个观察者创建自己的环境，并等待代理的命令来运行情节。 在每个情节中，一个观察者最多循环`n_steps`个迭代，并且在每个迭代中，它使用 RPC 将其环境状态传递给代理并取回操作。 然后，它将该操作应用于其环境，并从环境中获取奖励和下一个状态。 之后，观察者使用另一个 RPC 向代理报告奖励。 同样，请注意，这显然不是最有效的观察者实现。 例如，一个简单的优化可能是将当前状态和最后的报酬打包到一个 RPC 中，以减少通信开销。 但是，目标是演示 RPC API，而不是为 CartPole 构建最佳的求解器。 因此，在此示例中，让逻辑保持简单，并明确两个步骤。
+我们准备介绍观察员。 在此示例中，每个观察者创建自己的环境，并等待智能体的命令来运行情节。 在每个情节中，一个观察者最多循环`n_steps`个迭代，并且在每个迭代中，它使用 RPC 将其环境状态传递给智能体并取回操作。 然后，它将该操作应用于其环境，并从环境中获取奖励和下一个状态。 之后，观察者使用另一个 RPC 向智能体报告奖励。 同样，请注意，这显然不是最有效的观察者实现。 例如，一个简单的优化可能是将当前状态和最后的报酬打包到一个 RPC 中，以减少通信开销。 但是，目标是演示 RPC API，而不是为 CartPole 构建最佳的求解器。 因此，在此示例中，让逻辑保持简单，并明确两个步骤。
 
 ```py
 import argparse
@@ -105,7 +105,7 @@ class Observer:
 
 ```
 
-agent 的代码稍微复杂一点，我们将其分成多个部分。 在此示例中，代理既充当训练者又充当主角色，以便它向多个分布式观察者发送命令以运行情节，并且还记录本地的所有动作和奖励，这些动作和奖赏将在每个情节之后的训练阶段使用。 下面的代码显示了`Agent`构造器，其中大多数行都在初始化各种组件。 最后的循环在其他工作者上远程初始化观察者，并在本地将`RRefs`保留给这些观察者。 代理稍后将使用那些观察者`RRefs`发送命令。 应用无需担心`RRefs`的寿命。 每个`RRef`的所有者维护一个参考计数图以跟踪其生命周期，并保证只要该`RRef`的任何活动用户都不会删除远程数据对象。 有关详细信息，请参考`RRef` [设计文档](https://pytorch.org/docs/master/notes/rref.html)。
+agent 的代码稍微复杂一点，我们将其分成多个部分。 在此示例中，智能体既充当训练者又充当主角色，以便它向多个分布式观察者发送命令以运行情节，并且还记录本地的所有动作和奖励，这些动作和奖赏将在每个情节之后的训练阶段使用。 下面的代码显示了`Agent`构造器，其中大多数行都在初始化各种组件。 最后的循环在其他工作者上远程初始化观察者，并在本地将`RRefs`保留给这些观察者。 智能体稍后将使用那些观察者`RRefs`发送命令。 应用无需担心`RRefs`的寿命。 每个`RRef`的所有者维护一个参考计数图以跟踪其生命周期，并保证只要该`RRef`的任何活动用户都不会删除远程数据对象。 有关详细信息，请参考`RRef` [设计文档](https://pytorch.org/docs/master/notes/rref.html)。
 
 ```py
 import gym
@@ -136,7 +136,7 @@ class Agent:
 
 ```
 
-接下来，代理向观察者公开两个 API，以供他们选择动作和报告奖励。 这些功能仅在代理上本地运行，但是将由观察者通过 RPC 触发。
+接下来，智能体向观察者公开两个 API，以供他们选择动作和报告奖励。 这些功能仅在智能体上本地运行，但是将由观察者通过 RPC 触发。
 
 ```py
 class Agent:
@@ -154,7 +154,7 @@ class Agent:
 
 ```
 
-让我们在代理上添加`run_episode`函数，该函数告诉所有观察者执行片段。 在此功能中，它首先创建一个列表，以从异步 RPC 收集期货，然后在所有观察者`RRefs`上循环以生成异步 RPC。 在这些 RPC 中，代理还将自身的`RRef`传递给观察者，以便观察者也可以在代理上调用函数。 如上所示，每个观察者都将 RPC 返回给代理，它们是嵌套的 RPC。 在每个情节之后，`saved_log_probs`和`rewards`将包含记录的动作概率和奖励。
+让我们在智能体上添加`run_episode`函数，该函数告诉所有观察者执行片段。 在此功能中，它首先创建一个列表，以从异步 RPC 收集期货，然后在所有观察者`RRefs`上循环以生成异步 RPC。 在这些 RPC 中，智能体还将自身的`RRef`传递给观察者，以便观察者也可以在智能体上调用函数。 如上所示，每个观察者都将 RPC 返回给智能体，它们是嵌套的 RPC。 在每个情节之后，`saved_log_probs`和`rewards`将包含记录的动作概率和奖励。
 
 ```py
 class Agent:
@@ -177,7 +177,7 @@ class Agent:
 
 ```
 
-最后，在一集之后，代理需要训练模型，该模型在下面的`finish_episode`函数中实现。 此函数中没有 RPC，并且大多数是从单线程[示例](https://github.com/pytorch/examples/blob/master/reinforcement_learning)中借用的。 因此，我们跳过描述其内容。
+最后，在一集之后，智能体需要训练模型，该模型在下面的`finish_episode`函数中实现。 此函数中没有 RPC，并且大多数是从单线程[示例](https://github.com/pytorch/examples/blob/master/reinforcement_learning)中借用的。 因此，我们跳过描述其内容。
 
 ```py
 class Agent:
@@ -214,7 +214,7 @@ class Agent:
 
 ```
 
-使用`Policy`，`Observer`和`Agent`类，我们准备启动多个过程来执行分布式训练。 在此示例中，所有进程都运行相同的`run_worker`函数，并且它们使用等级来区分其角色。 等级 0 始终是代理，其他所有等级都是观察者。 代理通过重复调用`run_episode`和`finish_episode`作为主设备，直到运行的奖励超过环境指定的奖励阈值为止。 所有观察者都被动地等待来自代理的命令。 该代码由[`rpc.init_rpc`](https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.init_rpc)和[`rpc.shutdown`](https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.shutdown)包装，它们分别初始化和终止 RPC 实例。 [API 页面](https://pytorch.org/docs/master/rpc.html)中提供了更多详细信息。
+使用`Policy`，`Observer`和`Agent`类，我们准备启动多个过程来执行分布式训练。 在此示例中，所有进程都运行相同的`run_worker`函数，并且它们使用等级来区分其角色。 等级 0 始终是智能体，其他所有等级都是观察者。 智能体通过重复调用`run_episode`和`finish_episode`作为主设备，直到运行的奖励超过环境指定的奖励阈值为止。 所有观察者都被动地等待来自智能体的命令。 该代码由[`rpc.init_rpc`](https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.init_rpc)和[`rpc.shutdown`](https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.shutdown)包装，它们分别初始化和终止 RPC 实例。 [API 页面](https://pytorch.org/docs/master/rpc.html)中提供了更多详细信息。
 
 ```py
 import os

new/pt-tut-17/67.md

@@ -180,7 +180,7 @@ class Observer:
 
 ```
 
-与之前的教程[分布式 RPC 框架入门](https://pytorch.org/tutorials/intermediate/rpc_tutorial.html)相比，观察者的行为略有不同。 它不会在环境停止时退出，而是始终在每个情节中运行`n_steps`迭代。 当环境返回时，观察者只需重置环境并重新开始。 通过这种设计，代理将从每个观察者那里收到固定数量的状态，因此可以将它们打包成固定大小的张量。 在每个步骤中，`Observer`使用 RPC 将其状态发送到`Agent`，并通过返回值获取操作。 在每个情节的结尾，它将所有步骤的奖励返还给`Agent`。 注意，`Agent`将使用 RPC 调用此`run_episode`函数。 因此，此函数中的`rpc_sync`调用将是嵌套的 RPC 调用。 我们也可以将此功能标记为`@rpc.functions.async_execution`，以避免阻塞`Observer`上的一个线程。 但是，由于瓶颈是`Agent`而不是`Observer`，因此可以在`Observer`进程中阻塞一个线程。
+与之前的教程[分布式 RPC 框架入门](https://pytorch.org/tutorials/intermediate/rpc_tutorial.html)相比，观察者的行为略有不同。 它不会在环境停止时退出，而是始终在每个情节中运行`n_steps`迭代。 当环境返回时，观察者只需重置环境并重新开始。 通过这种设计，智能体将从每个观察者那里收到固定数量的状态，因此可以将它们打包成固定大小的张量。 在每个步骤中，`Observer`使用 RPC 将其状态发送到`Agent`，并通过返回值获取操作。 在每个情节的结尾，它将所有步骤的奖励返还给`Agent`。 注意，`Agent`将使用 RPC 调用此`run_episode`函数。 因此，此函数中的`rpc_sync`调用将是嵌套的 RPC 调用。 我们也可以将此功能标记为`@rpc.functions.async_execution`，以避免阻塞`Observer`上的一个线程。 但是，由于瓶颈是`Agent`而不是`Observer`，因此可以在`Observer`进程中阻塞一个线程。
 
 ```py
 import torch
@@ -337,7 +337,7 @@ class Agent:
 
 ```
 
-其余代码是正常的进程启动和日志记录，与其他 RPC 教程类似。 在本教程中，所有观察者都被动地等待来自代理的命令。 有关完整的实现，请参考[示例](https://github.com/pytorch/examples/tree/master/distributed/rpc)回购。
+其余代码是正常的进程启动和日志记录，与其他 RPC 教程类似。 在本教程中，所有观察者都被动地等待来自智能体的命令。 有关完整的实现，请参考[示例](https://github.com/pytorch/examples/tree/master/distributed/rpc)回购。
 
 ```py
 def run_worker(rank, world_size, n_episode, batch, print_log=True):

new/rl-tf/00.md

 # 前言
 
-**强化学习**（**RL**）使您可以在业务环境中开发智能，快速且自学的系统。 这是训练您的学习型代理商并解决人工智能中各种问题的有效方法，从游戏，自动驾驶汽车和机器人到企业应用，其范围从数据中心节能（冷却数据中心）到智能仓储解决方案。
+**强化学习**（**RL**）使您可以在业务环境中开发智能，快速且自学的系统。 这是训练您的学习型智能体并解决人工智能中各种问题的有效方法，从游戏，自动驾驶汽车和机器人到企业应用，其范围从数据中心节能（冷却数据中心）到智能仓储解决方案。
 
 本书涵盖了通过将深度神经网络架构与强化学习相结合而在深度强化学习中取得的主要进步和成功。 该书还向读者介绍了强化学习的概念，它的优点以及为什么它如此受欢迎。 它讨论了 MDP，蒙特卡洛树搜索，策略和值迭代，时间差异学习（例如 Q 学习）和 SARSA。 您将使用 TensorFlow 和 OpenAI Gym 来构建简单的神经网络模型，以从自己的行为中学习。 您还将看到强化学习算法如何在游戏，图像处理和 NLP 中发挥作用。
 

new/rl-tf/01.md

@@ -2,7 +2,7 @@
 
 人工神经网络是一种计算系统，为我们提供了解决诸如图像识别到语音翻译等具有挑战性的机器学习任务的重要工具。 最近的突破，例如 Google DeepMind 的 AlphaGo 击败了最好的围棋玩家，或者卡内基梅隆大学的 Libratus 击败了世界上最好的职业扑克玩家，都证明了算法的进步。 这些算法像人类一样学习狭窄的智能，并达到超人水平的性能。 用通俗易懂的话说，人工神经网络是我们可以在计算机上编程的人脑的松散表示。 确切地说，这是受我们对人脑功能知识的启发而产生的一种方法。 神经网络的一个关键概念是创建输入数据的表示空间，然后在该空间中解决问题。 也就是说，从数据的当前状态开始扭曲数据，以便可以以不同的状态表示数据，从而可以解决有关的问题陈述（例如分类或回归）。 深度学习意味着多个隐藏的表示，即具有许多层的神经网络，可以创建更有效的数据表示。 每一层都会细化从上一层收到的信息。
 
-另一方面，强化学习是机器学习的另一个方面，它是一种学习遵循一系列动作的任何类型的活动的技术。 强化学习智能体从环境中收集信息并创建状态表示； 然后执行一个导致新状态和报酬的动作（即来自环境的可量化反馈，告诉我们该动作是好是坏）。 这种现象一直持续到代理能够将性能提高到超过特定阈值（即最大化奖励的期望值）为止。 在每个步骤中，可以随机选择这些动作，将其固定或使用神经网络进行监督。 使用深度神经网络对动作预测进行监督将打开一个新领域，称为**深度强化学习**。 这构成了 AlphaGo，Libratus 和人工智能领域中许多其他突破性研究的基础。
+另一方面，强化学习是机器学习的另一个方面，它是一种学习遵循一系列动作的任何类型的活动的技术。 强化学习智能体从环境中收集信息并创建状态表示； 然后执行一个导致新状态和报酬的动作（即来自环境的可量化反馈，告诉我们该动作是好是坏）。 这种现象一直持续到智能体能够将性能提高到超过特定阈值（即最大化奖励的期望值）为止。 在每个步骤中，可以随机选择这些动作，将其固定或使用神经网络进行监督。 使用深度神经网络对动作预测进行监督将打开一个新领域，称为**深度强化学习**。 这构成了 AlphaGo，Libratus 和人工智能领域中许多其他突破性研究的基础。
 
 我们将在本章介绍以下主题：
 
@@ -28,7 +28,7 @@
 
 在本章的后续部分中，我们将详细介绍前面提到的神经网络，但是首先我们必须了解，根据问题陈述的目的使用了不同类型的神经网络。
 
-监督学习是机器学习中的一种方法，其中，使用输入特征对及其对应的输出/目标值（也称为标签）来训练代理。
+监督学习是机器学习中的一种方法，其中，使用输入特征对及其对应的输出/目标值（也称为标签）来训练智能体。
 
 传统的机器学习算法对于结构化数据非常有效，其中大多数输入特征都定义得很好。 对于非结构化数据（例如音频，图像和文本）而言，情况并非如此，其中数据分别是信号，像素和字母。 对于计算机而言，比结构化数据更难理解非结构化数据。 神经网络基于这种非结构化数据进行预测的能力是其普及并产生经济价值的关键原因。
 
@@ -282,7 +282,7 @@ ReLU 的导数图，对于`x <= 0`，`f'(x) = 1`，对于`x > 0`，`f'(x) = 0`
 
 *   ![](img/fbdcd2fc-ce0e-4eb7-a681-cc83616c6af7.png)
 
-上式中使用的`α`是指学习率。 学习速率是学习代理适应新知识的速度。 因此，`α`，即学习率是需要作为标量值或时间函数分配的超参数。 这样，在每次迭代中，`W`和`b`的值都按照上式进行更新，直到成本函数的值达到可接受的最小值为止。
+上式中使用的`α`是指学习率。 学习速率是学习智能体适应新知识的速度。 因此，`α`，即学习率是需要作为标量值或时间函数分配的超参数。 这样，在每次迭代中，`W`和`b`的值都按照上式进行更新，直到成本函数的值达到可接受的最小值为止。
 
 梯度下降算法意味着沿斜率向下移动。 曲线的斜率由关于参数的成本函数`J`表示。 斜率（即斜率）给出了正斜率（如果为正）和负斜率的方向。 因此，我们必须使用负号与斜率相乘，因为我们必须与增加斜率的方向相反并朝减小斜率的方向相反。
 
@@ -481,7 +481,7 @@ Xavier 初始化是神经网络中权重的初始化，是遵循高斯分布的
 
 *   `tanh`是激活函数`f`。
 
-*   `[h[t-1]; x[t]]`指这两个信息的串联。 假设您的输入`x[t]`的形状为`nxd`，即`n`样本/行和`d`尺寸/列，`h[t-1]`为`n*l`。 然后，您的串联将得到形状为`n*(d+l)`的矩阵。
+*   `[h[t-1]; x[t]]`指这两个信息的连接。 假设您的输入`x[t]`的形状为`nxd`，即`n`样本/行和`d`尺寸/列，`h[t-1]`为`n*l`。 然后，您的连接将得到形状为`n*(d+l)`的矩阵。
 
 由于任何隐藏状态`h[i]`的形状为`n*l`。 因此，`W[h]`的形状为`(d+l)*l`，`b[h]`的形状为`l`。
 
@@ -517,7 +517,7 @@ RNN 实际上无法处理**长期依赖项**。 随着输出序列中的输出
 
 ![](img/3822e6c5-1056-44e1-ad43-c0b7c68a00e0.png)
 
-LSTM 的关键特征是单元状态`C[t]`。 这有助于信息保持不变。 我们将从遗忘门层`f[t]`开始，该层将最后一个隐藏状态，`h[t-1]`和`x[t]`的串联作为输入，并训练一个神经网络，该神经网络对于其中的每个数字得出 0 到 1 之间的数字。 最后一个单元格状态`C[t-1]`，其中 1 表示保留该值，0 表示忘记该值。 因此，该层将识别过去要忘记的信息，并保留哪些信息。
+LSTM 的关键特征是单元状态`C[t]`。 这有助于信息保持不变。 我们将从遗忘门层`f[t]`开始，该层将最后一个隐藏状态，`h[t-1]`和`x[t]`的连接作为输入，并训练一个神经网络，该神经网络对于其中的每个数字得出 0 到 1 之间的数字。 最后一个单元格状态`C[t-1]`，其中 1 表示保留该值，0 表示忘记该值。 因此，该层将识别过去要忘记的信息，并保留哪些信息。
 
 ![](img/8e72b527-34c7-411d-ab7a-e134400a410a.png)
 
@@ -665,11 +665,11 @@ Inception 由 Google 团队于 2014 年创建。其主要思想是创建更广
 
 在无监督学习中，为训练目的给出了训练集的输入特征`X`。 没有关联的`Y`值。 目标是创建一个模型，该模型可通过了解底层模式来学习将数据隔离到不同的群集中，从而对数据进行分类以找到某种用途。 然后将该模型进一步用于输入特征`X'`，以预测它们与聚类之一的相似性。
 
-强化学习与有监督的和无监督的都不同。 强化学习可以指导代理人如何在现实世界中行动。 界面比训练向量更广泛，例如在有监督或无监督学习中。 这是整个环境，可以是真实的世界也可以是模拟的世界。 代理人以不同的方式进行训练，即目标是达到目标状态，这与监督学习的情况不同，后者的目的是使可能性最大化或成本最小化。
+强化学习与有监督的和无监督的都不同。 强化学习可以指导智能体如何在现实世界中行动。 界面比训练向量更广泛，例如在有监督或无监督学习中。 这是整个环境，可以是真实的世界也可以是模拟的世界。 智能体以不同的方式进行训练，即目标是达到目标状态，这与监督学习的情况不同，后者的目的是使可能性最大化或成本最小化。
 
-强化学习智能体会自动从环境中获得反馈，即从环境中获得奖励，这与监督学习中的标注需要耗时的人力不同。 强化学习的更大优势之一是，以目标的形式表述任何任务的目标有助于解决各种各样的问题。 例如，视频游戏代理商的目标是通过获得最高分数来赢得比赛。 这也有助于发现实现目标的新方法。 例如，当 AlphaGo 成为围棋世界冠军时，它发现了新颖独特的取胜方法。
+强化学习智能体会自动从环境中获得反馈，即从环境中获得奖励，这与监督学习中的标注需要耗时的人力不同。 强化学习的更大优势之一是，以目标的形式表述任何任务的目标有助于解决各种各样的问题。 例如，视频游戏智能体的目标是通过获得最高分数来赢得比赛。 这也有助于发现实现目标的新方法。 例如，当 AlphaGo 成为围棋世界冠军时，它发现了新颖独特的取胜方法。
 
-强化学习智能体就像人一样。 人类进化非常缓慢。 代理人可以增强力量，但它可以很快完成任务。 就感知环境而言，人类和人工智能代理都无法立即感知整个世界。 感知环境创建了一种状态，在该状态中，代理执行操作并落入新状态，即新感知的环境不同于早期环境。 这将创建一个既可以有限也可以无限的状态空间。
+强化学习智能体就像人一样。 人类进化非常缓慢。 智能体可以增强力量，但它可以很快完成任务。 就感知环境而言，人类和人工智能智能体都无法立即感知整个世界。 感知环境创建了一种状态，在该状态中，智能体执行操作并落入新状态，即新感知的环境不同于早期环境。 这将创建一个既可以有限也可以无限的状态空间。
 
 对此技术感兴趣的最大部门是国防。 强化学习智能体人可以代替不仅步行，还能战斗并做出重要决定的士兵吗？
 
@@ -678,10 +678,10 @@ Inception 由 Google 团队于 2014 年创建。其主要思想是创建更广
 以下是与强化学习相关的基本术语：
 
 *   **智能体**：我们是通过编程创建的，因此它能够感知环境，执行动作，接收反馈并尝试获得最大回报。
-*   **环境**：代理程序所在的世界。 它可以是真实的或模拟的。
-*   **状态**：代理感知的环境感知或配置。 状态空间可以是有限的或无限的。
-*   **奖励**：座席采取任何措施后收到的反馈。 代理的目标是最大化整体奖励，即立即和将来的奖励。 奖励是预先定义的。 因此，必须正确创建它们才能有效实现目标。
-*   **操作**：代理在给定环境中能够执行的任何操作。 动作空间可以是有限的或无限的。
+*   **环境**：智能体程序所在的世界。 它可以是真实的或模拟的。
+*   **状态**：智能体感知的环境感知或配置。 状态空间可以是有限的或无限的。
+*   **奖励**：座席采取任何措施后收到的反馈。 智能体的目标是最大化整体奖励，即立即和将来的奖励。 奖励是预先定义的。 因此，必须正确创建它们才能有效实现目标。
+*   **操作**：智能体在给定环境中能够执行的任何操作。 动作空间可以是有限的或无限的。
 *   **SAR 三元组**：（状态，动作，奖励）称为 SAR 三元组，表示为`(s, a, r)`。
 *   **剧集**：代表整个任务的一次完整运行。
 
@@ -696,15 +696,15 @@ Inception 由 Google 团队于 2014 年创建。其主要思想是创建更广
 最优性标准是根据数据创建的模型的拟合优度的度量。 例如，在监督分类学习算法中，我们将最大似然性作为最优性标准。 因此，根据问题陈述和客观最优标准不同。 在强化学习中，我们的主要目标是最大化未来的回报。 因此，我们有两个不同的最优性标准，分别是：
 
 *   **值函数**：根据未来可能的回报来量化状态
-*   **策略**：指导代理在给定状态下应采取的措施
+*   **策略**：指导智能体在给定状态下应采取的措施
 
 我们将在接下来的主题中详细讨论这两个方面。
 
 # 最优值函数
 
-代理商应该能够考虑立即和未来的回报。 因此，还会为每个遇到的状态分配一个值，该值也反映了此将来的信息。 这称为值函数。 延迟奖励的概念来了，目前，现在采取的行动将导致未来的潜在奖励。
+智能体应该能够考虑立即和未来的回报。 因此，还会为每个遇到的状态分配一个值，该值也反映了此将来的信息。 这称为值函数。 延迟奖励的概念来了，目前，现在采取的行动将导致未来的潜在奖励。
 
-`V(s)`，即状态的值定义为，从该状态到后续状态直到代理到达目标状态之前，所有将来在该状态下将要收到的奖励的期望值。 基本上，值函数告诉我们处于这种状态有多好。 值越高，状态越好。
+`V(s)`，即状态的值定义为，从该状态到后续状态直到智能体到达目标状态之前，所有将来在该状态下将要收到的奖励的期望值。 基本上，值函数告诉我们处于这种状态有多好。 值越高，状态越好。
 
 分配给每个`(s, a, s')`三元组的奖励是固定的。 状态值不是这种情况。 它会随着情节中的每个动作以及不同情节而变化。
 
@@ -720,15 +720,15 @@ V(s) = E[all future rewards discounted | S(t)=s]
 
 # 最优策略模型
 
-策略被定义为指导代理在不同状态下进行操作选择的模型。 策略被表示为`π`。 `π`本质上是在特定状态下某种动作的概率：
+策略被定义为指导智能体在不同状态下进行操作选择的模型。 策略被表示为`π`。 `π`本质上是在特定状态下某种动作的概率：
 
 ![](img/be42dad4-02e2-4f9e-8af8-bb8b677521d4.png)
 
-因此，策略图将提供给定特定状态的不同操作的概率集。 该策略与值函数一起创建了一个解决方案，可根据策略和状态的计算值来帮助代理导航。
+因此，策略图将提供给定特定状态的不同操作的概率集。 该策略与值函数一起创建了一个解决方案，可根据策略和状态的计算值来帮助智能体导航。
 
 # 强化学习的 Q 学习方法
 
-Q 学习是尝试学习在特定状态下向代理提供的特定操作的值`Q(s, a)`。 考虑一个表，其中行数代表状态数，而列数代表动作数。 这称为 Q 表。 因此，我们必须学习价值，以找出对于给定状态下的代理而言，哪种行动最合适。
+Q 学习是尝试学习在特定状态下向智能体提供的特定操作的值`Q(s, a)`。 考虑一个表，其中行数代表状态数，而列数代表动作数。 这称为 Q 表。 因此，我们必须学习价值，以找出对于给定状态下的智能体而言，哪种行动最合适。
 
 Q 学习涉及的步骤：
 
@@ -762,9 +762,9 @@ A3C 算法由 Google DeepMind 和 MILA 的联合团队于 2016 年 6 月发布
 
 我们将在此处重点讨论，但是我们将在第 6 章，“异步方法”中进行更深入的探讨。 让我们从名称开始，即**异步优势演员评论家**（**A3C**）算法，然后将其解压缩以获得该算法的基本概述：
 
-*   **异步**：在 DQN 中，您还记得我们将神经网络与我们的代理一起使用来预测动作。 这意味着只有一个代理，并且它正在与一个环境交互。 A3C 所做的是创建代理环境的多个副本，以使代理更有效地学习。 A3C 具有一个全球网络和多个工作人员代理，其中每个代理都有其自己的一组网络参数，并且每个参数都与其环境副本同时进行交互，而无需与另一个代理的环境进行交互。 它比单个代理更好的原因是每个代理的经验独立于其他代理的经验。 因此，所有工人代理人的总体经验导致了各种各样的训练。
-*   **演员评论家**：演员评论家结合了价值迭代和策略迭代的优势。 因此，网络将为给定状态 s 估计值函数`V(s)`和策略`π(s)`。 函数逼近器神经网络的顶部将有两个单独的全连接层，分别输出状态的值和状态策略。 代理使用值，该值充当批评者来更新策略，即，智能角色。
-*   **优势**：策略梯度使用折扣收益告诉代理该行动是好是坏。 用优势代替它不仅可以量化操作的好坏状态，而且可以更好地鼓励和劝阻操作（我们将在第 4 章，“策略梯度”中进行讨论）。
+*   **异步**：在 DQN 中，您还记得我们将神经网络与我们的智能体一起使用来预测动作。 这意味着只有一个智能体，并且它正在与一个环境交互。 A3C 所做的是创建智能体环境的多个副本，以使智能体更有效地学习。 A3C 具有一个全球网络和多个工作人员智能体，其中每个智能体都有其自己的一组网络参数，并且每个参数都与其环境副本同时进行交互，而无需与另一个智能体的环境进行交互。 它比单个智能体更好的原因是每个智能体的经验独立于其他智能体的经验。 因此，所有工人智能体的总体经验导致了各种各样的训练。
+*   **演员评论家**：演员评论家结合了价值迭代和策略迭代的优势。 因此，网络将为给定状态 s 估计值函数`V(s)`和策略`π(s)`。 函数逼近器神经网络的顶部将有两个单独的全连接层，分别输出状态的值和状态策略。 智能体使用值，该值充当批评者来更新策略，即，智能角色。
+*   **优势**：策略梯度使用折扣收益告诉智能体该行动是好是坏。 用优势代替它不仅可以量化操作的好坏状态，而且可以更好地鼓励和劝阻操作（我们将在第 4 章，“策略梯度”中进行讨论）。
 
 # TensorFlow 和 OpenAI Gym 简介
 

new/rl-tf/02.md

@@ -2,9 +2,9 @@
 
 OpenAI Gym 提供了许多虚拟环境来训练您的强化学习智能体。 在强化学习中，最困难的任务是创造环境。 OpenAI Gym 通过提供许多玩具游戏环境为用户提供了一个平台，以训练和确定他们的强化学习智能体，从而为救援提供了帮助。
 
-换句话说，它为强化学习智能体提供了一个学习和基准化他们的表现的场所，其中代理必须学会从开始状态导航到目标状态，而不会遭受任何不幸。
+换句话说，它为强化学习智能体提供了一个学习和基准化他们的表现的场所，其中智能体必须学会从开始状态导航到目标状态，而不会遭受任何不幸。
 
-因此，在本章中，我们将学习从 OpenAI Gym 了解和使用环境，并尝试实现基本的 Q 学习和 Q 网络，供我们的代理商学习。
+因此，在本章中，我们将学习从 OpenAI Gym 了解和使用环境，并尝试实现基本的 Q 学习和 Q 网络，供我们的智能体学习。
 
 OpenAI Gym 提供不同类型的环境。 它们如下：
 
@@ -27,7 +27,7 @@ OpenAI Gym 提供不同类型的环境。 它们如下：
 我们将在本章介绍以下主题：
 
 *   OpenAI Gym 环境
-*   使用 OpenAI Gym 环境对代理进行编程
+*   使用 OpenAI Gym 环境对智能体进行编程
 *   将 Q 网络用于实际应用
 
 # OpenAI Gym
@@ -75,7 +75,7 @@ import Gym
 env = Gym.make('FrozenLake-v0')   #make function of Gym loads the specified environment
 ```
 
-接下来，我们来重置环境。 在执行强化学习任务时，特工会经历多个情节的学习。 结果，在每个情节开始时，都需要重置环境，使其恢复到初始状态，并且代理从开始状态开始。 以下代码显示了重置环境的过程：
+接下来，我们来重置环境。 在执行强化学习任务时，智能体会经历多个情节的学习。 结果，在每个情节开始时，都需要重置环境，使其恢复到初始状态，并且智能体从开始状态开始。 以下代码显示了重置环境的过程：
 
 ```py
 import Gym 
@@ -87,7 +87,7 @@ print(s)
 0                #initial state is 0
 ```
 
-在执行每个操作之后，可能需要显示代理在环境中的状态。 通过以下方式可视化该状态：
+在执行每个操作之后，可能需要显示智能体在环境中的状态。 通过以下方式可视化该状态：
 
 ```py
 env.render()
@@ -112,7 +112,7 @@ HFFG
 env = env.unwrapped
 ```
 
-每个环境都由状态空间和供代理执行的操作空间定义。 为了构建增强学习代理，了解状态空间和动作空间的类型（离散或连续）和大小非常重要：
+每个环境都由状态空间和供智能体执行的操作空间定义。 为了构建增强学习智能体，了解状态空间和动作空间的类型（离散或连续）和大小非常重要：
 
 ```py
 print(env.action_space)
@@ -123,7 +123,7 @@ Discrete(4)
 4 
 ```
 
-`Discrete(4)`输出表示冰冻湖环境的动作空间是一组离散值，并且具有可由代理执行的四个不同的动作。
+`Discrete(4)`输出表示冰冻湖环境的动作空间是一组离散值，并且具有可由智能体执行的四个不同的动作。
 
 ```py
 print(env.observation_space)
@@ -134,13 +134,13 @@ Discrete(16)
 16
 ```
 
-`Discrete(16)`输出表示冻结湖环境的观察（状态）空间是一组离散值，并具有 16 种要由代理探索的不同状态。
+`Discrete(16)`输出表示冻结湖环境的观察（状态）空间是一组离散值，并具有 16 种要由智能体探索的不同状态。
 
 # 使用 OpenAI Gym 环境对智能体编程
 
 本节考虑的环境是 **FrozenLake-v0**。 有关环境的实际文档可以在[这个页面](https://gym.openai.com/envs/FrozenLake-v0/)中找到。
 
-此环境由代表一个湖泊的`4 x 4`网格组成。 因此，我们有 16 个网格块，其中每个块可以是开始块（`S`），冻结块（`F`），目标块（`G`）或孔块（`H`）。 因此，代理程序的目标是学会从头到尾进行导航而不会陷入困境：
+此环境由代表一个湖泊的`4 x 4`网格组成。 因此，我们有 16 个网格块，其中每个块可以是开始块（`S`），冻结块（`F`），目标块（`G`）或孔块（`H`）。 因此，智能体程序的目标是学会从头到尾进行导航而不会陷入困境：
 
 ```py
 import Gym
@@ -154,11 +154,11 @@ FFFH
 HFFG
 ```
 
-在任何给定状态下，代理都有四个要执行的动作，分别是上，下，左和右。 除了导致目标状态的那一步外，每一步的奖励都是 0，那么奖励将是 1。我们从`S`状态开始，我们的目标是达到`G`状态而不以最优化的路径通过`F`状态降落到`H`状态。
+在任何给定状态下，智能体都有四个要执行的动作，分别是上，下，左和右。 除了导致目标状态的那一步外，每一步的奖励都是 0，那么奖励将是 1。我们从`S`状态开始，我们的目标是达到`G`状态而不以最优化的路径通过`F`状态降落到`H`状态。
 
 # Q 学习
 
-现在，让我们尝试使用 Q 学习对增强学习代理进行编程。 Q 学习由一个 Q 表组成，该表包含每个状态动作对的 Q 值。 表中的行数等于环境中的状态数，而列数等于操作数。 由于状态数为`16`，而动作数为`4`，因此此环境的 Q 表由`16`行和`4`列组成。 它的代码在这里给出：
+现在，让我们尝试使用 Q 学习对增强学习智能体进行编程。 Q 学习由一个 Q 表组成，该表包含每个状态动作对的 Q 值。 表中的行数等于环境中的状态数，而列数等于操作数。 由于状态数为`16`，而动作数为`4`，因此此环境的 Q 表由`16`行和`4`列组成。 它的代码在这里给出：
 
 ```py
 print("Number of actions : ",env.action_space.n)
@@ -201,7 +201,7 @@ else:
 
 最终，经过几次迭代，我们发现了每个状态中所有状态中的最佳操作，因为它可以选择探索新的随机操作以及利用现有操作并对其进行优化。
 
-让我们尝试实现一种基本的 Q 学习算法，以使代理学习如何在从头到尾的 16 个网格的冰冻湖面中导航，而不会陷入困境：
+让我们尝试实现一种基本的 Q 学习算法，以使智能体学习如何在从头到尾的 16 个网格的冰冻湖面中导航，而不会陷入困境：
 
 ```py
 # importing dependency libraries
@@ -418,7 +418,7 @@ input_state = [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0]
 
 ![](img/d8af6b5f-f92c-4f40-84de-37dedd116228.png)
 
-让我们尝试用 Python 来实现这一点，并学习如何实现基本的 Q 网络算法，以使代理从头到尾在整个 16 个网格的冰冻湖面中导航，而不会陷入困境：
+让我们尝试用 Python 来实现这一点，并学习如何实现基本的 Q 网络算法，以使智能体从头到尾在整个 16 个网格的冰冻湖面中导航，而不会陷入困境：
 
 ```py
 # importing dependency libraries
@@ -569,6 +569,6 @@ Q 学习和 Q 网络都需要付出一定的稳定性。 在某些情况下，
 
 # 总结
 
-在本章中，我们学习了 OpenAI Gym，包括安装各种重要功能以加载，渲染和理解环境状态操作空间。 我们了解了 ε 贪婪方法作为探索与利用难题的解决方案，并尝试实现基本的 Q 学习和 Q 网络算法，以训练增强学习代理从 OpenAI Gym 导航环境。
+在本章中，我们学习了 OpenAI Gym，包括安装各种重要功能以加载，渲染和理解环境状态操作空间。 我们了解了 ε 贪婪方法作为探索与利用难题的解决方案，并尝试实现基本的 Q 学习和 Q 网络算法，以训练增强学习智能体从 OpenAI Gym 导航环境。
 
 在下一章中，我们将介绍强化学习中最基本的概念，包括**马尔可夫决策过程**（**MDP**），贝尔曼方程和 Markov Chain Monte Carlo。
\ No newline at end of file

new/rl-tf/03.md

@@ -6,7 +6,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 因此，任何遵循 Markov 属性的，由一组状态，动作和奖励组成的强化学习任务都将被视为 MDP。
 
-在本章中，我们将深入研究 MDP，状态，动作，奖励，策略，以及如何使用贝尔曼方程求解它们。 此外，我们将介绍部分可观察的 MDP 的基础知识及其解决的复杂性。 我们还将介绍探索利用难题和著名的 E3（开发，探索或利用）算法。 然后我们将进入引人入胜的部分，在该部分中，我们将为代理编程，以使用 MDP 原理学习和玩乒乓球。
+在本章中，我们将深入研究 MDP，状态，动作，奖励，策略，以及如何使用贝尔曼方程求解它们。 此外，我们将介绍部分可观察的 MDP 的基础知识及其解决的复杂性。 我们还将介绍探索利用难题和著名的 E3（开发，探索或利用）算法。 然后我们将进入引人入胜的部分，在该部分中，我们将为智能体编程，以使用 MDP 原理学习和玩乒乓球。
 
 我们将在本章介绍以下主题：
 
@@ -24,7 +24,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 *   **奖励**：`R(s), R(s, a), R(s, a, s')`
 *   **策略**：`π(s) -> a[π*]`是最佳策略
 
-对于 MDP，环境是完全可观察的，也就是说，代理在任何时间点所做的任何观察都足以做出最佳决策。 在部分可观察的环境中，代理程序需要一个内存来存储过去的观察结果，以便做出最佳决策。
+对于 MDP，环境是完全可观察的，也就是说，智能体在任何时间点所做的任何观察都足以做出最佳决策。 在部分可观察的环境中，智能体程序需要一个内存来存储过去的观察结果，以便做出最佳决策。
 
 让我们尝试将其分解为不同的乐高积木，以了解整个过程的含义。
 
@@ -38,7 +38,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 # `S`状态集
 
-**`S`状态集**是构成环境的一组不同状态，表示为`s`。 状态是从环境获得的数据的特征表示。 因此，来自代理传感器的任何输入都可以在状态形成中发挥重要作用。 状态空间可以是离散的也可以是连续的。 从开始状态开始，必须以最优化的路径达到目标状态，而不会在不良状态下结束（例如下图所示的红色状态）。
+**`S`状态集**是构成环境的一组不同状态，表示为`s`。 状态是从环境获得的数据的特征表示。 因此，来自智能体传感器的任何输入都可以在状态形成中发挥重要作用。 状态空间可以是离散的也可以是连续的。 从开始状态开始，必须以最优化的路径达到目标状态，而不会在不良状态下结束（例如下图所示的红色状态）。
 
 考虑以下网格世界，它具有 12 个离散状态，其中绿色网格是目标状态，红色是要避免的状态，黑色是一面碰到墙壁就会反弹的墙壁：
 
@@ -48,7 +48,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 # 动作
 
-**动作**是代理可以在特定状态下执行或执行的操作。 换句话说，动作是允许代理在给定环境中执行的一组操作。 像状态一样，动作也可以是离散的或连续的。
+**动作**是智能体可以在特定状态下执行或执行的操作。 换句话说，动作是允许智能体在给定环境中执行的一组操作。 像状态一样，动作也可以是离散的或连续的。
 
 考虑以下具有 12 个离散状态和 4 个离散动作（`UP`，`DOWN`，`RIGHT`和`LEFT`）的 gridworld 示例：
 
@@ -58,7 +58,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 # 转移模型
 
-转移模型`T(s, a, s')`是三个变量的函数，它们是当前状态（`s`），动作（`a`） 以及新状态（`s'`），并定义了在环境中玩游戏的规则。 它给出了`P(s' | s, a)`的概率，也就是说，假设代理采取了行动`a`，在给定状态`s`下降落到新的`s'`状态的概率。
+转移模型`T(s, a, s')`是三个变量的函数，它们是当前状态（`s`），动作（`a`） 以及新状态（`s'`），并定义了在环境中玩游戏的规则。 它给出了`P(s' | s, a)`的概率，也就是说，假设智能体采取了行动`a`，在给定状态`s`下降落到新的`s'`状态的概率。
 
 转移模型在随机世界中起着至关重要的作用，与确定性世界的情况不同，在确定性世界中，除了确定的着陆状态之外，任何着陆状态的概率都为零。
 
@@ -83,7 +83,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 对于特定环境，领域知识在不同状态的奖励分配中起着重要作用，因为奖励中的细微变化对于找到 MDP 问题的最佳解决方案确实很重要。
 
-当采取某种行动时，我们会奖励代理商以两种方式。 他们是：
+当采取某种行动时，我们会奖励智能体以两种方式。 他们是：
 
 *   **信用分配问题**：我们回顾过去，检查哪些活动导致了当前的奖励，即哪个活动获得了荣誉
 *   **延迟奖励**：相比之下，在当前状态下，我们检查要采取的行动会导致我们获得潜在的奖励
@@ -96,7 +96,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 ![](img/ec5c8b7c-4b92-426c-97e0-673286364a05.png)
 
-策略是将状态作为输入并输出要采取的措施的功能。 因此，该策略是代理必须遵守的命令。
+策略是将状态作为输入并输出要采取的措施的功能。 因此，该策略是智能体必须遵守的命令。
 
 ![](img/8b92a7d2-aa9e-465a-88d3-7880d412516e.png)被称为最佳策略，它使预期收益最大化。 在采取的所有策略中，最优策略是一种优化的策略，用于最大化一生中已收到或预期收到的奖励金额。 对于 MDP，生命周期没有尽头，您必须确定结束时间。
 
@@ -122,7 +122,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 # 序列的效用
 
-序列的效用是指当代理人经历状态序列时所获得的总报酬。 它表示为`U(s[0], s[1], s[2], ...)`，其中`s[0], s[1], s[2], ...`表示状态序列。
+序列的效用是指当智能体经历状态序列时所获得的总报酬。 它表示为`U(s[0], s[1], s[2], ...)`，其中`s[0], s[1], s[2], ...`表示状态序列。
 
 第二个假设是，如果有两个效用`U(s[0], s[1], s[2], ...)`和`U(s[0], s'[1], s'[2], ...)`，则两个序列的开始状态都相同，并且
 
@@ -185,7 +185,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 ![](img/2ccc6145-78d9-4ba3-a12e-19b454d98f69.png)，
 
-其中`E[...]`表示从状态序列获得的报酬的期望值，代理观察其是否遵循`π`策略。 因此，`argmax[π]`输出具有最高预期奖励的`π`策略。
+其中`E[...]`表示从状态序列获得的报酬的期望值，智能体观察其是否遵循`π`策略。 因此，`argmax[π]`输出具有最高预期奖励的`π`策略。
 
 同样，我们也可以计算状态为的策略效用，也就是说，如果我们处于`s`状态，则给定`π`策略，则， `s`状态的`π`策略，即`U[π](s)`将是从该状态开始的预期收益：
 
@@ -203,7 +203,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 ![](img/0ef93e7c-5cc5-45ab-8baf-db2a07bd9e29.png)
 
-其中，`R(s)`是即时奖励，`max[a] Σ[s'] T(s, a, s')U(s')`是来自未来的奖励，也就是说，如果采取行动`a`，代理可以从给定的`s`状态到达的`s'`状态的贴现效用。
+其中，`R(s)`是即时奖励，`max[a] Σ[s'] T(s, a, s')U(s')`是来自未来的奖励，也就是说，如果采取行动`a`，智能体可以从给定的`s`状态到达的`s'`状态的贴现效用。
 
 # 解决贝尔曼方程来找到策略
 
@@ -221,7 +221,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 多次迭代以得出状态的真实值。 迭代以收敛到状态的真实值的过程称为**值迭代**。
 
-对于游戏结束的终端状态，那些终端状态的效用等于代理在进入终端状态时所获得的立即奖励。
+对于游戏结束的终端状态，那些终端状态的效用等于智能体在进入终端状态时所获得的立即奖励。
 
 让我们尝试通过示例来理解这一点。
 
@@ -237,17 +237,17 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 *   绿色状态是目标状态`G`，奖励为 +1。
 
-*   红色状态为错误状态`B`，奖励为 -1，请尝试阻止您的代理进入此状态
+*   红色状态为错误状态`B`，奖励为 -1，请尝试阻止您的智能体进入此状态
 
 *   因此，绿色和红色状态是终端状态，进入其中一个状态，游戏结束。 如果座席遇到绿色状态（即进球状态），则座席获胜；如果他们进入红色状态，则座席将输掉比赛。
 
 *   `γ = 1/2`，`R(s) = -0.04`（即，对除`G`和`B`状态之外的所有状态的奖励是 -0.04），`U[0](s) = 0`（即，第一个时间步长的效用为 0，除`G`和`B`状态外）。
 
-*   如果沿期望的方向前进，则过渡概率`T(s, a, s')`等于 0.8； 否则，如果垂直于所需方向，则各为 0.1。 例如，如果操作是`UP`，则概率为 0.8，代理会`UP`，但概率为 0.1 时，它会`RIGHT`，而 0.1 则为`LEFT`。
+*   如果沿期望的方向前进，则过渡概率`T(s, a, s')`等于 0.8； 否则，如果垂直于所需方向，则各为 0.1。 例如，如果操作是`UP`，则概率为 0.8，智能体会`UP`，但概率为 0.1 时，它会`RIGHT`，而 0.1 则为`LEFT`。
 
 问题：
 
-1.  找到`U[1](X)`，时间步骤 1 的`X`状态的效用，也就是说，代理将进行一次迭代
+1.  找到`U[1](X)`，时间步骤 1 的`X`状态的效用，也就是说，智能体将进行一次迭代
 2.  同样，找到`U[2](X)`
 
 解：
@@ -378,7 +378,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 # 部分可观察的马尔可夫决策过程
 
-在 MDP 中，可观察的数量是动作，设置`A`，状态，设置`S`，转移模型，`T`和奖励，设置`R`。 在**部分可观察的 MDP**（也称为 **POMDP**）的情况下，情况并非如此。 在 POMDP 中，内部存在一个 MDP，代理无法直接观察到它，而是根据所做的任何观察来做出决定。
+在 MDP 中，可观察的数量是动作，设置`A`，状态，设置`S`，转移模型，`T`和奖励，设置`R`。 在**部分可观察的 MDP**（也称为 **POMDP**）的情况下，情况并非如此。 在 POMDP 中，内部存在一个 MDP，智能体无法直接观察到它，而是根据所做的任何观察来做出决定。
 
 在 POMDP 中，有一个观测集`Z`，它包含不同的可观测状态和观测函数`O`，它采用`s`状态和`z`观察值作为输入，输出在`s`状态下看到`z`观察值的可能性。
 
@@ -398,9 +398,9 @@ POMDP 难以解决，无法实现最佳解决方案。
 
 # 状态估计
 
-如果我们扩展状态空间，这将有助于我们将 POMDP 转换为 MDP，其中`Z`包含完全可观察的状态空间。 这给出了**信念状态**`b(s)`的概念，这是决策者将在 POMDP 上下文中使用的状态。 置信状态，即`b(s)`给出了代理处于`s`状态的可能性。 因此，置信状态`b`，是代表所有状态上概率分布的向量。 因此，一旦采取行动，信念状态就会更新。
+如果我们扩展状态空间，这将有助于我们将 POMDP 转换为 MDP，其中`Z`包含完全可观察的状态空间。 这给出了**信念状态**`b(s)`的概念，这是决策者将在 POMDP 上下文中使用的状态。 置信状态，即`b(s)`给出了智能体处于`s`状态的可能性。 因此，置信状态`b`，是代表所有状态上概率分布的向量。 因此，一旦采取行动，信念状态就会更新。
 
-假设存在一个信念状态`b`，该代理采取行动`a`并收到了一些观察结果`z`。 这形成了一个新的信念状态。 因此，我们正在将 POMDP 转换为信念 MDP，其中它将由信念状态组成为 MDP 状态。
+假设存在一个信念状态`b`，该智能体采取行动`a`并收到了一些观察结果`z`。 这形成了一个新的信念状态。 因此，我们正在将 POMDP 转换为信念 MDP，其中它将由信念状态组成为 MDP 状态。
 
 根据前述条件，给出的信息是置信状态`b`，动作`a`和观察值`z`。 因此，
 
@@ -534,7 +534,7 @@ After learning completion printing the utilities for each states below from stat
 
 12 13 14 15
 
-我们代理的起始状态为 0。让我们从`s = 0`开始，
+我们智能体的起始状态为 0。让我们从`s = 0`开始，
 
 `U[s = 0] = 0.023482`，现在动作可以是`UP`，`DOWN`，`LEFT`或`RIGHT` 。
 
@@ -598,6 +598,6 @@ After learning completion printing the utilities for each states below from stat
 
 在本章中，我们介绍了网格世界类型的环境的详细信息，并了解了马尔可夫决策过程的基础，即状态，动作，奖励，转移模型和策略。 此外，我们利用这些信息通过价值迭代和策略迭代方法来计算效用和最优策略。
 
-除此之外，我们对部分可观察的马尔可夫决策过程是什么样子以及解决它们的挑战有了基本的了解。 最后，我们从 OpenAI Gym 获取了我们最喜欢的 gridworld 环境，即 FrozenLake-v0，并实现了一种值迭代方法，以使我们的代理学会在该环境中导航。
+除此之外，我们对部分可观察的马尔可夫决策过程是什么样子以及解决它们的挑战有了基本的了解。 最后，我们从 OpenAI Gym 获取了我们最喜欢的 gridworld 环境，即 FrozenLake-v0，并实现了一种值迭代方法，以使我们的智能体学会在该环境中导航。
 
 在下一章中，我们将从策略梯度开始，然后从 **FrozenLake** 过渡到其他一些引人入胜的复杂环境。
\ No newline at end of file

new/rl-tf/04.md

 # 策略梯度
 
-到目前为止，我们已经看到了如何使用基于价值的方法从值函数中派生隐式策略。 在这里，代理将尝试直接学习策略。 做法是相似的，任何有经验的代理人都会在目睹之后更改策略。
+到目前为止，我们已经看到了如何使用基于价值的方法从值函数中派生隐式策略。 在这里，智能体将尝试直接学习策略。 做法是相似的，任何有经验的智能体都会在目睹之后更改策略。
 
 价值迭代，策略迭代和 Q 学习属于通过动态编程解决的基于价值的方法，而策略优化方法则涉及策略梯度和该知识与策略迭代的结合，从而产生了行动者批判算法。
 
@@ -21,7 +21,7 @@
 
 # 策略优化方法
 
-策略优化方法的目标是找到随机策略`π[θ]`，它是针对给定状态的操作分布，该状态使期望的奖励总和最大化。 它旨在直接找到该策略。 基本概述是创建一个神经网络（即策略网络），该网络处理一些状态信息并输出代理可能采取的行动的分布。
+策略优化方法的目标是找到随机策略`π[θ]`，它是针对给定状态的操作分布，该状态使期望的奖励总和最大化。 它旨在直接找到该策略。 基本概述是创建一个神经网络（即策略网络），该网络处理一些状态信息并输出智能体可能采取的行动的分布。
 
 策略优化的两个主要组成部分是：
 
@@ -72,7 +72,7 @@
 
 ![](img/c3a614ea-6981-49ca-b3a3-65614cdb7db6.png)
 
-在上图中，我们看到有八个状态，其中两个奖励为 -10 的状态是要避免的不良状态，并且有一个奖励为 10 的状态是良好状态，还有目标状态。 但是，我们主要担心的是灰色阴影状态，在该状态下，代理人无法区分这两个状态，因为它们具有相同的特征。
+在上图中，我们看到有八个状态，其中两个奖励为 -10 的状态是要避免的不良状态，并且有一个奖励为 10 的状态是良好状态，还有目标状态。 但是，我们主要担心的是灰色阴影状态，在该状态下，智能体无法区分这两个状态，因为它们具有相同的特征。
 
 假设任何状态的特征都为`φ(s, a)`，动作为北，东，西和南。
 
@@ -350,7 +350,7 @@ end for
 
 # 使用策略梯度的学习 Pong 的智能体
 
-在本节中，我们将创建一个策略网络，该策略网络将使用来自 pong 环境的原始像素（来自 OpenAI Gym 的 **pong-v0**）作为输入。 策略网络是一个单独的隐藏层神经网络，它全连接到输入层上 pong 的原始像素，还全连接到包含单个节点的输出层，该单个节点返回了桨上升的可能性。 我要感谢 Andrej Karpathy 提出了一种使代理使用策略梯度进行学习的解决方案。 我们将尝试实现类似的方法。
+在本节中，我们将创建一个策略网络，该策略网络将使用来自 pong 环境的原始像素（来自 OpenAI Gym 的 **pong-v0**）作为输入。 策略网络是一个单独的隐藏层神经网络，它全连接到输入层上 pong 的原始像素，还全连接到包含单个节点的输出层，该单个节点返回了桨上升的可能性。 我要感谢 Andrej Karpathy 提出了一种使智能体使用策略梯度进行学习的解决方案。 我们将尝试实现类似的方法。
 
 灰度大小为`80 * 80`的像素图像（我们将不使用 RGB，即`80 * 80 * 3`）。 因此，我们有一个`80 * 80`的二进制网格，它告诉我们桨和球的位置，并将其作为输入输入到神经网络。 因此，神经网络将包含以下内容：
 
@@ -367,7 +367,7 @@ end for
 
 这是巨大的，因此训练需要几天的时间才能见证您的经纪人流畅地打乒乓球。
 
-不能从静态帧播放 Pong，因此，需要捕获某种运动信息，可以通过串联两个这样的帧或新帧与前一帧之间的差异来完成。 因为我们没有使用卷积神经网络，所以除了 6400 个像素值在 0 和 1 之间翻转之外，没有可用的空间信息。 而不是桨和球的位置。
+不能从静态帧播放 Pong，因此，需要捕获某种运动信息，可以通过连接两个这样的帧或新帧与前一帧之间的差异来完成。 因为我们没有使用卷积神经网络，所以除了 6400 个像素值在 0 和 1 之间翻转之外，没有可用的空间信息。 而不是桨和球的位置。
 
 训练 130 万个参数的有效计算方法是使用策略梯度。 您可以将其与监督学习相关联，其中针对每个状态都提到了一个动作标签。 因此，数据和训练如下：
 
@@ -500,7 +500,7 @@ def policy_backward(arr_hidden_state,gradient_logp,observation_values):
     return {'W1':dW1,'W2':dW2}
 ```
 
-创建环境并结合先前的功能以使代理逐步学习多个情节的最终任务如下：
+创建环境并结合先前的功能以使智能体逐步学习多个情节的最终任务如下：
 
 ```py
 #implementation details
@@ -602,7 +602,7 @@ while True:
 
 ```
 
-代理商玩的游戏的屏幕截图：
+智能体玩的游戏的屏幕截图：
 
 ![](img/a93603fa-c7c9-450d-9df9-5549bb6fb056.png)
 

new/rl-tf/06.md

@@ -28,13 +28,13 @@
 
 Google DeepMind 和 MILA 的联合团队于 2016 年 6 月发布了用于深度强化学习的[**同步方法**](https://arxiv.org/pdf/1602.01783.pdf)。 它速度更快，并且能够在多核 CPU 上而不是使用 GPU 上显示出良好的效果。 异步方法也适用于连续动作空间和离散动作空间。
 
-如果我们回想起深度 Q 网络的方法，我们会使用经验回放作为存储所有经验的存储，然后使用其中的随机样本来训练我们的深度神经网络，从而反过来预测最大 Q 值。 有利的行动。 但是，随着时间的流逝，它具有高内存使用和大量计算的缺点。 这背后的基本思想是克服这个问题。 因此，不是使用经验回放，而是创建了环境的多个实例，并且多个代理以异步方式并行执行操作（如下图所示）：
+如果我们回想起深度 Q 网络的方法，我们会使用经验回放作为存储所有经验的存储，然后使用其中的随机样本来训练我们的深度神经网络，从而反过来预测最大 Q 值。 有利的行动。 但是，随着时间的流逝，它具有高内存使用和大量计算的缺点。 这背后的基本思想是克服这个问题。 因此，不是使用经验回放，而是创建了环境的多个实例，并且多个智能体以异步方式并行执行操作（如下图所示）：
 
 ![](img/f1e415ce-be75-4cb7-b24e-7e81937e3c04.png)
 
 深度强化学习中异步方法的高级示意图
 
-在异步方法中，为每个线程分配了一个进程，该进程包含一个学习器，该学习器表示与自己的环境副本进行交互的代理网络。 因此，这些多个学习器并行运行以探索他们自己的环境版本。 这种并行方法允许代理在任何给定的时间步长同时经历各种不同的状态，并涵盖了非策略学习和策略学习学习算法的基础。
+在异步方法中，为每个线程分配了一个进程，该进程包含一个学习器，该学习器表示与自己的环境副本进行交互的智能体网络。 因此，这些多个学习器并行运行以探索他们自己的环境版本。 这种并行方法允许智能体在任何给定的时间步长同时经历各种不同的状态，并涵盖了非策略学习和策略学习学习算法的基础。
 
 如上所述，异步方法能够在多核 CPU（而不是 GPU）中显示出良好的效果。 因此，异步方法非常快，因此成为最新的强化学习算法，因为到目前为止，深度强化学习算法的实现依赖于 GPU 驱动的机器和分布式架构，以见证所实现算法的更快收敛。
 
@@ -52,15 +52,15 @@ Google DeepMind 和 MILA 的联合团队于 2016 年 6 月发布了用于深度
 *   异步 N 步 Q 学习
 *   **异步优势演员评论家**（**A3C**）
 
-将变体 A3C 应用于各种 Atari 2600 游戏时，在多核 CPU 上获得了更好的基准测试结果，相对于早期的深度强化学习算法而言，其结果所需的时间要短得多，后者需要在 GPU 驱动的机器上运行。 因此，由于依赖于昂贵的硬件资源（如 GPU）以及不同的复杂分布式架构，因此解决了该问题。 由于所有这些优点，A3C 学习代理是当前最先进的强化学习智能体。
+将变体 A3C 应用于各种 Atari 2600 游戏时，在多核 CPU 上获得了更好的基准测试结果，相对于早期的深度强化学习算法而言，其结果所需的时间要短得多，后者需要在 GPU 驱动的机器上运行。 因此，由于依赖于昂贵的硬件资源（如 GPU）以及不同的复杂分布式架构，因此解决了该问题。 由于所有这些优点，A3C 学习智能体是当前最先进的强化学习智能体。
 
 # 异步单步 Q 学习
 
-异步单步 Q 学习的架构与 DQN 非常相似。 DQN 中的代理由一组主要网络和目标网络表示，其中一步损失的计算方法是主要网络预测的当前状态`s`的状态作用值与目标状态- 目标网络计算的当前状态的动作值。 相对于策略网络的参数来计算损失的梯度，然后使用梯度下降优化器将损失最小化，从而导致主网络的参数更新。
+异步单步 Q 学习的架构与 DQN 非常相似。 DQN 中的智能体由一组主要网络和目标网络表示，其中一步损失的计算方法是主要网络预测的当前状态`s`的状态作用值与目标状态- 目标网络计算的当前状态的动作值。 相对于策略网络的参数来计算损失的梯度，然后使用梯度下降优化器将损失最小化，从而导致主网络的参数更新。
 
-异步单步 Q 学习中的区别在于，有多个此类学习代理，例如，学习器并行运行并计算此损失。 因此，梯度计算也并行发生在不同的线程中，其中每个学习代理都与自己的环境副本进行交互。 这些梯度在多个时间步长上在不同线程中的累积用于在固定时间步长后或情节结束后更新策略网络参数。 梯度的累积优于策略网络参数更新，因为这样可以避免覆盖每个学习器代理执行的更改。
+异步单步 Q 学习中的区别在于，有多个此类学习智能体，例如，学习器并行运行并计算此损失。 因此，梯度计算也并行发生在不同的线程中，其中每个学习智能体都与自己的环境副本进行交互。 这些梯度在多个时间步长上在不同线程中的累积用于在固定时间步长后或情节结束后更新策略网络参数。 梯度的累积优于策略网络参数更新，因为这样可以避免覆盖每个学习器智能体执行的更改。
 
-此外，将不同的探索策略添加到不同的线程可以使学习变得多样化且稳定。 由于更好的探索，因此提高了性能，因为不同线程中的每个学习代理都受到不同的探索策略。 尽管有许多方法可以执行此操作，但一种简单的方法是在使用 ε 贪婪的同时为不同的线程使用不同的`ε`示例。
+此外，将不同的探索策略添加到不同的线程可以使学习变得多样化且稳定。 由于更好的探索，因此提高了性能，因为不同线程中的每个学习智能体都受到不同的探索策略。 尽管有许多方法可以执行此操作，但一种简单的方法是在使用 ε 贪婪的同时为不同的线程使用不同的`ε`示例。
 
 异步单步 Q 学习的伪代码如下所示。 这里，以下是全局参数：
 
@@ -152,7 +152,7 @@ repeat until  :
 
 # 异步 N 步 Q 学习
 
-异步 N 步 Q 学习的架构在某种程度上类似于异步单步 Q 学习的架构。 区别在于，使用探索策略最多选择`t[max]`步骤或直到达到终端状态，才能选择学习代理动作，以便计算策略网络参数的单个更新。 此过程列出了自上次更新以来`t[max]`来自环境的奖励。 然后，对于每个时间步长，将损失计算为该时间步长的折扣未来奖励与估计 Q 值之间的差。 对于每个时间步长，此损失相对于特定于线程的网络参数的梯度将被计算和累积。 有多个这样的学习代理并行运行和累积梯度。 这些累积的梯度用于执行策略网络参数的异步更新。
+异步 N 步 Q 学习的架构在某种程度上类似于异步单步 Q 学习的架构。 区别在于，使用探索策略最多选择`t[max]`步骤或直到达到终端状态，才能选择学习智能体动作，以便计算策略网络参数的单个更新。 此过程列出了自上次更新以来`t[max]`来自环境的奖励。 然后，对于每个时间步长，将损失计算为该时间步长的折扣未来奖励与估计 Q 值之间的差。 对于每个时间步长，此损失相对于特定于线程的网络参数的梯度将被计算和累积。 有多个这样的学习智能体并行运行和累积梯度。 这些累积的梯度用于执行策略网络参数的异步更新。
 
 异步 N 步 Q 学习的伪代码如下所示。 这里，以下是全局参数：
 
@@ -208,13 +208,13 @@ repeat until  :
 
 # 异步优势演员评论家
 
-在异步优势参与者批评者的架构中，每个学习代理都包含一个参与者批评者，该学习器结合了基于价值和基于策略的方法的优点。 参与者网络将状态作为输入，并预测该状态的最佳动作，而评论家网络将状态和动作作为输入，并输出动作分数以量化该状态的动作效果。 参与者网络使用策略梯度更新其权重参数，而评论者网络使用`TD(0)`来更新其权重参数，换言之，两个时间步长之间的值估计之差，如第 4 章“策略梯度”中所述。
+在异步优势参与者批评者的架构中，每个学习智能体都包含一个参与者批评者，该学习器结合了基于价值和基于策略的方法的优点。 参与者网络将状态作为输入，并预测该状态的最佳动作，而评论家网络将状态和动作作为输入，并输出动作分数以量化该状态的动作效果。 参与者网络使用策略梯度更新其权重参数，而评论家网络使用`TD(0)`来更新其权重参数，换言之，两个时间步长之间的值估计之差，如第 4 章“策略梯度”中所述。
 
 在第 4 章和“策略梯度”中，我们研究了如何通过从策略梯度的预期未来收益中减去基线函数来更新策略梯度，从而在不影响预期收益的情况下减少方差的情况。 梯度。 预期的未来奖励和基线函数之间的差称为**优势函数**； 它不仅告诉我们状态的好坏，而且还告诉我们该动作的预期好坏。
 
-卷积神经网络既用于演员网络，又用于评论者网络。 在每个`t[max]`步骤之后或直到达到终端状态之前，将更新策略和操作值参数。 将与以下伪代码一起说明网络更新，熵和目标函数。 此外，将策略`π`的熵`H`添加到目标函数中，以通过避免过早收敛到次优策略来改善探索。
+卷积神经网络既用于演员网络，又用于评论家网络。 在每个`t[max]`步骤之后或直到达到终端状态之前，将更新策略和操作值参数。 将与以下伪代码一起说明网络更新，熵和目标函数。 此外，将策略`π`的熵`H`添加到目标函数中，以通过避免过早收敛到次优策略来改善探索。
 
-因此，有多个这样的学习代理程序运行，每个学习代理程序都包含参与者关键网络，其中策略网络参数（即参与者网络参数）使用策略梯度进行更新，其中优势函数用于计算那些策略梯度。
+因此，有多个这样的学习智能体程序运行，每个学习智能体程序都包含参与者关键网络，其中策略网络参数（即参与者网络参数）使用策略梯度进行更新，其中优势函数用于计算那些策略梯度。
 
 异步单步 SARSA 的伪代码如下所示。 这里，以下是全局参数：
 
@@ -487,12 +487,12 @@ if __name__ == "__main__":
     plt.show()
 ```
 
-根据学习的输出的屏幕截图（绿色桨是我们的学习代理）：
+根据学习的输出的屏幕截图（绿色桨是我们的学习智能体）：
 
 ![](img/fae36238-a4f7-46b5-aeeb-0110aac10b23.png)
 
 # 总结
 
-我们看到，使用并行学习器更新共享模型可以大大改善学习过程。 我们了解了在深度学习中使用异步方法的原因及其不同的变体，包括异步单步 Q 学习，异步单步 SARSA，异步 N 步 Q 学习和异步优势参与者。 我们还学习了实现 A3C 算法的方法，在该方法中，我们使代理学习了 Breakout 和 Doom 游戏。
+我们看到，使用并行学习器更新共享模型可以大大改善学习过程。 我们了解了在深度学习中使用异步方法的原因及其不同的变体，包括异步单步 Q 学习，异步单步 SARSA，异步 N 步 Q 学习和异步优势参与者。 我们还学习了实现 A3C 算法的方法，在该方法中，我们使智能体学习了 Breakout 和 Doom 游戏。
 
 在接下来的章节中，我们将重点介绍不同的领域，以及如何以及可以应用深度强化学习。
\ No newline at end of file

new/rl-tf/07.md

@@ -24,7 +24,7 @@ Brett Sperry 首先使用术语**实时策略**（**RTS**）作为宣传其游
 *   该环境是部分可观察的，玩家只能感知该环境的一部分（即游戏地图/世界）
 *   因此，由于游戏环境的状态不断变化，因此系统应该是实时的，可以实时决定并执行动作。
 
-实时策略游戏已经发展了很多，现在具有包含许多实体的复杂虚拟环境，可以模拟各种现实问题。 因此，现实世界策略游戏已成为 AI 社区研究人员的良好测试平台，因为它们提供了复杂，多样，真实世界环境的仿真以测试其算法，从而创建更强大，更高效的算法。 因此，这些模拟环境实际上有助于创建更好的学习代理，这些学习代理可以在这些环境中生存和获胜，而无需在现实世界中进行测试，这在创建和维护方面非常昂贵。
+实时策略游戏已经发展了很多，现在具有包含许多实体的复杂虚拟环境，可以模拟各种现实问题。 因此，现实世界策略游戏已成为 AI 社区研究人员的良好测试平台，因为它们提供了复杂，多样，真实世界环境的仿真以测试其算法，从而创建更强大，更高效的算法。 因此，这些模拟环境实际上有助于创建更好的学习智能体，这些学习智能体可以在这些环境中生存和获胜，而无需在现实世界中进行测试，这在创建和维护方面非常昂贵。
 
 近几十年来，计算能力的提高使得实现高级 AI 算法成为可能。 因此，它使他们成为解决实际策略游戏中国家行动复杂性和时间问题的最有效的候选人选择。 大多数技术（例如 minimax 和基于案例的在线计划）都可以用来解决此问题，但是它们在有限的条件下可以高效运行。
 
@@ -54,7 +54,7 @@ Brett Sperry 首先使用术语**实时策略**（**RTS**）作为宣传其游
 
 在检索步骤中，从案例库中选择与问题相关的案例子集。 在重用步骤中，将根据所选情况调整解决方案。 然后，在修订步骤中，通过在实际环境中进行测试来验证适应的解决方案，并观察到量化预测解决方案准确率的反馈。 保留步骤决定是否将此新解决的案例存储在案例库中。 因此，基于案例的推理和计划涉及重用以前的计划，并使它们适应新情况。
 
-基于案例的推理主要应用于静态域，也就是说，代理有时间决定要采取的操作，与此同时，环境的状态也不会改变。 但是现实世界中的问题是动态的，并且有时间限制。 因此，基于案例的推理不适合实际的策略游戏，这导致**基于案例的在线规划**，其中与基于案例的推理不同，实时进行计划和执行。 下图给出了基于案例的在线计划的架构：
+基于案例的推理主要应用于静态域，也就是说，智能体有时间决定要采取的操作，与此同时，环境的状态也不会改变。 但是现实世界中的问题是动态的，并且有时间限制。 因此，基于案例的推理不适合实际的策略游戏，这导致**基于案例的在线规划**，其中与基于案例的推理不同，实时进行计划和执行。 下图给出了基于案例的在线计划的架构：
 
 ![](img/2296ca03-8f44-4eff-b1f6-5e92a222af79.png)
 
@@ -97,7 +97,7 @@ Brett Sperry 首先使用术语**实时策略**（**RTS**）作为宣传其游
 *   奖励`R`
 *   转移模型（如果基于策略，非策略学习不需要）
 
-如果这些组件在接收来自给定游戏环境的信号时被学习代理上的传感器感知和处理，则可以成功应用强化学习算法。 传感器感知到的信号可以进行处理，以形成当前的环境状态，根据状态信息预测动作，并接收反馈，即在所采取动作的好坏之间进行奖励。 这将更新状态-动作对值，即根据收到的反馈加强其学习。
+如果这些组件在接收来自给定游戏环境的信号时被学习智能体上的传感器感知和处理，则可以成功应用强化学习算法。 传感器感知到的信号可以进行处理，以形成当前的环境状态，根据状态信息预测动作，并接收反馈，即在所采取动作的好坏之间进行奖励。 这将更新状态-动作对值，即根据收到的反馈加强其学习。
 
 此外，可以使用深度自编码器将较高维度的状态和操作空间编码为紧凑的较低维度。 这将状态和动作空间的特征尺寸减小为重要特征。
 
@@ -133,9 +133,9 @@ Brett Sperry 首先使用术语**实时策略**（**RTS**）作为宣传其游
 
 基本的强化学习算法，例如 Q 学习和 SARSA 算法（在第 5 章，“Q 学习和深度 Q 网络”中进行了解释），与早期的在线案例学习相比，在收敛时间和比率方面表现更好 。
 
-此外，在深度强化学习领域中正在进行大量研究，该研究集中于使用图像进行代理感知以在更复杂的领域中更好地工作。 以前的自编码器方法有助于将非常复杂的域转换为更简单的域。 此外，学习奖励功能和自编码器的其他变体，尤其是去噪堆叠式自编码器，将进一步改善结果。
+此外，在深度强化学习领域中正在进行大量研究，该研究集中于使用图像进行智能体感知以在更复杂的领域中更好地工作。 以前的自编码器方法有助于将非常复杂的域转换为更简单的域。 此外，学习奖励功能和自编码器的其他变体，尤其是去噪堆叠式自编码器，将进一步改善结果。
 
-此外，使用异步或分布式多主体强化学习方法（在第 6 章，“异步方法”中讨论），其中学习代理与自己的环境副本并行工作，这将进一步减少收敛时间，并产生更好的结果。
+此外，使用异步或分布式多主体强化学习方法（在第 6 章，“异步方法”中讨论），其中学习智能体与自己的环境副本并行工作，这将进一步减少收敛时间，并产生更好的结果。
 
 # 总结
 

new/rl-tf/08.md

@@ -21,7 +21,7 @@
 
 如前所述，游戏是测试这些 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)
 
@@ -170,7 +170,7 @@ Silver 等人
 
 AlphaGo Zero 背后最重要的想法是，它完全从空白状态（即清晰的围棋棋盘）中学习，并通过自己的玩法自行弄清楚，而无需任何人类知识，没有任何人类游戏示例和数据，甚至没有任何人为干预。 它从最初的基本原理中发现并发展了学习围棋游戏的直觉。 这种从头开始的学习称为**表格学习**或**白板学习**。
 
-Tabula rasa 学习对于任何 AI 代理都是非常重要的，因为如果有一个代理已实现 Tabula rasa 学习，则可以将其从围棋游戏移植到其他域环境（可能是其他任何游戏）。 Tabula rasa 学习将代理与其所在领域的具体情况脱钩，并尝试开发一种算法，该算法足够通用，可以学习以实现与该环境相关的目标，并且可以在任何地方应用。
+Tabula rasa 学习对于任何 AI 智能体都是非常重要的，因为如果有一个智能体已实现 Tabula rasa 学习，则可以将其从围棋游戏移植到其他域环境（可能是其他任何游戏）。 Tabula rasa 学习将智能体与其所在领域的具体情况脱钩，并尝试开发一种算法，该算法足够通用，可以学习以实现与该环境相关的目标，并且可以在任何地方应用。
 
 AlphaGo 项目背后的目标不是击败最佳的人类围棋选手，而是发现学习和做科学的意义以及对于计算机程序学习知识和直觉本质的意义。 AlphaGo Zero 不仅重新发现了人类倾向于玩的常见模式和空缺，还通过自行弄清它们来学习它们，并且还抛弃了许多已知的人类移动，而是优先选择了在数百万游戏中在数天之内发现的更好的移动。 这些更好的举动甚至是人类所不知道的。
 

new/rl-tf/09.md

@@ -62,7 +62,7 @@
 
 # 自动驾驶中的强化学习
 
-由于与环境的强大交互作用以及环境中的多个障碍和操作（如前所述），无法通过全面的有监督的学习方法来解决自动驾驶所带来的挑战。 强化学习的奖励机制必须非常有效，这样代理才能对内部个体的安全以及外部所有障碍（无论是人类，动物还是任何正在进行的构造）保持谨慎。
+由于与环境的强大交互作用以及环境中的多个障碍和操作（如前所述），无法通过全面的有监督的学习方法来解决自动驾驶所带来的挑战。 强化学习的奖励机制必须非常有效，这样智能体才能对内部个体的安全以及外部所有障碍（无论是人类，动物还是任何正在进行的构造）保持谨慎。
 
 奖励的方法之一可能是：
 
@@ -76,7 +76,7 @@
 
 # 创建自动驾驶智能体
 
-驾驶车辆需要良好的技能，专注力和经验。 因此，作为一项高技能的任务，创建自动驾驶代理所涉及的过程可以大致分为三类，如下图所示：
+驾驶车辆需要良好的技能，专注力和经验。 因此，作为一项高技能的任务，创建自动驾驶智能体所涉及的过程可以大致分为三类，如下图所示：
 
 ![](img/a439e6b9-b14f-40fb-84e3-2d8ef4bf84ca.png)
 
@@ -159,7 +159,7 @@
 
 [DeepTraffic](https://selfdrivingcars.mit.edu/deeptraffic/) 是为课程《MIT 6.S094：用于自动驾驶汽车的深度学习》创建的，由 Lex Fridman 教授 。 课程内容和作业是公开的。 DeepTraffic 由于其排行榜而获得了很多欢迎。 迄今为止，DeepTraffic 拥有 13,000 多个提交文件，竞争非常激烈。 用户必须在`convnet.js`（由 Andrej Karpathy 创建的框架）中使用本节开头提到的链接中存在的编码依据来编写其神经网络。 平均速度最高的座席在排行榜上居首。
 
-诸如 DeepTraffic 之类的模拟可帮助训练不同的方法，以使汽车代理迅速适应模拟环境。 此外，它的竞争性元素随着时间的推移增加了更好的提交，超过了过去的最高得分。 比赛很有趣，但在现实世界中，学生无法测试他们的深度强化学习脚本。 因此，DeepTraffic 为下一代 AI 开发人员提供了使用不同方法的最佳测试平台，这肯定会导致未来的 AI 开发人员在现实世界中创造出自动驾驶汽车，而这要得益于这些模拟的学习。
+诸如 DeepTraffic 之类的模拟可帮助训练不同的方法，以使汽车智能体迅速适应模拟环境。 此外，它的竞争性元素随着时间的推移增加了更好的提交，超过了过去的最高得分。 比赛很有趣，但在现实世界中，学生无法测试他们的深度强化学习脚本。 因此，DeepTraffic 为下一代 AI 开发人员提供了使用不同方法的最佳测试平台，这肯定会导致未来的 AI 开发人员在现实世界中创造出自动驾驶汽车，而这要得益于这些模拟的学习。
 
 众所周知，在现实世界中，自动驾驶汽车应该规划最安全的道路。 因此，将需要大量修剪和更好的神经网络架构来实现该目标。 DeepTraffic 是朝着这个方向迈出的第一步，因此 AI 社区中感兴趣的人们可以玩耍并创建更好的学习架构和方法：
 

new/rl-tf/10.md

 # 金融投资组合管理
 
-金融投资组合是将资金分配到不同金融产品中的过程。 在项目组合管理中实现深度学习一直是人工智能界的一个研究部门。 随着强化学习的进步，在创建免费的无财务模型的强化学习框架以产生端到端的财务组合管理代理方面，人们进行了积极的研究。
+金融投资组合是将资金分配到不同金融产品中的过程。 在项目组合管理中实现深度学习一直是人工智能界的一个研究部门。 随着强化学习的进步，在创建免费的无财务模型的强化学习框架以产生端到端的财务组合管理智能体方面，人们进行了积极的研究。
 
 投资组合管理是一个连续的决策过程，将资金重新分配到众多不同的金融产品中，以期获得最大的回报。
 
@@ -62,7 +62,7 @@
 
 所提出的强化学习框架的核心是**相同独立评估器**（**EIIE**）拓扑。 在这里，EIIE 是一个神经网络，它将资产历史记录作为输入并评估未来资产的潜在增长。 每个资产的评估得分用于计算下一个交易期的投资组合权重。
 
-投资组合权重（我们将在后面讨论）实际上是由强化学习驱动的投资组合管理代理的市场行为。 将购买目标权重增加的资产，而目标权重减小的资产将被出售。 因此，最后交易期间的投资组合权重也作为 EIIE 的输入。 因此，每个期间的投资组合权重存储在**投资组合向量存储器**（**PVM**）中。
+投资组合权重（我们将在后面讨论）实际上是由强化学习驱动的投资组合管理智能体的市场行为。 将购买目标权重增加的资产，而目标权重减小的资产将被出售。 因此，最后交易期间的投资组合权重也作为 EIIE 的输入。 因此，每个期间的投资组合权重存储在**投资组合向量存储器**（**PVM**）中。
 
 EIIE 通过**在线随机批量学习**（**OSBL**）进行训练，其中强化学习框架的奖励函数是该时期的平均对数回报。 由于奖励功能是动态的，因此，随着训练是通过梯度上升进行的，EIIE 也在不断发展。 如前所述，EIIE 由一个神经网络组成，因此，对于当前框架，使用不同类型的神经网络测试了三种不同类型的 EIIE，即**卷积神经网络**（**CNN**），**循环神经网络**（**RNN**）和**长短期记忆网络**（**LSTM**），这是 RNN 单元。 这种类型的框架可以轻松扩展到不同的市场，而不仅限于一个。
 
@@ -73,11 +73,11 @@ EIIE 通过**在线随机批量学习**（**OSBL**）进行训练，其中强化
 *   加密货币的去中心化（不是控制协议的中央机构）
 *   加密货币市场的开放性（更易进入的市场）
 *   加密货币中的小批量货币丰富
-*   加密货币市场一直都是开放的，因此，对于学习代理来说，随着时间的流逝学习非常有用，这与受时间限制的现实世界不同。
+*   加密货币市场一直都是开放的，因此，对于学习智能体来说，随着时间的流逝学习非常有用，这与受时间限制的现实世界不同。
 
 # 问题定义
 
-众所周知，投资组合管理是指跨多种金融产品（资产）对资金进行持续重新分配。 在这项工作中，时间分为相等长度的时间段，其中每个时间段`T = 30`分钟。 在每个时期的开始，交易代理将资金重新分配到不同的资产上。 资产的价格在一段时间内会波动，但要考虑四个重要的价格指标，它们足以表示该期间资产的价格变动。 这些价格指标如下：
+众所周知，投资组合管理是指跨多种金融产品（资产）对资金进行持续重新分配。 在这项工作中，时间分为相等长度的时间段，其中每个时间段`T = 30`分钟。 在每个时期的开始，交易智能体将资金重新分配到不同的资产上。 资产的价格在一段时间内会波动，但要考虑四个重要的价格指标，它们足以表示该期间资产的价格变动。 这些价格指标如下：
 
 *   开盘价
 *   最高价
@@ -127,7 +127,7 @@ EIIE 通过**在线随机批量学习**（**OSBL**）进行训练，其中强化
 
 *   **零滞后**：每笔定单在下单时均以最后价格执行，没有滞后，立即进行交易
 
-*   **零市场影响**：交易代理商在市场上的投资金额微不足道，不会影响市场
+*   **零市场影响**：交易智能体在市场上的投资金额微不足道，不会影响市场
 
 # 数据准备
 
@@ -156,7 +156,7 @@ EIIE 通过**在线随机批量学习**（**OSBL**）进行训练，其中强化
 
 ![](img/d4c0367b-bfe2-4e38-8ee5-421da65351e6.png)
 
-投资组合管理代理使用输入张量`X[t]`和上一个时间段的（即`t-1`），投资组合权重向量`w[t-1]`输出时间段`t`的投资组合权重向量`w[t]`。 根据策略`π`。
+投资组合管理智能体使用输入张量`X[t]`和上一个时间段的（即`t-1`），投资组合权重向量`w[t-1]`输出时间段`t`的投资组合权重向量`w[t]`。 根据策略`π`。
 
 因此：
 
@@ -170,12 +170,12 @@ EIIE 通过**在线随机批量学习**（**OSBL**）进行训练，其中强化
 
 # 强化学习
 
-在算法投资组合管理的实验中，投资组合管理代理在强化学习的支持下在金融市场环境中执行交易操作。 环境包括给定市场的所有可用资产。 由于环境庞大而复杂，因此代理程序无法完全观察状态，即获取状态的所有信息。 而且，由于市场的全部订购历史太大而无法处理，因此从订购历史数据中进行子采样可以简化环境状态表示的处理。 这些子采样方法包括：
+在算法投资组合管理的实验中，投资组合管理智能体在强化学习的支持下在金融市场环境中执行交易操作。 环境包括给定市场的所有可用资产。 由于环境庞大而复杂，因此智能体程序无法完全观察状态，即获取状态的所有信息。 而且，由于市场的全部订购历史太大而无法处理，因此从订购历史数据中进行子采样可以简化环境状态表示的处理。 这些子采样方法包括：
 
 *   **周期性特征提取**：将时间离散化为多个时段，然后提取每个时段的开盘价，最高价，最低价和收盘价
 *   **数据切片**：仅考虑最近时间段的数据，并避免使用较旧的历史数据，以便进行环境的当前状态表示
 
-代理根据时段输出的投资组合权重向量`w[t]`，在时段`t`结束时，即在时段`t + 1`的开始进行了一些买卖交易。 神经网络。 因此，主体在时间`t`的动作仅由投资组合权重向量`w[t]`表示。 因此，在当前框架中，`w[t-1]`被视为环境的一部分，并作为输入输入到代理中，以输出下一个时间段即`w[t]`的代理的操作策略。 因此，在时期`t`，即`s[t]`的状态由价格张量`X[t]`和前一时期`w[t-1]`的投资组合权重向量表示：
+智能体根据时段输出的投资组合权重向量`w[t]`，在时段`t`结束时，即在时段`t + 1`的开始进行了一些买卖交易。 神经网络。 因此，主体在时间`t`的动作仅由投资组合权重向量`w[t]`表示。 因此，在当前框架中，`w[t-1]`被视为环境的一部分，并作为输入输入到智能体中，以输出下一个时间段即`w[t]`的智能体的操作策略。 因此，在时期`t`，即`s[t]`的状态由价格张量`X[t]`和前一时期`w[t-1]`的投资组合权重向量表示：
 
 ![](img/64a779b3-9055-47fd-831e-92c8c108a54d.png)
 
@@ -183,7 +183,7 @@ EIIE 通过**在线随机批量学习**（**OSBL**）进行训练，其中强化
 
 ![](img/d5f51e96-dd52-43ae-b0f9-9e032433e0d0.png)
 
-如前所述，投资组合管理代理的目标是使最终投资组合价值最大化，即`p[f]`，其中：
+如前所述，投资组合管理智能体的目标是使最终投资组合价值最大化，即`p[f]`，其中：
 
 ![](img/bba610ef-98f6-4e3c-9da9-080f917f3770.png)
 
@@ -201,7 +201,7 @@ PVM 是按时间步长顺序（即时间顺序）收集投资组合向量的集
 
 单个内存堆栈（例如 PVM）还有助于使用小批量提高训练过程的并行性，从而提高训练过程的效率。
 
-对于有监督的学习，数据的排序以小批量为单位，但是在这里，数据需要按照训练过程中每批传递的时间步长进行排序。 现在，由于数据是按时间序列格式的，因此从不同时间段开始的小批量是更可取的，因为它们涵盖了训练过程的独特数据。 金融市场的持续性导致不断向代理网络输入新数据，从而导致训练数据中的数据爆炸。
+对于有监督的学习，数据的排序以小批量为单位，但是在这里，数据需要按照训练过程中每批传递的时间步长进行排序。 现在，由于数据是按时间序列格式的，因此从不同时间段开始的小批量是更可取的，因为它们涵盖了训练过程的独特数据。 金融市场的持续性导致不断向智能体网络输入新数据，从而导致训练数据中的数据爆炸。
 
 因此，提出了 OSBL，其中在时段`t`结束时，时段的价格变动将添加到训练集中。 在完成时间段`t + 1`的订单后，使用从该组中随机选择的小批量对策略网络进行训练。 有关 OSBL 的完整详细研究超出了本书的范围，但是为了进一步探索，请阅读[《金融组合管理问题的深层强化学习框架》](https://arxiv.org/pdf/1706.10059.pdf)中的 5.3 节 。
 
@@ -225,7 +225,7 @@ PVM 是按时间步长顺序（即时间顺序）收集投资组合向量的集
 
 # 进一步的改进
 
-可以对以前的框架进行进一步的改进，也可以使用深度强化学习来创建端到端金融投资组合管理代理的更好方法。 它们如下：
+可以对以前的框架进行进一步的改进，也可以使用深度强化学习来创建端到端金融投资组合管理智能体的更好方法。 它们如下：
 
 *   当前框架假设为零滑点和零市场影响。 因此，考虑市场影响和滑点将提供真实的交易样本，这将改善训练数据集。
 *   使用行为者-批评类型的框架将有助于长期的市场反应。

new/rl-tf/11.md

@@ -27,7 +27,7 @@
 
 与机器人技术有关的任何任务都由高维，连续状态和动作空间表示。 环境状态不是完全可观察到的。 仅在模拟中学习不足以说强化学习智能体已经为现实世界做好了准备。 在使用机器人技术的情况下，强化学习智能体应该在现实世界中遇到不确定性，但是获取和复制起来既困难又昂贵。
 
-鲁棒性是机器人技术的重中之重。 在常规分析或传统机器学习问题中，数据，预处理或算法中的细微错误会导致行为发生重大变化，尤其是对于动态任务。 因此，需要能够捕获实际细节的健壮算法。 机器人强化学习的下一个挑战是奖励功能。 由于奖励功能在优化学习中起着最重要的作用，因此需要生成特定领域的奖励功能，以帮助学习代理尽快更好地适应现实世界。 因此，领域知识是设计好的奖励功能的关键，而这又是机器人机器学习中的艰巨任务。
+鲁棒性是机器人技术的重中之重。 在常规分析或传统机器学习问题中，数据，预处理或算法中的细微错误会导致行为发生重大变化，尤其是对于动态任务。 因此，需要能够捕获实际细节的健壮算法。 机器人强化学习的下一个挑战是奖励功能。 由于奖励功能在优化学习中起着最重要的作用，因此需要生成特定领域的奖励功能，以帮助学习智能体尽快更好地适应现实世界。 因此，领域知识是设计好的奖励功能的关键，而这又是机器人机器学习中的艰巨任务。
 
 在这里，将讨论通过我们在本书中研究的强化学习算法可以实现的机器人领域中的任务类型，并尝试将它们连接在一起以构建一种有前途的方法。
 
@@ -49,7 +49,7 @@
 *   操纵
 *   自主机器控制
 
-如前所述，为了使增强型学习代理在现实世界中的任务中表现更好，它应该具有定义明确，特定领域的奖励功能，这很难实现。 通过使用学徒制学习等技术可以解决此问题。 解决奖励不确定性的另一种方法是根据状态不断更新奖励功能，以便生成最优化的策略。 这种方法称为逆强化学习。
+如前所述，为了使增强型学习智能体在现实世界中的任务中表现更好，它应该具有定义明确，特定领域的奖励功能，这很难实现。 通过使用学徒制学习等技术可以解决此问题。 解决奖励不确定性的另一种方法是根据状态不断更新奖励功能，以便生成最优化的策略。 这种方法称为逆强化学习。
 
 由于许多挑战，机器人强化学习是一个很难解决的问题。 第一个是连续的状态动作空间。 根据问题陈述，决定是采用 DAS 算法还是 CAS 算法。 这意味着机器人控制应处于何种粒度级别。 一大挑战是现实系统的复杂性，这导致执行时间，手动干预和维护的增加。 因此，需要一种可以实时运行并应对现实世界复杂性的算法。
 
@@ -106,15 +106,15 @@ Perkins 和 Barto（2002）提出了一种基于 Lyapunov 函数构造强化学
 
 # 机器人要实现的最终目标是什么？
 
-奖励功能对于在机器人强化学习中指定学习代理的目标至关重要。 如我们所知，对于强化学习算法，最终目标是使从开始状态到达到目标状态的预期奖励总和最大化。
+奖励功能对于在机器人强化学习中指定学习智能体的目标至关重要。 如我们所知，对于强化学习算法，最终目标是使从开始状态到达到目标状态的预期奖励总和最大化。
 
 在现实世界中，设计好的奖励功能是一个巨大的挑战。 因此，代表或指定目标是现实世界中的挑战。 现实世界中充满不确定性，因此，奖励函数应能够捕获与此类不确定性相关的积极状态。
 
 一些领域在任务完成后获得奖励，不确定性较小，但在某些情况下，导致更好的最终结果的每个动作都具有不同的奖励。 这是由于每个状态的重要性，因为每个状态都像在现实情况中那样采取了行动。 因此，任务完成奖励机制不能在现实世界中实现，因为它不会捕获不确定性，也不会导致学习趋同，从而导致性能下降。
 
-在我们遇到的大多数现有模拟中，我们看到了一种二元奖励机制，该机制仅捕获了学习代理的成功和失败。 将中间奖励包含为奖励功能的一部分，将比二元奖励方法更好，从而导致更好的解决方案。 包括中间奖励在内，将捕获现实系统中从状态到状态转换的不确定性。
+在我们遇到的大多数现有模拟中，我们看到了一种二元奖励机制，该机制仅捕获了学习智能体的成功和失败。 将中间奖励包含为奖励功能的一部分，将比二元奖励方法更好，从而导致更好的解决方案。 包括中间奖励在内，将捕获现实系统中从状态到状态转换的不确定性。
 
-因此，奖励功能通常表示为状态动作对的函数。 如前所述，由于先前讨论的现实世界的挑战，该模拟不能准确地表示现实世界的状态。 但是，除了环境因素和时间滞后之外，由于具有良好的奖励功能，机器人加固代理还可以学习优化时间和管理风险，并避免了实际系统设置和维护的成本。
+因此，奖励功能通常表示为状态动作对的函数。 如前所述，由于先前讨论的现实世界的挑战，该模拟不能准确地表示现实世界的状态。 但是，除了环境因素和时间滞后之外，由于具有良好的奖励功能，机器人加固智能体还可以学习优化时间和管理风险，并避免了实际系统设置和维护的成本。
 
 最近，已经进行了进一步的研究开发，以在简单模型的基础上构建复杂策略，以通过使用更好的参数化奖励函数来探索那些复杂策略来实现此目标。 在他们的研究中，Sorg 等人（2010 年）以及 Zucker 和 Bagnell（2012 年）通过调整奖励功能，通过策略搜索技术实现简单的最优控制，得出了复杂的策略。
 

new/rl-tf/12.md

@@ -82,21 +82,21 @@
 *   状态空间包含出价信息和实时活动参数
 *   动作是要设定的买入价
 
-因此，在每个步骤中，代表广告商出价者的代理都会观察到由当前广告系列参数（例如预算和剩余时间）以及针对该特定广告印象的出价请求组成的状态。 然后，它发布一个动作； 例如，确定出价，中奖结果和用户反馈将一起作为对所采取措施的奖励，并将用于加强模型。 由于在现实世界中出价量很大，因此 MDP 框架已与基于 Q 网络的方法一起使用，该方法使用神经网络作为状态作用值函数逼近器。 竞标的基本强化学习框架如下所示：
+因此，在每个步骤中，代表广告商出价者的智能体都会观察到由当前广告系列参数（例如预算和剩余时间）以及针对该特定广告印象的出价请求组成的状态。 然后，它发布一个动作； 例如，确定出价，中奖结果和用户反馈将一起作为对所采取措施的奖励，并将用于加强模型。 由于在现实世界中出价量很大，因此 MDP 框架已与基于 Q 网络的方法一起使用，该方法使用神经网络作为状态作用值函数逼近器。 竞标的基本强化学习框架如下所示：
 
 ![](img/6807396c-6fb5-4a47-8cd9-2ba802d62c72.png)
 
-最初，预算`b`是​​提供给代理的，此处的目标是在随后的出价`t`中获得尽可能多的点击。 以下是代理考虑的重要信息：
+最初，预算`b`是​​提供给智能体的，此处的目标是在随后的出价`t`中获得尽可能多的点击。 以下是智能体考虑的重要信息：
 
 *   其余出价，即剩余出价编号`t ∈ {0, ···, T}`
 *   初始分配预算中剩余的剩余金额，即未用预算`b ∈ {0, ..., B}`
 *   特征向量`x`，代表出价请求
 
-在每个情节中，每次出价都会按顺序发送给代理商，代理商针对每个代理商根据当前信息`t`，`b`和`x`。 因此，代理基于出价的剩余时间，初始分配预算中剩余的剩余量以及提出的投标请求的所有关键信息来决定适当的动作。
+在每个情节中，每次出价都会按顺序发送给智能体，智能体针对每个智能体根据当前信息`t`，`b`和`x`。 因此，智能体基于出价的剩余时间，初始分配预算中剩余的剩余量以及提出的投标请求的所有关键信息来决定适当的动作。
 
-如上图所示，代理维护剩余的出价`t`和剩余的预算`b`。 在每个时间步，代理都收到一个竞标请求以及出价`x ∈ X`（特征向量空间），并且它必须确定竞标价格`a`。
+如上图所示，智能体维护剩余的出价`t`和剩余的预算`b`。 在每个时间步，智能体都收到一个竞标请求以及出价`x ∈ X`（特征向量空间），并且它必须确定竞标价格`a`。
 
-给定特征向量`x`的市场价格概率分布函数为`m(δ, x)`，其中`δ`是市场价格， `m`是其概率。 因此，如果代理商以`a ≥ δ`的价格出价，则它将赢得竞标并支付`δ`，剩余预算将变为`b-δ`。 万一失败，代理商从竞标中得不到任何东西。 在此，如果将赢得出价视为预期奖励，则将**预测 CTR**（**pCTR**）表示为`θ(x)`。 在每次出价之后，剩余的出价数量减少 1。当`t = 0`时，也就是说，没有剩余的出价，则情节结束。 随着当前情节的结束，剩余的出价编号和预算都将分别重置为`T`和`B`。
+给定特征向量`x`的市场价格概率分布函数为`m(δ, x)`，其中`δ`是市场价格， `m`是其概率。 因此，如果智能体以`a ≥ δ`的价格出价，则它将赢得竞标并支付`δ`，剩余预算将变为`b-δ`。 万一失败，智能体从竞标中得不到任何东西。 在此，如果将赢得出价视为预期奖励，则将**预测 CTR**（**pCTR**）表示为`θ(x)`。 在每次出价之后，剩余的出价数量减少 1。当`t = 0`时，也就是说，没有剩余的出价，则情节结束。 随着当前情节的结束，剩余的出价编号和预算都将分别重置为`T`和`B`。
 
 以下是前面的增强型学习框架要投标的实现的伪代码：
 
@@ -139,6 +139,6 @@ end for
 
 # 总结
 
-在本章中，我们了解了广告技术领域的基本概念和挑战。 我们还了解了相关的业务模型，例如 CPC，CPM 和 CPA，以及实时策略出价，以及为什么需要一个独立的代理商来使流程自动化。 此外，我们讨论了一种将在线广告中实时出价的问题状态转换为强化学习框架的基本方法。 这是用于强化学习的全新领域。 利用强化学习技术进行广告技术开发的更多探索性作品及其结果尚未发布。
+在本章中，我们了解了广告技术领域的基本概念和挑战。 我们还了解了相关的业务模型，例如 CPC，CPM 和 CPA，以及实时策略出价，以及为什么需要一个独立的智能体来使流程自动化。 此外，我们讨论了一种将在线广告中实时出价的问题状态转换为强化学习框架的基本方法。 这是用于强化学习的全新领域。 利用强化学习技术进行广告技术开发的更多探索性作品及其结果尚未发布。
 
 在下一章中，我们将研究在计算机视觉领域，尤其是在对象检测中，如何使用强化学习。
\ No newline at end of file

new/rl-tf/13.md

@@ -8,7 +8,7 @@
 
 # 深度强化学习中的分层对象检测
 
-在本节中，我们将尝试理解如何根据 Bellver 等人（2016）在[《使用深度强化学习的分层对象检测》](https://arxiv.org/pdf/1611.03718.pdf)中建议的框架，将深度增强学习应用于分层对象检测。 该实验展示了一种使用深度强化学习在图像中执行分层对象检测的方法，该方法主要侧重于承载更丰富信息的图像重要部分。 此处的目的是训练一个深度增强学习代理，为其提供一个图像窗口，并将图像进一步分为五个较小的窗口，并且该代理成功地将注意力集中在较小的窗口之一上。
+在本节中，我们将尝试理解如何根据 Bellver 等人（2016）在[《使用深度强化学习的分层对象检测》](https://arxiv.org/pdf/1611.03718.pdf)中建议的框架，将深度增强学习应用于分层对象检测。 该实验展示了一种使用深度强化学习在图像中执行分层对象检测的方法，该方法主要侧重于承载更丰富信息的图像重要部分。 此处的目的是训练一个深度增强学习智能体，为其提供一个图像窗口，并将图像进一步分为五个较小的窗口，并且该智能体成功地将注意力集中在较小的窗口之一上。
 
 现在，让我们考虑一下人类如何看待图像。 我们总是以顺序的方式提取信息以了解图像的内容：
 
@@ -18,9 +18,9 @@
 
 在计算机视觉中，图像是在局部范围内进行分析的，我们使用一个像素大小的小窗口，然后滑动窗口以扫描整个图像。 传统上，这就是我们处理图像处理和分析任务的方式。 使用这种窗口滑动方法，可以独立地分析图像的不同部分，而不会相互关联。 可以通过图像的分层表示来实现不同图像部分的关联。
 
-为了获得图像的分层表示，首先，像以前一样，顺序进行图像的自顶向下扫描，以聚焦于包含相关信息的图像的不同局部部分。 使用强化学习，可以使代理具有足够的能力来检测图像中的对象。 代理首先分析整个图像，然后决定要聚焦的部分，并且代理在找到图像中的对象后最终停止。 在此实验中，图像窗口分为五个预定义的较小部分，其中四个部分代表四个象限，一个部分代表中心区域。
+为了获得图像的分层表示，首先，像以前一样，顺序进行图像的自顶向下扫描，以聚焦于包含相关信息的图像的不同局部部分。 使用强化学习，可以使智能体具有足够的能力来检测图像中的对象。 智能体首先分析整个图像，然后决定要聚焦的部分，并且智能体在找到图像中的对象后最终停止。 在此实验中，图像窗口分为五个预定义的较小部分，其中四个部分代表四个象限，一个部分代表中心区域。
 
-之所以使用强化学习，是因为代理可以按不同的顺序探索层次结构表示，并且仍然可以达到目标。 这是因为其目标是在目标状态为找到包含对象的图像部分的情况下，最大化预期的总和回报。
+之所以使用强化学习，是因为智能体可以按不同的顺序探索层次结构表示，并且仍然可以达到目标。 这是因为其目标是在目标状态为找到包含对象的图像部分的情况下，最大化预期的总和回报。
 
 # 相关作品
 
@@ -98,18 +98,18 @@ YOLO 还可以预测训练中所有班级每个盒子的班级得分。 因此
 
 # 分层对象检测模型
 
-在这里，我们将尝试通过强化学习框架来实现对象检测问题，在强化学习框架中，强化学习智能体将与环境图像进行交互，并且每步，代理将决定关注哪个区域，以实现目标。 以最少的时间步长找到对象。 问题陈述以**马尔可夫决策过程**（**MDP**）框架表示，其不同参数讨论如下：
+在这里，我们将尝试通过强化学习框架来实现对象检测问题，在强化学习框架中，强化学习智能体将与环境图像进行交互，并且每步，智能体将决定关注哪个区域，以实现目标。 以最少的时间步长找到对象。 问题陈述以**马尔可夫决策过程**（**MDP**）框架表示，其不同参数讨论如下：
 
 # 状态
 
-代理状态的第一部分由使用两个模型提取的视觉特征定义，它们是：
+智能体状态的第一部分由使用两个模型提取的视觉特征定义，它们是：
 
 *   图像缩放模型
 *   Pool45-作物模型
 
 在下面的“模型和训练”部分中说明了这两种变化。
 
-代理状态的第二部分是存储向量，它捕获了代理为了搜索对象而采取的过去四个时间步骤的动作。 在每个时间步长，都有六种可能的操作（在下面的部分中进行介绍）。 因此，存储向量的尺寸为`4 * 6 = 24`。 已经发现该存储向量对于稳定搜索轨迹很有用。
+智能体状态的第二部分是存储向量，它捕获了智能体为了搜索对象而采取的过去四个时间步骤的动作。 在每个时间步长，都有六种可能的操作（在下面的部分中进行介绍）。 因此，存储向量的尺寸为`4 * 6 = 24`。 已经发现该存储向量对于稳定搜索轨迹很有用。
 
 # 动作
 
@@ -147,7 +147,7 @@ YOLO 还可以预测训练中所有班级每个盒子的班级得分。 因此
 
 # 模型与训练
 
-在这里，训练了一个深度 Q 网络，针对该网络使用两个模型来创建代理状态表示的一部分。 这两种模型如下：
+在这里，训练了一个深度 Q 网络，针对该网络使用两个模型来创建智能体状态表示的一部分。 这两种模型如下：
 
 *   ImageZooms 模型
 *   Pool45-作物模型
@@ -162,18 +162,18 @@ YOLO 还可以预测训练中所有班级每个盒子的班级得分。 因此
 
 # 训练细节
 
-通过 ε 贪婪方法学习了一个深层 Q 网络，该网络以`ε = 1`（完全 100% 探索）开始，并以 0.1 的步长直到 0.1（仅 10% 探索，90% 开发）减少。 在探索过程中，选择随机动作是因为通过更好的探索，可以避免局部最小值，并且还可以揭示通往目标状态的未知优化路径。 而且，为了帮助代理学习终端动作，每当当前区域具有`IoU > τ`时，代理便被迫采取该动作，这反过来又加速了学习过程。
+通过 ε 贪婪方法学习了一个深层 Q 网络，该网络以`ε = 1`（完全 100% 探索）开始，并以 0.1 的步长直到 0.1（仅 10% 探索，90% 开发）减少。 在探索过程中，选择随机动作是因为通过更好的探索，可以避免局部最小值，并且还可以揭示通往目标状态的未知优化路径。 而且，为了帮助智能体学习终端动作，每当当前区域具有`IoU > τ`时，智能体便被迫采取该动作，这反过来又加速了学习过程。
 
-我们在训练时发现的一个事实是，我们不应强加要首先看图像的哪个对象。 在每个时间步长，代理都将专注于当前区域中与地面真实性重叠程度最高的对象。 这样，目标对象有可能在自顶向下的探索过程中发生变化。
+我们在训练时发现的一个事实是，我们不应强加要首先看图像的哪个对象。 在每个时间步长，智能体都将专注于当前区域中与真实情况性重叠程度最高的对象。 这样，目标对象有可能在自顶向下的探索过程中发生变化。
 
 从正态分布和 Adam 优化器初始化深 Q 网络的权重和偏差参数，以使损失最小化。 高伽玛（折扣系数）用于平衡当前和未来的回报。
 
-使用深度强化学习进行对象检测的这种方法显示了一种由学习代理自上而下探索区域层次结构的方法。 因此，通过适当的层次结构，可以在更少的时间步长内正确检测对象，如下图共享的结果所示：
+使用深度强化学习进行对象检测的这种方法显示了一种由学习智能体自上而下探索区域层次结构的方法。 因此，通过适当的层次结构，可以在更少的时间步长内正确检测对象，如下图共享的结果所示：
 
 ![](img/85511cca-8996-4088-9567-e5fea761e566.png)
 
 # 总结
 
-在本章中，我们介绍了对象检测中的各种最新技术，例如 R-CNN，Fast R-CNN，Faster R-CNN，YOLO，SSD 等。 此外，我们探索了 Bellver 等人（2016）在《使用深度强化学习的分层对象检测》中所提供的方法。按照这种方法，我们学习了如何创建 MDP 框架以进行对象检测，并以最短的时间步长以自上而下的探索方法分层检测对象。 图像中的对象检测是计算机视觉中的一种应用。 还有其他领域，例如视频中的对象检测，视频标记等等，在这些领域中，强化学习可以创建最先进的学习代理。
+在本章中，我们介绍了对象检测中的各种最新技术，例如 R-CNN，Fast R-CNN，Faster R-CNN，YOLO，SSD 等。 此外，我们探索了 Bellver 等人（2016）在《使用深度强化学习的分层对象检测》中所提供的方法。按照这种方法，我们学习了如何创建 MDP 框架以进行对象检测，并以最短的时间步长以自上而下的探索方法分层检测对象。 图像中的对象检测是计算机视觉中的一种应用。 还有其他领域，例如视频中的对象检测，视频标记等等，在这些领域中，强化学习可以创建最先进的学习智能体。
 
 在下一章中，我们将学习如何在 NLP（自然语言处理）领域应用强化学习。
\ No newline at end of file

new/rl-tf/14.md

@@ -6,7 +6,7 @@
 
 为什么在 NLP 中使用强化学习？
 
-*   面向 NLP 的系统（例如文本摘要，对话框生成，问题解答，机器翻译等）确实具有典型的强化学习场景。 例如，对话系统具有增强型学习代理，该学习代理根据接收到的查询生成响应，其中接收到的查询可以是代表当前状态的信号，并且可以采取某种行动来生成响应，代理可以以奖励的形式对此进行反馈。
+*   面向 NLP 的系统（例如文本摘要，对话框生成，问题解答，机器翻译等）确实具有典型的强化学习场景。 例如，对话系统具有增强型学习智能体，该学习智能体根据接收到的查询生成响应，其中接收到的查询可以是代表当前状态的信号，并且可以采取某种行动来生成响应，智能体可以以奖励的形式对此进行反馈。
 *   有很多隐藏变量，它们以隐藏状态的形式存在，还有更多。 决定要包括哪个潜在变量也可以表示为与某些奖励相关的动作。
 *   当前，对于序列到序列模型，我们有一个 BLEU 分数（请参见附录 A，“强化学习中的其他主题”），该分数用于评估生成的语言和实际输出之间的错误分数，但 BLEU 分数只能在生成输入的整个预测语言之后进行评估。 它无法评估代持续进行的时间； 因此，它无法改善旅途中的流程。
 
@@ -55,7 +55,7 @@
 
 # 神经内部注意模型
 
-本节说明了编码器-解码器网络上的神经内部注意模型。 此处，`x = [x[1], x[2], ..., x[n]]`代表输入（文章）标记的序列，`y = [y[1], y[2], ..., y[m]]`代表输出（摘要）标记的序列。 网络的编码器部分由双向 LSTM 组成（请参见附录 A，“强化学习”中的其他主题）。 因此，使用双向 LSTM 读取输入序列`x`，该 LSTM 从`x[i]`的嵌入向量计算隐藏状态`h[i]^e = [h[i]^e_fwd || h[i]^e_bwd]`，其中`||`表示向量的串联。
+本节说明了编码器-解码器网络上的神经内部注意模型。 此处，`x = [x[1], x[2], ..., x[n]]`代表输入（文章）标记的序列，`y = [y[1], y[2], ..., y[m]]`代表输出（摘要）标记的序列。 网络的编码器部分由双向 LSTM 组成（请参见附录 A，“强化学习”中的其他主题）。 因此，使用双向 LSTM 读取输入序列`x`，该 LSTM 从`x[i]`的嵌入向量计算隐藏状态`h[i]^e = [h[i]^e_fwd || h[i]^e_bwd]`，其中`||`表示向量的连接。
 
 在框架的解码器部分，使用单个 LSTM，该 LSTM 从`y[t]`的嵌入向量计算隐藏状态`h[t]^d`。 在时间步零处的初始隐藏状态（即`h[0]^d`）使用编码器的最后一个隐藏状态（即`h[n]^e`）进行初始化。 因此，`h[0]^d = h[n]^e`。
 
@@ -161,7 +161,7 @@ Paulus 等人（2017）在[《用于抽象摘要的深度强化模型》](https:
 
 问题回答是提供文档上下文以及在给定文档上下文中存在其答案的问题的任务。 现有的问题回答模型用于优化交叉熵损失，该模型用于鼓励准确答案并惩罚与准确答案同等准确的其他可能答案。 这些现有的问题回答模型（Xiong 等人，2017 年的最新动态动态求职网络）经过训练，可以从文档上下文中输出所问问题的准确答案范围。 实际地面真相答案的开始和结束位置将用作此监督学习方法的目标。 因此，该监督模型在两个位置上都使用了交叉熵损失，目的是使两个位置上的总损失最小化。
 
-如我们所见，优化是通过使用位置来完成的，评估是通过使用答案的文本内容来完成的。 因此，优化和评估方法之间存在脱节。 由于这种脱节，许多文本上相似的答案由于其在其他位置的存在而受到惩罚，就好像它们是不正确的答案一样，这与地面真实答案的位置不同。
+如我们所见，优化是通过使用位置来完成的，评估是通过使用答案的文本内容来完成的。 因此，优化和评估方法之间存在脱节。 由于这种脱节，许多文本上相似的答案由于其在其他位置的存在而受到惩罚，就好像它们是不正确的答案一样，这与真实情况答案的位置不同。
 
 为了解决这个问题，熊等人发表了他们的研究《DCN+：问答的混合目标和深度残差协作》，*提出了使用混合目标函数的方法，该函数是交叉熵损失和自我批判策略学习的组合。 这个混合目标使用从单词重叠中获得的奖励来解决现有模型中评估与优化之间的脱节问题。
 
@@ -239,10 +239,10 @@ Ground Truth Answer: Colorado Springs
 
 DCN 在答案的开始位置创建概率分布，并在答案的结束位置创建单独的概率分布。 在每个解码时间步长，模型会汇总每个位置的交叉熵损失。 问答任务包括两个评估指标。 它们如下：
 
-*   **完全匹配**：一个二进制值，指示模型输出的答案范围与地面真实答案范围具有精确的字符串匹配
-*   **F1 分数**：该值用于量化模型在预测答案范围和地面真实答案范围之间的单词重叠程度
+*   **完全匹配**：一个二进制值，指示模型输出的答案范围与真实情况答案范围具有精确的字符串匹配
+*   **F1 分数**：该值用于量化模型在预测答案范围和真实情况答案范围之间的单词重叠程度
 
-根据原始的 DCN 框架，目标函数和评估指标是不连贯的，因此，对确切的匹配给予了极大的鼓励。 举例来说，有两个答案范围`A`和`B`，但它们都不与地面真实答案范围匹配，但是`A`具有完全匹配的字符串，而`B`没有字符串匹配。 然后，在这种情况下，尽管根据先前的完全匹配指标，`A`是正确的输出，但仅交叉熵损失的旧客观方法将同等地惩罚`A`和`B`和 F1 得分。
+根据原始的 DCN 框架，目标函数和评估指标是不连贯的，因此，对确切的匹配给予了极大的鼓励。 举例来说，有两个答案范围`A`和`B`，但它们都不与真实情况答案范围匹配，但是`A`具有完全匹配的字符串，而`B`没有字符串匹配。 然后，在这种情况下，尽管根据先前的完全匹配指标，`A`是正确的输出，但仅交叉熵损失的旧客观方法将同等地惩罚`A`和`B`和 F1 得分。
 
 如果我们检查 F1 分数，则`A`的量度显示单词在跨度`A`中重叠且具有真实答案范围，但答案`B`则不是这种情况。 因此，F1 分数与自关键策略梯度算法一起用作训练的奖励函数。
 

new/rl-tf/15.md

@@ -27,7 +27,7 @@ TRPO 由 Schulman 等（2017）发布在名为[《信任区域策略优化》](h
 
 ![](img/c5f5537b-51ac-414c-9dd1-d8461a257262.png)
 
-可以将先前的更新规则合并到策略网络中，在该策略网络中使用随机梯度上升来更新参数。 这可以通过确定性的行为者批判方法来实现，其中批评者估计动作值函数，而行为者从批评者获得其梯度以更新其参数。 如 Silver 等人在[《确定性策略梯度算法》](http://proceedings.mlr.press/v32/silver14.pdf)中所述。 在实验之后，他们能够成功得出结论，确定性的策略梯度比随机的梯度更有效率。 此外，确定性演员评论家者的表现优于随机行动者。 有关此主题的详细说明超出了本书的范围。 因此，请转到前面提到的研究出版物链接。
+可以将先前的更新规则合并到策略网络中，在该策略网络中使用随机梯度上升来更新参数。 这可以通过确定性的行为者批判方法来实现，其中批评者估计动作值函数，而行为者从批评者获得其梯度以更新其参数。 如 Silver 等人在[《确定性策略梯度算法》](http://proceedings.mlr.press/v32/silver14.pdf)中所述。 在实验之后，他们能够成功得出结论，确定性的策略梯度比随机的梯度更有效率。 此外，确定性演员评论家的表现优于随机行动者。 有关此主题的详细说明超出了本书的范围。 因此，请转到前面提到的研究出版物链接。
 
 # NLP 序列模型中的评分机制