2020-12-22 22:11:04

afc3f7fa · wizardforcel · 0970d2b1 · afc3f7fa · afc3f7fa · afc3f7fa
19 changed file
--- a/new/handson-meta-learn-py/03.md
+++ b/new/handson-meta-learn-py/03.md
@@ -384,7 +384,7 @@ for epoch in range(num_epochs):

 因此，在高斯原型网络中，编码器的输出将是嵌入以及协方差矩阵。 除了使用完整的协方差矩阵之外，我们还包括来自协方差矩阵的半径或对角线分量以及嵌入：

-*   **半径分量：**如果我们使用协方差矩阵的半径分量，则我们的协方差矩阵的维数将为 1，因为半径只是一个整数。
+*   **半径分量**：如果我们使用协方差矩阵的半径分量，则我们的协方差矩阵的维数将为 1，因为半径只是一个整数。
 *   **对角分量**：如果我们使用协方差矩阵的对角分量，则我们的协方差矩阵的维数将与嵌入矩阵的维数相同。

 此外，我们使用协方差矩阵的逆矩阵来代替直接使用协方差矩阵。 我们可以使用以下任何一种方法将原始协方差矩阵转换为逆协方差矩阵。 令`S_ori`为协方差矩阵，`S`为逆协方差矩阵：
@@ -539,7 +539,7 @@ elif inverse_transform_type == "other":

 但是，这种方法的问题在于，由于我们使用的是软 k 均值，因此所有未标记的示例将属于任何类原型。 让我们说，我们的支持集中有三个类别，`{Lion, Eleph, Dog}`； 如果我们的未标记示例具有代表猫的数据点，则将猫放置在支持集中的任何类别中是没有意义的。 因此，我们没有将数据点添加到现有的类中，而是为未标记的示例分配了一个新类，称为`Distractor`类。

-但是即使采用这种方法，我们也会遇到另一个问题，因为干扰项类别本身将具有很大的差异。 例如，考虑我们的未标记集合`R`包含完全不相关的数据点，例如 *{猫，直升机，公共汽车和其他}* ； 在这种情况下，建议不要将所有未标记的示例都放在一个称为“干扰项”类的类中，因为它们已经不纯且彼此无关。
+但是即使采用这种方法，我们也会遇到另一个问题，因为干扰项类别本身将具有很大的差异。 例如，考虑我们的未标记集合`R`包含完全不相关的数据点，例如`{cats, helicopter, bus, others}`； 在这种情况下，建议不要将所有未标记的示例都放在一个称为“干扰项”类的类中，因为它们已经不纯且彼此无关。

 因此，我们将分心器类重塑为示例，这些示例不在所有类原型的某个阈值距离之内。 我们如何计算该阈值？ 首先，我们计算所有类原型的未标记集合`R`中未标记示例之间的标准化距离。 接下来，我们通过将归一化距离的各种统计数据（例如最小，最大，偏度和峰度）输入神经网络来计算每个类原型的阈值。 基于此阈值，我们向类原型添加或忽略未标记的示例。


--- a/new/handson-meta-learn-py/05.md
+++ b/new/handson-meta-learn-py/05.md
@@ -2,7 +2,7 @@

 到目前为止，在前面的章节中，我们已经学习了几种基于距离的度量学习算法。 我们从连体网络开始，了解了连体网络如何学会区分两个输入，然后我们研究了原型网络以及原型网络的变体，例如高斯原型网络和半原型网络。 展望未来，我们探索了有趣的匹配网络和关系网络。

-在本章中，我们将学习用于一次性学习的**记忆增强神经网络**（**MANN**）。 在进入 MANN 之前，我们将了解他们的前身**神经图灵机**（**NTM**）。 我们将学习 NTM 如何使用外部存储器来存储和检索信息，并且还将看到如何使用 NTM 执行复制任务。
+在本章中，我们将学习用于一次性学习的**内存增强神经网络**（**MANN**）。 在进入 MANN 之前，我们将了解他们的前身**神经图灵机**（**NTM**）。 我们将学习 NTM 如何使用外部存储器来存储和检索信息，并且还将看到如何使用 NTM 执行复制任务。

 在本章中，我们将学习以下内容：

@@ -283,7 +283,7 @@ for i, head_parameter in enumerate(head_parameter_list):
    p_list.append({'k': k, 'beta': beta, 'g': g, 's': s, 'gamma': gamma})
 ```

-**读取操作：**
+**读取操作**：

 选择读取头，如下所示：

@@ -302,7 +302,7 @@ for i in range(self.read_head_num):
    read_vector_list.append(read_vector)
 ```

-**写入操作：**
+**写入操作**：

 与读取操作不同，写入操作涉及擦除和添加两个步骤。

@@ -355,11 +355,11 @@ state = {
 self.step += 1
 ```

-**寻址机制：**
+**寻址机制**：

 众所周知，我们使用两种寻址方式：基于内容的寻址和基于位置的寻址。

-**基于内容的寻址：**
+**基于内容的寻址**：

 计算关键向量和存储矩阵之间的余弦相似度：

@@ -381,7 +381,7 @@ K_amplified = tf.exp(tf.expand_dims(beta, axis=1) * K)
 w_c = K_amplified / tf.reduce_sum(K_amplified, axis=1, keepdims=True) # eq (5)
 ```

-**基于位置的寻址：**
+**基于位置的寻址**：

 基于位置的寻址涉及其他三个步骤：

@@ -389,7 +389,7 @@ w_c = K_amplified / tf.reduce_sum(K_amplified, axis=1, keepdims=True) # eq (5)
 2.  卷积移位
 3.  锐化

-**插值：**
+**插值**：

 这用于决定我们应该使用在上一个时间步获得的权重`prev_w`还是使用通过基于内容的寻址获得的权重`w_c`。 但是我们如何决定呢？ 我们使用一个新的标量参数`g`，该参数用于确定应使用的权重：

@@ -398,7 +398,7 @@ g = tf.expand_dims(g, axis=1)
 w_g = g * w_c + (1 - g) * prev_w 
 ```

-**卷积移位：**
+**卷积移位**：

 插值后，我们执行卷积移位，以便控制器可以专注于其他行：

@@ -418,7 +418,7 @@ w_ = tf.reduce_sum(tf.expand_dims(w_g, axis=1) * s_matrix, axis=2) # eq (8)

 ```

-**锐化：**
+**锐化**：

 最后，我们执行锐化操作以防止偏移的权重向量模糊：


--- a/new/handson-meta-learn-py/06.md
+++ b/new/handson-meta-learn-py/06.md
 # MAML 及其变体

-在上一章中，我们了解了**神经图灵机**（**NTM**）以及它如何存储和从内存中检索信息。 我们还了解了称为记忆增强神经网络的 NTM 变体，该变体广泛用于单次学习中。 在本章中，我们将学习一种有趣的，最流行的元学习算法，称为**模型不可知元学习**（**MAML**）。 我们将了解什么是不可知论元学习模型，以及如何在监督和强化学习设置中使用它。 我们还将学习如何从头开始构建 MAML，然后我们将学习**对抗性元学习**（**ADML**）。 我们将看到如何使用 ADML 查找健壮的模型参数。 接下来，我们将学习如何为分类任务实现 ADML。 最后，我们将学习用于元学习的**上下文适应**（**CAML**）。
+在上一章中，我们了解了**神经图灵机**（**NTM**）以及它如何存储和从内存中检索信息。 我们还了解了称为记忆增强神经网络的 NTM 变体，该变体广泛用于单次学习中。 在本章中，我们将学习一种有趣的，最流行的元学习算法，称为**模型不可知元学习**（**MAML**）。 我们将了解什么是不可知论元学习模型，以及如何在监督和强化学习设置中使用它。 我们还将学习如何从头开始构建 MAML，然后我们将学习**对抗性元学习**（**ADML**）。 我们将看到如何使用 ADML 查找健壮的模型参数。 接下来，我们将学习如何为分类任务实现 ADML。 最后，我们将学习用于元学习的**上下文适应元学习**（**CAML**）。

 在本章中，您将了解以下内容：

@@ -51,7 +51,7 @@ MAML 的基本思想是找到一个更好的初始参数，以便具有良好的
 *   `α`是超参数
 *   ![](img/ca737a0e-ee85-48f8-a6f6-22bf740544cc.png)是任务`Ti`的梯度

-因此，在前面的渐变更新之后，我们将为采样的所有五个任务提供最佳参数：
+因此，在前面的梯度更新之后，我们将为采样的所有五个任务提供最佳参数：

 ![](img/74cd014c-db87-4c48-a462-2b94e7b93a5c.png)

@@ -92,11 +92,11 @@ MAML 非常擅长寻找最佳初始参数，对吗？ 现在，我们将看到
 1.  假设我们有一个由参数θ参数化的模型`f`，并且在任务`p(T)`上有分布。 首先，我们随机初始化模型参数θ。
 2.  我们从任务分配中抽取一些任务`Ti`，即`Ti ~ p(T)`。 假设我们采样了三个任务，然后`T = {T1, T2, T3}`。

-3.  **内环**：对于任务（`T`）中的每个任务（`Ti`），我们对`k`数据进行采样 点并准备我们的训练和测试数据集：
+3.  **内循环**：对于任务（`T`）中的每个任务（`Ti`），我们对`k`数据进行采样 点并准备我们的训练和测试数据集：

 ![](img/037ef61e-e595-4eb7-8fd1-00f6fce23823.png) ![](img/259b87df-9fd2-430a-9a11-1718a717f16f.png)

-等待！ 什么是训练集和测试集？ 我们使用内循环中的训练集来找到最佳参数![](img/2c1b7399-fe99-4705-86e9-4c00965e3a71.png)，并使用外循环中的测试集来寻找最佳参数θ。 **测试集并不意味着我们正在检查模型的性能。 它基本上充当外循环中的火车。 我们也可以将测试集称为元训练集。**
+等待！ 什么是训练集和测试集？ 我们使用内循环中的训练集来找到最佳参数![](img/2c1b7399-fe99-4705-86e9-4c00965e3a71.png)，并使用外循环中的测试集来寻找最佳参数`θ`。 **测试集并不意味着我们正在检查模型的性能。 它基本上充当外循环中的火车。 我们也可以将测试集称为元训练集。**

 现在，我们在![](img/984d186b-b6d4-46c5-9a55-87f19defde08.png)上应用任何监督学习算法，使用梯度下降法计算损失并最小化损失，并获得最佳参数![](img/564e60d8-1814-4165-9753-e98e5e9d7a41.png)，因此![](img/14ab5c68-d1fc-4e0b-83e9-22ac42196cde.png)。 因此，对于每个任务，我们对`k`个数据点进行采样，并最小化训练集![](img/984d186b-b6d4-46c5-9a55-87f19defde08.png)上的损失，并获得最佳参数![](img/065680be-ffc9-48b6-a31a-ea1398e39aa4.png)。 当我们采样三个任务时，我们将拥有三个最佳参数![](img/5966dcc0-2ffb-4884-9117-3e09f3119dad.png)。

@@ -272,7 +272,7 @@ def __init__(self):
                self.theta_.append(self.theta - self.alpha*gradient)
 ```

-我们初始化元渐变：
+我们初始化元梯度：

 ```py
            meta_gradient = np.zeros(self.theta.shape)
@@ -294,13 +294,13 @@ def __init__(self):
                YPred = self.sigmoid(a)
 ```

-我们计算元渐变：
+我们计算元梯度：

 ```py
                meta_gradient += np.matmul(XTest.T, (YPred - YTest)) / self.num_samples
 ```

-我们使用元渐变更新随机初始化的模型参数θ：
+我们使用元梯度更新随机初始化的模型参数θ：

 ![](img/246959bb-2867-4fda-bb30-01b1ecba3bc2.png)

@@ -449,7 +449,7 @@ Sampling Next Batch of Tasks

 # MAML 强化学习

-如何在**强化学习**（**RL**）设置中应用 MAML？ 在 RL 中，我们的目标是找到正确的策略功能，该功能将告诉我们在每种状态下要执行哪些操作。 但是我们如何在 RL 中应用元学习呢？ 假设我们训练了代理商以解决两臂老虎机问题。 但是，我们不能使用相同的代理来解决四臂老虎机问题。 我们必须再次从头开始训练特工，以解决这个新的四臂老虎机问题。 当另一名`n`臂老虎机进来时，情况也是如此。我们一直在从头训练代理以解决新问题，即使它与代理已经学会解决的问题密切相关。 因此，代替执行此操作，我们可以应用元学习并在一组相关任务上对代理进行培训，以便代理可以利用其先前的知识在最短的时间内学习新的相关任务，而无需从头开始进行培训。
+如何在**强化学习**（**RL**）设置中应用 MAML？ 在 RL 中，我们的目标是找到正确的策略函数，该功能将告诉我们在每种状态下要执行哪些操作。 但是我们如何在 RL 中应用元学习呢？ 假设我们训练了代理商以解决两臂老虎机问题。 但是，我们不能使用相同的代理来解决四臂老虎机问题。 我们必须再次从头开始训练特工，以解决这个新的四臂老虎机问题。 当另一名`n`臂老虎机进来时，情况也是如此。我们一直在从头训练代理以解决新问题，即使它与代理已经学会解决的问题密切相关。 因此，代替执行此操作，我们可以应用元学习并在一组相关任务上对代理进行培训，以便代理可以利用其先前的知识在最短的时间内学习新的相关任务，而无需从头开始进行培训。

 在 RL 中，我们可以将轨迹称为包含一系列观察和动作的元组。 因此，我们在这些轨迹上训练模型以学习最佳策略。 但是，同样，我们应该使用哪种算法来训练我们的模型？ 对于 MAML，我们可以使用可以通过梯度下降训练的任何 RL 算法。 我们使用策略梯度来训练我们的模型。 策略梯度通过直接将带有某些参数θ的策略π参数化为π<sub>θ</sub>来找到最佳策略。 因此，使用 MAML，我们尝试找到可在各个任务之间推广的最佳参数θ。

@@ -471,7 +471,7 @@ Sampling Next Batch of Tasks

 # 对抗式元学习

-我们已经看到了如何使用 MAML 查找可跨任务通用的最佳参数θ。 现在，我们将看到一个称为 ADML 的 MAML 变体，该变体同时使用干净样本和对抗样本来查找更好且更健壮的初始模型参数θ。 在继续之前，让我们了解什么是对抗性样本。 通过对抗攻击获得对抗样本。 假设我们有一张图片； 对抗性攻击包括以无法被我们的眼睛察觉的方式稍微修改此图像，并将此修改后的图像称为对抗图像。 当我们将该对抗图像提供给模型时，它无法正确分类。 有几种不同的对抗攻击可用于获取对抗样本。 我们将看到一种常用的方法，称为**快速渐变符号方法**（**FGSM**）。
+我们已经看到了如何使用 MAML 查找可跨任务通用的最佳参数θ。 现在，我们将看到一个称为 ADML 的 MAML 变体，该变体同时使用干净样本和对抗样本来查找更好且更健壮的初始模型参数θ。 在继续之前，让我们了解什么是对抗性样本。 通过对抗攻击获得对抗样本。 假设我们有一张图片； 对抗性攻击包括以无法被我们的眼睛察觉的方式稍微修改此图像，并将此修改后的图像称为对抗图像。 当我们将该对抗图像提供给模型时，它无法正确分类。 有几种不同的对抗攻击可用于获取对抗样本。 我们将看到一种常用的方法，称为**快速梯度符号方法**（**FGSM**）。

 # 固定 GSM

@@ -1033,7 +1033,7 @@ Sampling Next Batch of Tasks
 1.  假设我们有一个由参数θ参数化的模型`f`，并且在任务`p(T)`上有分布。 首先，我们随机初始化模型参数θ。 我们还初始化了上下文参数`∅[0] = 0`。
 2.  现在，我们从任务分配中抽样一些任务`Ti`，即`Ti ~ p(T)`。

-3.  **内环**：对于任务（`T`）中的每个任务（`Ti`），我们对`k`数据进行采样 点并准备我们的训练和测试数据集：
+3.  **内循环**：对于任务（`T`）中的每个任务（`Ti`），我们对`k`数据进行采样 点并准备我们的训练和测试数据集：

 ![](img/4e2552d7-1491-4538-abef-5499fce82cf0.png)


--- a/new/handson-meta-learn-py/07.md
+++ b/new/handson-meta-learn-py/07.md
@@ -25,7 +25,7 @@
 *   学习率![](img/40c2a80c-fccb-4967-92da-cfb4414bafb0.png)
 *   更新方向

-我们通常将参数![](img/05042986-9743-46c4-8ca1-959c4a60bae7.png)设置为某个随机值，并在训练过程中尝试找到最佳值，然后将学习率![](img/ba73a6a4-1909-4e48-b193-83df22947bb3.png)的值设置为一个小数值，或者随时间推移以及随后的更新方向将其衰减 渐变。 我们是否可以通过元学习来学习梯度下降的所有这些关键要素，以便可以从几个数据点快速学习？ 在上一章中，我们已经看到 MAML 如何找到可在各个任务之间推广的最佳初始参数![](img/6ede3380-b579-4038-b812-1adb08174574.png)。 有了最佳的初始参数，我们就可以减少渐变步骤，并快速学习新任务。
+我们通常将参数![](img/05042986-9743-46c4-8ca1-959c4a60bae7.png)设置为某个随机值，并在训练过程中尝试找到最佳值，然后将学习率![](img/ba73a6a4-1909-4e48-b193-83df22947bb3.png)的值设置为一个小数值，或者随时间推移以及随后的更新方向将其衰减 梯度。 我们是否可以通过元学习来学习梯度下降的所有这些关键要素，以便可以从几个数据点快速学习？ 在上一章中，我们已经看到 MAML 如何找到可在各个任务之间推广的最佳初始参数![](img/6ede3380-b579-4038-b812-1adb08174574.png)。 有了最佳的初始参数，我们就可以减少梯度步骤，并快速学习新任务。

 因此，现在我们是否可以学习最佳的学习率和更新方向，从而可以跨任务进行概括，从而实现更快的收敛和培训？ 让我们看看如何通过将其与 MAML 进行比较在 Meta-SGD 中学习。 如果您还记得，请在 MAML 内循环中，通过最小化梯度下降带来的损失，找到每个任务![](img/51e430e3-f3ad-41bf-9337-421b7aed2d90.png)的最佳参数![](img/dfe499c9-9ce1-4919-a6ef-49e6219f0a39.png)：

@@ -45,7 +45,7 @@

 现在，在外循环中，我们执行元优化-也就是说，我们计算相对于最佳参数![](img/c4c19dae-7f53-476e-b898-63f12bf58e8b.png)的损耗梯度，并更新我们随机初始化的模型参数![](img/99137e58-3e34-4154-98fc-82accae4a3b3.png)。 在 Meta-SGD 中，我们还更新了随机初始化的![](img/ec484259-3736-4c6f-a6f7-20fb53fe5075.png)，而不是单独更新![](img/ee550292-f8a9-4069-9207-0474131d4115.png)，如下所示：

-**![](img/6f85d711-9900-47ad-a8b7-312381b5d153.png)**
+![](img/6f85d711-9900-47ad-a8b7-312381b5d153.png)

 ![](img/0c7acdb6-ec47-439a-bf52-852b0d82256a.png)

@@ -68,7 +68,7 @@

 因此，对于每个任务，我们对`k`个数据点进行采样，并最大程度地减少训练集![](img/a8afb953-fc65-4a5c-b264-9eb11dd52860.png)上的损失，并获得最佳参数![](img/e3d076ba-9621-4303-a086-8ce8dfbebbde.png)。 当我们采样三个任务时，我们将拥有三个最佳参数![](img/c4bfe2b5-6305-4a31-910d-9622680d4991.png)。

-4.  **外循环：**现在，我们在测试集（元训练集）中执行元优化-也就是说，在这里，我们尝试使测试集![](img/676fd37d-bccd-442f-83ec-94bec90c816a.png)中的损失最小化。 通过计算相对于上一步中计算出的最佳参数![](img/e8c3e3a7-ff30-430b-985c-fc2c9ba93d86.png)的梯度，我们将损失降至最低，并使用测试集更新随机初始化的参数![](img/3f34c96e-f941-44e3-9c16-d799676bf738.png)。 我们不仅更新![](img/3f34c96e-f941-44e3-9c16-d799676bf738.png)，还更新我们的随机初始化参数![](img/98a33218-adb9-4ac6-8f52-388c828f6230.png)，它可以表示为：
+4.  **外循环**：现在，我们在测试集（元训练集）中执行元优化-也就是说，在这里，我们尝试使测试集![](img/676fd37d-bccd-442f-83ec-94bec90c816a.png)中的损失最小化。 通过计算相对于上一步中计算出的最佳参数![](img/e8c3e3a7-ff30-430b-985c-fc2c9ba93d86.png)的梯度，我们将损失降至最低，并使用测试集更新随机初始化的参数![](img/3f34c96e-f941-44e3-9c16-d799676bf738.png)。 我们不仅更新![](img/3f34c96e-f941-44e3-9c16-d799676bf738.png)，还更新我们的随机初始化参数![](img/98a33218-adb9-4ac6-8f52-388c828f6230.png)，它可以表示为：

 ![](img/a47cf1ed-4e4c-4f4b-be13-640639749882.png)

@@ -216,13 +216,13 @@ class MetaSGD(object):
                gradient = np.matmul(XTrain.T, (YHat - YTrain)) / self.num_samples
 ```

-之后，我们更新渐变并为每个任务找到最佳参数![](img/b27c91a5-1554-4f38-b1eb-9e2031070cd6.png)：
+之后，我们更新梯度并为每个任务找到最佳参数![](img/b27c91a5-1554-4f38-b1eb-9e2031070cd6.png)：

 ```py
                self.theta_.append(self.theta - (np.multiply(self.alpha,gradient)))
 ```

-我们初始化元渐变：
+我们初始化元梯度：

 ```py
            meta_gradient = np.zeros(self.theta.shape)
@@ -244,7 +244,7 @@ class MetaSGD(object):
                YPred = self.sigmoid(a)
 ```

-我们计算元渐变：
+我们计算元梯度：

 ```py
                meta_gradient += np.matmul(XTest.T, (YPred - YTest)) / self.num_samples
@@ -426,7 +426,7 @@ Sampling Next Batch of Tasks

 爬行动物算法已被 OpenAI 提出作为对 MAML 的改进。 它很容易实现。 我们知道，在 MAML 中，我们可以计算二阶导数，即梯度的梯度。 但是从计算上来说，这不是一个有效的任务。 因此，OpenAI 提出了对 MAML 的改进，称为 Reptile。 爬行动物的算法非常简单。 对一些`n`个任务进行采样，然后运行**随机梯度下降**（**SGD**），以减少每个采样任务的迭代次数，然后沿某个方向更新模型参数 这是所有任务的共同点。 由于我们对每个任务执行的 SGD 迭代次数较少，因此间接暗示我们正在计算损失的二阶导数。 与 MAML 不同，它在计算上很有效，因为我们不直接计算二阶导数也不展开计算图，因此易于实现。

-假设我们从任务分布中采样了两个任务![](img/c5ea074d-c6d3-4b6e-aa5b-0f7c2f52e9c6.png)和![](img/ca55535c-9882-4e53-9c2c-784ecb577915.png)，并随机初始化了模型参数![](img/f10d9828-d108-4808-bd3c-e68186827601.png)。 首先，我们接受任务![](img/0760630d-8894-43e4-bc70-89dd8c449426.png)并对某些`n`次迭代执行 SGD，并获得最佳参数![](img/65859715-81b5-44c1-ab58-59f1e43f0e89.png)。 然后我们执行下一个任务![](img/c8516922-7cdd-40e2-b27f-b9f4de9c4878.png)，对*次*迭代执行 SGD，并获得最佳参数![](img/90700324-178a-4cbd-b9e9-f900eb70d5b8.png)。 因此，我们有两个最佳参数集：![](img/454789fc-30c8-40d0-93db-eafdedb42ee3.png)。 现在，我们需要沿更靠近这两个最佳参数的方向移动参数![](img/8cd84028-bd5a-49ba-a7b1-25e560c54242.png)，如下图所示：
+假设我们从任务分布中采样了两个任务![](img/c5ea074d-c6d3-4b6e-aa5b-0f7c2f52e9c6.png)和![](img/ca55535c-9882-4e53-9c2c-784ecb577915.png)，并随机初始化了模型参数![](img/f10d9828-d108-4808-bd3c-e68186827601.png)。 首先，我们接受任务![](img/0760630d-8894-43e4-bc70-89dd8c449426.png)并对某些`n`次迭代执行 SGD，并获得最佳参数![](img/65859715-81b5-44c1-ab58-59f1e43f0e89.png)。 然后我们执行下一个任务![](img/c8516922-7cdd-40e2-b27f-b9f4de9c4878.png)，迭代执行 SGD `n`次，并获得最佳参数![](img/90700324-178a-4cbd-b9e9-f900eb70d5b8.png)。 因此，我们有两个最佳参数集：![](img/454789fc-30c8-40d0-93db-eafdedb42ee3.png)。 现在，我们需要沿更靠近这两个最佳参数的方向移动参数![](img/8cd84028-bd5a-49ba-a7b1-25e560c54242.png)，如下图所示：

 ![](img/9ffe5aca-b37c-41cc-90d1-3fb1b6bf018c.png)


--- a/new/handson-meta-learn-py/08.md
+++ b/new/handson-meta-learn-py/08.md
@@ -4,12 +4,12 @@

 在本章中，我们将学习以下内容：

-*   渐变协议
+*   梯度协议
 *   重量计算
 *   梯度一致性算法
 *   使用 MAML 构建梯度一致性算法

-# 渐变协议作为优化
+# 梯度协议作为优化

 梯度一致性算法是一种有趣且最近引入的算法，可作为元学习算法的增强功能。 在 MAML 和 Reptile 中，我们尝试找到一个更好的模型参数，该参数可在多个相关任务中推广，以便我们可以使用更少的数据点快速学习。 如果我们回顾前面几章中学到的知识，就会发现我们随机初始化了模型参数，然后从任务分配![](img/f31ea39c-34ba-4674-8cdc-c84a89c8bd4d.png)中抽取了一批随机任务![](img/6a76c328-6ece-4221-b362-dfb12c664952.png)进行了采样。 对于每个采样任务![](img/6a76c328-6ece-4221-b362-dfb12c664952.png)，我们通过计算梯度将损失降到最低，并获得更新的参数![](img/dd9ec7a2-16b0-4c48-a13e-9ce398fdff63.png)，这形成了我们的内部循环：

@@ -31,7 +31,7 @@

 好的，我们如何计算这些权重？ 这些权重与任务梯度的内积和采样批次任务中所有任务的梯度平均值的乘积成正比。 但这意味着什么？

-它暗示**，如果任务的梯度与采样的一批任务中所有任务的平均梯度在同一方向上，则我们可以增加其权重，以便为更新模型参数做出更大的贡献。 同样，如果任务的梯度方向与采样的任务批次中所有任务的平均梯度方向大不相同，则我们可以降低其权重，以便在更新模型参数**时贡献较小 。 我们将在下一节中看到如何精确计算这些权重。
+它暗示，如果任务的梯度与采样的一批任务中所有任务的平均梯度在同一方向上，则我们可以增加其权重，以便为更新模型参数做出更大的贡献。 同样，如果任务的梯度方向与采样的任务批次中所有任务的平均梯度方向大不相同，则我们可以降低其权重，以便在更新模型参数时贡献较小 。 我们将在下一节中看到如何精确计算这些权重。

 我们不仅可以将梯度一致性算法应用于 MAML，还可以应用于 Reptile 算法。 因此，我们的爬行动物更新方程如下：

@@ -76,11 +76,11 @@ for i in range(num_tasks):

 # 算法

-现在，让我们看一下渐变协议的工作原理：
+现在，让我们看一下梯度协议的工作原理：

 1.  假设我们有一个由参数![](img/8d358d29-40fc-4658-99ec-8dce07ffed4e.png)参数化的模型![](img/bfb72f9a-40a2-4714-af50-7413e94d75c5.png)和任务![](img/cee73716-a0c5-4331-8c95-8008acc3de5d.png)上的分布。 首先，我们随机初始化模型参数![](img/903a7361-1e91-4fe0-bb13-768777903a48.png)。
 2.  我们从任务分配中![](img/30fb6037-d542-4092-9f74-8a1f4e026b43.png)采样了一些任务![](img/ecdf7adc-d6ac-4ae0-ae47-b1117c642370.png)。 假设我们采样了两个任务，然后是![](img/2b20fb20-d4ea-4a02-be86-be16c4afa37b.png)。
-3.  **内循环：**对于任务（![](img/9004a396-a086-42e6-8cca-5a2212f0fbef.png)）中的每个任务（![](img/ec769f15-277c-41ad-98f3-673c370b9c8a.png)），我们对`k`个数据点进行采样，并准备训练和测试数据集：
+3.  **内循环**：对于任务（![](img/9004a396-a086-42e6-8cca-5a2212f0fbef.png)）中的每个任务（![](img/ec769f15-277c-41ad-98f3-673c370b9c8a.png)），我们对`k`个数据点进行采样，并准备训练和测试数据集：

 ![](img/b66a819c-dc38-44e0-a336-69e7b76ed4f0.png)

@@ -92,7 +92,7 @@ for i in range(num_tasks):

 因此，对于每个任务，我们对`k`个数据点进行采样，并最大程度地减少训练集![](img/cf4419e2-a8d6-4dac-8d7d-2ad60a97e533.png)上的损失，并获得最佳参数![](img/a0c23bd8-6c63-4d2f-82f1-955b158a6bd1.png)。 当我们采样两个任务时，我们将有两个最佳参数![](img/226a362b-771e-4092-82c0-46e2afd1b203.png)，并且我们将为这两个任务中的每一个都有一个梯度更新向量![](img/11b42fa8-3a92-4824-ac83-286a7a62a445.png)。

-4.  **外循环：**现在，在执行元优化之前，我们将按以下方式计算权重：
+4.  **外循环**：现在，在执行元优化之前，我们将按以下方式计算权重：

 ![](img/a735063f-a419-46f8-bd00-d06a0e7df3d0.png)

@@ -144,9 +144,9 @@ YHat = sigmoid(a)

 因此，我们将梯度协议与 MAML 结合使用，以找到可在各个任务之间通用的最佳参数值`theta`。 这样一来，对于一项新任务，我们可以通过采取较少的梯度步骤，在较短的时间内从几个数据点中学习。

-# MAML 中的渐变协议
+# MAML 中的梯度协议

-现在，我们将定义一个名为`GradientAgreement_MAML`的类，在其中将实现渐变协议 MAML 算法。 在`__init__`方法中，我们将初始化所有必需的变量。 然后，我们将定义 S 型激活函数。 接下来，我们将定义`train`函数。
+现在，我们将定义一个名为`GradientAgreement_MAML`的类，在其中将实现梯度协议 MAML 算法。 在`__init__`方法中，我们将初始化所有必需的变量。 然后，我们将定义 S 型激活函数。 接下来，我们将定义`train`函数。

 让我们一步一步看一下，然后看一下整体代码：

@@ -263,7 +263,7 @@ class GradientAgreement_MAML(object):

 ```

-我们初始化加权元渐变：
+我们初始化加权元梯度：

 ```py
            weighted_gradient = np.zeros(self.theta.shape)
@@ -286,7 +286,7 @@ class GradientAgreement_MAML(object):
                YPred = self.sigmoid(a)
 ```

-我们计算元渐变：
+我们计算元梯度：

 ```py
                meta_gradient = np.matmul(XTest.T, (YPred - YTest)) / self.num_samples

--- a/new/handson-meta-learn-py/09.md
+++ b/new/handson-meta-learn-py/09.md
@@ -46,7 +46,7 @@

 1.  假设我们有一个由参数![](img/c1e0144f-78d5-48cb-8e02-0adea07d991e.png)参数化的模型![](img/08ecbe90-9f6f-43f3-93a6-fdcec639d3fe.png)，并且有一个任务![](img/a825dccd-bd1e-4db2-b9da-a5319bfd992c.png)分布。 首先，我们随机初始化模型参数![](img/a65ea6f1-8004-4f5d-9a15-8f1e261747ca.png)。
 2.  从任务分配（即![](img/40a964d2-4371-47ca-8d09-d5153bbd1460.png)）中抽样一批任务。 假设我们然后采样了三个任务：![](img/f84bc6ff-fc89-4e29-9c66-75170c39673e.png)。
-3.  **内环**：对于任务![](img/a4dd0e5f-d85f-478b-9faf-830f942b9204.png)中的每个任务![](img/dc64c417-5f65-4d0c-99a2-c77ce2c03695.png)，我们对`k`个数据点进行采样，并准备训练和测试数据集：
+3.  **内循环**：对于任务![](img/a4dd0e5f-d85f-478b-9faf-830f942b9204.png)中的每个任务![](img/dc64c417-5f65-4d0c-99a2-c77ce2c03695.png)，我们对`k`个数据点进行采样，并准备训练和测试数据集：

 ![](img/80b962fa-2b54-4df4-bc58-0183d150ca2f.png)

@@ -108,7 +108,7 @@ Theil 指数是另一种常用的不平等度量。 它以荷兰计量经济学

 1.  假设我们有一个由参数![](img/53d3dc76-12a8-491b-ab66-d6b3ebde9efd.png)参数化的模型![](img/01f9bd08-13b2-4ea7-958a-09214bf4b7c2.png)，并且在任务![](img/3440c36e-b520-42e4-8cb3-7f2eb4f4bb32.png)上进行了分配。 首先，我们随机初始化模型参数![](img/e4892101-3bd1-4b09-9a51-d223240a925f.png)。
 2.  我们从任务分配（即![](img/181155d0-1308-4107-8643-3b9e9c08be85.png)）中抽样一批任务。 说，我们已经采样了三个任务，然后是![](img/77e9b020-7613-418c-8b05-88c279662e17.png)。
-3.  **内环**：对于任务![](img/254d5fa6-57c7-467d-bd1c-bb332d597f45.png)中的每个任务![](img/78734e39-e45f-4627-86d6-c522e000c1ae.png)，我们对`k`个数据点进行采样，并准备训练和测试数据集：
+3.  **内循环**：对于任务![](img/254d5fa6-57c7-467d-bd1c-bb332d597f45.png)中的每个任务![](img/78734e39-e45f-4627-86d6-c522e000c1ae.png)，我们对`k`个数据点进行采样，并准备训练和测试数据集：

 ![](img/d0798dcf-d7e3-421a-b9f1-9cbb126ce62d.png)

@@ -152,7 +152,7 @@ MIL 中涉及的步骤如下：

 1.  假设我们有一个由参数![](img/85eb5935-3a73-46b5-8640-2cfd910dc860.png)参数化的模型![](img/ed115e20-4a1d-4167-bab0-8eb27a449684.png)，并且有一个任务![](img/04636868-15b2-451d-9fbb-028f28964066.png)分布。 首先，我们随机初始化模型参数![](img/b66aaca9-0610-4d99-9051-e5cae694f41f.png)。
 2.  从任务分配（即![](img/e2fa1e6d-dbee-46ac-af21-4d1881c86394.png)）中抽样一些任务![](img/ae40a0d2-2055-47a7-a692-1646b9fcb70b.png)。
-3.  **内环**：对于采样任务中的每个任务，我们都采样了一个演示数据-即![](img/8eac4a91-cf13-4f86-96b0-a71e7c450fa5.png)。 现在，我们通过执行梯度下降来计算损耗并将损耗降至最低，从而获得了最佳参数![](img/0be605e3-6244-4a9f-9417-3c140ba08c6b.png)-![](img/d0b3cebd-6140-481a-bb50-b2eff476cd95.png)。 然后，我们还为元训练采样了另一个演示数据：![](img/a5023b00-9574-48fc-ab63-1b47736c2954.png)。
+3.  **内循环**：对于采样任务中的每个任务，我们都采样了一个演示数据-即![](img/8eac4a91-cf13-4f86-96b0-a71e7c450fa5.png)。 现在，我们通过执行梯度下降来计算损耗并将损耗降至最低，从而获得了最佳参数![](img/0be605e3-6244-4a9f-9417-3c140ba08c6b.png)-![](img/d0b3cebd-6140-481a-bb50-b2eff476cd95.png)。 然后，我们还为元训练采样了另一个演示数据：![](img/a5023b00-9574-48fc-ab63-1b47736c2954.png)。
 4.  **外循环**：现在，我们通过元优化使用![](img/52f9c1bd-016c-4d11-a1f1-bc87b2d7db2e.png)更新我们的初始参数，如下所示：

 ![](img/23c259ec-0245-4c0b-846f-d9d902a53025.png)
@@ -161,7 +161,7 @@ MIL 中涉及的步骤如下：

 # 仙人掌

-我们已经了解了 MAML 如何帮助我们找到最佳的初始模型参数，以便可以将其推广到许多其他相关任务。 我们还了解了 MAML 如何在监督学习和强化学习设置中使用。 但是，我们如何在没有数据点标签的无监督学习环境中应用 MAML？ 因此，我们引入了一种称为 **CACTUS** 的新算法，该算法是**聚类的缩写，可自动生成无监督 M** **odel 不可知论元学习** **的任务。**
+我们已经了解了 MAML 如何帮助我们找到最佳的初始模型参数，以便可以将其推广到许多其他相关任务。 我们还了解了 MAML 如何在监督学习和强化学习设置中使用。 但是，我们如何在没有数据点标签的无监督学习环境中应用 MAML？ 因此，我们引入了一种称为 **CACTUS** 的新算法，该算法是`Clustering to Automatically Generate Tasks for Unsupervised Model Agnostic Meta Learning`的缩写。

 假设我们有一个数据集![](img/48be7952-a3e9-415e-956f-04dc9ab3457b.png)，其中包含未标记的示例：![](img/f87c1526-0dbc-43df-98ee-4087f4e1aa41.png)。 现在，我们可以使用该数据集做什么？ 我们如何在该数据集上应用 MAML？ 首先，使用 MAML 进行培训需要什么？ 我们需要按任务分配，并通过对一批任务进行采样并找到最佳模型参数来训练模型。 任务应包含功能及其标签。 但是，如何从未标记的数据集中生成任务？

@@ -264,7 +264,7 @@ MIL 中涉及的步骤如下：
 4.  我们将这两种损耗合并在一起，并尝试使用 SGD 来使损耗最小化，并获取更新的模型参数：![](img/ea15185a-9d9c-4728-9ceb-eda6dfd75b43.png)。
 5.  对`n`次迭代重复步骤 2 到 4。

-再次恭喜您学习了所有重要且流行的元学习算法。 元学习是 AI 的一个有趣且最有前途的领域，它将使我们更接近**人工智能**（**AGI**）。 现在，您已经阅读完本书，可以开始探索元学习的各种进步，并开始尝试各种项目。 学习和元学习！
+再次恭喜您学习了所有重要且流行的元学习算法。 元学习是 AI 的一个有趣且最有前途的领域，它将使我们更接近**广义人工智能**（**AGI**）。 现在，您已经阅读完本书，可以开始探索元学习的各种进步，并开始尝试各种项目。 学习和元学习！

 # 概要


--- a/new/handson-meta-learn-py/10.md
+++ b/new/handson-meta-learn-py/10.md
@@ -7,7 +7,7 @@
 3.  为了使我们的模型从一些数据点中学习，我们将以相同的方式对其进行训练。 因此，当我们有一个数据集`D`时，我们从数据集中存在的每个类中采样一些数据点，并将其称为支持集。
 4.  我们从与支持集不同的每个类中采样不同的数据点，并将其称为查询集。
 5.  在基于度量的元学习设置中，我们将学习适当的度量空间。 假设我们要找出两个图像之间的相似性。 在基于度量的设置中，我们使用一个简单的神经网络，该网络从两个图像中提取特征并通过计算这两个图像的特征之间的距离来查找相似性。
-6.  我们以**情景式**训练模型； 也就是说，在每个情节中，我们从数据集`D`中采样一些数据点，并准备我们的支持集并在支持集上学习。 因此，在一系列事件中，我们的模型将学习如何从较小的数据集中学习。
+6.  我们以**剧情方式**训练模型； 也就是说，在每个剧情中，我们从数据集`D`中采样一些数据点，并准备我们的支持集并在支持集上学习。 因此，在一系列事件中，我们的模型将学习如何从较小的数据集中学习。

 # 第 2 章：使用连体网络的面部和音频识别

@@ -17,7 +17,7 @@

    ![](img/eb7b45ed-a6b9-4a3d-aff4-1cea02fba160.png)

-    在前面的公式中，`Y`的值是真实的标签，当两个输入值相似时为 1，如果两个输入值不相似则为 0，而`E`为 我们的能量函数，可以是任何距离度量。 术语**保证金**用于保持约束； 也就是说，当两个输入值不相同且它们之间的距离大于边距时，则不会造成损失。
+    在前面的公式中，`Y`的值是真实的标签，当两个输入值相似时为 1，如果两个输入值不相似则为 0，而`E`为 我们的能量函数，可以是任何距离度量。 术语**边距**用于保持约束； 也就是说，当两个输入值不相同且它们之间的距离大于边距时，则不会造成损失。

 3.  能量函数告诉我们两个输入的相似程度。 它基本上是任何相似性度量，例如欧几里得距离和余弦相似性。

@@ -76,7 +76,7 @@
 2.  学习率在适应项中隐式实现。 因此，在 Meta-SGD 中，我们不会以较小的标量值初始化学习率。 相反，我们使用与![](img/f4d705b6-6a27-43af-9987-650463402393.png)相同形状的随机值初始化它们，然后与![](img/48af46b5-42f6-4af5-b115-3182de1bb664.png)一起学习它们。

 3.  学习率的更新公式可以表示为![](img/b41f82a1-d32d-4c12-ac8d-a07e86ef0f59.png)。
-4.  对*个*任务进行采样，并在每个采样任务上以较少的迭代次数运行 SGD，然后按照所有任务共有的方向更新模型参数。
+4.  对`n`个任务进行采样，并在每个采样任务上以较少的迭代次数运行 SGD，然后按照所有任务共有的方向更新模型参数。
 5.  爬行动物更新方程可表示为![](img/6bdc020a-39a6-4c37-906f-23dde9efaecd.png)。

 # 第 8 章：梯度协议作为优化目标

--- a/new/handson-rl-py/01.md
+++ b/new/handson-rl-py/01.md
@@ -31,7 +31,7 @@

 ![](img/00007.gif)

-RL 代理可以**探索可能提供良好奖励的**不同动作，也可以**利用**（使用）导致良好奖励的先前动作。 如果 RL 代理探索不同的行动，则该代理很可能会收到较差的报酬，因为所有行动都不会成为最佳行动。 如果 RL 代理仅利用已知的最佳动作，那么也有可能会错过最佳动作，这可能会提供更好的回报。 勘探与开发之间总是要权衡取舍。 我们不能同时进行勘探和开发。 在接下来的章节中，我们将详细讨论勘探与开发难题。
+RL 代理可以**探索**可能提供良好奖励的不同动作，也可以**利用**（使用）导致良好奖励的先前动作。 如果 RL 代理探索不同的行动，则该代理很可能会收到较差的报酬，因为所有行动都不会成为最佳行动。 如果 RL 代理仅利用已知的最佳动作，那么也有可能会错过最佳动作，这可能会提供更好的回报。 勘探与开发之间总是要权衡取舍。 我们不能同时进行勘探和开发。 在接下来的章节中，我们将详细讨论勘探与开发难题。

 # RL 算法

@@ -180,7 +180,7 @@ RL 被广泛用于金融投资组合管理，这是将资金不断重新分配

 # 自然语言处理与计算机视觉

-凭借深度学习和 RL 的统一能力，**深度强化学习**（**DRL**）在**自然语言处理**（**NLP）领域中得到了极大的发展。**）和**计算机视觉**（**CV**）。 DRL 已用于文本摘要，信息提取，机器翻译和图像识别，比当前系统具有更高的准确性。
+凭借深度学习和 RL 的统一能力，**深度强化学习**（**DRL**）在**自然语言处理**（**NLP**）和**计算机视觉**（**CV**）领域中得到了极大的发展。。 DRL 已用于文本摘要，信息提取，机器翻译和图像识别，比当前系统具有更高的准确性。

 # 概要


--- a/new/handson-rl-py/02.md
+++ b/new/handson-rl-py/02.md
@@ -441,7 +441,7 @@ while True:

 显然，特工（汽车）无法在整个游戏中前进； 它需要转弯，避免障碍物，并且还会撞到其他车辆。 但是它必须确定是否应该转弯，如果需要转弯，则应朝哪个方向转弯。

-首先，我们将计算到目前为止获得的奖励的平均值； 如果是`0`，则很明显我们在前进时被卡在某处，我们需要转弯。 然后，我们需要转向哪个方向？ 您是否还记得我们在第 1 章，“强化学习简介”中研究的**策略功能**。
+首先，我们将计算到目前为止获得的奖励的平均值； 如果是`0`，则很明显我们在前进时被卡在某处，我们需要转弯。 然后，我们需要转向哪个方向？ 您是否还记得我们在第 1 章，“强化学习简介”中研究的**策略函数**。

 关于同一概念，我们这里有两个策略：一个是左转，另一个是右转。 我们将在这里采取随机政策，并计算出奖励并加以改善。


--- a/new/handson-rl-py/03.md
+++ b/new/handson-rl-py/03.md
 # 马尔可夫决策过程与动态规划

-**马尔可夫决策过程**（**MDP**）提供了解决**强化学习**（**RL**）问题的数学框架。 几乎所有的 RL 问题都可以建模为 MDP。 MDP 被广泛用于解决各种优化问题。 在本章中，我们将了解什么是 MDP 以及如何使用它来解决 RL 问题。 我们还将学习动态编程，它是一种有效解决复杂问题的技术。
+**马尔可夫决策过程**（**MDP**）提供了解决**强化学习**（**RL**）问题的数学框架。 几乎所有的 RL 问题都可以建模为 MDP。 MDP 被广泛用于解决各种优化问题。 在本章中，我们将了解什么是 MDP 以及如何使用它来解决 RL 问题。 我们还将学习动态规划，它是一种有效解决复杂问题的技术。

 在本章中，您将学习以下主题：

@@ -19,15 +19,15 @@

 例如，如果我们知道当前状态是多云，则可以预测下一个状态可能是雨天。 我们得出的结论是，只有考虑当前状态（多云）而不考虑过去的状态（可能是晴天，大风等），下一个状态才会下雨。 但是，Markov 属性并不适用于所有进程。 例如，掷骰子（下一个状态）与前一个数字无关，无论骰子上显示的是什么（当前状态）。

-从一种状态移动到另一种状态称为**过渡**，其概率称为**过渡概率**。 我们可以用表格的形式来表示转移概率，如下所示，它被称为 **Markov table** 。 在给定当前状态的情况下，它显示了移至下一个状态的概率为：
+从一种状态移动到另一种状态称为**转移**，其概率称为**转移概率**。 我们可以用表格的形式来表示转移概率，如下所示，它被称为**马尔可夫表**。 在给定当前状态的情况下，它显示了移至下一个状态的概率为：

 | **当前状态** | **下一个状态** | **转移概率** |
-| 多云的 | 多雨的 | 0.6 |
-| 多雨的 | 多雨的 | 0.2 |
-| 阳光明媚 | 多云的 | 0.1 |
-| 多雨的 | 阳光明媚 | 0.1 |
+| 多云 | 下雨 | 0.6 |
+| 下雨 | 下雨 | 0.2 |
+| 晴天 | 多云 | 0.1 |
+| 下雨 | 晴天 | 0.1 |

-我们还可以以状态图的形式表示马尔可夫链，该状态图显示过渡概率：
+我们还可以以状态图的形式表示马尔可夫链，该状态图显示转移概率：

 ![](img/00018.jpeg)

@@ -107,9 +107,9 @@ MDP 由五个重要元素表示：

 # 政策功能

-我们已经在第 1 章，“强化学习简介”中了解了策略功能，该功能将状态映射到操作。 用π表示。
+我们已经在第 1 章，“强化学习简介”中了解了策略函数，该功能将状态映射到操作。 用π表示。

-策略功能可以表示为![](img/00042.jpeg)，指示从状态到动作的映射。 因此，基本上，策略功能会说明在每种状态下要执行的操作。 我们的最终目标在于找到最佳策略，该策略指定在每个状态下执行的正确操作，从而最大化回报。
+策略函数可以表示为![](img/00042.jpeg)，指示从状态到动作的映射。 因此，基本上，策略函数会说明在每种状态下要执行的操作。 我们的最终目标在于找到最佳策略，该策略指定在每个状态下执行的正确操作，从而最大化回报。

 # 状态值功能

@@ -249,9 +249,9 @@ MDP 由五个重要元素表示：

 我们可以通过求解 Bellman 最优性方程来找到最优策略。 为了解决 Bellman 最优性方程，我们使用一种称为动态规划的特殊技术。

-# 动态编程
+# 动态规划

-**动态编程**（**DP**）是一种解决复杂问题的技术。 在 DP 中，不是一次解决一个复杂的问题，而是将问题分解为简单的子问题，然后针对每个子问题，我们计算并存储解决方案。 如果出现相同的子问题，我们将不会重新计算，而是使用已经计算的解决方案。 因此，DP 有助于极大地减少计算时间。 它的应用广泛，包括计算机科学，数学，生物信息学等。
+**动态规划**（**DP**）是一种解决复杂问题的技术。 在 DP 中，不是一次解决一个复杂的问题，而是将问题分解为简单的子问题，然后针对每个子问题，我们计算并存储解决方案。 如果出现相同的子问题，我们将不会重新计算，而是使用已经计算的解决方案。 因此，DP 有助于极大地减少计算时间。 它的应用广泛，包括计算机科学，数学，生物信息学等。

 我们使用两种强大的算法来求解 Bellman 方程：

@@ -285,13 +285,15 @@ MDP 由五个重要元素表示：

 让我们计算所有状态动作对的`Q`值。

-Q 值告诉我们每个状态下一个动作的值。 首先，让我们计算状态`A`的`Q`值。 调用`Q`函数的方程式。 为了进行计算，我们需要过渡和奖励概率。 让我们考虑状态`A`的转移和奖励概率，如下所示：
+Q 值告诉我们每个状态下一个动作的值。 首先，让我们计算状态`A`的`Q`值。 调用`Q`函数的方程式。 为了进行计算，我们需要转移和奖励概率。 让我们考虑状态`A`的转移和奖励概率，如下所示：

 ![](img/00079.gif)

 状态`A`的 Q 函数可以计算如下：

-*Q（s，a）=转移概率*（奖励概率+ gamma * next_state 的值）*
+```
+Q(s, a) = 转移概率 * (奖励概率 + gamma * next_state 的值)
+```

 在此，`gamma`是折扣因子； 我们将其视为`1`。

@@ -371,7 +373,7 @@ Q(A, 1) = 0.3

 考虑我们在*值迭代*部分中看到的相同网格示例。 我们的目标是找到最佳策略：

-1.  初始化随机策略功能。
+1.  初始化随机策略函数。

 让我们通过为每个状态指定随机动作来初始化随机策略函数：

@@ -435,11 +437,11 @@ policy_iteration():
 *   **状态**：状态集。 在这里，我们有 16 个状态（网格中的每个小方框）。
 *   **动作**：所有可能动作的集合（左，右，上，下；这是我们的代理商在冰冻湖面环境中可以采取的所有四种可能动作）。
 *   **转移概率**：通过执行动作`a`从一种状态（`F`）转换为另一种状态（`H`）的概率。
-*   **奖励概率**：这是从一种状态（`F`）迁移到另一种状态（`H`）时获得奖励的概率。 执行*和*动作。
+*   **奖励概率**：这是执行动作`a`从一种状态（`F`）迁移到另一种状态（`H`）时获得奖励的概率。

 现在我们的目标是解决 MDP。 解决 MDP 意味着寻找最佳策略。 现在，我们介绍三个特殊功能：

-*   **策略功能**：指定在每种状态下要执行的操作
+*   **策略函数**：指定在每种状态下要执行的操作
 *   **值函数**：指定状态的良好程度
 *   **Q 函数**：指定动作在特定状态下的状态

@@ -511,9 +513,9 @@ Q(A, 1) = (0.3 * (0 + 0)) + (0.1 * (-1.0 + 0)) + (0.5 + (1.0 + 0))
 Q(A, 1) = 0.5
 ```

-我们没有为每个状态创建`Q`表，而是创建了一个名为`Q_value`的列表，然后为该状态中的每个动作创建了一个名为`next_states_rewards`的列表，该列表存储了`Q_value` 下一个过渡状态。 然后，我们对`next_state_rewards`求和并将其附加到我们的`Q_value`中。
+我们没有为每个状态创建`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`值并将其更新为我们的状态值：


--- a/new/handson-rl-py/04.md
+++ b/new/handson-rl-py/04.md
 # 蒙特卡洛方法进行游戏

-蒙特卡洛算法是从物理，机械到计算机科学的各个领域中最受欢迎和最常用的算法之一。 当未知环境模型时，在**强化学习**（**RL**）中使用 Monte Carlo 算法。 在上一章第 3 章，“马尔可夫决策过程和动态规划”中，我们着眼于使用**动态规划**（**DP**）查找 我们了解模型动态的最佳策略，即过渡和奖励概率。 但是，当我们不知道模型动态时，如何确定最佳策略？ 在这种情况下，我们使用蒙特卡洛算法； 当我们不了解环境时，它对于找到最佳策略非常有用。
+蒙特卡洛算法是从物理，机械到计算机科学的各个领域中最受欢迎和最常用的算法之一。 当未知环境模型时，在**强化学习**（**RL**）中使用 Monte Carlo 算法。 在上一章第 3 章，“马尔可夫决策过程和动态规划”中，我们着眼于使用**动态规划**（**DP**）查找 我们了解模型动态的最佳策略，即转移和奖励概率。 但是，当我们不知道模型动态时，如何确定最佳策略？ 在这种情况下，我们使用蒙特卡洛算法； 当我们不了解环境时，它对于找到最佳策略非常有用。

 在本章中，您将了解以下内容：

@@ -16,7 +16,7 @@

 蒙特卡洛方法通过随机采样找到近似解，也就是说，它通过运行多个踪迹来近似结果的概率。 通过抽样找到近似答案是一种统计技术。 让我们通过一个示例更好地直观地了解蒙特卡洛。

-**有趣的事实：**蒙特卡洛以斯坦尼斯瓦夫·乌兰的叔叔的名字命名，他经常从亲戚那里借钱在蒙特卡洛赌场赌博。
+**有趣的事实**：蒙特卡洛以斯坦尼斯瓦夫·乌兰的叔叔的名字命名，他经常从亲戚那里借钱在蒙特卡洛赌场赌博。

 # 使用蒙特卡洛估算 pi 的值

@@ -161,7 +161,7 @@ print("Approximate value of pi is {}" .format(calculate_pi(points_inside_circle,

 # 蒙特卡洛预测

-在 DP 中，我们通过使用值迭代和策略迭代来解决**马尔可夫决策过程**（**MDP**）。 这两种技术都需要转换和奖励概率才能找到最佳策略。 但是，当我们不知道过渡和奖励概率时，如何解决 MDP？ 在这种情况下，我们使用蒙特卡洛方法。 蒙特卡洛方法仅需要状态，动作和奖励的样本序列。 蒙特卡罗方法仅适用于情节任务。 由于 Monte Carlo 不需要任何模型，因此称为无模型学习算法。
+在 DP 中，我们通过使用值迭代和策略迭代来解决**马尔可夫决策过程**（**MDP**）。 这两种技术都需要转换和奖励概率才能找到最佳策略。 但是，当我们不知道转移和奖励概率时，如何解决 MDP？ 在这种情况下，我们使用蒙特卡洛方法。 蒙特卡洛方法仅需要状态，动作和奖励的样本序列。 蒙特卡罗方法仅适用于情节任务。 由于 Monte Carlo 不需要任何模型，因此称为无模型学习算法。

 蒙特卡洛方法的基本思想非常简单。 您还记得我们在上一章第 3 章，“马尔可夫决策过程和动态规划”中如何定义最佳值函数以及如何得出最佳策略吗？

@@ -205,7 +205,7 @@ print("Approximate value of pi is {}" .format(calculate_pi(points_inside_circle,
 *   最初，给玩家一张两张牌。 这两个卡都面朝上，即对其他人可见。
 *   庄家也得到了两张牌。 一张卡面朝上，另一张面朝下。 也就是说，发牌人只显示他的一张牌。

-*   如果在收到两张牌后，一张牌的总和为 21（例如，一位牌手已收到 10 + 11 = 21 的杰克和王牌），则称其为**自然**或 **Blackjack [** ，玩家获胜。
+*   如果在收到两张牌后，一张牌的总和为 21（例如，一位牌手已收到 10 + 11 = 21 的杰克和王牌），则称其为**自然**或 **Blackjack**，玩家获胜。
 *   如果发牌人在收到两张卡后立即的总卡数也为 21，则称为**开奖**，因为它们两张都有 21 张。
 *   在每个回合中，玩家决定是否需要另一张纸牌来总计接近 21 张纸牌。
 *   如果玩家需要纸牌，则称其为**命中**。

--- a/new/handson-rl-py/05.md
+++ b/new/handson-rl-py/05.md
 # 时间差异学习

-在上一章第四章，“使用蒙特卡洛方法的游戏”中，我们了解了有趣的蒙特卡洛方法，该方法用于解决**马尔可夫决策过程**（**MDP**），而不像动态编程那样预先未知环境的模型动力学。 我们研究了蒙特卡洛预测方法，该方法用于预测值函数，而控制方法用于进一步优化值函数。 但是蒙特卡洛方法存在一些陷阱。 它仅适用于情景任务。 如果情节很长，那么我们必须等待很长时间才能计算价值函数。 因此，我们将使用另一种有趣的算法，称为**时差**（**TD**）学习，这是一种无模型的学习算法：不需要知道模型动力学 先进，它也可以用于非临时性任务。
+在上一章第四章，“使用蒙特卡洛方法的游戏”中，我们了解了有趣的蒙特卡洛方法，该方法用于解决**马尔可夫决策过程**（**MDP**），而不像动态规划那样预先未知环境的模型动力学。 我们研究了蒙特卡洛预测方法，该方法用于预测值函数，而控制方法用于进一步优化值函数。 但是蒙特卡洛方法存在一些陷阱。 它仅适用于情景任务。 如果情节很长，那么我们必须等待很长时间才能计算价值函数。 因此，我们将使用另一种有趣的算法，称为**时差**（**TD**）学习，这是一种无模型的学习算法：不需要知道模型动力学 先进，它也可以用于非临时性任务。

 在本章中，您将学习：

@@ -12,7 +12,7 @@

 # TD 学习

-TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo 方法和**动态编程**（**DP**）的优点。 像蒙特卡洛方法一样，它不需要模型动力学，而像 DP 一样，它不需要等到情节结束就可以估计值函数。 取而代之的是，它基于先前学习的估算值来估算当前估算值，这也称为自举。 如果您在蒙特卡洛方法中看到没有引导程序，那么我们仅在情节结束时进行估计，但在 TD 方法中我们可以进行引导。
+TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo 方法和**动态规划**（**DP**）的优点。 像蒙特卡洛方法一样，它不需要模型动力学，而像 DP 一样，它不需要等到情节结束就可以估计值函数。 取而代之的是，它基于先前学习的估算值来估算当前估算值，这也称为自举。 如果您在蒙特卡洛方法中看到没有引导程序，那么我们仅在情节结束时进行估计，但在 TD 方法中我们可以进行引导。

 # TD 预测


--- a/new/handson-rl-py/07.md
+++ b/new/handson-rl-py/07.md
@@ -121,7 +121,7 @@

 ![](img/00179.gif)

-我们如何向下移动该点（初始权重）？ 我们如何下降并到达最低点？ 我们可以通过计算成本函数相对于该点的梯度来移动该点（初始权重）。 渐变是导数，实际上是切线的斜率，如下图所示。 因此，通过计算梯度，我们下降（向下移动）并到达最低点：
+我们如何向下移动该点（初始权重）？ 我们如何下降并到达最低点？ 我们可以通过计算成本函数相对于该点的梯度来移动该点（初始权重）。 梯度是导数，实际上是切线的斜率，如下图所示。 因此，通过计算梯度，我们下降（向下移动）并到达最低点：

 ![](img/00180.gif)


--- a/new/handson-rl-py/08.md
+++ b/new/handson-rl-py/08.md
@@ -50,9 +50,9 @@ DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧

 # 体验重播

-我们知道，在 RL 环境中，我们通过执行某些操作`a`，从一个状态`s`过渡到下一状态`s'`，并获得奖励`r`。 我们将此过渡信息作为![](img/00250.jpeg)保存在称为重播缓冲区或体验重播的缓冲区中。 这些过渡称为代理的经验。
+我们知道，在 RL 环境中，我们通过执行某些操作`a`，从一个状态`s`转移到下一状态`s'`，并获得奖励`r`。 我们将此转移信息作为![](img/00250.jpeg)保存在称为重播缓冲区或体验重播的缓冲区中。 这些转移称为代理的经验。

-体验重播的关键思想是，我们使用从重播缓冲区采样的过渡来训练深度 Q 网络，而不是使用最后的过渡进行训练。 座席的经历一次相关，因此从重播缓冲区中随机选择一批训练样本将减少座席的经历之间的相关性，并有助于座席更好地从广泛的经验中学习。
+体验重播的关键思想是，我们使用从重播缓冲区采样的转移来训练深度 Q 网络，而不是使用最后的转移进行训练。 座席的经历一次相关，因此从重播缓冲区中随机选择一批训练样本将减少座席的经历之间的相关性，并有助于座席更好地从广泛的经验中学习。

 而且，神经网络将过拟合相关经验，因此通过从答复缓冲区中选择随机的经验批次，我们将减少过拟合。 我们可以使用统一采样来采样经验。 我们可以将体验重播视为队列而不是列表。 重播缓冲区将仅存储固定数量的最新体验，因此，当出现新信息时，我们将删除旧信息：

@@ -83,8 +83,8 @@ DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧
 1.  首先，我们预处理游戏屏幕（状态`s`）并将其馈送到 DQN，DQN 将返回该状态下所有可能动作的`Q`值。
 2.  现在，我们使用 epsilon-greedy 策略选择一个动作：对于概率 epsilon，我们选择一个随机动作`a`；对于概率为 1-epsilon，我们选择一个具有最大`Q`的动作 ]值，例如![](img/00258.jpeg)。
 3.  在选择动作`a`之后，我们在`s`状态下执行此动作，然后移至新的`s'`状态并获得奖励。 下一个状态`s'`是下一个游戏屏幕的预处理图像。
-4.  我们将此过渡存储在`<s,a,r,s'>`的重播缓冲区中。
-5.  接下来，我们从重播缓冲区中抽取一些随机的过渡批次并计算损失。
+4.  我们将此转移存储在`<s,a,r,s'>`的重播缓冲区中。
+5.  接下来，我们从重播缓冲区中抽取一些随机的转移批次并计算损失。
 6.  我们知道![](img/00259.jpeg)就像目标`Q`与预测的`Q`之间的平方差一样。
 7.  我们针对实际网络参数![](img/00260.jpeg)执行梯度下降，以最大程度地减少这种损失。
 8.  在每个`k`个步骤之后，我们将实际网络权重![](img/00261.jpeg)复制到目标网络权重![](img/00262.jpeg)。
@@ -406,7 +406,7 @@ with tf.Session() as sess:

 # 优先体验重播

-在 DQN 架构中，我们使用经验重播来消除训练样本之间的相关性。 但是，从记忆重放中均匀采样过渡不是最佳方法。 相反，我们可以确定转换的优先级并根据优先级进行采样。 优先安排过渡有助于网络快速有效地学习。 我们如何确定过渡的优先级？ 我们优先考虑具有较高 TD 错误的转换。 我们知道，TD 误差指定了估计的 Q 值和实际 Q 值之间的差。 因此，具有较高 TD 误差的过渡是我们必须关注和学习的过渡，因为这些过渡与我们的估计背道而驰。 凭直觉，让我们说您尝试解决一系列问题，但是您无法解决其中两个问题。 然后，您仅将这两个问题放在首位，以专注于问题所在并尝试解决该问题：
+在 DQN 架构中，我们使用经验重播来消除训练样本之间的相关性。 但是，从记忆重放中均匀采样转移不是最佳方法。 相反，我们可以确定转换的优先级并根据优先级进行采样。 优先安排转移有助于网络快速有效地学习。 我们如何确定转移的优先级？ 我们优先考虑具有较高 TD 错误的转换。 我们知道，TD 误差指定了估计的 Q 值和实际 Q 值之间的差。 因此，具有较高 TD 误差的转移是我们必须关注和学习的转移，因为这些转移与我们的估计背道而驰。 凭直觉，让我们说您尝试解决一系列问题，但是您无法解决其中两个问题。 然后，您仅将这两个问题放在首位，以专注于问题所在并尝试解决该问题：

 ![](img/00272.gif)

@@ -426,7 +426,7 @@ with tf.Session() as sess:

 ![](img/00283.jpeg)

-`rank(i)`指定过渡`i`在重播缓冲区中的位置，在该位置中，过渡从高 TD 错误到低 TD 错误被分类。 计算优先级后，我们可以使用相同的公式![](img/00284.jpeg)将优先级转换为概率。
+`rank(i)`指定转移`i`在重播缓冲区中的位置，在该位置中，转移从高 TD 错误到低 TD 错误被分类。 计算优先级后，我们可以使用相同的公式![](img/00284.jpeg)将优先级转换为概率。

 # 决斗网络架构


--- a/new/handson-rl-py/09.md
+++ b/new/handson-rl-py/09.md
@@ -12,7 +12,7 @@

 # DRQN

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

 为了回顾我们在前几章中学到的知识，请考虑以下所示的 Pong 游戏。 仅通过查看当前的游戏屏幕，我们就可以知道球的位置，但是我们还需要知道球的运动方向和球的速度，以便采取最佳行动。 但是，仅查看当前的游戏屏幕并不能告诉我们球的方向和速度：

@@ -30,7 +30,7 @@

 因此，我们将游戏屏幕作为卷积层的输入。 卷积层对图像进行卷积并生成特征图。 然后将生成的特征图传递到 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`个步骤。 因此，通过这种方式，我们既可以适应随机化，又可以适应另一种实际的体验。
+等待。 体验重播缓冲区如何？ 在 DQN 中，为避免相关的体验，我们使用了体验重播，该体验存储了游戏的转移，并使用了随机的一组体验来训练网络。 对于 DRQN，我们将整个情节存储在体验缓冲区中，并从随机的情节批次中随机采样`n`个步骤。 因此，通过这种方式，我们既可以适应随机化，又可以适应另一种实际的体验。

 # 训练特工玩《毁灭战士》


--- a/new/handson-rl-py/11.md
+++ b/new/handson-rl-py/11.md
@@ -15,13 +15,13 @@

 # 政策梯度

-策略梯度是**强化学习**（**RL**）的惊人算法之一，在该算法中，我们直接优化由某些参数![](img/00304.jpeg)设置的策略。 到目前为止，我们已经使用 Q 函数来找到最佳策略。 现在，我们将了解如何找到没有 Q 函数的最优策略。 首先，让我们将策略功能定义为![](img/00305.jpeg)，即在状态为`s`的情况下采取`a`动作的概率。 我们通过参数![](img/00306.jpeg)将策略参数化为![](img/00307.jpeg)，这使我们能够确定状态下的最佳操作。
+策略梯度是**强化学习**（**RL**）的惊人算法之一，在该算法中，我们直接优化由某些参数![](img/00304.jpeg)设置的策略。 到目前为止，我们已经使用 Q 函数来找到最佳策略。 现在，我们将了解如何找到没有 Q 函数的最优策略。 首先，让我们将策略函数定义为![](img/00305.jpeg)，即在状态为`s`的情况下采取`a`动作的概率。 我们通过参数![](img/00306.jpeg)将策略参数化为![](img/00307.jpeg)，这使我们能够确定状态下的最佳操作。

 策略梯度方法具有多个优点，它可以处理连续动作空间，在该连续动作空间中，我们具有无限数量的动作和状态。 假设我们正在制造自动驾驶汽车。 驾驶汽车时应避免撞到其他车辆。 当汽车撞到车辆时，我们得到负奖励，而当汽车没有撞到其他车辆时，我们得到正奖励。 我们以仅获得积极奖励的方式更新模型参数，以使我们的汽车不会撞到任何其他车辆。 这是策略梯度的基本思想：我们以最大化报酬的方式更新模型参数。 让我们详细看一下。

 我们使用神经网络来找到最佳策略，我们将此网络称为策略网络。 策略网络的输入将是状态，而输出将是该状态中每个操作的概率。 一旦有了这个概率，就可以从该分布中采样一个动作，并在状态下执行该动作。 但是我们采样的动作可能不是在该状态下执行的正确动作。 很好-我们执行动作并存储奖励。 同样，我们通过从分布中采样一个动作来在每种状态下执行动作，并存储奖励。 现在，这成为我们的训练数据。 我们执行梯度下降并以这样的方式更新梯度：在状态下产生高奖励的动作将具有较高的概率，而在状态下产生低奖励的动作将具有较低的概率。 什么是损失函数？ 在这里，我们使用 softmax 交叉熵损失，然后将损失乘以奖励值。

-# 使用策略渐变的 Lunar Lander
+# 使用策略梯度的 Lunar Lander

 假设我们的经纪人正在驾驶航天器，而我们的经纪人的目标是正确着陆在着陆垫上。 如果我们的特工（着陆器）从着陆点着陆，则它会失去奖励，并且如果特工崩溃或休息，情节将终止。 在环境中可用的四个离散动作是“不执行任何操作”，“向左射击引擎”，“向主机射击”和“向右引擎”。

@@ -220,7 +220,7 @@ class PolicyGradient:

 在第 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 体系结构：
+因此，我们使用称为 Actor Critic 的新架构，该架构具有两个网络-Actor 和 Critic。 Actor Critic 体系结构结合了策略梯度和状态操作值功能。 **Actor** 网络的作用是通过调整参数![](img/00310.jpeg)来确定**状态**中的最佳动作，而 **Critic** 的作用是评估 **Actor** 产生的动作。 **评论家**通过计算时间差异误差来评估演员的行动。 也就是说，我们在 **Actor** 网络上执行策略梯度以选择操作， **Critic** 网络评估由 **Actor** 产生的操作 ]网络使用 TD 错误。 下图显示了 Actor Critic 体系结构：

 ![](img/00311.gif)

@@ -237,9 +237,9 @@ 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 误差计算为：
+经过一些迭代后，我们从重播缓冲区采样转移并训练网络，然后计算目标`Q`值![](img/00321.jpeg)。 我们将 TD 误差计算为：

 ![](img/00322.jpeg)


--- a/new/handson-rl-py/12.md
+++ b/new/handson-rl-py/12.md
@@ -668,7 +668,7 @@ while num_frames <= TOTAL_FRAMES+1:
    next_state,reward,done,_ = env.step(action)
 ```

-将此过渡信息存储在`experience_replay_buffer`中：
+将此转移信息存储在`experience_replay_buffer`中：

 ```py
    if current_game_frames >= init_no_ops:

--- a/new/intel-proj-py/06.md
+++ b/new/intel-proj-py/06.md
@@ -480,7 +480,7 @@ python preprocess_ratings.py --path '/home/santanu/ML_DS_Catalog-/Collaborating

 现在我们拥有所有必需的功能，我们将创建 TensorFlow 操作，以在给定可见输入的情况下对隐藏状态`self.h`进行采样，并在给定采样状态下对可见单位`self.x`进行采样。 我们还使用对比散度从 v 和 h 的联合概率分布（即`P(v,h/model)`）中抽取`(self.x_s,self.h_s)`作为代表性样本，以计算梯度中的不同期望项。

-`_network`函数的最后一步基于渐变更新 RBM 模型的权重和偏差。 如我们先前所见，梯度基于给定可见层输入的隐藏层激活`self.h`以及通过对比发散得出的联合概率分布`P(v,h/model)`的代表性样本`(self.x_s,self.h_s)`。
+`_network`函数的最后一步基于梯度更新 RBM 模型的权重和偏差。 如我们先前所见，梯度基于给定可见层输入的隐藏层激活`self.h`以及通过对比发散得出的联合概率分布`P(v,h/model)`的代表性样本`(self.x_s,self.h_s)`。

 TensorFlow ops `self.x_`指的是给定隐藏层激活`self.h`的可见层激活，在推断过程中将有用以推导尚未被每个用户评级的电影的评级：


--- a/new/whats-new-tf2/4.md
+++ b/new/whats-new-tf2/4.md
@@ -41,7 +41,7 @@ TensorFlow 1.x 已建议为其高级 API 集使用`tf.estimator` API，该 API 

 TensorFlow 提供了丰富的 API 集来构建上述生成模型和判别模型。 此外，在 TF 2.0 中，通过引入急切的执行（在第 2 章， “Keras 默认集成和急切执行”中进行了解释），创建这些模型的理念发生了整体变化， 这使得`tf.keras`的使用非常简单且易于调试。 此外，TensorFlow 2.0 中的`tf.keras` API 丰富了 TF 在 TF 1.x 版本中可以执行的全部功能。 在本书中，除非另有说明，否则我们主要使用`tf.keras` API 来构建，训练和预测神经网络模型，并且不会讨论低级或中级 TF API。

-TensorFlow 建立深度学习模型并对其进行训练时的理念是，首先定义神经网络层（也称为构建由节点和边组成的计算图）； 定义损失函数，准确性度量和适当的优化器； 然后训练模型以更新渐变。 这三个步骤在使用构建，编译和拟合的`tf.keras` API 中得到了体现，如下图所示：
+TensorFlow 建立深度学习模型并对其进行训练时的理念是，首先定义神经网络层（也称为构建由节点和边组成的计算图）； 定义损失函数，准确性度量和适当的优化器； 然后训练模型以更新梯度。 这三个步骤在使用构建，编译和拟合的`tf.keras` API 中得到了体现，如下图所示：

 ![](img/acaa1019-a9a9-4896-bc8e-75554932da62.png)

@@ -290,7 +290,7 @@ new_model = keras.models.load_model('my_model.h5') ...

 # 定制培训逻辑

-如前所述，TF 2.0 带来了默认的紧急执行，这意味着基于图的代码流的传统 TF 1.x 自定义训练逻辑实现现在已过时。 为了在 TF 2.0 中实现有关急切执行的自定义训练逻辑，可以使用`tf.GradientTape`。 `tf.GradientTape`的目的是记录用于自动微分的运算，或者用于计算运算或计算相对于其输入变量的梯度。 这可以通过使用`tf.GradientTape`作为上下文管理器来完成。 TensorFlow 将在`tf.GradientTape`上下文中执行的所有操作记录到磁带上，然后将其与渐变一起与那些操作关联，以使用反向模式微分计算记录的操作的梯度。
+如前所述，TF 2.0 带来了默认的紧急执行，这意味着基于图的代码流的传统 TF 1.x 自定义训练逻辑实现现在已过时。 为了在 TF 2.0 中实现有关急切执行的自定义训练逻辑，可以使用`tf.GradientTape`。 `tf.GradientTape`的目的是记录用于自动微分的运算，或者用于计算运算或计算相对于其输入变量的梯度。 这可以通过使用`tf.GradientTape`作为上下文管理器来完成。 TensorFlow 将在`tf.GradientTape`上下文中执行的所有操作记录到磁带上，然后将其与梯度一起与那些操作关联，以使用反向模式微分计算记录的操作的梯度。

 例如，一个简单的立方体操作的梯度可以如下计算：

@@ -308,7 +308,7 @@ dy_dx = tape.gradient(y, x) # 12.0

 `tf.GradientTape`还允许使用更多自定义训练逻辑，因为它提供了在使用优化程序之前操纵梯度的选项。 与内置的`tf.keras.Model.fit`相比，它提供了一种替代的，更加复杂且功能强大的深度学习模型训练方法。 为此，所有前向通过操作都记录在磁带上，并且为了计算这些操作的梯度，将磁带向后播放然后丢弃。 这里要注意的重要一点是，特定的`tf.GradientTape`模型只能计算一个梯度。

-要首先使用`tf.GradientTape`实现模型的简单训练，请在`tf.GradentTape`上下文管理器内部的输入张量上调用前向传递，然后计算`loss`函数。 这样可以确保将所有计算结果记录在渐变磁带上。 然后，针对模型中的所有可训练变量计算梯度。 一旦计算出梯度，就可以在将其传递给优化器以将其应用于模型变量之前执行任何所需的梯度截断，归一化或变换。 看下面的例子：
+要首先使用`tf.GradientTape`实现模型的简单训练，请在`tf.GradentTape`上下文管理器内部的输入张量上调用前向传递，然后计算`loss`函数。 这样可以确保将所有计算结果记录在梯度磁带上。 然后，针对模型中的所有可训练变量计算梯度。 一旦计算出梯度，就可以在将其传递给优化器以将其应用于模型变量之前执行任何所需的梯度截断，归一化或变换。 看下面的例子：

 ```py
 NUM_EXAMPLES = 2000
@@ -391,7 +391,7 @@ def train(model, optimizer):
  return step, loss, accuracy
 ```

-TF 2.0 还提供了一种创建自定义渐变以覆盖默认渐变计算的方法。 这是通过使用`tf.custom_gradient`装饰器完成的。 使用自定义渐变的一个常见原因是为一系列操作提供数值稳定的渐变，并且它们也可以用于限制渐变的范数。
+TF 2.0 还提供了一种创建自定义梯度以覆盖默认梯度计算的方法。 这是通过使用`tf.custom_gradient`装饰器完成的。 使用自定义梯度的一个常见原因是为一系列操作提供数值稳定的梯度，并且它们也可以用于限制梯度的范数。

 要使用`tf.custom_gradient`装饰器，我们必须定义一个函数，该函数既返回所需的计算结果，又返回计算的梯度。 一个示例是在反向传播过程中实现梯度裁剪：