2020-12-21 22:31:13

new/handson-meta-learn-py/05.md

@@ -37,15 +37,15 @@ NTM 的重要组成部分如下：
 
 ![](img/53982af6-a5b7-4b34-bf95-f2fdb6fb121e.png)
 
-让我们用 *w <sub>t</sub>* 表示归一化权重向量，其中下标 *t，*表示时间， *w <sub>t</sub> （i ）*表示权重向量中的元素，其索引为 *i，*和时间`t`：
+让我们用`w[t]`表示归一化权重向量，其中下标`t`表示时间，`w[t](i)`表示权重向量中的元素，其索引为`i`，和时间`t`：
 
 ![](img/3785fb36-a7c4-401d-a42f-9b505f26a800.png)
 
-我们的存储矩阵由`N`行和`M`列组成，如下图所示。 让我们将`t`时的存储矩阵表示为 *M <sub>t</sub>* ：
+我们的存储矩阵由`N`行和`M`列组成，如下图所示。 让我们将`t`时的存储矩阵表示`M[t]`：
 
 ![](img/3f50d7d5-cd0c-4e69-b381-d1f21dbb1683.png)
 
-现在我们有了权重向量和存储矩阵，我们执行了存储矩阵 *M <sub>t</sub>* 和权重向量 *w <sub>t [</sub>* ，以获取读取向量 *r <sub>t</sub>* ，如下图所示：
+现在我们有了权重向量和存储矩阵，我们执行了存储矩阵`M[t]`和权重向量`w[t]`，以获取读取向量`r[t]`，如下图所示：
 
 ![](img/8352e643-7590-42e7-a342-dd8556ff8ca6.png)
 
@@ -131,7 +131,7 @@ NTM 的重要组成部分如下：
 
 # 卷积移位
 
-下一步称为卷积移位。 用于移动头部位置。 即，它用于将焦点从一个位置转移到另一位置。 每个磁头发出一个称为移位权重![](img/55b42a60-c235-432c-b1a2-40da0ccfdba3.png)的参数，该参数为我们提供了一个分布，在该分布上可以执行允许的整数移位。 例如，假设我们在-1 和 1 之间进行了转换，那么![](img/838da61f-2b69-45c6-a18c-f405970a8071.png)的长度将变为 3，包括 *{-1,0,1}* 。
+下一步称为卷积移位。 用于移动头部位置。 即，它用于将焦点从一个位置转移到另一位置。 每个磁头发出一个称为移位权重![](img/55b42a60-c235-432c-b1a2-40da0ccfdba3.png)的参数，该参数为我们提供了一个分布，在该分布上可以执行允许的整数移位。 例如，假设我们在-1 和 1 之间进行了转换，那么![](img/838da61f-2b69-45c6-a18c-f405970a8071.png)的长度将变为 3，包括`{-1, 0, 1}`。
 
 那么，这些转变究竟意味着什么？ 假设权重向量中有三个元素![](img/6f1e25f0-feea-4ea0-b690-69f4dfd45171.png)-即![](img/9fdc6124-c3ae-49ba-bcdc-20e603d86f61.png)，而移位权重向量中有三个元素-![](img/1593106b-61ec-476e-979e-105bdb56dcdd.png)。
 
@@ -147,7 +147,7 @@ NTM 的重要组成部分如下：
 
 ![](img/51f8b11f-7921-424a-a41f-1fcc6c03314f.png)
 
-因此，以这种方式，我们对权重矩阵中的元素执行卷积移位。 如果我们将 0 到 *N-1* 个存储位置，则可以表示卷积移位如下：
+因此，以这种方式，我们对权重矩阵中的元素执行卷积移位。 如果我们将 0 到`N-1`个存储位置，则可以表示卷积移位如下：
 
 ![](img/1bb69aaa-0933-48bc-9f40-90bf6c2819a3.png)
 

new/handson-meta-learn-py/06.md

@@ -240,7 +240,7 @@ def __init__(self):
             for i in range(self.num_tasks):
 ```
 
-对*个*数据点进行采样，并准备我们的火车组-![](img/b2ee78f7-c579-42b4-ae9d-efa16a24c666.png)：
+对`num_samples`个数据点进行采样，并准备我们的火车组-![](img/b2ee78f7-c579-42b4-ae9d-efa16a24c666.png)：
 
 ```py
                 XTrain, YTrain = sample_points(self.num_samples)
@@ -457,7 +457,7 @@ Sampling Next Batch of Tasks
 
 ![](img/75cd4f0f-ba3e-4a2d-b1f9-6e819e8b8336.png)
 
-但是上一个方程式中发生了什么？ *R（x <sub>y</sub> ， <sub>t</sub> ）*表示对状态`x`具有作用`a`的奖励 时间`t`和`t = 1`至`H`表示我们的时间步长，其中`H`是地平线-我们的最终时间步长。
+但是上一个方程式中发生了什么？ `R(x[y, t])`表示对状态`x`具有作用`a`的奖励 时间`t`和`t = 1`至`H`表示我们的时间步长，其中`H`是地平线-我们的最终时间步长。
 
 假设我们有一个由`θ`参数化的模型`f`，也就是`f[θ]()`和任务的分布`p(T)`。 首先，我们用一些随机值初始化参数`θ`。 接下来，我们从任务分布中抽样一些任务`Ti`： `Ti ~ p(T)`。
 

new/handson-rl-py/03.md

@@ -89,9 +89,9 @@ MDP 由五个重要元素表示：
 
 # 折现系数
 
-我们已经看到，代理商的目标是使回报最大化。 对于一项临时任务，我们可以将返回定义为 *R <sub class="calibre24">t</sub> = r <sub class="calibre24">t + 1</sub> + r <sub class="calibre24">t + 2</sub> +...。 + r <sub class="calibre24">T</sub>* ，其中`T`是情节的最终状态，我们尝试最大化回报 *R <sub class="calibre24">t</sub>* 。
+我们已经看到，代理商的目标是使回报最大化。 对于一项临时任务，我们可以将返回定义为`R[t] = r[t + 1] + r[t + 2] + ... + r[T]`，其中`T`是情节的最终状态，我们尝试最大化回报`R[t]`。
 
-由于连续任务没有任何最终状态，因此我们可以将连续任务的收益定义为 *R <sub class="calibre24">t</sub> = r <sub class="calibre24">t + 1</sub> + r <sub class="calibre24">t + 2</sub> + ....* ，总和为无穷大。 但是，如果永不止息，我们如何才能最大化回报呢？
+由于连续任务没有任何最终状态，因此我们可以将连续任务的收益定义为`R[t] = r[t + 1] + r[t + 2] + ...`，总和为无穷大。 但是，如果永不止息，我们如何才能最大化回报呢？
 
 这就是为什么我们引入折扣因子的概念。 我们可以使用折扣因子![](img/00039.jpeg)重新定义收益，如下所示：
 
@@ -113,13 +113,13 @@ MDP 由五个重要元素表示：
 
 # 状态值功能
 
-状态值函数也简称为值函数。 它通过策略*π*指定代理处于特定状态的状态如何。 值函数通常由 *V（s）*表示。 它表示遵循策略的状态的值。
+状态值函数也简称为值函数。 它通过策略`π`指定代理处于特定状态的状态如何。 值函数通常由`V(s)`表示。 它表示遵循策略的状态的值。
 
 我们可以定义一个状态值函数，如下所示：
 
 ![](img/00043.jpeg)
 
-这根据策略*π*指定从状态`s`开始的预期收益。 我们可以用（2）的值函数替换 *R <sub class="calibre24">t</sub>* 的值，如下所示：
+这根据策略`π`指定从状态`s`开始的预期收益。 我们可以用（2）的值函数替换`R[t]`的值，如下所示：
 
 ![](img/00044.jpeg)
 
@@ -135,13 +135,13 @@ MDP 由五个重要元素表示：
 
 # 状态作用值功能（Q 功能）
 
-状态作用值函数也称为`Q`函数。 它指定代理在具有策略*π*的状态下执行特定操作的效果如何。`Q`函数由 *Q（s）*表示。 它表示在遵循策略*π*的状态下执行操作的值。
+状态作用值函数也称为`Q`函数。 它指定代理在具有策略`π`的状态下执行特定操作的效果如何。`Q`函数由`Q(s)`表示。 它表示在遵循策略`π`的状态下执行操作的值。
 
 我们可以定义`Q`函数，如下所示：
 
 ![](img/00045.jpeg)
 
-这根据策略*π*指定从状态`s`开始的预期回报，其动作为`a`。 我们可以从（2）的`Q`函数中替换 *R <sub class="calibre24">t</sub>* 的值，如下所示：
+这根据策略`π`指定从状态`s`开始的预期回报，其动作为`a`。 我们可以从（2）的`Q`函数中替换`R[t]`的值，如下所示：
 
 ![](img/00046.jpeg)
 
@@ -157,7 +157,7 @@ MDP 由五个重要元素表示：
 
 因此，`Q`表显示了所有可能的状态动作对的值。 因此，通过查看此表，我们可以得出结论，在状态 1 中执行动作 1 和在状态 2 中执行动作 2 是更好的选择，因为它具有很高的价值。
 
-每当我们说值函数 *V（S）*或`Q`函数 *Q（S，a），*时，它实际上表示值表，而`Q`表，如前所示。
+每当我们说值函数`V(S)`或`Q`函数`Q(S, a)`时，它实际上表示值表，而`Q`表，如前所示。
 
 # Bellman 方程和最优性
 
@@ -193,11 +193,11 @@ MDP 由五个重要元素表示：
 
 如果您对数学不感兴趣，可以跳过本节。 但是，数学将非常有趣。
 
-首先，我们将![](img/00054.jpeg)定义为在执行动作*和*时从状态![](img/00055.jpeg)转换为![](img/00056.jpeg)的转移概率：
+首先，我们将![](img/00054.jpeg)定义为在执行动作`a`时从状态![](img/00055.jpeg)转换为![](img/00056.jpeg)的转移概率：
 
 ![](img/00057.jpeg)
 
-我们将![](img/00058.jpeg)定义为在执行动作*和*时从状态![](img/00059.jpeg)移至![](img/00060.jpeg)所获得的奖励概率：
+我们将![](img/00058.jpeg)定义为在执行动作`a`时从状态![](img/00059.jpeg)移至![](img/00060.jpeg)所获得的奖励概率：
 
 ![](img/00061.jpeg)
 
@@ -213,7 +213,7 @@ MDP 由五个重要元素表示：
 
 ![](img/00065.jpeg) ---（6）
 
-如果我们处于状态`s`，并通过策略*π*执行动作*和*，则值函数中的期望值指定了期望收益。
+如果我们处于状态`s`，并通过策略`π`执行动作`a`，则值函数中的期望值指定了期望收益。
 
 因此，我们可以通过总结所有可能的动作和奖励来明确地重写我们的期望，如下所示：
 
@@ -223,7 +223,7 @@ MDP 由五个重要元素表示：
 
 ![](img/00068.jpeg)
 
-同样，在 LHS 中，我们将从等式（2）中替换 *r <sub class="calibre24">t + 1</sub>* 的值，如下所示：
+同样，在 LHS 中，我们将从等式（2）中替换`r[t + 1]`的值，如下所示：
 
 ![](img/00069.jpeg)
 
@@ -267,8 +267,8 @@ MDP 由五个重要元素表示：
 值迭代涉及的步骤如下：
 
 1.  首先，我们初始化随机值函数，即每个状态的随机值。
-2.  然后，我们为 *Q（s，a）*的所有状态动作对计算`Q`函数。
-3.  然后，我们使用 *Q（s，a）*中的最大值更新值函数。
+2.  然后，我们为`Q(s, a)`的所有状态动作对计算`Q`函数。
+3.  然后，我们使用`Q(s, a)`中的最大值更新值函数。
 4.  我们重复这些步骤，直到 value 函数的变化很小。
 
 让我们通过手动逐步执行值迭代来直观地理解它。
@@ -291,33 +291,37 @@ Q 值告诉我们每个状态下一个动作的值。 首先，让我们计算
 
 状态`A`的 Q 函数可以计算如下：
 
-*Q（s，a）=转移概率*（奖励概率+伽玛* next_state 的值）*
+*Q（s，a）=转移概率*（奖励概率+ gamma * next_state 的值）*
 
-在此，*伽马*是折扣因子； 我们将其视为`1`。
+在此，`gamma`是折扣因子； 我们将其视为`1`。
 
-*状态`A`和操作`0`*的 Q* 值：*
+状态`A`和操作`0`的 Q 值：
 
 ![](img/00080.jpeg)
 
-*Q（A，0）=（0.1 *（0 + 0））+（0.4 *（-1.0 + 0））+（0.3 *（1.0 + 0））*
+```
+Q(A, 0) = (0.1 * (0 + 0)) + (0.4 * (-1.0 + 0)) + (0.3 * (1.0 + 0))
 
-Q（A，0）= -0.1
+Q(A, 0) = -0.1
+```
 
-现在我们将计算状态`A`和操作 *1：*的`Q`值
+现在我们将计算状态`A`和操作`1`的`Q`值：
 
 ![](img/00081.jpeg)
 
-*Q（A，1）=（0.3 *（0 + 0））+（0.1 *（-2.0 + 0））+（0.5 *（1.0 + 0））*
+```
+Q(A, 1) = (0.3 * (0 + 0)) + (0.1 * (-2.0 + 0)) + (0.5 * (1.0 + 0))
 
-*Q（A，1）= 0.3*
+Q(A, 1) = 0.3
+```
 
 现在，我们将在`Q`表中对此进行更新，如下所示：
 
 ![](img/00082.gif)
 
-从 *Q（s，a）*更新值函数为最大值。
+从`Q(s, a)`更新值函数为最大值。
 
-如果您查看前面的`Q`函数，则 *Q（A，1）*的值大于 *Q（A，0）*的值，因此我们将更新该值 状态`A`的形式为 *Q（A，1）*：
+如果您查看前面的`Q`函数，则`Q(A, 1)`的值大于`Q(A, 0)`的值，因此我们将更新该值 状态`A`的形式为`Q(A, 1)`：
 
 ![](img/00083.gif)
 
@@ -371,11 +375,11 @@ Q（A，0）= -0.1
 
 让我们通过为每个状态指定随机动作来初始化随机策略函数：
 
-说 *A-> 0*
-
-*B-> 1*
-
-*C-> 0*
+```
+A -> 0
+B -> 1
+C -> 0
+```
 
 2.  查找随机初始化策略的值函数。
 
@@ -387,11 +391,11 @@ Q（A，0）= -0.1
 
 我们说新政策的结果是：
 
-*A-> 0*
-
-*B-> 1*
-
-*C-> 1*
+```
+A -> 0
+B -> 1
+C -> 1
+```
 
 我们检查旧策略，即随机初始化的策略和新策略。 如果它们相同，则我们已经达到收敛，即找到了最佳策略。 如果没有，我们将旧策略（随机策略）更新为新策略，并从步骤`2`开始重复。
 
@@ -428,9 +432,9 @@ policy_iteration():
 
 我们可以将问题建模为我们先前研究的 MDP。 MDP 包含以下内容：
 
-*   **状态**：状态集。 在这里，我们有 16 个州（网格中的每个小方框）。
+*   **状态**：状态集。 在这里，我们有 16 个状态（网格中的每个小方框）。
 *   **动作**：所有可能动作的集合（左，右，上，下；这是我们的代理商在冰冻湖面环境中可以采取的所有四种可能动作）。
-*   **转移概率**：通过执行动作*和*从一种状态（`F`）转换为另一种状态（`H`）的概率。
+*   **转移概率**：通过执行动作`a`从一种状态（`F`）转换为另一种状态（`H`）的概率。
 *   **奖励概率**：这是从一种状态（`F`）迁移到另一种状态（`H`）时获得奖励的概率。 执行*和*动作。
 
 现在我们的目标是解决 MDP。 解决 MDP 意味着寻找最佳策略。 现在，我们介​​绍三个特殊功能：
@@ -501,13 +505,15 @@ no_of_iterations = 100000
 
 我们将使用之前解决的示例来理解代码。 我们在上一个示例中计算了状态`A`和操作`1`的`Q`值：
 
-*Q（A，1）=（0.3 *（0 + 0））+（0.1 *（-1.0 + 0））+（0.5 +（1.0 + 0））*
+```
+Q(A, 1) = (0.3 * (0 + 0)) + (0.1 * (-1.0 + 0)) + (0.5 + (1.0 + 0))
 
-*Q（A，1）= 0.5*
+Q(A, 1) = 0.5
+```
 
 我们没有为每个状态创建`Q`表，而是创建了一个名为`Q_value`的列表，然后为该状态中的每个动作创建了一个名为`next_states_rewards`的列表，该列表存储了`Q_value` 下一个过渡状态。 然后，我们对`next_state_rewards`求和并将其附加到我们的`Q_value`中。
 
-请看前面的示例，其中状态为`A`，操作为`1`。 *（0.3 *（0 + 0））*是过渡状态`A`和*（0.1 *（-1.0 + 0））*的下一个状态奖励 过渡状态`B`的下一状态奖励。 *（0.5 +（1.0 + 0））*是过渡状态`C`的下一个状态奖励。 我们将所有这些加总为`next_state_reward`，并将其附加到`Q_value`中，该值为 0.5。
+请看前面的示例，其中状态为`A`，操作为`1`。 `(0.3 * (0 + 0))`是过渡状态`A`和`(0.1 * (-1.0 + 0))`的下一个状态奖励 过渡状态`B`的下一状态奖励。 `(0.5 + (1.0 + 0))`是过渡状态`C`的下一个状态奖励。 我们将所有这些加总为`next_state_reward`，并将其附加到`Q_value`中，该值为 0.5。
 
 当我们为状态的所有动作计算`next_state_rewards`并将其附加到`Q`值时，我们选取​​最大的`Q`值并将其更新为我们的状态值：
 
@@ -837,7 +843,7 @@ print (policy_iteration(env))
 
 # 概要
 
-在本章中，我们了解了什么是马尔可夫链和马尔可夫过程，以及如何使用 MDP 表示 RL 问题。 我们还研究了 Bellman 方程，并解决了 Bellman 方程，从而使用 DP 推导了最优策略。 在下一章[，第 4 章](04.html#2VBO80-3c5bb317ad314d43ac43a332c0db6f00)，*使用蒙特卡洛方法*进行游戏中，我们将研究蒙特卡洛树搜索以及如何使用它进行智能游戏的构建。
+在本章中，我们了解了什么是马尔可夫链和马尔可夫过程，以及如何使用 MDP 表示 RL 问题。 我们还研究了 Bellman 方程，并解决了 Bellman 方程，从而使用 DP 推导了最优策略。 在下一章第 4 章，“使用蒙特卡洛方法进行游戏”中，我们将研究蒙特卡洛树搜索以及如何使用它进行智能游戏的构建。
 
 # 问题
 

new/handson-rl-py/04.md

@@ -165,7 +165,7 @@ print("Approximate value of pi is {}" .format(calculate_pi(points_inside_circle,
 
 蒙特卡洛方法的基本思想非常简单。 您还记得我们在上一章第 3 章，“马尔可夫决策过程和动态规划”中如何定义最佳值函数以及如何得出最佳策略吗？
 
-值函数基本上是状态`S`与策略*π*的预期收益。 在这里，我们使用均值回报代替预期回报。
+值函数基本上是状态`S`与策略`π`的预期收益。 在这里，我们使用均值回报代替预期回报。
 
 因此，在蒙特卡洛预测中，我们通过取均值回报而不是期望回报来近似值函数。
 
@@ -497,7 +497,7 @@ plot_blackjack(value, axes[0], axes[1])
 
 估计动作值比估计状态值更直观，因为状态值根据我们选择的策略而变化。 例如，在二十一点游戏中，假设我们处于某些纸牌为 20 的状态。该状态的价值是什么？ 这完全取决于政策。 如果我们选择政策作为命中目标，那将不是一个好的状态，而且此状态的价值非常低。 但是，如果我们选择我们的政策作为立场，那肯定是一个好的国家。因此，国家的价值取决于我们选择的政策。 因此，估计操作的值而不是状态的值更为重要。
 
-我们如何估算作用值？ 还记得我们在第 3 章，“马尔可夫决策过程和动态规划”中学习的`Q`函数吗？ 表示为 *Q（s，a）*的`Q`函数用于确定特定状态下的动作有多好。 它基本上指定了状态-动作对。
+我们如何估算作用值？ 还记得我们在第 3 章，“马尔可夫决策过程和动态规划”中学习的`Q`函数吗？ 表示为`Q(s, a)`的`Q`函数用于确定特定状态下的动作有多好。 它基本上指定了状态-动作对。
 
 但是，这里出现了探索的问题。如果我们还没有处于状态状态值，我们如何知道状态状态值？ 如果我们不采取所有可能的措施探索所有州，我们可能会错过丰厚的回报。
 
@@ -513,7 +513,7 @@ MC-ES 算法非常简单，如下所示：
 *   我们只为唯一的状态-动作对计算返回值，因为同一状态-动作对多次出现在情节中，并且没有多余的信息点
 *   然后，我们对返回列表中的返回值取平均值，然后将该值分配给我们的`Q`函数
 
-*   最后，我们将为一个状态选择一个最佳策略，为该状态选择具有最大 *Q（s，a）*的操作
+*   最后，我们将为一个状态选择一个最佳策略，为该状态选择具有最大`Q(s, a)`的操作
 *   我们将永久重复整个过程，或者重复进行多次，以便涵盖所有不同的状态和动作对
 
 这是一个流程图：
@@ -569,7 +569,7 @@ def epsilon_greedy_policy(state, epsilon):
 4.  我们将情节中发生的每个状态操作对的返回存储到返回列表中。
 
 5.  然后，我们对返回列表中的返回值取平均值，然后将该值分配给`Q`函数。
-6.  现在，由ε决定由状态`s`选择动作*和*的可能性。
+6.  现在，由ε决定由状态`s`选择动作`a`的可能性。
 7.  如果概率为 1-ε，我们将选择最大`Q`值的动作。
 8.  如果概率为ε，我们将探索不同的动作。
 
@@ -588,7 +588,7 @@ 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.  我们选择行为政策。 行为策略不是贪婪的，它可以选择任何状态-行为对。
@@ -596,7 +596,7 @@ def epsilon_greedy_policy(state, epsilon):
 5.  现在，对于情节中的每个州，我们执行以下操作：
     1.  我们将计算回报`G`。 我们知道回报是折扣奖励的总和： *G =折扣因子* G +奖励*。
     2.  然后我们将 *C（s，a）*更新为 *C（s，a）= C（s，a）+ w。*
-    3.  我们更新 *Q（s，a）*：![](img/00109.jpeg)。
+    3.  我们更新`Q(s, a)`：![](img/00109.jpeg)。
     4.  我们更新`w`：![](img/00110.jpeg)的值。
 
 # 概要

new/handson-rl-py/06.md

@@ -21,7 +21,7 @@ MAB 如下所示：
 
 ![](img/00143.jpeg)
 
-由于每台老虎机都通过自己的概率分布为我们提供奖励，因此我们的目标是找出哪台老虎机将在一段时间内为我们提供最大的累积奖励。 因此，代理在每个时间步`t`上执行动作 *a <sub class="calibre24">t</sub>* ，即从投币游戏机中拉出一条手臂并获得奖励 *r <sub class="calibre24">t</sub>* <sub class="calibre24">和</sub>，我们代理商的目标是使累积奖励最大化。
+由于每台老虎机都通过自己的概率分布为我们提供奖励，因此我们的目标是找出哪台老虎机将在一段时间内为我们提供最大的累积奖励。 因此，代理在每个时间步`t`上执行动作`a[t]`，即从投币游戏机中拉出一条手臂并获得奖励`R[t]`<sub class="calibre24">和</sub>，我们代理商的目标是使累积奖励最大化。
 
 我们将手臂 *Q（a）*的值定义为通过拉动手臂获得的平均奖励：
 

new/handson-rl-py/07.md

@@ -463,7 +463,7 @@ LSTM 单元称为内存，它们负责存储信息。 但是信息必须在存
 *   输入门
 *   输出门
 
-如果查看 LSTM 单元，则顶部水平线 *C <sub class="calibre24">t</sub>* 被称为单元状态。 这是信息流向的地方。 LSTM 门将不断更新有关单元状态的信息。 现在，我们将看到这些门的功能：
+如果查看 LSTM 单元，则顶部水平线`C[t]`被称为单元状态。 这是信息流向的地方。 LSTM 门将不断更新有关单元状态的信息。 现在，我们将看到这些门的功能：
 
 *   **忘记门**：忘记门负责确定哪些信息不应处于单元状态。 看下面的陈述：
     *哈里是一位好歌手。 他住在纽约。 Zayn 还是一位出色的歌手。*

new/handson-rl-py/08.md

@@ -81,8 +81,8 @@ DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧
 现在，我们将了解 DQN 的整体工作方式。 DQN 涉及的步骤如下：
 
 1.  首先，我们预处理游戏屏幕（状态`s`）并将其馈送到 DQN，DQN 将返回该状态下所有可能动作的`Q`值。
-2.  现在，我们使用 epsilon-greedy 策略选择一个动作：对于概率 epsilon，我们选择一个随机动作*和*；对于概率为 1-epsilon，我们选择一个具有最大`Q`的动作 ]值，例如![](img/00258.jpeg)。
-3.  在选择动作*和*之后，我们在`s`状态下执行此动作，然后移至新的 *s'*状态并获得奖励。 下一个状态*的*是下一个游戏屏幕的预处理图像。
+2.  现在，我们使用 epsilon-greedy 策略选择一个动作：对于概率 epsilon，我们选择一个随机动作`a`；对于概率为 1-epsilon，我们选择一个具有最大`Q`的动作 ]值，例如![](img/00258.jpeg)。
+3.  在选择动作`a`之后，我们在`s`状态下执行此动作，然后移至新的 *s'*状态并获得奖励。 下一个状态*的*是下一个游戏屏幕的预处理图像。
 4.  我们将此过渡存储在`<s,a,r,s'>`的重播缓冲区中。
 5.  接下来，我们从重播缓冲区中抽取一些随机的过渡批次并计算损失。
 6.  我们知道![](img/00259.jpeg)就像目标`Q`与预测的`Q`之间的平方差一样。
@@ -430,9 +430,9 @@ with tf.Session() as sess:
 
 # 决斗网络架构
 
-我们知道`Q`函数指定代理在状态*或*下执行动作*和*有多好，而值函数则指定有多好 使代理处于*或*状态。 现在，我们引入一个称为优势函数的新函数，该函数可以定义为值函数和优势函数之间的差。 优势功能指定与其他动作相比，代理执行一个动作*和*有多好。
+我们知道`Q`函数指定代理在状态*或*下执行动作`a`有多好，而值函数则指定有多好 使代理处于*或*状态。 现在，我们引入一个称为优势函数的新函数，该函数可以定义为值函数和优势函数之间的差。 优势功能指定与其他动作相比，代理执行一个动作`a`有多好。
 
-因此，值函数指定状态的优劣，而优势函数指定动作的优劣。 如果我们将价值功能和优势功能结合起来会发生什么？ 这将告诉我们代理在状态*或*实际上是我们的`Q`功能下执行动作*和*有多好。 因此，我们可以像![](img/00285.jpeg)中那样将`Q`函数定义为值函数和优势函数的和。
+因此，值函数指定状态的优劣，而优势函数指定动作的优劣。 如果我们将价值功能和优势功能结合起来会发生什么？ 这将告诉我们代理在状态*或*实际上是我们的`Q`功能下执行动作`a`有多好。 因此，我们可以像![](img/00285.jpeg)中那样将`Q`函数定义为值函数和优势函数的和。
 
 现在，我们将看到决斗网络体系结构是如何工作的。 下图显示了对决 DQN 的体系结构：
 

new/handson-rl-py/09.md

@@ -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 <sub class="calibre24">t</sub>* 是网络在上一个时间步长返回的输入。 即， *h <sub class="calibre24">t</sub>* *= LSTM（h <sub class="calibre24">t-1</sub> o <sub class="calibre24">t</sub>* ）。 当我们使用 RNN 时，我们通过时间的反向传播来训练我们的网络。
+因此，我们将游戏屏幕作为卷积层的输入。 卷积层对图像进行卷积并生成特征图。 然后将生成的特征图传递到 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 时，我们通过时间的反向传播来训练我们的网络。
 
 等待。 体验重播缓冲区如何？ 在 DQN 中，为避免相关的体验，我们使用了体验重播，该体验存储了游戏的过渡，并使用了随机的一组体验来训练网络。 对于 DRQN，我们将整个情节存储在体验缓冲区中，并从随机的情节批次中随机采样`n`个步骤。 因此，通过这种方式，我们既可以适应随机化，又可以适应另一种实际的体验。
 
@@ -577,7 +577,7 @@ DARQN 的体系结构如下所示：
 注意有两种类型：
 
 *   **软关注**：我们知道，卷积层产生的特征图将作为输入提供给关注层，然后生成上下文向量。 轻描淡写地，这些上下文向量只是卷积层产生的所有输出（特征图）的加权平均值。 根据功能的相对重要性选择权重。
-*   **刻苦关注**：刻苦关注，根据某些位置选择策略*π*，我们仅关注图像在特定时间步长`t`上的特定位置。 该策略由神经网络表示，其权重是策略参数，网络的输出是位置选择概率。 但是，硬注意力不比软注意力好多少。
+*   **刻苦关注**：刻苦关注，根据某些位置选择策略`π`，我们仅关注图像在特定时间步长`t`上的特定位置。 该策略由神经网络表示，其权重是策略参数，网络的输出是位置选择概率。 但是，硬注意力不比软注意力好多少。
 
 # 概要
 

new/handson-rl-py/10.md

@@ -21,7 +21,7 @@ A3C 网络风起云涌，并接管了 DQN。 除了前面提到的优点之外
 
 在 A3C 中，第一个 A **异步**表示其工作方式。 在这里，我们有多个与环境交互的代理，而不是像 DQN 那样有单个代理尝试学习最佳策略。 由于我们有多个代理同时与环境交互，因此我们将环境的副本提供给每个代理，以便每个代理可以与自己的环境副本进行交互。 因此，所有这些多个代理都称为辅助代理，我们有一个单独的代理，称为全局网络，所有代理都向其报告。 全球网络汇集了学习内容。
 
-第二个 A 是**优势**； 在讨论 DQN 的决斗网络体系结构时，我们已经看到了优势功能。 优势函数可以定义为 Q 函数和值函数之间的差。 我们知道 Q 函数指定状态下动作的状态，而 value 函数指定状态下状态的状态。 现在，凭直觉思考； 两者之间的区别意味着什么？ 它告诉我们，与其他所有动作相比，代理在状态*或*下执行动作*和*有多好。
+第二个 A 是**优势**； 在讨论 DQN 的决斗网络体系结构时，我们已经看到了优势功能。 优势函数可以定义为 Q 函数和值函数之间的差。 我们知道 Q 函数指定状态下动作的状态，而 value 函数指定状态下状态的状态。 现在，凭直觉思考； 两者之间的区别意味着什么？ 它告诉我们，与其他所有动作相比，代理在状态*或*下执行动作`a`有多好。
 
 第三个 A 是 **Actor Critic** ； 该架构具有两种类型的网络，即参与者和评论者。 演员的角色是学习政策，评论家的角色是评估演员学习的政策有多好。
 

new/handson-rl-py/13.md

@@ -127,7 +127,7 @@ MAXQ 值函数分解是 HRL 中最常用的算法之一。 让我们看看 MAXQ
 
 子任务![](img/00442.jpeg)使用状态![](img/00443.jpeg)，操作![](img/00444.jpeg)，概率转换函数![](img/00445.jpeg)和预期奖励函数![](img/00446.jpeg)定义半 MDP，其中![](img/00447.jpeg)是子任务![](img/00448.jpeg)的投影值函数 ]处于![](img/00449.jpeg)状态。
 
-如果动作*和*是原始动作，那么我们可以将![](img/00450.jpeg)定义为在`s`状态下执行动作`a`的预期立即回报：
+如果动作`a`是原始动作，那么我们可以将![](img/00450.jpeg)定义为在`s`状态下执行动作`a`的预期立即回报：
 
 ![](img/00451.jpeg)
 

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)`函数后，在基于给定状态*或*进行游戏时，我们可以采取最佳措施![](img/d91fdd02-4626-4db2-9fc4-1a656f64dde2.png)， 作为最大化 Q 功能的策略：
 
 ![](img/88e6ee5c-d64d-4d70-a9cf-ee3eb0e6c32a.png)
 

new/intel-proj-py/09.md

@@ -22,7 +22,7 @@
 
 您现在可能想知道座席如何采取行动。 应该是随机的还是基于启发式的？ 好吧，这取决于代理与相关环境的交互程度。 在初始阶段，代理可能会采取随机行动，因为他们不了解环境。 但是，一旦代理与环境进行了足够的交互（基于奖励和惩罚），代理就会了解在给定状态下采取哪种适当的措施。 类似于人们倾向于采取有益于长期奖励的行动一样，RL 代理商也采取行动，最大限度地提高了长期奖励。
 
-数学上，代理尝试为每个状态动作对*（s∈S，a∈A）*学习 Q 值 *Q（s，a）*。 对于给定状态 *s <sup>（t）</sup>* ，RL 代理选择动作 *a，*，该动作给出最大 Q 值。 代理采取的动作 *a <sup>（t）</sup>* 可以表示如下：
+数学上，代理尝试为每个状态动作对*（s∈S，a∈A）*学习 Q 值`Q(s, a)`。 对于给定状态 *s <sup>（t）</sup>* ，RL 代理选择动作 *a，*，该动作给出最大 Q 值。 代理采取的动作 *a <sup>（t）</sup>* 可以表示如下：
 
 ![](img/cd87a708-3a74-4d2e-9d4c-4327e5649d5c.png)
 
@@ -75,7 +75,7 @@ Q 值表也通过迭代`t`进行索引，因为代理只能查看到目前为止
 
 图 9.3：深度 Q 网络的图示
 
-该图学习将每对状态*（s，a）*和动作映射到输出 Q 值输出 *Q（s，a），*，而在右侧图中，对于 每个状态*，*我们学习与每个动作*和*有关的 Q 值。 如果每个状态都有`n`个可能的动作，则网络的输出会产生`n`输出 *Q（s， <sub>1</sub> ），Q（s ， <sub>2</sub> ），。 。 。 。 。 。 Q（s， <sub>n</sub> ）*。
+该图学习将每对状态*（s，a）*和动作映射到输出 Q 值输出 *Q（s，a），*，而在右侧图中，对于 每个状态*，*我们学习与每个动作`a`有关的 Q 值。 如果每个状态都有`n`个可能的动作，则网络的输出会产生`n`输出 *Q（s， <sub>1</sub> ），Q（s ， <sub>2</sub> ），。 。 。 。 。 。 Q（s， <sub>n</sub> ）*。
 
 深度 Q 学习网络的训练方法很简单，称为体验重播。 让 RL 代理与环境交互并将经验以*（s，a，r，s <sup>'</sup>）*的元组形式存储在重播缓冲区中。 可以从此重播缓冲区采样迷你批处理以训练网络。 首先，重播缓冲区是随机存储的。