2021-01-24 22:18:23

new/dl-pt-workshop/2.md

@@ -268,7 +268,7 @@ Rosenblatt 还介绍了权重的概念（`w1`，`w2`，...，`wn`），这些数
 
     对于监督学习问题，输入数据包含一对特征和目标。 网络的工作是发现特征与目标之间的相关性或依赖性。
 
-2.  **隐藏层**：接下来，可以找到隐藏层。 神经网络可以具有许多隐藏层，这意味着在输入层和输出层之间可以有任意数量的层。 它具有的层越多，可以解决的数据问题就越复杂，但培训时间也将更长。 还有一些神经网络架构根本不包含隐藏层，单层网络就是这种情况。
+2.  **隐藏层**：接下来，可以找到隐藏层。 神经网络可以具有许多隐藏层，这意味着在输入层和输出层之间可以有任意数量的层。 它具有的层越多，可以解决的数据问题就越复杂，但训练时间也将更长。 还有一些神经网络架构根本不包含隐藏层，单层网络就是这种情况。
 
     在每一层中，都会根据从上一层作为输入接收的信息执行计算，然后将其用于输出将成为下一层输入的值。
 

new/dl-pt-workshop/6.md

@@ -454,7 +454,7 @@ onehot = onehot_flat.reshape((batch.shape[0],\
 
 ## 练习 6.02：预处理输入数据并创建单热矩阵
 
-在本练习中，您将预处理文本片段，然后将其转换为一键式矩阵。 请按照以下步骤完成此练习：
+在本练习中，您将预处理文本片段，然后将其转换为单热矩阵。 请按照以下步骤完成此练习：
 
 1.  导入 NumPy。
 
@@ -530,7 +530,7 @@ onehot = onehot_flat.reshape((batch.shape[0],\
 
 ![Figure 6.22: One-hot representation of sample text ](img/B16118_06_22.jpg)
 
-图 6.22：示例文本的一键式表示
+图 6.22：示例文本的单热表示
 
 注意
 
@@ -538,7 +538,7 @@ onehot = onehot_flat.reshape((batch.shape[0],\
 
 您也可以通过[这里](https://packt.live/38foCxD)在线运行此示例。 您必须执行整个笔记本才能获得所需的结果。
 
-您已成功将一些示例文本转换为一键式矩阵。
+您已成功将一些示例文本转换为单热矩阵。
 
 ## 构建架构
 

new/pt-ai-fund/6.md

@@ -658,7 +658,7 @@ pip install numpy
 
 在本秘籍中，我们将研究**渐进 GAN**（**PGGAN**），与 DCGAN 相比它们是高级 GAN，并且能够生成逼真的图像。 PGGAN 分多个阶段训练 GAN 网络。 它具有`z`的潜在特征，并使用两个反卷积层生成`4×4`图像。 在判别器方面，网络使用两个卷积层训练生成的`4 x 4`图像。 网络稳定后，它会在判别器中再增加两个卷积层以将图像上采样到`8 x 8`，再增加两个卷积层以对图像下采样。
 
-经过 9 个这样的级数后，生成器将生成`1024 x 1024`个图像。 PGGAN 的渐进式训练策略相对于常规 GAN 具有优势，因为它可以加快并稳定训练。 之所以如此，是因为大多数训练都是在较低的分辨率下进行的，而在网络达到各个阶段的稳定性之后，会逐渐发展为较高的分辨率。
+经过 9 个这样的序列后，生成器将生成`1024 x 1024`个图像。 PGGAN 的渐进式训练策略相对于常规 GAN 具有优势，因为它可以加快并稳定训练。 之所以如此，是因为大多数训练都是在较低的分辨率下进行的，而在网络达到各个阶段的稳定性之后，会逐渐发展为较高的分辨率。
 
 以下是 PGGAN 的抽象表示形式：
 

new/pt-dl-handson/5.md

@@ -94,7 +94,7 @@ array([[O., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
 
 #### 词嵌入
 
-使用自然语言（或由离散的单个单元组成的任何序列）的标准方法是将每个单词转换为一个热编码向量，并将其用于网络的后期。 这种方法的明显缺点是，随着词汇量的增加，输入层的大小也会增加。
+使用自然语言（或由离散的单个单元组成的任何序列）的标准方法是将每个单词转换为单热编码向量，并将其用于网络的后期。 这种方法的明显缺点是，随着词汇量的增加，输入层的大小也会增加。
 
 词嵌入是减少数组或张量维数的数十年历史的想法。 **潜在迪利克雷分配**（**LDA**）和**潜在语义分析**（**LSA**）是我们用来进行嵌入的两个此类示例。 但是，在 Facebook 研究科学家 Tomas Mikolov 和他的团队于 2013 年实现 word2vec 之后，就开始将嵌入视为前提。
 

new/pt-dl-handson/7.md

@@ -44,11 +44,11 @@
 
 ## 情景任务与连续任务
 
-在现实世界中，我们指定的许多任务都有明确定义的终点。 例如，如果智能体正在玩游戏，则当智能体获胜或失败或死亡时，情节或任务便会结束。
+在现实世界中，我们指定的许多任务都有明确定义的终点。 例如，如果智能体正在玩游戏，则当智能体获胜或失败或死亡时，剧集或任务便会结束。
 
-在无人驾驶汽车的情况下，任务在汽车到达目的地或撞车时结束。 这些具有明确终点的任务称为情节任务。 智能体在每个情节的结尾都会获得奖励，这是智能体决定自己在环境中做得如何的时候。 然后，智能体从头开始但继续拥有下一个情节的先验信息，然后继续执行下一个情节，因此效果更好。
+在无人驾驶汽车的情况下，任务在汽车到达目的地或撞车时结束。 这些具有明确终点的任务称为剧集任务。 智能体在每个剧集的结尾都会获得奖励，这是智能体决定自己在环境中做得如何的时候。 然后，智能体从头开始但继续拥有下一个剧集的先验信息，然后继续执行下一个剧集，因此效果更好。
 
-随着时间的流逝，在一段情节中，智能体将学会玩游戏或将汽车开到特定的目的地，因此将受到训练。 您会记得，智能体的目标是在剧集结束时最大限度地提高累积奖励。
+随着时间的流逝，在一段剧集中，智能体将学会玩游戏或将汽车开到特定的目的地，因此将受到训练。 您会记得，智能体的目标是在剧集结束时最大限度地提高累积奖励。
 
 但是，有些任务可能永远持续下去。 例如，在股票市场上交易股票的机器人没有明确的终点，必须在每个时间步骤中学习和提高自己。 这些任务称为连续任务。 因此，在那种情况下，奖励是在特定的时间间隔提供给业务代表的，但任务没有尽头，因此业务代表必须从环境中学习并同时进行预测。
 
@@ -371,7 +371,7 @@ for i_episode in range(num_episodes):
 env.close()
 ```
 
-让我们看看我们的训练循环。 对于每个情节，我们都会重置环境。 我们从环境中获得了两个屏幕，将当前状态定义为两个屏幕之间的差异。 然后，对于情节中的每个时间步，我们使用`select_action`函数选择一个动作。 我们要求环境采取该行动，并将奖励和`done`标志归还（它告诉我们情节是否结束，也就是卡塔普尔跌倒了）。 我们观察到已经提出的新状态。 然后，我们将刚刚经历的事务推入存储体，并移至下一个状态。 下一步是优化模型。 我们将很快介绍该函数。
+让我们看看我们的训练循环。 对于每个剧集，我们都会重置环境。 我们从环境中获得了两个屏幕，将当前状态定义为两个屏幕之间的差异。 然后，对于剧集中的每个时间步，我们使用`select_action`函数选择一个动作。 我们要求环境采取该行动，并将奖励和`done`标志归还（它告诉我们剧集是否结束，也就是卡塔普尔跌倒了）。 我们观察到已经提出的新状态。 然后，我们将刚刚经历的事务推入存储体，并移至下一个状态。 下一步是优化模型。 我们将很快介绍该函数。
 
 我们还将每五集使用`policy_net`权重的副本更新`target_net`。
 

new/pt-tut-17/05.md

@@ -131,7 +131,7 @@ out.backward(torch.randn(1, 10))
 
 例如，`nn.Conv2d`将采用`nSamples x nChannels x Height x Width`的 4D 张量。
 
-如果您只有一个样品，只需使用`input.unsqueeze(0)`添加一个假批量尺寸。
+如果您只有一个样本，只需使用`input.unsqueeze(0)`添加一个假批量尺寸。
 
 在继续之前，让我们回顾一下到目前为止所看到的所有类。
 

new/pt-tut-17/28.md

@@ -118,7 +118,7 @@ print(category_lines['Italian'][:5])
 
 现在我们已经组织了所有名称，我们需要将它们转换为张量以使用它们。
 
-为了表示单个字母，我们使用大小为`<1 x n_letters>`的单热向量。 一个热门向量用 0 填充，但当前字母的索引处的数字为 1，例如 `"b" = <0 1 0 0 0 ...>`。
+为了表示单个字母，我们使用大小为`<1 x n_letters>`的单热向量。 单热向量用 0 填充，但当前字母的索引处的数字为 1，例如 `"b" = <0 1 0 0 0 ...>`。
 
 为了制造一个单词，我们将其中的一些连接成 2D 矩阵`<line_length x 1 x n_letters>`。
 

new/pt-tut-17/34.md

@@ -211,7 +211,7 @@ plt.show()
 该单元实例化我们的模型及其优化器，并定义一些工具：
 
 *   `select_action`-将根据 ε 贪婪策略选择一个动作。 简而言之，有时我们会使用模型来选择操作，有时我们会统一采样。 选择随机动作的可能性将从`EPS_START`开始，并朝`EPS_END`呈指数衰减。 `EPS_DECAY`控制衰减率。
-*   `plot_durations`-绘制情节持续时间以及最近 100 个情节的平均值（官方评估中使用的度量）的助手。 该图将在包含主要训练循环的单元下面，并且将在每个情节之后更新。
+*   `plot_durations`-绘制剧集持续时间以及最近 100 个剧集的平均值（官方评估中使用的度量）的助手。 该图将在包含主要训练循环的单元下面，并且将在每个剧集之后更新。
 
 ```py
 BATCH_SIZE = 128
@@ -282,7 +282,7 @@ def plot_durations():
 
 最后，是训练模型的代码。
 
-在这里，您可以找到执行优化步骤的`optimize_model`函数。 它首先对一批进行采样，将所有张量连接为一个张量，计算`Q(s[t], a[t])`和`V(s[t+1])= max[a] Q(s[t+1], a)`，并将其合并为我们的损失。 根据定义，如果`s`为终端状态，则设置`V(s) = 0`。 我们还使用目标网络来计算`V(s[t+1])`，以提高稳定性。 目标网络的权重大部分时间保持冻结状态，但经常更新以策略网络的权重。 通常这是一组固定的步骤，但是为了简单起见，我们将使用情节。
+在这里，您可以找到执行优化步骤的`optimize_model`函数。 它首先对一批进行采样，将所有张量连接为一个张量，计算`Q(s[t], a[t])`和`V(s[t+1])= max[a] Q(s[t+1], a)`，并将其合并为我们的损失。 根据定义，如果`s`为终端状态，则设置`V(s) = 0`。 我们还使用目标网络来计算`V(s[t+1])`，以提高稳定性。 目标网络的权重大部分时间保持冻结状态，但经常更新以策略网络的权重。 通常这是一组固定的步骤，但是为了简单起见，我们将使用剧集。
 
 ```py
 def optimize_model():
@@ -331,7 +331,7 @@ def optimize_model():
 
 ```
 
-在下面，您可以找到主要的训练循环。 首先，我们重置环境并初始化`state`张量。 然后，我们采样一个动作，执行它，观察下一个屏幕和奖励（总是 1），并一次优化我们的模型。 当情节结束（我们的模型失败）时，我们重新开始循环。
+在下面，您可以找到主要的训练循环。 首先，我们重置环境并初始化`state`张量。 然后，我们采样一个动作，执行它，观察下一个屏幕和奖励（总是 1），并一次优化我们的模型。 当剧集结束（我们的模型失败）时，我们重新开始循环。
 
 下面，将`num_episodes`设置得较小。 您应该下载笔记本并运行更多的片段，例如 300 多个片段，才能显着改善持续时间。
 

new/pt-tut-17/35.md

@@ -596,7 +596,7 @@ class MetricLogger:
 
 ## 开始吧！
 
-在此示例中，我们运行了 10 个情节的训练循环，但是对于马里奥要真正了解他的世界的方式，我们建议运行至少 40,000 个情节的循环！
+在此示例中，我们运行了 10 个剧集的训练循环，但是对于马里奥要真正了解他的世界的方式，我们建议运行至少 40,000 个剧集的循环！
 
 ```py
 use_cuda = torch.cuda.is_available()

new/pt-tut-17/64.md

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

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
@@ -298,7 +298,7 @@ class Agent:
 
 ```
 
-现在，让我们定义如何将不同的 RPC 函数结合在一起。 `Agent`控制每个情节的执行。 它首先使用`rpc_async`在所有观察者上开始该情节，并阻止将由观察者奖励填充的返还期货。 请注意，以下代码使用 RRef 帮助器`ob_rref.rpc_async()`在具有提供的参数的`ob_rref` RRef 的所有者上启动`run_episode`函数。 然后将保存的动作概率和返回的观察者奖励转换为期望的数据格式，并开始训练步骤。 最后，它将重置所有状态并返回当前情节的奖励。 此函数是运行一集的入口。
+现在，让我们定义如何将不同的 RPC 函数结合在一起。 `Agent`控制每个剧集的执行。 它首先使用`rpc_async`在所有观察者上开始该剧集，并阻止将由观察者奖励填充的返还期货。 请注意，以下代码使用 RRef 帮助器`ob_rref.rpc_async()`在具有提供的参数的`ob_rref` RRef 的所有者上启动`run_episode`函数。 然后将保存的动作概率和返回的观察者奖励转换为期望的数据格式，并开始训练步骤。 最后，它将重置所有状态并返回当前剧集的奖励。 此函数是运行一集的入口。
 
 ```py
 class Agent:

new/rl-tf/01.md

@@ -706,7 +706,7 @@ Inception 由 Google 团队于 2014 年创建。其主要思想是创建更广
 
 `V(s)`，即状态的值定义为，从该状态到后续状态直到智能体到达目标状态之前，所有将来在该状态下将要收到的奖励的期望值。 基本上，值函数告诉我们处于这种状态有多好。 值越高，状态越好。
 
-分配给每个`(s, a, s')`三元组的奖励是固定的。 状态值不是这种情况。 它会随着情节中的每个动作以及不同情节而变化。
+分配给每个`(s, a, s')`三元组的奖励是固定的。 状态值不是这种情况。 它会随着剧集中的每个动作以及不同剧集而变化。
 
 我们想到一个解决方案，而不是值函数，为什么我们不存储每个可能状态的知识呢？
 
@@ -746,7 +746,7 @@ Q 学习涉及的步骤：
     
     其中`γ`是折扣因子。
 
-6.  然后，将当前状态的值设置为新状态，并重复该过程以完成一个情节，即达到终端状态
+6.  然后，将当前状态的值设置为新状态，并重复该过程以完成一个剧集，即达到终端状态
 
 7.  运行多个剧集来训练智能体
 

new/rl-tf/02.md

@@ -75,7 +75,7 @@ import Gym
 env = Gym.make('FrozenLake-v0')   #make function of Gym loads the specified environment
 ```
 
-接下来，我们来重置环境。 在执行强化学习任务时，智能体会经历多个情节的学习。 结果，在每个情节开始时，都需要重置环境，使其恢复到初始状态，并且智能体从开始状态开始。 以下代码显示了重置环境的过程：
+接下来，我们来重置环境。 在执行强化学习任务时，智能体会经历多个剧集的学习。 结果，在每个剧集开始时，都需要重置环境，使其恢复到初始状态，并且智能体从开始状态开始。 以下代码显示了重置环境的过程：
 
 ```py
 import Gym 

new/rl-tf/04.md

@@ -163,7 +163,7 @@
 
 # 时差规则
 
-首先，**时间差**（**TD**）是两个时间步之间的值估计值之差。 这与基于结果的蒙特卡洛方法不同，后者基于前瞻性的观点直到情节结束才完成，以更新学习参数。 在时间差异学习的情况下，仅需完成一个步骤，而下一步的状态值估计将用于更新当前状态的值估计。 因此，学习参数会不断更新。 进行时差学习的不同规则是`TD(1)`，`TD(0)`和`TD(λ)`规则。 所有方法中的基本概念是，下一步的值估计用于更新当前状态的值估计。
+首先，**时间差**（**TD**）是两个时间步之间的值估计值之差。 这与基于结果的蒙特卡洛方法不同，后者基于前瞻性的观点直到剧集结束才完成，以更新学习参数。 在时间差异学习的情况下，仅需完成一个步骤，而下一步的状态值估计将用于更新当前状态的值估计。 因此，学习参数会不断更新。 进行时差学习的不同规则是`TD(1)`，`TD(0)`和`TD(λ)`规则。 所有方法中的基本概念是，下一步的值估计用于更新当前状态的值估计。
 
 # `TD(1)`规则
 
@@ -183,14 +183,14 @@ Episode T
 *   对于所有状态`s`，合格分数`e(s) = 0`
 *   对于所有状态`s`，给定`Episode T`中的状态值`V[T](s)`等于`V[T-1](s)`
 
-在情节的每个时间步，即当前步`t`，我们更新要离开的状态`s[t-1]`的资格，然后为所有状态更新以下内容：
+在剧集的每个时间步，即当前步`t`，我们更新要离开的状态`s[t-1]`的资格，然后为所有状态更新以下内容：
 
 *   针对当前离开状态`s[t-1]`（即`r[t] + γ V[T-1](s[t]) + V[T-1](s[t-1])`）和要更改其值的状态的合格分数`e(s)`使用时间差误差的状态值函数
 *   通过给定折扣系数进行折扣的资格分数
 
 由于这些更新针对所有状态独立发生，因此可以针对所有状态并行执行这些操作。
 
-在完成情节的最后一步之后扩展每个州的计算值估计值时，我们发现基于值的更新与基于结果的更新相同，例如在蒙特卡洛方法中，我们会进行全面的展望，直到剧集的结尾。 因此，我们需要一种更好的方法来更新我们的值函数估计值，而无需多做一步。 通过合并`TD(0)`规则，我们可以解决此问题。
+在完成剧集的最后一步之后扩展每个州的计算值估计值时，我们发现基于值的更新与基于结果的更新相同，例如在蒙特卡洛方法中，我们会进行全面的展望，直到剧集的结尾。 因此，我们需要一种更好的方法来更新我们的值函数估计值，而无需多做一步。 通过合并`TD(0)`规则，我们可以解决此问题。
 
 # `TD(0)`规则
 
@@ -500,7 +500,7 @@ def policy_backward(arr_hidden_state,gradient_logp,observation_values):
     return {'W1':dW1,'W2':dW2}
 ```
 
-创建环境并结合先前的函数以使智能体逐步学习多个情节的最终任务如下：
+创建环境并结合先前的函数以使智能体逐步学习多个剧集的最终任务如下：
 
 ```py
 #implementation details

new/rl-tf/05.md

@@ -59,11 +59,11 @@ DeepMind 在研究期刊 **Nature** 上发表了他们的论文[《通过深度
 
 # 蒙特卡洛学习
 
-蒙特卡洛（Monte Carlo）是用于模型免费学习的最简单方法，在该方法中，智能体会观察情节中前进的所有步骤（即前瞻）的回报。 因此，在时间`t`时的总估计报酬为`R[t]`：
+蒙特卡洛（Monte Carlo）是用于模型免费学习的最简单方法，在该方法中，智能体会观察剧集中前进的所有步骤（即前瞻）的回报。 因此，在时间`t`时的总估计报酬为`R[t]`：
 
 ![](img/142010fa-0c37-4b54-b47d-e27ca48bd3d6.png)
 
-这里，`γ`是折扣因子，`T`是情节结束的时间步长。 我们可以使用以下代码初始化蒙特卡洛学习技术：
+这里，`γ`是折扣因子，`T`是剧集结束的时间步长。 我们可以使用以下代码初始化蒙特卡洛学习技术：
 
 ```py
 Initialize:
@@ -85,7 +85,7 @@ Repeat forever:
 
 # 时差学习
 
-与在蒙特卡洛学习中我们要全面展望未来不同，在时间差异学习中，我们只有一个展望，也就是说，我们只观察到情节的下一步：
+与在蒙特卡洛学习中我们要全面展望未来不同，在时间差异学习中，我们只有一个展望，也就是说，我们只观察到剧集的下一步：
 
 ![](img/d82f0db8-7eb5-4425-b229-a08877c1ba7d.png)
 
@@ -226,7 +226,7 @@ Making new env: MountainCar-v0
 (2,)
 ```
 
-因此，我们看到动作空间是一个离散集合，显示了三个可能的动作，状态空间是一个二维连续空间，其中一个维度满足位置，而另一个则满足汽车的速度。 接下来，我们将使用以下代码分配超参数，例如状态数，情节数，学习率（初始和最小值），折扣因子伽玛，情节中的最大步数以及 ε 贪婪的`ε`：
+因此，我们看到动作空间是一个离散集合，显示了三个可能的动作，状态空间是一个二维连续空间，其中一个维度满足位置，而另一个则满足汽车的速度。 接下来，我们将使用以下代码分配超参数，例如状态数，剧集数，学习率（初始和最小值），折扣因子伽玛，剧集中的最大步数以及 ε 贪婪的`ε`：
 
 ```py
 n_states = 40  # number of states
@@ -703,7 +703,7 @@ Episode 10 with Reward : 38.7923903502 at epsilon 0.9002 in steps 126
 *   `theta`：显示以弧度为单位的角度（最小值为 -0.73，最大值为 0.73）
 *   `theta_dot`：显示角速度（最小值为`-∞`，最大值为`∞`）
 
-在给定状态下的每一步，都有两种可能的动作，即推车可以向左或向右移动，并且每一步收到的奖励为 1。这里，只要杆子靠近垂直，推车在边界内。 如果发生以下情况，则情节被视为结束：
+在给定状态下的每一步，都有两种可能的动作，即推车可以向左或向右移动，并且每一步收到的奖励为 1。这里，只要杆子靠近垂直，推车在边界内。 如果发生以下情况，则剧集被视为结束：
 
 *   极点下降超过某个角度，即超过 ±0.20944 弧度
 *   推车超出框架左侧或右侧太远，即超出 ±2.4
@@ -846,7 +846,7 @@ Episode 150 with Reward : 1053.0 at epsilon 0.9002 in steps 1052
 Mean over last 100 episodes are: 248.72999999999999
 ```
 
-由于输出日志太长，因此在这里，我们的输出适合最近六个情节以及最近 100 个情节的每集平均奖励。
+由于输出日志太长，因此在这里，我们的输出适合最近六个剧集以及最近 100 个剧集的每集平均奖励。
 
 # 用于 OpenAI Gym Atari Breakout 的深度 Q 网络
 
@@ -1315,7 +1315,7 @@ MCTS 是独立于域的，不需要复杂的手写试探法。 因此，它是
 
 # SARSA 算法
 
-**状态-动作-奖励-状态-动作**（**SARSA**）算法是一种基于策略的学习问题。 就像 Q 学习一样，SARSA 也是一个时差学习问题，也就是说，它会预测情节的下一步以估计未来的回报。 SARSA 和 Q 学习之间的主要区别在于，具有最大 Q 值的动作不用于更新当前状态动作对的 Q 值。 取而代之的是，选择作为当前策略结果的操作的 Q 值，或者由于采用诸如 ε 贪婪之类的探索步骤来更新当前状态操作对的 Q 值。 SARSA 之所以得名，是因为使用五元组`Q(s, a, r, s', a')`完成了 Q 值更新，其中：
+**状态-动作-奖励-状态-动作**（**SARSA**）算法是一种基于策略的学习问题。 就像 Q 学习一样，SARSA 也是一个时差学习问题，也就是说，它会预测剧集的下一步以估计未来的回报。 SARSA 和 Q 学习之间的主要区别在于，具有最大 Q 值的动作不用于更新当前状态动作对的 Q 值。 取而代之的是，选择作为当前策略结果的操作的 Q 值，或者由于采用诸如 ε 贪婪之类的探索步骤来更新当前状态操作对的 Q 值。 SARSA 之所以得名，是因为使用五元组`Q(s, a, r, s', a')`完成了 Q 值更新，其中：
 
 *   `s`，`a`：当前状态和操作
 *   `r`：采取行动后观察到的奖励`a`
@@ -1396,7 +1396,7 @@ Making new env: MountainCar-v0
 (2,)
 ```
 
-接下来，我们将使用以下代码分配超参数，例如状态数，情节数，学习率（初始和最小值），折扣因子伽玛，情节中的最大步长以及 ε 贪婪的`ε`：
+接下来，我们将使用以下代码分配超参数，例如状态数，剧集数，学习率（初始和最小值），折扣因子伽玛，剧集中的最大步长以及 ε 贪婪的`ε`：
 
 ```py
 n_states = 40  # number of states

new/rl-tf/06.md

@@ -58,7 +58,7 @@ Google DeepMind 和 MILA 的联合团队于 2016 年 6 月发布了用于深度
 
 异步单步 Q 学习的架构与 DQN 非常相似。 DQN 中的智能体由一组主要网络和目标网络表示，其中一步损失的计算方法是主要网络预测的当前状态`s`的状态作用值与目标状态- 目标网络计算的当前状态的动作值。 相对于策略网络的参数来计算损失的梯度，然后使用梯度下降优化器将损失最小化，从而导致主网络的参数更新。
 
-异步单步 Q 学习中的区别在于，有多个此类学习智能体，例如，学习器并行运行并计算此损失。 因此，梯度计算也并行发生在不同的线程中，其中每个学习智能体都与自己的环境副本进行交互。 这些梯度在多个时间步长上在不同线程中的累积用于在固定时间步长后或情节结束后更新策略网络参数。 梯度的累积优于策略网络参数更新，因为这样可以避免覆盖每个学习器智能体执行的更改。
+异步单步 Q 学习中的区别在于，有多个此类学习智能体，例如，学习器并行运行并计算此损失。 因此，梯度计算也并行发生在不同的线程中，其中每个学习智能体都与自己的环境副本进行交互。 这些梯度在多个时间步长上在不同线程中的累积用于在固定时间步长后或剧集结束后更新策略网络参数。 梯度的累积优于策略网络参数更新，因为这样可以避免覆盖每个学习器智能体执行的更改。
 
 此外，将不同的探索策略添加到不同的线程可以使学习变得多样化且稳定。 由于更好的探索，因此提高了表现，因为不同线程中的每个学习智能体都受到不同的探索策略。 尽管有许多方法可以执行此操作，但一种简单的方法是在使用 ε 贪婪的同时为不同的线程使用不同的`ε`示例。
 

new/rl-tf/11.md

@@ -138,7 +138,7 @@ Perkins 和 Barto（2002）提出了一种基于 Lyapunov 函数构造强化学
 *   先验领域知识的重要性是什么？
 
     *   先验知识对于强化学习智能体的准确率更好。
-    *   在尽可能少的情节中更好地学习所需的先验知识量尚不确定，并且尚待解决。 因此，重复大量的迭代以确保更好的学习。
+    *   在尽可能少的剧集中更好地学习所需的先验知识量尚不确定，并且尚待解决。 因此，重复大量的迭代以确保更好的学习。
     *   在某些情况下，由于与环境相关的大量不确定性，先验知识可能无济于事。
 *   我们如何根据感知数据仔细学习？
     *   繁重的预处理和约束条件使感知到的大多数关键信息抽象化

new/rl-tf/12.md

@@ -92,11 +92,11 @@
 *   初始分配预算中剩余的剩余金额，即未用预算`b ∈ {0, ..., B}`
 *   特征向量`x`，代表出价请求
 
-在每个情节中，每次出价都会按顺序发送给智能体，智能体针对每个智能体根据当前信息`t`，`b`和`x`。 因此，智能体基于出价的剩余时间，初始分配预算中剩余的剩余量以及提出的投标请求的所有关键信息来决定适当的动作。
+在每个剧集中，每次出价都会按顺序发送给智能体，智能体针对每个智能体根据当前信息`t`，`b`和`x`。 因此，智能体基于出价的剩余时间，初始分配预算中剩余的剩余量以及提出的投标请求的所有关键信息来决定适当的动作。
 
 如上图所示，智能体维护剩余的出价`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`。
 
 以下是前面的增强型学习框架要投标的实现的伪代码：
 

new/rl-tf/13.md

@@ -166,7 +166,7 @@ YOLO 还可以为每个盒子预测训练中所有类的类得分。 因此，
 
 我们在训练时发现的一个事实是，我们不应强加要首先看图像的哪个对象。 在每个时间步长，智能体都将专注于当前区域中与真实情况性重叠程度最高的对象。 这样，目标对象有可能在自顶向下的探索过程中发生变化。
 
-从正态分布和 Adam 优化器初始化深 Q 网络的权重和偏差参数，以使损失最小化。 高伽玛（折扣系数）用于平衡当前和未来的回报。
+从正态分布和 Adam 优化器初始化深度 Q 网络的权重和偏差参数，以使损失最小化。 高伽玛（折扣系数）用于平衡当前和未来的回报。
 
 使用深度强化学习进行对象检测的这种方法显示了一种由学习智能体自上而下探索区域层次结构的方法。 因此，通过适当的层次结构，可以在更少的时间步长内正确检测对象，如下图共享的结果所示：