2020-12-23 22:25:39

new/handson-rl-py/05.md

@@ -114,11 +114,11 @@ V(s) = -0.0315
 
 现在，我们将使用不同的步骤来理解算法。
 
-考虑相同的冻湖示例。 假设我们处于状态（3,2），并且有两个动作（左和右）。 现在让我们参考该图，并将其与`ε`贪婪策略进行比较：
+考虑相同的冻湖示例。 假设我们处于状态`(3, 2)`，并且有两个动作（左和右）。 现在让我们参考该图，并将其与`ε`贪婪策略进行比较：
 
 ![](img/00124.jpeg)
 
-在“ Q 学习”中，我们使用`ε`贪婪策略选择一个动作。 我们要么探索概率为ε的新动作，要么选择概率为 1ε的最佳动作。 假设我们选择一个概率`ε`，并探索一个新的动作**向下**，然后选择该动作：
+在“Q 学习”中，我们使用`ε`贪婪策略选择一个动作。 我们要么探索概率为ε的新动作，要么选择概率为`1ε`的最佳动作。 假设我们选择一个概率`ε`，并探索一个新的动作**向下**，然后选择该动作：
 
 ![](img/00125.jpeg)
 
@@ -148,7 +148,7 @@ Q( (3,2), down) = 0.8 + 0.1 ( 0.3 + 1 max [0.3, 0.5, 0.8] - 0.8 )
 
 因此，我们将`Q((3, 2), down)`的值更新为`0.83`。
 
-请记住，在选择要采取的操作时，我们将执行`ε`贪婪策略：我们要么探索具有概率`epsilon`的新操作，要么采取具有最大值的概率 1-epsilon。 在更新 Q 值时，我们不执行`ε`贪婪策略，我们仅选择具有最大值的操作。
+请记住，在选择要采取的操作时，我们将执行`ε`贪婪策略：我们要么探索具有概率`epsilon`的新操作，要么采取具有最大值的概率 1 `epsilon`。 在更新 Q 值时，我们不执行`ε`贪婪策略，我们仅选择具有最大值的操作。
 
 现在我们处于状态`(4, 2)`，我们必须执行一个动作。 我们应该执行什么动作？ 我们决定基于`ε`贪婪策略，要么探索具有概率`epsilon`的新操作，要么选择具有概率 *1-epsilon* 的最佳操作。 假设我们选择概率`1-ε`，然后选择最佳操作。 因此，在`(4, 2)`中，向右的操作具有最大值。 因此，我们将选择**向右**操作：
 
@@ -182,7 +182,7 @@ Q ( (4,2), right) = 0.8 + 0.1 (0.3 + 1 max [ 0.1,0.3] - 0.8)
 
 # 使用 Q 学习解决出租车问题
 
-为了演示该问题，我们假设代理是驱动程序。 有四个地点，代理商必须在一个地点接客并在另一地点下车。 座席将获得+20 积分作为成功下车的奖励，而每走一步便获得-1 积分。 该代理商还将因非法取送丢掉-10 分。 因此，我们代理商的目标是学会在短时间内在正确的位置上落客而不增加非法乘客。
+为了演示该问题，我们假设代理是驱动程序。 有四个地点，代理商必须在一个地点接客并在另一地点下车。 座席将获得 +20 积分作为成功下车的奖励，而每走一步便获得 -1 积分。 该代理商还将因非法取送丢掉 -10 分。 因此，我们代理商的目标是学会在短时间内在正确的位置上落客而不增加非法乘客。
 
 这里显示的环境中，字母（`R`，`G`，`Y`，`B`）代表不同的位置，并且是一个小矩形 是驾驶出租车的代理商：
 
@@ -234,7 +234,7 @@ def update_q_table(prev_state, action, reward, nextstate, alpha, gamma):
     q[(prev_state,action)] += alpha * (reward + gamma * qa -q[(prev_state,action)])
 ```
 
-然后，我们定义一个函数以执行`ε`贪婪策略，并在其中传递状态和`epsilon`值。 我们生成一些均匀分布的随机数，如果该数小于 epsilon，则在状态中探索不同的动作，否则我们将利用具有最大 q 值的动作：
+然后，我们定义一个函数以执行`ε`贪婪策略，并在其中传递状态和`epsilon`值。 我们生成一些均匀分布的随机数，如果该数小于`epsilon`，则在状态中探索不同的动作，否则我们将利用具有最大 q 值的动作：
 
 ```py
 
@@ -319,7 +319,7 @@ for i in range(8000):
 
         env.render()
 
-        # In each state, we select the action by`ε`贪婪policy
+        # In each state, we select the action by ε-greedy policy
         action = epsilon_greedy_policy(prev_state, epsilon)
 
         # then we perform the action and move to the next state, and 
@@ -377,7 +377,7 @@ Q( (4,2), right) = Q( (4,2),right) + 0.1 ( 0.3 + 1 Q( (4,3), action)) - Q((4,2)
 
 ![](img/00139.jpeg)
 
-我们在这里也遵循`ε`贪婪策略。 我们要么以概率`epsilon`进行探索，要么以概率 1`epsilon`进行利用。 假设我们选择概率ε并探索新的动作。 我们探索一个新动作**向右**，然后选择该动作：
+我们在这里也遵循`ε`贪婪策略。 我们要么以概率`epsilon`进行探索，要么以概率 1 `epsilon`进行利用。 假设我们选择概率`ε`并探索新的动作。 我们探索一个新动作**向右**，然后选择该动作：
 
 ![](img/00140.jpeg)
 
@@ -559,7 +559,7 @@ Q 学习和 SARSA 对许多人来说总是很困惑。 让我们分解一下两
 2.  TD 错误到底是什么？
 3.  TD 预测和控制之间有什么区别？
 4.  如何使用 Q 学习构建智能代理？
-5.  Q learning 和 SARSA 有什么区别？
+5.  Q 学习和 SARSA 有什么区别？
 
 # 进一步阅读
 

new/handson-rl-py/06.md

@@ -140,7 +140,7 @@ The optimal arm is 3
 
 # softmax 探索算法
 
-Softmax 探索（也称为 Boltzmann 探索）是用于找到最佳老虎机的另一种策略。 在`ε`贪婪策略中，我们等效地考虑所有非最佳分支，但是在 softmax 探索中，我们根据来自 Boltzmann 分布的概率选择一个分支。 选择手臂的概率由下式给出：
+Softmax 探索（也称为玻尔兹曼探索）是用于找到最佳老虎机的另一种策略。 在`ε`贪婪策略中，我们等效地考虑所有非最佳分支，但是在 softmax 探索中，我们根据来自玻尔兹曼分布的概率选择一个分支。 选择手臂的概率由下式给出：
 
 ![](img/00147.jpeg)
 
@@ -312,7 +312,7 @@ The optimal arm is 1
 
 ![](img/00155.gif)
 
-由于我们有伯努利奖赏，因此我们使用 beta 分布来计算先验。 beta 分布[alpha，beta]的值在[0,1]区间内。 Alpha 代表我们获得正面奖励的次数，而 Beta 代表我们获得负面奖励的次数。
+由于我们有伯努利奖赏，因此我们使用 beta 分布来计算先验。 beta 分布`[alpha, beta]`的值在`[0, 1]`区间内。 Alpha 代表我们获得正面奖励的次数，而 Beta 代表我们获得负面奖励的次数。
 
 现在，我们将看到 TS 如何帮助我们选择最佳手臂。 TS 中涉及的步骤如下：
 
@@ -405,7 +405,7 @@ The optimal arm is 3
 
 假设您正在运营一个网站，并且同一广告有五个不同的横幅，并且您想知道哪个横幅吸引了用户。 我们将此问题陈述建模为老虎机问题。 假设这五个横幅是老虎机的五个武器，如果用户点击广告，我们将奖励 1 分；如果用户未点击广告，我们将奖励 0 分。
 
-在正常的 A / B 测试中，我们将对这五个横幅广告进行完整的探索，然后再确定哪个横幅广告是最好的。 但这将耗费我们大量的精力和时间。 取而代之的是，我们将使用良好的探索策略来确定哪个横幅广告将为我们带来最多的回报（最多的点击次数）。
+在正常的 AB 测试中，我们将对这五个横幅广告进行完整的探索，然后再确定哪个横幅广告是最好的。 但这将耗费我们大量的精力和时间。 取而代之的是，我们将使用良好的探索策略来确定哪个横幅广告将为我们带来最多的回报（最多的点击次数）。
 
 首先，让我们导入必要的库：
 
@@ -417,7 +417,7 @@ import seaborn as sns
 %matplotlib inline
 ```
 
-让我们模拟一个形状为 5 x 10,000 的数据集，其中列为`Banner_type`广告，行为`0`或`1`，即是否单击了广告（`1`或 没有被用户分别点击（`0`）：
+让我们模拟一个形状为`5 x 10,000`的数据集，其中列为`Banner_type`广告，行为`0`或`1`，即是否单击了广告（`1`或 没有被用户分别点击（`0`）：
 
 ```py
 df = pd.DataFrame()

new/handson-rl-py/07.md

@@ -155,11 +155,11 @@
 
 ![](img/00193.jpeg)
 
-其中![](img/00194.jpeg)是我们的 S 型激活函数的导数。 我们知道 Sigmoid 函数是![](img/00195.jpeg)，所以 Sigmoid 函数的导数将是![](img/00196.jpeg)。
+其中![](img/00194.jpeg)是我们的 Sigmoid 激活函数的导数。 我们知道 Sigmoid 函数是![](img/00195.jpeg)，所以 Sigmoid 函数的导数将是![](img/00196.jpeg)。
 
 ![](img/00197.jpeg)
 
-我们将所有这些替换为第一个方程式（1）。
+我们将所有这些替换为第一个方程式`(1)`。
 
 现在，我们需要针对下一个权重`w[xh]`来计算`J`的导数。 同样，我们无法直接根据`J`计算`w[xh]`的导数，因为我们在`J`中的没有任何`w[xh]`项。 因此，我们需要使用链式规则； 再次回顾我们的前向传播步骤：*
 
@@ -173,7 +173,7 @@
 
 现在，权重`w[xh]`的梯度计算将变为：
 
-![](img/00200.jpeg)-（2）
+![](img/00200.jpeg) ----（2）
 
 我们将计算以下每一项：
 
@@ -189,7 +189,7 @@
 
 一旦我们计算了两个权重的梯度，就将根据权重更新规则更新以前的权重。
 
-现在，让我们做一些编码。 看等式（1）和（2）。 我们在两个方程式中都有![](img/00206.jpeg)和![](img/00207.jpeg)，因此我们不必一遍又一遍地进行计算。 我们将其定义为`delta3`：
+现在，让我们做一些编码。 看等式`(1)`和`(2)`。 我们在两个方程式中都有![](img/00206.jpeg)和![](img/00207.jpeg)，因此我们不必一遍又一遍地进行计算。 我们将其定义为`delta3`：
 
 ```py
 delta3 = np.multiply(-(y-yHat),sigmoidPrime(z2))
@@ -439,9 +439,9 @@ RNN 是一种特殊类型的神经网络，广泛应用于顺序数据。 换句
 
 ![](img/00222.jpeg)
 
-但是，此方法存在问题。 梯度计算涉及计算关于激活函数的梯度。 当我们计算相对于 S 型/ tanh 函数的梯度时，该梯度将变得非常小。 当我们在许多时间步长上进一步传播网络并乘以梯度时，梯度将趋于变得越来越小。 这称为消失梯度问题。 那么，由于这个问题会发生什么呢？ 由于梯度会随着时间消失，因此我们无法了解有关长期依赖关系的信息，也就是说，RNN 无法将信息在内存中保留更长的时间。
+但是，此方法存在问题。 梯度计算涉及计算关于激活函数的梯度。 当我们计算相对于 Sigmoid/tanh 函数的梯度时，该梯度将变得非常小。 当我们在许多时间步长上进一步传播网络并乘以梯度时，梯度将趋于变得越来越小。 这称为消失梯度问题。 那么，由于这个问题会发生什么呢？ 由于梯度会随着时间消失，因此我们无法了解有关长期依赖关系的信息，也就是说，RNN 无法将信息在内存中保留更长的时间。
 
-逐渐消失的梯度不仅会出现在 RNN 中，还会发生在其他深层网络中，在这些深层网络中，当我们使用 S 型/ tanh 函数时会出现许多隐藏层。 还有一个称为爆炸梯度的问题，其中梯度值变得大于 1，当我们将这些梯度相乘时，它将导致很大的数字。
+逐渐消失的梯度不仅会出现在 RNN 中，还会发生在其他深层网络中，在这些深层网络中，当我们使用 Sigmoid/tanh 函数时会出现许多隐藏层。 还有一个称为爆炸梯度的问题，其中梯度值变得大于 1，当我们将这些梯度相乘时，它将导致很大的数字。
 
 一种解决方案是将 ReLU 用作激活函数。 但是，我们有一个称为 LSTM 的 RNN 变体，它可以有效解决消失的梯度问题。 我们将在接下来的部分中看到它的工作原理。
 
@@ -719,7 +719,7 @@ i wanna see you, yes, and she said yes!
 
 # 卷积神经网络
 
-CNN，也称为 ConvNet，是一种特殊的神经网络，广泛用于计算机视觉。 CNN 的应用范围包括从自动驾驶汽车中的视觉功能到 Facebook 图片中朋友的自动标记。 CNN 利用空间信息来识别图像。 但是它们如何真正起作用？ 神经网络如何识别这些图像？ 让我们逐步进行此步骤。
+CNN，也称为卷积网络（ConvNet），是一种特殊的神经网络，广泛用于计算机视觉。 CNN 的应用范围包括从自动驾驶汽车中的视觉功能到 Facebook 图片中朋友的自动标记。 CNN 利用空间信息来识别图像。 但是它们如何真正起作用？ 神经网络如何识别这些图像？ 让我们逐步进行此步骤。
 
 CNN 通常包含三个主要层：
 
@@ -729,7 +729,7 @@ CNN 通常包含三个主要层：
 
 # 卷积层
 
-当我们输入图像作为输入时，它实际上将转换为像素值矩阵。 这些像素值的范围为 0 到 255，此矩阵的尺寸为`[图像高度 * 图像宽度 * 通道数]`。 如果输入图像的尺寸为 64 x 64，则像素矩阵尺寸将为 64 x 64 x 3，其中 3 表示通道号。 灰度图像具有 1 个通道，彩色图像具有 3 个通道（RGB）。 看下面的照片。 当将此图像作为输入输入时，它将转换为像素值矩阵，我们稍后将看到。 为了更好地理解，我们将考虑灰度图像，因为灰度图像具有 1 个通道，因此我们将获得 2D 矩阵。
+当我们输入图像作为输入时，它实际上将转换为像素值矩阵。 这些像素值的范围为 0 到 255，此矩阵的尺寸为`[图像高度 * 图像宽度 * 通道数]`。 如果输入图像的尺寸为`64 x 64`，则像素矩阵尺寸将为`64 x 64 x 3`，其中 3 表示通道号。 灰度图像具有 1 个通道，彩色图像具有 3 个通道（RGB）。 看下面的照片。 当将此图像作为输入输入时，它将转换为像素值矩阵，我们稍后将看到。 为了更好地理解，我们将考虑灰度图像，因为灰度图像具有 1 个通道，因此我们将获得 2D 矩阵。
 
 输入图像如下：
 
@@ -793,7 +793,7 @@ CNN 通常包含三个主要层：
 
 在卷积层之后，我们有了池化层。 池化层用于减少特征映射的维数，并且仅保留必要的细节，因此可以减少计算量。 例如，要确定图像中是否有一只狗，我们不想了解狗在图像中的哪个位置，我们只需要狗的特征。 因此，池化层通过仅保留重要特征来减小空间尺寸。 有多种类型的池化操作。 最大池化是最常用的池化操作之一，我们仅从窗口内的要素图中获取最大值。
 
-带有 2 x 2 过滤器且步幅为 2 的最大池如下所示：
+带有`2 x 2`过滤器且步幅为 2 的最大池如下所示：
 
 ![](img/00236.gif)
 
@@ -915,7 +915,7 @@ y = 8 (Bag)
 x = tf.placeholder(tf.float32, [None, 784])
 ```
 
-我们需要将输入调整为`[p,q,r,s]`格式，其中`q`和`r`是输入图像的实际尺寸，即 28 x 28，`s`是通道号。 由于我们只有灰度图像，因此`s`的值为`1`。 `p`表示训练样本的数量，即批量大小。 由于我们不知道批次大小，因此可以将其设置为`-1`，并且在训练过程中会动态更改它：
+我们需要将输入调整为`[p,q,r,s]`格式，其中`q`和`r`是输入图像的实际尺寸，即`28 x 28`，`s`是通道号。 由于我们只有灰度图像，因此`s`的值为`1`。 `p`表示训练样本的数量，即批量大小。 由于我们不知道批次大小，因此可以将其设置为`-1`，并且在训练过程中会动态更改它：
 
 ```py
 x_shaped = tf.reshape(x, [-1, 28, 28, 1])    
@@ -947,7 +947,7 @@ def maxpool2d(x):
 
 因此，权重矩阵将初始化为`[filter_shape[0],filter_shape[1], number_of_input_channel, filter_size]`。
 
-我们将使用 5 x 5 滤镜，并将滤镜尺寸设置为`32`。 由于我们使用灰度图像，因此我们的输入通道号将为`1`。 因此，我们的权重矩阵将为`[5,5,1,32]`：
+我们将使用`5 x 5`滤镜，并将滤镜尺寸设置为`32`。 由于我们使用灰度图像，因此我们的输入通道号将为`1`。 因此，我们的权重矩阵将为`[5,5,1,32]`：
 
 ```py
 w_c1 = tf.Variable(tf.random_normal([5,5,1,32]))

new/handson-rl-py/08.md

-# 带有 Deep Q Network 的 Atari Games
+# 深度 Q 网络和 Atari 游戏
 
 **深度 Q 网络**（**DQN**）是非常流行且广泛使用的**深度强化学习**（**DRL**）算法之一。 实际上，它在发布之后，在**强化学习**（**RL**）社区周围引起了很多轰动。 该算法由 Google 的 DeepMind 的研究人员提出，在玩任何 Atari 游戏时，只要将游戏屏幕作为输入，就可以达到人类水平的结果。
 
@@ -36,9 +36,9 @@
 
 # 卷积网络
 
-DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧。 因此，我们采用原始框架并将其传递给卷积层以了解游戏状态。 但是原始帧将具有 210 x 160 像素和 128 个调色板，并且如果我们直接输入原始像素，显然将需要大量的计算和内存。 因此，我们将像素下采样为 84 x 84，并将 RGB 值转换为灰度值，然后将经过预处理的游戏屏幕作为卷积层的输入。 卷积层通过识别图像中不同对象之间的空间关系来理解游戏屏幕。 我们使用两个卷积层，然后使用具有 ReLU 作为激活函数的全连接层。 在这里，我们不使用池化层。
+DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧。 因此，我们采用原始框架并将其传递给卷积层以了解游戏状态。 但是原始帧将具有`210 x 160`像素和 128 个调色板，并且如果我们直接输入原始像素，显然将需要大量的计算和内存。 因此，我们将像素下采样为`84 x 84`，并将 RGB 值转换为灰度值，然后将经过预处理的游戏屏幕作为卷积层的输入。 卷积层通过识别图像中不同对象之间的空间关系来理解游戏屏幕。 我们使用两个卷积层，然后使用具有 ReLU 作为激活函数的全连接层。 在这里，我们不使用池化层。
 
-当执行诸如对象检测或分类之类的任务时，池层非常有用，其中我们不考虑对象在图像中的位置，而只想知道所需对象是否在图像中。 例如，如果我们要对图像中是否有狗进行分类，我们只查看图像中是否有狗，而不检查狗在哪里。 在那种情况下，使用池化层对图像进行分类，而与狗的位置无关。 但是对于我们来说，要了解游戏屏幕，位置很重要，因为它描述了游戏状态。 例如，在 Pong 游戏中，我们不仅要分类游戏屏幕上是否有球。 我们想知道球的位置，以便我们下一步行动。 这就是为什么我们在架构中不使用池化层的原因。
+当执行诸如对象检测或分类之类的任务时，池层非常有用，其中我们不考虑对象在图像中的位置，而只想知道所需对象是否在图像中。 例如，如果我们要对图像中是否有狗进行分类，我们只查看图像中是否有狗，而不检查狗在哪里。 在那种情况下，使用池化层对图像进行分类，而与狗的位置无关。 但是对于我们来说，要了解游戏屏幕，位置很重要，因为它描述了游戏状态。 例如，在乒乓游戏中，我们不仅要分类游戏屏幕上是否有球。 我们想知道球的位置，以便我们下一步行动。 这就是为什么我们在架构中不使用池化层的原因。
 
 好的，我们如何计算 Q 值？ 如果我们传递一个游戏画面和一个动作作为 DQN 的输入，它将给我们 Q 值。 但这将需要一个完整的前向通过，因为一个状态中将有许多动作。 而且，游戏中将有许多状态，每个动作都有一个前移，这在计算上将是昂贵的。 因此，我们只需将游戏屏幕单独作为输入，并通过将输出层中的单位数设置为游戏状态下的动作数，即可获得该状态下所有可能动作的 Q 值。
 
@@ -74,14 +74,14 @@ DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧
 
 # 削减奖励
 
-我们如何分配奖励？ 奖励分配因每个游戏而异。 在某些游戏中，我们可以分配奖励，例如+1 表示获胜，-1 表示损失，而 0 则不计任何收益，但是在某些其他游戏中，我们必须分配诸如+ 100 表示​​执行某项操作和+50 表示进行另一项操作等奖励 行动。 为避免出现此问题，我们将所有奖励分别裁剪为-1 和+1。
+我们如何分配奖励？ 奖励分配因每个游戏而异。 在某些游戏中，我们可以分配奖励，例如 +1 表示获胜，-1 表示损失，而 0 则不计任何收益，但是在某些其他游戏中，我们必须分配诸如 +100 表示​​执行某项操作和 +50 表示进行另一项操作等奖励 行动。 为避免出现此问题，我们将所有奖励分别裁剪为 -1 和 +1。
 
 # 了解算法
 
 现在，我们将了解 DQN 的整体工作方式。 DQN 涉及的步骤如下：
 
 1.  首先，我们预处理游戏屏幕（状态`s`）并将其馈送到 DQN，DQN 将返回该状态下所有可能动作的`Q`值。
-2.  现在，我们使用`ε`贪婪策略选择一个动作：对于概率 epsilon，我们选择一个随机动作`a`；对于概率为 1-epsilon，我们选择一个具有最大`Q`的动作 ]值，例如![](img/00258.jpeg)。
+2.  现在，我们使用`ε`贪婪策略选择一个动作：对于概率`epsilon`，我们选择一个随机动作`a`；对于概率为 1 `epsilon`，我们选择一个具有最大`Q`的动作值，例如![](img/00258.jpeg)。
 3.  在选择动作`a`之后，我们在`s`状态下执行此动作，然后移至新的`s'`状态并获得奖励。 下一个状态`s'`是下一个游戏屏幕的预处理图像。
 4.  我们将此转移存储在`<s,a,r,s'>`的回放缓冲区中。
 5.  接下来，我们从回放缓冲区中抽取一些随机的转移批次并计算损失。
@@ -392,7 +392,7 @@ with tf.Session() as sess:
 
 # 双 DQN
 
-深度 Q 学习非常酷，对吗？ 它已经普及了玩任何 Atari 游戏的学习。 但是 DQN 的问题在于，它倾向于高估`Q`值。 这是因为`Q`学习方程式中的最大值算子。 max 运算符在选择和评估动作时使用相同的值。 那是什么意思 假设我们处于`s`状态，并且我们有五个动作`a[1]`至`a[5]`。 假设`a[3]`是最好的动作。 当我们估计状态为`s`的所有这些动作的`Q`值时，估计的`Q`值会有些杂音并且与实际值有所不同。 由于这种噪声，动作`a[2]`会比最佳动作`a[3]`获得更高的值。 现在，如果我们选择最佳动作作为具有最大值的动作，则最终将选择次优动作`a[2]`而不是最佳动作`a[3]`。
+深度 Q 学习非常酷，对吗？ 它已经普及了玩任何 Atari 游戏的学习。 但是 DQN 的问题在于，它倾向于高估`Q`值。 这是因为`Q`学习方程式中的最大值算子。 最大运算符在选择和评估动作时使用相同的值。 那是什么意思 假设我们处于`s`状态，并且我们有五个动作`a[1]`至`a[5]`。 假设`a[3]`是最好的动作。 当我们估计状态为`s`的所有这些动作的`Q`值时，估计的`Q`值会有些杂音并且与实际值有所不同。 由于这种噪声，动作`a[2]`会比最佳动作`a[3]`获得更高的值。 现在，如果我们选择最佳动作作为具有最大值的动作，则最终将选择次优动作`a[2]`而不是最佳动作`a[3]`。
 
 我们可以通过具有两个单独的`Q`函数来解决此问题，每个函数都是独立学习的。 一个`Q`功能用于选择一个动作，另一个`Q`功能用于评估一个动作。 我们可以通过调整 DQN 的目标功能来实现。 调用 DQN 的目标函数：
 

new/handson-rl-py/09.md

@@ -14,7 +14,7 @@
 
 那么，当我们在 Atari 游戏中以人为水平执行 DQN 时，为什么我们需要 DRQN？ 为了回答这个问题，让我们理解**部分可观察的马尔可夫决策过程**（**POMDP**）的问题。 当我们可获得的关于环境的信息有限时，该环境称为部分可观察的 MDP。 到目前为止，在前面的章节中，我们已经看到了一个完全可观察的 MDP，在其中我们了解所有可能的动作和状态-尽管该代理可能不知道转移和奖励的可能性，但它对环境有完整的了解，例如，冰冻的湖泊 环境，我们清楚地知道了环境的所有状态和行为； 我们轻松地将该环境建模为一个完全可观察的 MDP。 但是大多数现实世界环境只能部分观察到。 我们看不到所有状态。 考虑代理学习如何在现实环境中行走； 显然，代理将不会完全了解环境，它将无法获得任何信息。 在 POMDP 中，状态仅提供部分信息，但是将有关过去状态的信息保留在内存中可能会帮助代理更好地了解环境的性质并改善策略。 因此，在 POMDP 中，我们需要保留有关先前状态的信息，以便采取最佳措施。
 
-为了回顾我们在前几章中学到的知识，请考虑以下所示的 Pong 游戏。 仅通过查看当前的游戏屏幕，我们就可以知道球的位置，但是我们还需要知道球的运动方向和球的速度，以便采取最佳行动。 但是，仅查看当前的游戏屏幕并不能告诉我们球的方向和速度：
+为了回顾我们在前几章中学到的知识，请考虑以下所示的乒乓游戏。 仅通过查看当前的游戏屏幕，我们就可以知道球的位置，但是我们还需要知道球的运动方向和球的速度，以便采取最佳行动。 但是，仅查看当前的游戏屏幕并不能告诉我们球的方向和速度：
 
 ![](img/00287.jpeg)
 

new/handson-rl-py/10.md

@@ -129,7 +129,7 @@ no_of_actions = env.action_space.shape[0]
 action_bound = [env.action_space.low, env.action_space.high]
 ```
 
-我们将在`ActorCritic`类中定义 Actor Critic 网络。 像往常一样，我们首先了解一个类中每个函数的代码，并在最后看到整个最终代码。 注释被添加到每行代码中，以更好地理解。 最后，我们将研究干净无注释的整个代码：
+我们将在`ActorCritic`类中定义演员评论家网络。 像往常一样，我们首先了解一个类中每个函数的代码，并在最后看到整个最终代码。 注释被添加到每行代码中，以更好地理解。 最后，我们将研究干净无注释的整个代码：
 
 ```py
 class ActorCritic(object):
@@ -443,7 +443,7 @@ tensorboard --logdir=logs --port=6007 --host=127.0.0.1
 
 在本章中，我们学习了 A3C 网络的工作方式。 在 A3C 中，“异步”表示多个代理通过与环境的多个副本进行交互而独立工作，“优势”表示“优势”功能，即 Q 函数和值函数之间的差异，“演员评论家”是指演员评论家网络，其中行为者 网络负责生成策略，评论家网络评估由参与者网络生成的策略。 我们已经了解了 A3C 的工作原理，并了解了如何使用该算法解决山地车问题。
 
-在下一章[，第 11 章](11.html#5RRUQ0-3c5bb317ad314d43ac43a332c0db6f00)，“策略梯度和优化”中，我们将看到无需 Q 函数即可直接优化策略的策略梯度方法。
+在下一章第 11 章，“策略梯度和优化”中，我们将看到无需 Q 函数即可直接优化策略的策略梯度方法。
 
 # 问题
 

new/handson-rl-py/11.md

@@ -226,7 +226,7 @@ class PolicyGradient:
 
 与 DQN 相似，这里我们使用经验缓冲区，通过采样少量的经验来训练 Actor 和 Critic 网络。 我们还使用单独的目标 Actor 和 Critic 网络来计算损失。
 
-例如，在 Pong 游戏中，我们将具有不同比例的不同特征，例如位置，速度等。 因此，我们以所有要素都处于相同比例的方式来缩放要素。 我们使用一种称为批归一化的方法来缩放要素。 它将所有特征归一化以具有单位均值和方差。 我们如何探索新的行动？ 在连续环境中，将有`n`个动作。 为了探索新动作，我们在 Actor 网络产生的动作中添加了一些噪声`N`。 我们使用称为 Ornstein-Uhlenbeck 随机过程的过程来生成此噪声。
+例如，在乒乓游戏中，我们将具有不同比例的不同特征，例如位置，速度等。 因此，我们以所有要素都处于相同比例的方式来缩放要素。 我们使用一种称为批归一化的方法来缩放要素。 它将所有特征归一化以具有单位均值和方差。 我们如何探索新的行动？ 在连续环境中，将有`n`个动作。 为了探索新动作，我们在 Actor 网络产生的动作中添加了一些噪声`N`。 我们使用称为 Ornstein-Uhlenbeck 随机过程的过程来生成此噪声。
 
 现在，我们将详细介绍 DDPG 算法。