2020-12-21 22:56:23

new/handson-rl-py/04.md

@@ -28,7 +28,7 @@
 
 ![](img/00092.jpeg)
 
-我们知道一个圆的面积是*πr <sup class="calibre123">2</sup>* ，一个正方形的面积是 *a <sup class="calibre123">2</sup>* ：
+我们知道一个圆的面积是`πr^2`，一个正方形的面积是`a^2`：
 
 ![](img/00093.jpeg)
 
@@ -541,7 +541,7 @@ MC-ES 算法非常简单，如下所示：
 
 ![](img/00105.gif)
 
-假设我们将 epsilon 的值设置为 *0.3* 。 在下面的代码中，我们从均匀分布中生成一个随机值，如果该值小于 epsilon 值，即 0.3，则选择一个随机动作（以这种方式，我们搜索一个不同的动作）。 如果来自均匀分布的随机值大于 0.3，则我们选择具有最佳值的操作。 因此，通过这种方式，我们以概率 epsilon 探索了以前从未见过的动作，并从概率为 1-epsilon 的探索动作中选择了最佳动作：
+假设我们将 epsilon 的值设置为`0.3`。 在下面的代码中，我们从均匀分布中生成一个随机值，如果该值小于 epsilon 值，即 0.3，则选择一个随机动作（以这种方式，我们搜索一个不同的动作）。 如果来自均匀分布的随机值大于 0.3，则我们选择具有最佳值的操作。 因此，通过这种方式，我们以概率 epsilon 探索了以前从未见过的动作，并从概率为 1-epsilon 的探索动作中选择了最佳动作：
 
 ```py
 def epsilon_greedy_policy(state, epsilon):
@@ -588,14 +588,14 @@ def epsilon_greedy_policy(state, epsilon):
 
 让我们一步一步看一下：
 
-1.  首先，我们将`Q(s, a)`初始化为随机值，并将 *C（s，a）*初始化为`0`，权重`w`为`1`。
+1.  首先，我们将`Q(s, a)`初始化为随机值，并将`C(s, a)`初始化为`0`，权重`w`为`1`。
 2.  然后我们选择目标策略，这是一个贪婪策略。 这意味着它将从`Q`表中选取具有最大值的策略。
 
 3.  我们选择行为政策。 行为策略不是贪婪的，它可以选择任何状态-行为对。
-4.  然后，我们开始我们的情节，并根据我们的行为政策在*或*状态下执行*和*动作，并存储奖励。 我们重复此操作直到情节结束。
+4.  然后，我们开始我们的情节，并根据我们的行为政策在*或*状态下执行动作`a`，并存储奖励。 我们重复此操作直到情节结束。
 5.  现在，对于情节中的每个州，我们执行以下操作：
     1.  我们将计算回报`G`。 我们知道回报是折扣奖励的总和： *G =折扣因子* G +奖励*。
-    2.  然后我们将 *C（s，a）*更新为 *C（s，a）= C（s，a）+ w。*
+    2.  然后我们将`C(s, a)`更新为`C(s, a) + C(s, a) + w`。
     3.  我们更新`Q(s, a)`：![](img/00109.jpeg)。
     4.  我们更新`w`：![](img/00110.jpeg)的值。
 

new/handson-rl-py/05.md

 # 时间差异学习
 
-在上一章[的第四章](04.html#2VBO80-3c5bb317ad314d43ac43a332c0db6f00)，*使用蒙特卡洛方法的游戏*中，我们了解了有趣的蒙特卡洛方法，该方法用于解决**马尔可夫决策过程**（**MDP**），而不像动态编程那样预先未知环境的模型动力学。 我们研究了蒙特卡洛预测方法，该方法用于预测值函数，而控制方法用于进一步优化值函数。 但是蒙特卡洛方法存在一些陷阱。 它仅适用于情景任务。 如果情节很长，那么我们必须等待很长时间才能计算价值函数。 因此，我们将使用另一种有趣的算法，称为**时差**（**TD**）学习，这是一种无模型的学习算法：不需要知道模型动力学 先进，它也可以用于非临时性任务。
+在上一章第四章，“使用蒙特卡洛方法的游戏”中，我们了解了有趣的蒙特卡洛方法，该方法用于解决**马尔可夫决策过程**（**MDP**），而不像动态编程那样预先未知环境的模型动力学。 我们研究了蒙特卡洛预测方法，该方法用于预测值函数，而控制方法用于进一步优化值函数。 但是蒙特卡洛方法存在一些陷阱。 它仅适用于情景任务。 如果情节很长，那么我们必须等待很长时间才能计算价值函数。 因此，我们将使用另一种有趣的算法，称为**时差**（**TD**）学习，这是一种无模型的学习算法：不需要知道模型动力学 先进，它也可以用于非临时性任务。
 
 在本章中，您将学习：
 
@@ -20,7 +20,9 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo
 
 ![](img/00111.jpeg)
 
-*先前状态的值=先前状态的值+ learning_rate（奖励+ Discount_factor（当前状态的值）-先前状态的值）*
+```
+先前状态的值 = 先前状态的值 + 学习率（奖励 + 折扣因子（当前状态的值）- 先前状态的值）
+```
 
 这个方程实际上是什么意思？
 
@@ -28,47 +30,51 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo
 
 你注意到了吗？ 由于我们将实际值和预测值之差作为![](img/00114.jpeg)，因此实际上是一个错误。 我们可以称其为 TD 错误。 在多次迭代中，我们将尝试最小化此错误。
 
-让我们通过前面几章中的冰湖示例来了解 TD 预测。 接下来显示的是冰冻的湖泊环境。 首先，对于所有状态，我们将值函数初始化为`0`，就像在 *V（S）*中将其初始化为`0`一样，如以下状态值图所示 ：
+让我们通过前面几章中的冰湖示例来了解 TD 预测。 接下来显示的是冰冻的湖泊环境。 首先，对于所有状态，我们将值函数初始化为`0`，就像在`V(S)`中将其初始化为`0`一样，如以下状态值图所示 ：
 
 ![](img/00115.jpeg)
 
-假设我们处于*（s）* **（1,1）**的初始状态，我们将采取正确的操作并移至下一个状态*（s'）* **（1,2）**，并获得-0.3 的奖励*（r）*。 我们如何使用此信息来更新状态的值？
+假设我们处于`s = (1, 1)`的初始状态，我们将采取正确的操作并移至下一个状态`s' = (1, 2)`，并获得 -0.3 的奖励（`r`）。 我们如何使用此信息来更新状态的值？
 
 回忆一下 TD 更新公式：
 
 ![](img/00116.jpeg)
 
-让我们将学习率（α）视为 *0.1* ，将折现率（![](img/00117.jpeg)）视为 *0.5* ； 我们知道状态**（1,1）**的值（如 *v（s）*中的值）为 0，而下一个状态**（1,2）的值** 与 *V（s）*一样，也是`0`。 我们获得的奖励*（r）*为-0.3。 我们将其替换为 TD 规则，如下所示：
-
-*V（s）= 0 + 0.1 [-0.3 + 0.5（0）-0]*
+让我们将学习率（`α`）视为`0.1`，将折现率（`γ`）视为 0.5； 我们知道状态`(1, 1)`的值（如`V(S)`中的值）为 0，而下一个状态`(1, 2)`的值与`V(S)`一样，也是`0`。 我们获得的奖励（`r`）为 -0.3。 我们将其替换为 TD 规则，如下所示：
 
-*v（s）=-0.03*
+```
+V(s) = 0 + 0.1 * (-0.3 + 0.5 (0) - 0)
+V(s) = -0.03
+```
 
-因此，我们在值表中将状态**（1,1）**的值更新为 **-0.03** ，如下图所示：
+因此，我们在值表中将状态`(1, 1)`的值更新为`-0.03`，如下图所示：
 
 ![](img/00118.jpeg)
 
-现在我们以**（1,2）**的状态处于*（s）*的状态，我们将采取正确的操作并移至下一个状态*（s'）* **（1,3）**并获得奖励*（r）* *-0.3* 。 我们现在如何更新状态**（1、2）**的值？
+现在我们以`(1, 2)`的状态处于`s`的状态，我们将采取正确的操作并移至下一个状态`s' = (1, 3)`并获得奖励`r = -0.3`。 我们现在如何更新状态`(1, 2)`的值？
 
 像我们之前所做的那样，我们将 TD 更新方程中的值替换为：
 
-*V（s）= 0 + 0.1 [-0.3 + 0.5（0）-0]*
-
-*V（s）= -0.03*
+```
+V(s) = 0 + 0.1 * (-0.3 + 0.5(0) - 0)
+V(s) = -0.03
+```
 
 因此，我们将状态**（1,2）**的值设置为 **-0.03** ，并在值表中对其进行更新，如下所示：
 
 ![](img/00119.jpeg)
 
-现在我们处于*（s）* **（1,3）**状态； 假设我们要采取行动了。 我们再次回到该状态*（s'）* **（1,2）**，我们将获得奖励*（r）* *-0.3* 。 此处，状态**（1,3）**的值为`0`，下一个状态**（1,2）**的值为 **-0.03 值表中的**。
+现在我们处于`s = (1, 3)`状态； 假设我们要采取行动了。 我们再次回到该状态`s' = (1, 2)`，我们将获得奖励`r = -0.3`。 此处，状态`(1, 3)`的值为`0`，下一个状态`(1, 2)`的值为值表中的`-0.03`。
 
-现在我们可以更新状态**（1,3）**的值，如下所示：
+现在我们可以更新状态`(1, 3)`的值，如下所示：
 
-*V（s）= 0 +0.1 [-0.3 + 0.5（-0.03）-0）]*
+```
+V(s) = 0 + 0.1 * (-0.3 + 0.5 * (-0.03) - 0))
 
-*V（s）= 0.1 [-0.315]*
+V(s) = 0.1 * -0.315
 
-*V（s）= -0.0315*
+V(s) = -0.0315
+```
 
 因此，我们在值表中将状态**（1,3）**的值更新为 **-0.0315** ，如下所示：
 
@@ -76,8 +82,8 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo
 
 以类似的方式，我们使用 TD 更新规则更新所有状态的值。 TD 预测算法涉及的步骤如下：
 
-1.  首先，我们将 *V（S）*初始化为`0`或一些任意值
-2.  然后我们开始该情节，并在情节中的每个步骤中，在状态`S`中执行动作`A`，并获得奖励`R`，然后移至下一个 状态*（s'）*
+1.  首先，我们将`V(S)`初始化为`0`或一些任意值
+2.  然后我们开始该情节，并在情节中的每个步骤中，在状态`S`中执行动作`A`，并获得奖励`R`，然后移至下一个状态`s'`
 3.  现在，我们使用 TD 更新规则更新先前状态的值
 4.  重复步骤`3`和`4`，直到达到终端状态
 
@@ -120,7 +126,7 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo
 
 ![](img/00126.jpeg)
 
-让我们将 alpha 视为 *0.1* ，并将折现因子视为`1`：
+让我们将`alpha`视为`0.1`，并将折现因子视为`1`：
 
 ![](img/00127.jpeg)
 

new/handson-rl-py/06.md

@@ -23,7 +23,7 @@ MAB 如下所示：
 
 由于每台老虎机都通过自己的概率分布为我们提供奖励，因此我们的目标是找出哪台老虎机将在一段时间内为我们提供最大的累积奖励。 因此，代理在每个时间步`t`上执行动作`a[t]`，即从投币游戏机中拉出一条手臂并获得奖励`R[t]`<sub class="calibre24">和</sub>，我们代理商的目标是使累积奖励最大化。
 
-我们将手臂 *Q（a）*的值定义为通过拉动手臂获得的平均奖励：
+我们将手臂`Q(a)`的值定义为通过拉动手臂获得的平均奖励：
 
 ![](img/00144.jpeg)
 
@@ -213,7 +213,7 @@ The optimal arm is 3
 
 通过 epsilon-greedy 和 softmax 探索，我们以概率探索了随机动作。 随机动作对于探索各种武器很有用，但也可能导致我们尝试无法给我们带来丰厚回报的动作。 我们也不想错过实际上是好的武器，但在最初的回合中却给出了差的奖励。 因此，我们使用一种称为**上置信界上限**（**UCB**）的新算法。 它基于面对不确定性时称为乐观的原则。
 
-UCB 算法可帮助我们根据置信区间选择最佳分支。 好的，置信区间是多少？ 让我们说我们有两条手臂。 我们拉开这两个手臂，发现第一手臂给了我们 0.3 奖励，第二手臂给了我们 0.8 奖励。 但是，随着一轮拉动手臂，我们不应该得出这样的结论：第二臂将给我们最好的回报。 我们必须尝试几次拉动手臂，取每个手臂获得的奖励平均值，然后选择平均值最高的手臂。 但是，我们如何才能找到每个臂的正确平均值？ 这是置信区间进入图片的位置。 置信区间指定武器平均奖励值所在的区间。 如果手臂 1 的置信区间为 *[0.2，0.9]* ，则表示手臂 1 的平均值在此区间 0.2 至 0.9 内。 0.2 称为下置信界，而 0.9 称为 UCB。 UCB 选择具有较高 UCB 的机器进行探索。
+UCB 算法可帮助我们根据置信区间选择最佳分支。 好的，置信区间是多少？ 让我们说我们有两条手臂。 我们拉开这两个手臂，发现第一手臂给了我们 0.3 奖励，第二手臂给了我们 0.8 奖励。 但是，随着一轮拉动手臂，我们不应该得出这样的结论：第二臂将给我们最好的回报。 我们必须尝试几次拉动手臂，取每个手臂获得的奖励平均值，然后选择平均值最高的手臂。 但是，我们如何才能找到每个臂的正确平均值？ 这是置信区间进入图片的位置。 置信区间指定武器平均奖励值所在的区间。 如果手臂 1 的置信区间为`[0.2, 0.9]`，则表示手臂 1 的平均值在此区间 0.2 至 0.9 内。 0.2 称为下置信界，而 0.9 称为 UCB。 UCB 选择具有较高 UCB 的机器进行探索。
 
 假设我们有三台老虎机，并且每台老虎机都玩了十次。 下图显示了这三个老虎机的置信区间：
 
@@ -231,7 +231,7 @@ UCB 背后的想法非常简单：
 
 但是，我们如何计算 UCB？
 
-我们可以使用公式![](img/00153.jpeg)计算 UCB，其中 *N（a）*是拉动手臂的次数，`t`是回合的总数。
+我们可以使用公式![](img/00153.jpeg)计算 UCB，其中`N(a)`是拉动手臂的次数，`t`是回合的总数。
 
 因此，在 UCB 中，我们选择具有以下公式的手臂：
 
@@ -308,7 +308,7 @@ The optimal arm is 1
 
 # 汤普森采样算法
 
-**汤普森采样**（**TS**）是另一种广泛使用的算法，可克服勘探开发难题。 它是一种概率算法，基于先验分布。 TS 背后的策略非常简单：首先，我们先计算每个`k`武器的平均回报，也就是说，我们从*每个武器中提取`n`个样本 ] k* 手臂并计算`k`分布。 这些初始分布将与真实分布不同，因此我们将其称为先验分布：
+**汤普森采样**（**TS**）是另一种广泛使用的算法，可克服勘探开发难题。 它是一种概率算法，基于先验分布。 TS 背后的策略非常简单：首先，我们先计算每个`k`武器的平均回报，也就是说，我们从`K`个手臂的每个中提取`n`个样本，并计算`k`个分布。 这些初始分布将与真实分布不同，因此我们将其称为先验分布：
 
 ![](img/00155.gif)
 

new/handson-rl-py/08.md

@@ -430,9 +430,9 @@ with tf.Session() as sess:
 
 # 决斗网络架构
 
-我们知道`Q`函数指定代理在状态*或*下执行动作`a`有多好，而值函数则指定有多好 使代理处于*或*状态。 现在，我们引入一个称为优势函数的新函数，该函数可以定义为值函数和优势函数之间的差。 优势功能指定与其他动作相比，代理执行一个动作`a`有多好。
+我们知道`Q`函数指定代理在状态`s`下执行动作`a`有多好，而值函数则指定有多好 使代理处于*或*状态。 现在，我们引入一个称为优势函数的新函数，该函数可以定义为值函数和优势函数之间的差。 优势功能指定与其他动作相比，代理执行一个动作`a`有多好。
 
-因此，值函数指定状态的优劣，而优势函数指定动作的优劣。 如果我们将价值功能和优势功能结合起来会发生什么？ 这将告诉我们代理在状态*或*实际上是我们的`Q`功能下执行动作`a`有多好。 因此，我们可以像![](img/00285.jpeg)中那样将`Q`函数定义为值函数和优势函数的和。
+因此，值函数指定状态的优劣，而优势函数指定动作的优劣。 如果我们将价值功能和优势功能结合起来会发生什么？ 这将告诉我们代理在状态`s`实际上是我们的`Q`功能下执行动作`a`有多好。 因此，我们可以像![](img/00285.jpeg)中那样将`Q`函数定义为值函数和优势函数的和。
 
 现在，我们将看到决斗网络体系结构是如何工作的。 下图显示了对决 DQN 的体系结构：
 

new/handson-rl-py/09.md

@@ -20,7 +20,7 @@
 
 为了克服这个问题，我们将不仅仅考虑当前的游戏屏幕，而将使用过去的四个游戏屏幕来了解球的方向和速度。 这就是我们在 DQN 中看到的。 我们将过去的四个游戏屏幕以及当前的游戏屏幕作为输入输入到卷积层，并接收该状态下所有可能动作的 Q 值。 但是，您认为仅使用过去的四个屏幕将有助于我们了解不同的环境吗？ 在某些环境下，我们甚至可能需要过去的 100 个游戏屏幕来更好地了解当前游戏状态。 但是，堆叠过去的`n`游戏画面会减慢我们的训练过程，而且还会增加我们的体验重播缓冲区的大小。
 
-因此，只要需要，我们就可以利用 RNN 的优势来理解和保留有关先前状态的信息。 在第 7 章和*深度学习基础知识中，*我们了解了如何将**长短期记忆循环神经网络**（**LSTM RNN**）用于 通过保留，忘记和更新所需的信息来生成文本以及了解文本的上下文。 我们将通过扩展 LSTM 层来修改 DQN 体系结构，以了解先前的信息。 在 DQN 架构中，我们用 LSTM RNN 替换了第一卷积后全连接层。 这样，我们也可以解决部分可观察性的问题，因为现在我们的代理可以记住过去的状态并可以改进策略。
+因此，只要需要，我们就可以利用 RNN 的优势来理解和保留有关先前状态的信息。 在第 7 章“深度学习基础知识”中，我们了解了如何将**长短期记忆循环神经网络**（**LSTM RNN**）用于 通过保留，忘记和更新所需的信息来生成文本以及了解文本的上下文。 我们将通过扩展 LSTM 层来修改 DQN 体系结构，以了解先前的信息。 在 DQN 架构中，我们用 LSTM RNN 替换了第一卷积后全连接层。 这样，我们也可以解决部分可观察性的问题，因为现在我们的代理可以记住过去的状态并可以改进策略。
 
 # DRQN 的体系结构
 
@@ -28,7 +28,7 @@
 
 ![](img/00288.gif)
 
-因此，我们将游戏屏幕作为卷积层的输入。 卷积层对图像进行卷积并生成特征图。 然后将生成的特征图传递到 LSTM 层。 LSTM 层具有用于保存信息的内存。 LSTM 层保留有关重要的先前游戏状态的信息，并根据需要随时间步长更新其内存。 穿过完全连接的层后，它将输出`Q`值。 因此，与 DQN 不同，我们不直接估计 *Q（s <sub class="calibre24">t</sub> ， <sub class="calibre24">t</sub>* *）*。 相反，我们估算 *Q（h <sub class="calibre24">t</sub>* *， <sub class="calibre24">t</sub> ）*，其中`h[t]`是网络在上一个时间步长返回的输入。 即，`h[t]`*= LSTM（h <sub class="calibre24">t-1</sub> o <sub class="calibre24">t</sub>* ）。 当我们使用 RNN 时，我们通过时间的反向传播来训练我们的网络。
+因此，我们将游戏屏幕作为卷积层的输入。 卷积层对图像进行卷积并生成特征图。 然后将生成的特征图传递到 LSTM 层。 LSTM 层具有用于保存信息的内存。 LSTM 层保留有关重要的先前游戏状态的信息，并根据需要随时间步长更新其内存。 穿过完全连接的层后，它将输出`Q`值。 因此，与 DQN 不同，我们不直接估计`Q(s[t], a[t])`。 相反，我们估算`Q(h[t], a[t])`，其中`h[t]`是网络在上一个时间步长返回的输入。 即，`h[t] = LSTM(h[t-1], o[t])`。 当我们使用 RNN 时，我们通过时间的反向传播来训练我们的网络。
 
 等待。 体验重播缓冲区如何？ 在 DQN 中，为避免相关的体验，我们使用了体验重播，该体验存储了游戏的过渡，并使用了随机的一组体验来训练网络。 对于 DRQN，我们将整个情节存储在体验缓冲区中，并从随机的情节批次中随机采样`n`个步骤。 因此，通过这种方式，我们既可以适应随机化，又可以适应另一种实际的体验。
 
@@ -583,7 +583,7 @@ DARQN 的体系结构如下所示：
 
 在本章中，我们学习了如何使用 DRQN 记住有关先前状态的信息，以及它如何克服部分可观察的 MDP 问题。 我们已经看到了如何训练我们的特工使用 DRQN 算法玩《毁灭战士》游戏。 我们还了解了 DARQN 作为 DRQN 的改进，它在卷积层的顶部增加了一个关注层。 在此之后，我们看到了两种类型的注意力机制： 即软硬关注。
 
-在下一章[，第 10 章](10.html#5IAP60-3c5bb317ad314d43ac43a332c0db6f00)，*异步优势参与者评论者网络，*中，我们将学习另一种有趣的深度强化学习算法，称为异步优势参与者批评者网络。
+在下一章第 10 章，“异步优势参与者评论者网络”中，我们将学习另一种有趣的深度强化学习算法，称为异步优势参与者批评者网络。
 
 # 问题
 

new/handson-rl-py/10.md

@@ -21,7 +21,7 @@ A3C 网络风起云涌，并接管了 DQN。 除了前面提到的优点之外
 
 在 A3C 中，第一个 A **异步**表示其工作方式。 在这里，我们有多个与环境交互的代理，而不是像 DQN 那样有单个代理尝试学习最佳策略。 由于我们有多个代理同时与环境交互，因此我们将环境的副本提供给每个代理，以便每个代理可以与自己的环境副本进行交互。 因此，所有这些多个代理都称为辅助代理，我们有一个单独的代理，称为全局网络，所有代理都向其报告。 全球网络汇集了学习内容。
 
-第二个 A 是**优势**； 在讨论 DQN 的决斗网络体系结构时，我们已经看到了优势功能。 优势函数可以定义为 Q 函数和值函数之间的差。 我们知道 Q 函数指定状态下动作的状态，而 value 函数指定状态下状态的状态。 现在，凭直觉思考； 两者之间的区别意味着什么？ 它告诉我们，与其他所有动作相比，代理在状态*或*下执行动作`a`有多好。
+第二个 A 是**优势**； 在讨论 DQN 的决斗网络体系结构时，我们已经看到了优势功能。 优势函数可以定义为 Q 函数和值函数之间的差。 我们知道 Q 函数指定状态下动作的状态，而 value 函数指定状态下状态的状态。 现在，凭直觉思考； 两者之间的区别意味着什么？ 它告诉我们，与其他所有动作相比，代理在状态`s`下执行动作`a`有多好。
 
 第三个 A 是 **Actor Critic** ； 该架构具有两种类型的网络，即参与者和评论者。 演员的角色是学习政策，评论家的角色是评估演员学习的政策有多好。
 
@@ -55,7 +55,7 @@ A3C 网络风起云涌，并接管了 DQN。 除了前面提到的优点之外
 
 ![](img/00297.jpeg)
 
-好的，新术语 *H（π）*是什么？ 它是熵项。 它用于确保充分探索政策。 熵告诉我们行动概率的扩散。 当熵值高时，每个动作的概率都将相同，因此代理将不确定要执行哪个动作，而当熵值降低时，一个动作将比其他动作具有更高的概率，并且代理可以 拿起这个可能性很高的动作。 因此，将熵添加到损失函数中会鼓励代理进一步探索并避免陷入局部最优状态。
+好的，新项目`H(π)`是什么？ 它是熵项。 它用于确保充分探索政策。 熵告诉我们行动概率的扩散。 当熵值高时，每个动作的概率都将相同，因此代理将不确定要执行哪个动作，而当熵值降低时，一个动作将比其他动作具有更高的概率，并且代理可以 拿起这个可能性很高的动作。 因此，将熵添加到损失函数中会鼓励代理进一步探索并避免陷入局部最优状态。
 
 # 驾驶 A3C 上山
 

new/handson-rl-py/11.md

@@ -15,7 +15,7 @@
 
 # 政策梯度
 
-策略梯度是**强化学习**（**RL**）的惊人算法之一，在该算法中，我们直接优化由某些参数![](img/00304.jpeg)设置的策略。 到目前为止，我们已经使用 Q 函数来找到最佳策略。 现在，我们将了解如何找到没有 Q 函数的最优策略。 首先，让我们将策略功能定义为![](img/00305.jpeg)，即在状态为*的情况下*采取*和*动作的概率。 我们通过参数![](img/00306.jpeg)将策略参数化为![](img/00307.jpeg)，这使我们能够确定状态下的最佳操作。
+策略梯度是**强化学习**（**RL**）的惊人算法之一，在该算法中，我们直接优化由某些参数![](img/00304.jpeg)设置的策略。 到目前为止，我们已经使用 Q 函数来找到最佳策略。 现在，我们将了解如何找到没有 Q 函数的最优策略。 首先，让我们将策略功能定义为![](img/00305.jpeg)，即在状态为`s`的情况下采取`a`动作的概率。 我们通过参数![](img/00306.jpeg)将策略参数化为![](img/00307.jpeg)，这使我们能够确定状态下的最佳操作。
 
 策略梯度方法具有多个优点，它可以处理连续动作空间，在该连续动作空间中，我们具有无限数量的动作和状态。 假设我们正在制造自动驾驶汽车。 驾驶汽车时应避免撞到其他车辆。 当汽车撞到车辆时，我们得到负奖励，而当汽车没有撞到其他车辆时，我们得到正奖励。 我们以仅获得积极奖励的方式更新模型参数，以使我们的汽车不会撞到任何其他车辆。 这是策略梯度的基本思想：我们以最大化报酬的方式更新模型参数。 让我们详细看一下。
 
@@ -218,7 +218,7 @@ class PolicyGradient:
 
 # 深度确定性政策梯度
 
-在第 8 章，*具有深度 Q 网络的 Atari 游戏*，中，我们研究了 DQN 的工作原理，并应用了 DQN 玩 Atari 游戏。 但是，在那些离散的环境中，我们只有一组有限的动作。 想象一个连续的环境空间，例如训练机器人走路； 在那些环境中，应用 Q 学习是不可行的，因为要找到一个贪婪的策略将需要在每一步进行很多优化。 即使我们使连续的环境离散，我们也可能会失去重要的功能并最终获得大量的动作空间。 当我们拥有巨大的行动空间时，很难实现融合。
+在第 8 章，“深度 Q 网络和 Atari 游戏”中，我们研究了 DQN 的工作原理，并应用了 DQN 玩 Atari 游戏。 但是，在那些离散的环境中，我们只有一组有限的动作。 想象一个连续的环境空间，例如训练机器人走路； 在那些环境中，应用 Q 学习是不可行的，因为要找到一个贪婪的策略将需要在每一步进行很多优化。 即使我们使连续的环境离散，我们也可能会失去重要的功能并最终获得大量的动作空间。 当我们拥有巨大的行动空间时，很难实现融合。
 
 因此，我们使用称为 Actor Critic 的新架构，该架构具有两个网络-Actor 和 Critic。 Actor Critic 体系结构结合了策略梯度和状态操作值功能。 **Actor** 网络的作用是通过调整参数![](img/00310.jpeg)来确定**状态**中的最佳动作，而 **Critic** 的作用是评估 **Actor** 产生的动作。 **评论家**通过计算时间差异误差来评估演员的行动。 也就是说，我们在 **Actor** 网络上执行策略渐变以选择操作， **Critic** 网络评估由 **Actor** 产生的操作 ]网络使用 TD 错误。 下图显示了 Actor Critic 体系结构：
 
@@ -237,7 +237,7 @@ class PolicyGradient:
 
 我们使用策略梯度更新 Actor 网络权重，并使用根据 TD 误差计算得出的梯度更新 Critic 网络权重。
 
-首先，我们通过将探索噪声`N`添加到 Actor 网络产生的动作（例如![](img/00320.jpeg)）来选择动作。 我们在`s`状态下执行此操作，获得`r`奖励，然后移至新状态 *s'*。 我们将此过渡信息存储在体验重播缓冲区中。
+首先，我们通过将探索噪声`N`添加到 Actor 网络产生的动作（例如![](img/00320.jpeg)）来选择动作。 我们在`s`状态下执行此操作，获得`r`奖励，然后移至新状态`s'`。 我们将此过渡信息存储在体验重播缓冲区中。
 
 经过一些迭代后，我们从重播缓冲区采样过渡并训练网络，然后计算目标`Q`值![](img/00321.jpeg)。 我们将 TD 误差计算为：
 
@@ -594,7 +594,7 @@ Kakade 和 Langford 从（1）得出以下方程式：
 
 ![](img/00366.jpeg)
 
-在前面的等式中，我们可以理解，最大化 *M <sub class="calibre24">i</sub>* 可以保证我们期望收益的最大化。 因此，现在我们的目标是最大化 *M <sub class="calibre24">i</sub>* ，从而最大化我们的预期回报。 由于我们使用参数化策略，因此在上一个公式中将![](img/00367.jpeg)替换为![](img/00368.jpeg)，然后使用![](img/00369.jpeg)表示我们要改进的策略，如下所示：
+在前面的等式中，我们可以理解，最大化`M[i]`可以保证我们期望收益的最大化。 因此，现在我们的目标是最大化`M[i]`，从而最大化我们的预期回报。 由于我们使用参数化策略，因此在上一个公式中将![](img/00367.jpeg)替换为![](img/00368.jpeg)，然后使用![](img/00369.jpeg)表示我们要改进的策略，如下所示：
 
 ![](img/00370.jpeg)
 
@@ -634,7 +634,7 @@ Kakade 和 Langford 从（1）得出以下方程式：
 
 ![](img/00384.jpeg)
 
-*L <sup class="calibre123">CPI</sup>* 表示保守策略迭代。 但是最大化`L`会导致无限制地进行大量策略更新。 因此，我们通过添加惩罚项来重新定义我们的目标函数，该惩罚项会惩罚较大的政策更新。 现在目标函数变为：
+`L_CPI`表示保守策略迭代。 但是最大化`L`会导致无限制地进行大量策略更新。 因此，我们通过添加惩罚项来重新定义我们的目标函数，该惩罚项会惩罚较大的政策更新。 现在目标函数变为：
 
 ![](img/00385.jpeg)
 
@@ -658,7 +658,7 @@ Kakade 和 Langford 从（1）得出以下方程式：
 
 ![](img/00402.jpeg)
 
-*c <sub class="calibre24">1</sub>* 和 *c <sub class="calibre24">2</sub>* 是系数，![](img/00403.jpeg)是实际值和目标值函数之间的平方误差损失，即 是![](img/00404.jpeg)和`S`是熵加。
+`c[1]`和`c[2]`是系数，![](img/00403.jpeg)是实际值和目标值函数之间的平方误差损失，即 是![](img/00404.jpeg)和`S`是熵加。
 
 # 概要
 
@@ -666,7 +666,7 @@ Kakade 和 Langford 从（1）得出以下方程式：
 
 然后，我们研究了诸如 TRPO 之类的策略优化算法，该算法通过对新旧策略之间的 KL 差异实施不大于![](img/00405.jpeg)的限制来确保单调策略的改进。
 
-我们还研究了近端策略优化，该优化通过惩罚大型策略更新将约束变为惩罚。 在下一章[，第 12 章](12.html#65D4E0-3c5bb317ad314d43ac43a332c0db6f00)， *Capstone 项目–使用 DQN* 进行赛车，我们将了解如何构建能够赢得赛车游戏的代理。
+我们还研究了近端策略优化，该优化通过惩罚大型策略更新将约束变为惩罚。 在下一章第 12 章， “Capstone 项目 – 使用 DQN 进行赛车”，我们将了解如何构建能够赢得赛车游戏的代理。
 
 # 问题
 

new/handson-rl-py/12.md

@@ -162,7 +162,7 @@ class EnvWrapper:
 *   **4b 层**：512 个单元的全连接层+ RELU
 *   **第 5a 层**：1 个 FC + RELU（状态值）
 *   **第 5b 层**：动作 FC + RELU（优势值）
-*   **第 6 层**：总计 *V（s）+ A（s，a）*
+*   **第 6 层**：总计`V(s) + A(s, a)`
 
 ```py
 class QNetworkDueling(QNetwork):
@@ -736,7 +736,7 @@ env.monitor.close()
 
 # 概要
 
-在本章中，我们学习了如何详细实现对决 DQN。 我们从用于游戏画面预处理的基本环境包装器功能开始，然后定义了`QNetworkDueling`类。 在这里，我们实现了决斗 Q 网络，该网络将 DQN 的最终完全连接层分为值流和优势流，然后将这两个流组合以计算`q`值。 之后，我们看到了如何创建重播缓冲区，该缓冲区用于存储经验并为网络训练提供经验的小批量样本，最后，我们使用 OpenAI 的 Gym 初始化了赛车环境并训练了我们的代理。 在下一章[，第 13 章](13.html#6DVPG0-3c5bb317ad314d43ac43a332c0db6f00)，*最新进展和后续步骤*中，我们将看到 RL 的一些最新进展。
+在本章中，我们学习了如何详细实现对决 DQN。 我们从用于游戏画面预处理的基本环境包装器功能开始，然后定义了`QNetworkDueling`类。 在这里，我们实现了决斗 Q 网络，该网络将 DQN 的最终完全连接层分为值流和优势流，然后将这两个流组合以计算`q`值。 之后，我们看到了如何创建重播缓冲区，该缓冲区用于存储经验并为网络训练提供经验的小批量样本，最后，我们使用 OpenAI 的 Gym 初始化了赛车环境并训练了我们的代理。 在下一章第 13 章，“最新进展和后续步骤”中，我们将看到 RL 的一些最新进展。
 
 # 问题
 

new/intel-proj-py/01.md

@@ -460,7 +460,7 @@ Figure 1.14: GAN architecture
 
 该算法通过根据![](img/bdb0479f-f8a3-491a-a423-17d150e6d6fe.png)的值对旧期望值和新长期奖励值进行加权平均，来不断更新期望长期累积奖励。
 
-通过迭代算法构建了`Q(s, a)`函数后，在基于给定状态*或*进行游戏时，我们可以采取最佳措施![](img/d91fdd02-4626-4db2-9fc4-1a656f64dde2.png)， 作为最大化 Q 功能的策略：
+通过迭代算法构建了`Q(s, a)`函数后，在基于给定状态`s`进行游戏时，我们可以采取最佳措施![](img/d91fdd02-4626-4db2-9fc4-1a656f64dde2.png)， 作为最大化 Q 功能的策略：
 
 ![](img/88e6ee5c-d64d-4d70-a9cf-ee3eb0e6c32a.png)