2020-12-20 19:45:16

2c708a54 · wizardforcel · 87c6fe24 · 2c708a54 · 2c708a54 · 2c708a54
55 changed file
--- a/new/begin-app-dev-tf-keras/1.md
+++ b/new/begin-app-dev-tf-keras/1.md
@@ -31,7 +31,7 @@

 自从 40 年代以一种形式或另一种形式出现以来，一直在研究神经网络。 但是，直到最近，深度学习系统才在大型工业应用中成功使用。

-神经网络的当代支持者已在语音识别，语言翻译，图像分类和其他领域取得了巨大的成功。 其当前的突出优势是可用计算能力的显着提高以及**图形处理单元**（ **GPU** ）和**张量处理单元**（[ **TPU** ）比常规 CPU 能够执行更多的同时数学运算，并且数据可用性更高。
+神经网络的当代支持者已在语音识别，语言翻译，图像分类和其他领域取得了巨大的成功。 其当前的突出优势是可用计算能力的显着提高以及**图形处理单元**（**GPU**）和**张量处理单元**（[ **TPU**）比常规 CPU 能够执行更多的同时数学运算，并且数据可用性更高。

 不同 AlphaGo 算法的功耗。 AlphaGo 是 DeepMind 的一项举措，旨在开发出一系列击败 Go 游戏的算法。 它被认为是深度学习的强大典范。 TPU 是 Google 开发的一种芯片组，用于深度学习程序。

@@ -318,7 +318,7 @@ Michael Heydt（2017 年 6 月，Packt 出版）的*学习熊猫*和 Dan Toomey

 ##### MNIST 数据集

-**修改后的美国国家标准技术研究院**（ **MNIST** ）数据集包含 60,000 张图像的训练集和 10,000 张图像的测试集。 每个图像都包含一个手写数字。 该数据集（是美国政府创建的数据集的衍生产品）最初用于测试解决计算机系统识别手写文本问题的不同方法。 为了提高邮政服务，税收系统和政府服务的绩效，能够做到这一点很重要。 对于现代方法，MNIST 数据集被认为过于幼稚。 在现代研究中（例如 CIFAR）使用了不同的和更新的数据集。 但是，MNIST 数据集对于了解神经网络的工作原理仍然非常有用，因为已知的模型可以高效地达到很高的准确性。
+**修改后的美国国家标准技术研究院**（**MNIST**）数据集包含 60,000 张图像的训练集和 10,000 张图像的测试集。 每个图像都包含一个手写数字。 该数据集（是美国政府创建的数据集的衍生产品）最初用于测试解决计算机系统识别手写文本问题的不同方法。 为了提高邮政服务，税收系统和政府服务的绩效，能够做到这一点很重要。 对于现代方法，MNIST 数据集被认为过于幼稚。 在现代研究中（例如 CIFAR）使用了不同的和更新的数据集。 但是，MNIST 数据集对于了解神经网络的工作原理仍然非常有用，因为已知的模型可以高效地达到很高的准确性。

 ### 注意


--- a/new/begin-app-dev-tf-keras/2.md
+++ b/new/begin-app-dev-tf-keras/2.md
@@ -21,7 +21,7 @@

 ## 通用架构

-考虑到有许多种可能的架构，经常被用作两种应用的两种流行架构：**卷积神经网络**（ **CNN** ）和 **递归神经网络**（ **RNN** ）。 这些是基本的网络，应该被视为大多数项目的起点。 由于它们在该领域中的相关性，我们还包括了另外三个网络的描述： **RNN 变体的长期短期记忆**（ **LSTM** ）网络； **生成对抗网络**（ **GAN** ）； 和深度强化学习。 后面的这些体系结构在解决当代问题方面取得了巨大的成功，但是使用起来有些困难。
+考虑到有许多种可能的架构，经常被用作两种应用的两种流行架构：**卷积神经网络**（**CNN**）和 **递归神经网络**（**RNN**）。 这些是基本的网络，应该被视为大多数项目的起点。 由于它们在该领域中的相关性，我们还包括了另外三个网络的描述： **RNN 变体的长期短期记忆**（**LSTM**）网络； **生成对抗网络**（**GAN**）； 和深度强化学习。 后面的这些体系结构在解决当代问题方面取得了巨大的成功，但是使用起来有些困难。

 ### 卷积神经网络

@@ -65,7 +65,7 @@ CNN 的基本见解是将紧密相关的数据用作培训过程的要素，而

 ### 生成对抗网络

-**生成对抗网络**（ **GAN** ）由蒙特利尔大学的 Ian Goodfellow 和他的同事于 2014 年发明。 GAN 提出，与其拥有一个优化权重和偏向以最小化其误差为目标的神经网络，不如两个神经网络为此目的相互竞争。
+**生成对抗网络**（**GAN**）由蒙特利尔大学的 Ian Goodfellow 和他的同事于 2014 年发明。 GAN 提出，与其拥有一个优化权重和偏向以最小化其误差为目标的神经网络，不如两个神经网络为此目的相互竞争。

 ### 注意

@@ -161,7 +161,7 @@ GAN 已成功用于数据具有清晰拓扑结构的领域。 它的原始实现

 ![Maximum and Minimum Normalization](img/image02_14.jpg)

-在这里，![Maximum and Minimum Normalization](img/image02_11.jpg)是![Maximum and Minimum Normalization](img/image02_12.jpg)观测值， *O* 表示具有所有 O 值的向量，并且函数 min（O）和 max（O）分别表示该序列的最小值和最大值 。
+在这里，![Maximum and Minimum Normalization](img/image02_11.jpg)是![Maximum and Minimum Normalization](img/image02_12.jpg)观测值，`O`表示具有所有 O 值的向量，并且函数 min（O）和 max（O）分别表示该序列的最小值和最大值 。

 在*活动 3* 和*探索比特币数据集并为模型准备数据时，*我们将准备可用的比特币数据以用于我们的 LSTM 模式。 其中包括选择感兴趣的变量，选择相关时段并应用先前的点相对归一化技术。


--- a/new/begin-app-dev-tf-keras/3.md
+++ b/new/begin-app-dev-tf-keras/3.md
@@ -78,9 +78,9 @@

 |
 | --- | --- | --- | --- |
-| 回归 | 均方误差（ **MSE** ） | 预测连续功能。 即，预测值范围内的值。 | 使用过去的温度测量结果来预测将来的温度。 |
-| 回归 | 均方根误差（ **RMSE** ） | 与前面相同，但处理负值。 RMSE 通常提供更可解释的结果。 | 与前面相同。 |
-| 回归 | 平均绝对百分比误差（ **MAPE** ） | 预测连续功能。 在使用非标准化范围时具有更好的性能。 | 使用产品属性（例如，价格，类型，目标受众，市场条件）预测产品的销售。 |
+| 回归 | 均方误差（**MSE**） | 预测连续功能。 即，预测值范围内的值。 | 使用过去的温度测量结果来预测将来的温度。 |
+| 回归 | 均方根误差（**RMSE**） | 与前面相同，但处理负值。 RMSE 通常提供更可解释的结果。 | 与前面相同。 |
+| 回归 | 平均绝对百分比误差（**MAPE**） | 预测连续功能。 在使用非标准化范围时具有更好的性能。 | 使用产品属性（例如，价格，类型，目标受众，市场条件）预测产品的销售。 |
 | 分类 | 二元交叉熵 | 两个类别之间或两个值之间的分类（即`true`或`false`）。 | 根据浏览器的活动预测网站的访问者是男性还是女性。 |
 | 分类 | 分类交叉熵 | 一组已知类别中许多类别之间的分类。 | 根据讲英语的口音来预测说话者的国籍。 |


--- a/new/begin-app-dev-tf-keras/4.md
+++ b/new/begin-app-dev-tf-keras/4.md
@@ -83,7 +83,7 @@

 > *代码段 2* ：`Model()`类中的`train()`方法。 该方法使用来自`self.X`和`self.Y`的数据训练`self.model`中可用的模型。

-在前面的代码片段中，您将注意到`train()`方法类似于“第 3 课”，*中对*活动 6* 和 *7* 的解决方案。 模型评估与优化*。 总体思路是，可以很容易地将 Keras 工作流程中的每个过程（构建或设计，训练，评估和预测）转变为程序的不同部分。 在我们的例子中，我们将它们变成可以从`Model()`类调用的方法。 这将组织我们的程序，并提供一系列约束（例如在模型体系结构或某些 API 参数上），以帮助我们在稳定的环境中部署模型。
+在前面的代码片段中，您将注意到`train()`方法类似于“第 3 课”，*中对*活动 6* 和`7`的解决方案。 模型评估与优化*。 总体思路是，可以很容易地将 Keras 工作流程中的每个过程（构建或设计，训练，评估和预测）转变为程序的不同部分。 在我们的例子中，我们将它们变成可以从`Model()`类调用的方法。 这将组织我们的程序，并提供一系列约束（例如在模型体系结构或某些 API 参数上），以帮助我们在稳定的环境中部署模型。

 在下一部分中，我们将探讨处理新数据的通用策略。


--- a/new/handson-dl-img-tf/2.md
+++ b/new/handson-dl-img-tf/2.md
@@ -2,7 +2,7 @@

 在上一章中，我们准备了机器学习工具包，在其中设置了 Keras 和 Docker，以便允许我们运行 Jupyter Notebooks 处理机器学习。

-在本章中，我们将研究准备供机器学习使用的图像数据，以及将其连接到 Keras 中涉及的步骤。 我们将从了解 MNIST 数字开始。 这些是图像形式的手写字符，我们将在机器学习中有效执行**光学字符识别**（ **OCR** ）。 然后，我们将讨论张量。 张量听起来像是一个数学词，的确是，但是作为一名程序员，您已经看到了多维数组，因此您实际上已经在使用张量，我将向您展示其等效性。 之后，我们将图像转换为张量。 正如您习惯在计算机上看到图像一样，图像需要一种特殊的编码形式才能与机器学习一起使用。
+在本章中，我们将研究准备供机器学习使用的图像数据，以及将其连接到 Keras 中涉及的步骤。 我们将从了解 MNIST 数字开始。 这些是图像形式的手写字符，我们将在机器学习中有效执行**光学字符识别**（**OCR**）。 然后，我们将讨论张量。 张量听起来像是一个数学词，的确是，但是作为一名程序员，您已经看到了多维数组，因此您实际上已经在使用张量，我将向您展示其等效性。 之后，我们将图像转换为张量。 正如您习惯在计算机上看到图像一样，图像需要一种特殊的编码形式才能与机器学习一起使用。

 然后，我们将转向类别； 在这种情况下，我们将使用零到九（这是单个数字的字符），并将它们变成类别标签。 最后，我们将进行回顾，并且我将向您展示一本有关如何为机器学习准备数据时如何思考数据的食谱。

@@ -110,10 +110,10 @@ o 到 9 个预测

 输出位图

-创建机器学习算法时，我们要做的是让计算机学习或发现将一个图像（数字 9）转换为另一图像（在第 9 列上设置一位的位图）的功能， 这就是我们所说的机器学习。 请记住，张量只是多维数组， *x* 和 *y* 值只是像素。 我们对这些值进行归一化，这意味着我们将它们从零到一的范围中获取，以便它们在机器学习算法中很有用。 标签或输出类只是我们要映射的值的数组，并且我们将使用单热编码对这些值进行编码，这又意味着只有一个是热的或设置为一个。
+创建机器学习算法时，我们要做的是让计算机学习或发现将一个图像（数字 9）转换为另一图像（在第 9 列上设置一位的位图）的功能， 这就是我们所说的机器学习。 请记住，张量只是多维数组，`x`和`y`值只是像素。 我们对这些值进行归一化，这意味着我们将它们从零到一的范围中获取，以便它们在机器学习算法中很有用。 标签或输出类只是我们要映射的值的数组，并且我们将使用单热编码对这些值进行编码，这又意味着只有一个是热的或设置为一个。

 # 概要

 在本章中，我们了解了 MNIST 数字，以及如何获取它们。 张量实际上只是多维数组； 我们如何将图像数据编码为张量； 我们如何将分类或分类数据编码为张量； 然后我们进行了快速回顾，并采用了食谱的方法来考虑尺寸和张量，以获取用于机器学习的数据。

-现在，我们已经学习了如何为机器学习设置输入和输出数据，我们将继续下一章，在该章中，我们将创建一个*“经典神经网络”*（ **CNN** ）。
\ No newline at end of file
+现在，我们已经学习了如何为机器学习设置输入和输出数据，我们将继续下一章，在该章中，我们将创建一个*“经典神经网络”*（**CNN**）。
\ No newline at end of file
--- a/new/handson-dl-img-tf/3.md
+++ b/new/handson-dl-img-tf/3.md
@@ -209,4 +209,4 @@ Keras 功能模型

 在本章中，我们实际上涵盖了很多内容。 我们看到了经典或密集神经网络的结构。 我们了解了激活和非线性，并了解了`softmax`。 然后，我们建立测试和训练数据，并学习了如何使用`Dropout`和`Flatten`构建网络。 我们还学习了有关求解器的所有知识，或者机器学习的实际学习方式。 然后，我们探索了超参数，最后，我们通过网格搜索对模型进行了微调。

-在下一章中，我们将学到的知识并改变网络的结构，以构建所谓的**卷积神经网络**（ **CNN** ）。
\ No newline at end of file
+在下一章中，我们将学到的知识并改变网络的结构，以构建所谓的**卷积神经网络**（**CNN**）。
\ No newline at end of file
--- a/new/handson-meta-learn-py/01.md
+++ b/new/handson-meta-learn-py/01.md
 # 元学习导论

-元学习是当前人工智能领域最有前途和趋势的研究领域之一。 它被认为是获得**人工智能**（ **AGI** ）的垫脚石。 在本章中，我们将了解什么是元学习以及为什么元学习是当前人工智能中最令人振奋的研究。 我们将了解什么是少拍，单拍和零拍学习，以及如何在元学习中使用它。 我们还将学习不同类型的元学习技术。 然后，我们将探索学习通过梯度下降学习梯度下降的概念，其中我们了解如何使用元学习器来学习梯度下降优化。 继续进行，我们还将学习优化作为几次学习的模型，我们将了解如何在几次学习设置中将元学习器用作优化算法。
+元学习是当前人工智能领域最有前途和趋势的研究领域之一。 它被认为是获得**人工智能**（**AGI**）的垫脚石。 在本章中，我们将了解什么是元学习以及为什么元学习是当前人工智能中最令人振奋的研究。 我们将了解什么是少拍，单拍和零拍学习，以及如何在元学习中使用它。 我们还将学习不同类型的元学习技术。 然后，我们将探索学习通过梯度下降学习梯度下降的概念，其中我们了解如何使用元学习器来学习梯度下降优化。 继续进行，我们还将学习优化作为几次学习的模型，我们将了解如何在几次学习设置中将元学习器用作优化算法。

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

@@ -14,15 +14,15 @@

 目前，元学习是 AI 领域中令人振奋的研究领域。 凭借大量的研究论文和进步，元学习显然在 AI 领域取得了重大突破。 在进行元学习之前，让我们看看我们当前的 AI 模型是如何工作的。

-近年来，借助强大的算法（如生成对抗网络和胶囊网络），深度学习取得了飞速的发展。 但是深度神经网络的问题在于，我们需要拥有大量的训练集来训练我们的模型，而当我们只有很少的数据点时，它将突然失败。 假设我们训练了一个深度学习模型来执行任务 *A* 。 现在，当我们有一个新任务 *B，*与 *A* 密切相关时，我们不能使用相同的模型。 我们需要从头开始为任务 *B* 训练模型。 因此，对于每项任务，我们都需要从头开始训练模型，尽管它们可能是相关的。
+近年来，借助强大的算法（如生成对抗网络和胶囊网络），深度学习取得了飞速的发展。 但是深度神经网络的问题在于，我们需要拥有大量的训练集来训练我们的模型，而当我们只有很少的数据点时，它将突然失败。 假设我们训练了一个深度学习模型来执行任务`A`。 现在，当我们有一个新任务 *B，*与`A`密切相关时，我们不能使用相同的模型。 我们需要从头开始为任务`B`训练模型。 因此，对于每项任务，我们都需要从头开始训练模型，尽管它们可能是相关的。

 深度学习真的是真正的 AI 吗？ 好吧，不是。 人类如何学习？ 我们将学习概括为多个概念并从中学习。 但是当前的学习算法仅能完成一项任务。 这就是元学习的用武之地。元学习产生了一个通用的 AI 模型，该模型可以学习执行各种任务，而无需从头开始进行培训。 我们使用很少的数据点在各种相关任务上训练我们的元学习模型，因此对于新的相关任务，它可以利用从先前任务中获得的学习知识，而不必从头开始进行训练。 许多研究人员和科学家认为，元学习可以使我们更接近实现 AGI。 在接下来的部分中，我们将确切学习元学习模型如何元学习过程。

 # 元学习和少拍

-从较少的数据点中学习称为**少镜头学习**或`k`**-镜头学习**，其中 *k* 表示每个数据点的数量 数据集中的类。 假设我们正在对猫和狗进行图像分类。 如果我们正好有一只狗和一只猫的图像，那么它被称为**单次学习**，也就是说，我们每个班级仅从一个数据点开始学习。 如果我们有 10 张狗的图像和 10 张猫的图像，则称为 10 次学习。 因此， *k-* 镜头学习中的 *k* 意味着每个班级都有许多数据点。 还有**零击学习**，每个班级没有任何数据点。 等待。 什么？ 根本没有数据点时，我们如何学习？ 在这种情况下，我们将没有数据点，但是将获得有关每个类的元信息，并且将从元信息中学习。 由于我们的数据集中有两个类别，即狗和猫，因此可以将其称为双向学习 *k* -shot learning； 因此 *n* -way 表示我们在数据集中拥有的类的数量。
+从较少的数据点中学习称为**少镜头学习**或`k`**-镜头学习**，其中`k`表示每个数据点的数量 数据集中的类。 假设我们正在对猫和狗进行图像分类。 如果我们正好有一只狗和一只猫的图像，那么它被称为**单次学习**，也就是说，我们每个班级仅从一个数据点开始学习。 如果我们有 10 张狗的图像和 10 张猫的图像，则称为 10 次学习。 因此， *k-* 镜头学习中的`k`意味着每个班级都有许多数据点。 还有**零击学习**，每个班级没有任何数据点。 等待。 什么？ 根本没有数据点时，我们如何学习？ 在这种情况下，我们将没有数据点，但是将获得有关每个类的元信息，并且将从元信息中学习。 由于我们的数据集中有两个类别，即狗和猫，因此可以将其称为双向学习`k`-shot learning； 因此`n`-way 表示我们在数据集中拥有的类的数量。

-为了使我们的模型从一些数据点中学习，我们将以相同的方式对其进行训练。 因此，当我们有一个数据集 *D* 时，我们从数据集中存在的每个类中采样一些数据点，并将其称为**支持集。** 同样，我们从每个类中采样一些不同的数据点，并将其称为**查询集。** 因此，我们使用支持集训练模型，并使用查询集进行测试。 我们以**情节形式**训练模型-也就是说，在每个情节中，我们从数据集中 *D* 中采样一些数据点，准备支持集和查询集，然后进行训练 在支持集上并在查询集上进行测试。 因此，在一系列情节中，我们的模型将学习如何从较小的数据集中学习。 我们将在接下来的章节中对此进行更详细的探讨。
+为了使我们的模型从一些数据点中学习，我们将以相同的方式对其进行训练。 因此，当我们有一个数据集`D`时，我们从数据集中存在的每个类中采样一些数据点，并将其称为**支持集。** 同样，我们从每个类中采样一些不同的数据点，并将其称为**查询集。** 因此，我们使用支持集训练模型，并使用查询集进行测试。 我们以**情节形式**训练模型-也就是说，在每个情节中，我们从数据集中`D`中采样一些数据点，准备支持集和查询集，然后进行训练 在支持集上并在查询集上进行测试。 因此，在一系列情节中，我们的模型将学习如何从较小的数据集中学习。 我们将在接下来的章节中对此进行更详细的探讨。

 # 元学习的类型

@@ -48,7 +48,7 @@

 现在，我们将看到一种有趣的元学习算法，称为学习通过梯度下降学习梯度下降。 这个名字不是很令人生畏吗？ 好吧，事实上，它是最简单的元学习算法之一。 我们知道，在元学习中，我们的目标是元学习过程。 通常，我们如何训练神经网络？ 我们通过计算损耗并通过梯度下降使损耗最小化来训练我们的网络。 因此，我们使用梯度下降来优化模型。 除了使用梯度下降，我们还能自动学习此优化过程吗？

-但是我们如何学习呢？ 我们用**递归神经网络**（ **RNN** ）取代了传统的优化器（梯度下降）。 但这如何工作？ 如何用 RNN 代替梯度下降？ 如果您仔细研究，我们在梯度下降中到底在做什么？ 这基本上是从输出层到输入层的一系列更新，我们将这些更新存储在一个状态中。 因此，我们可以使用 RNN 并将更新存储在 RNN 单元中。
+但是我们如何学习呢？ 我们用**递归神经网络**（**RNN**）取代了传统的优化器（梯度下降）。 但这如何工作？ 如何用 RNN 代替梯度下降？ 如果您仔细研究，我们在梯度下降中到底在做什么？ 这基本上是从输出层到输入层的一系列更新，我们将这些更新存储在一个状态中。 因此，我们可以使用 RNN 并将更新存储在 RNN 单元中。

 因此，该算法的主要思想是用 RNN 代替梯度下降。 但是问题是 RNN 如何学习？ 我们如何优化 RNN？ 为了优化 RNN，我们使用梯度下降。 **因此，简而言之，我们正在学习通过 RNN 执行梯度下降，并且 RNN 通过梯度下降进行了优化，这就是所谓的通过梯度下降学习梯度下降的名称。**

@@ -75,7 +75,7 @@

 因此，我们使用![](img/87eef6f8-65e0-47ea-ae13-ab5c09919322.png)更新了模型参数值。

-如下图所示，我们的优化器![](img/03b25ae6-ed75-49ff-9ed3-b03f6c6111ce.png)每次 *t* 处于隐藏状态![](img/9c3e7306-ddd7-46e6-884e-fc2f610ae3d2.png)，并且梯度![](img/451f86c5-2616-486f-95ee-bd434c6db4b3.png)作为![](img/55357743-14b7-478c-962b-ff8d1cec3e78.png)作为输入，计算![](img/c870b0b2-dbf7-46f8-b8f1-22a19f18c7a5.png)并将其发送到我们的优化器，然后在其中添加![](img/8cd0cc05-b03f-444a-8fff-faf4386945d7.png)，并在接下来的时间步骤中成为![](img/7fe07d7c-0ce0-4e6a-b591-38154d096708.png)进行更新：
+如下图所示，我们的优化器![](img/03b25ae6-ed75-49ff-9ed3-b03f6c6111ce.png)每次`t`处于隐藏状态![](img/9c3e7306-ddd7-46e6-884e-fc2f610ae3d2.png)，并且梯度![](img/451f86c5-2616-486f-95ee-bd434c6db4b3.png)作为![](img/55357743-14b7-478c-962b-ff8d1cec3e78.png)作为输入，计算![](img/c870b0b2-dbf7-46f8-b8f1-22a19f18c7a5.png)并将其发送到我们的优化器，然后在其中添加![](img/8cd0cc05-b03f-444a-8fff-faf4386945d7.png)，并在接下来的时间步骤中成为![](img/7fe07d7c-0ce0-4e6a-b591-38154d096708.png)进行更新：

 ![](img/b450d276-d3ef-408a-9a7d-aa3177d40e9c.png)

@@ -130,11 +130,11 @@

 假设我们有一个由![](img/46fb0ba6-818f-4315-926b-6c5502f897fa.png)参数化的基础网络![](img/96e5a664-2281-469b-bc8c-3a93da8a4d8a.png)和由![](img/6b477c6b-dca3-4a40-8c43-bf844d4acf51.png)参数化的 LSTM 元学习器![](img/781fbd22-771e-4aab-ae43-36cb517b8b74.png)。 假设我们有一个数据集![](img/3a868eff-e1e0-4800-b315-c3d89407a051.png)。 我们将数据集分为![](img/8ea53b48-98b0-4abc-ab06-ee1020fbbb7c.png)和![](img/7a42e349-bf47-41c9-a4e6-7295534d7473.png)分别进行训练和测试。 首先，我们随机初始化元学习器参数![](img/7f6407d1-42b8-4442-80e9-f09b2e884040.png)。

-对于某些 *T* 迭代次数，我们从![](img/8ea53b48-98b0-4abc-ab06-ee1020fbbb7c.png)中随机采样数据点，计算损失，然后相对于模型参数![](img/e3edc475-656e-4d41-bf0b-1a51a6078d03.png)计算损失的梯度。 现在，我们将此梯度，损失和元学习器参数![](img/4593a096-0a79-40bf-9e2a-2116c6d24062.png)输入到我们的元学习器。 我们的元学习器![](img/2a1edc09-a4d0-4fe1-8ec8-ecc85fc2356a.png)将返回单元状态![](img/28a759a2-3729-4b33-871c-d3be31207596.png)，然后我们将 *t* 的基础网络![](img/96e5a664-2281-469b-bc8c-3a93da8a4d8a.png)参数![](img/f17b6173-5f5b-467f-b3ed-5255f61ba7d4.png)更新为![](img/ade55668-74fb-4aaa-b834-8f66ee022488.png)。 我们重复 *N* 次，如下图所示：
+对于某些`T`迭代次数，我们从![](img/8ea53b48-98b0-4abc-ab06-ee1020fbbb7c.png)中随机采样数据点，计算损失，然后相对于模型参数![](img/e3edc475-656e-4d41-bf0b-1a51a6078d03.png)计算损失的梯度。 现在，我们将此梯度，损失和元学习器参数![](img/4593a096-0a79-40bf-9e2a-2116c6d24062.png)输入到我们的元学习器。 我们的元学习器![](img/2a1edc09-a4d0-4fe1-8ec8-ecc85fc2356a.png)将返回单元状态![](img/28a759a2-3729-4b33-871c-d3be31207596.png)，然后我们将`t`的基础网络![](img/96e5a664-2281-469b-bc8c-3a93da8a4d8a.png)参数![](img/f17b6173-5f5b-467f-b3ed-5255f61ba7d4.png)更新为![](img/ade55668-74fb-4aaa-b834-8f66ee022488.png)。 我们重复`N`次，如下图所示：

 ![](img/c85a3a23-876b-46aa-a6c1-6a2b664e0c2a.png)

-因此，在 *T* 次迭代之后，我们将获得一个最佳参数![](img/a864b10a-01ce-4acf-aa4a-2fbc72a0441e.png)。 但是，我们如何检查![](img/1e7893f9-7981-46e3-aac3-625c5d712452.png)的性能以及如何更新元学习器参数？ 我们采用测试集，并使用参数![](img/0b771654-d8fb-4b8f-8363-29c51d27d162.png)计算测试集的损耗。 然后，我们根据元学习器参数![](img/6b477c6b-dca3-4a40-8c43-bf844d4acf51.png)计算损耗的梯度，然后更新![](img/6b477c6b-dca3-4a40-8c43-bf844d4acf51.png)，如下所示：
+因此，在`T`次迭代之后，我们将获得一个最佳参数![](img/a864b10a-01ce-4acf-aa4a-2fbc72a0441e.png)。 但是，我们如何检查![](img/1e7893f9-7981-46e3-aac3-625c5d712452.png)的性能以及如何更新元学习器参数？ 我们采用测试集，并使用参数![](img/0b771654-d8fb-4b8f-8363-29c51d27d162.png)计算测试集的损耗。 然后，我们根据元学习器参数![](img/6b477c6b-dca3-4a40-8c43-bf844d4acf51.png)计算损耗的梯度，然后更新![](img/6b477c6b-dca3-4a40-8c43-bf844d4acf51.png)，如下所示：

 ![](img/7e4c2e2a-1fe8-47fe-ba23-096cf093cdc4.png)

@@ -144,7 +144,7 @@

 # 概要

-我们首先了解了元学习是什么，以及元学习中如何使用单发，少发和零发学习。 我们了解到，支持集和查询集更像是火车集和测试集，但每个类中都有 *k* 个数据点。 我们还看到了 *n* -方式 k 射击的含义。 后来，我们了解了不同类型的元学习技术。 然后，我们探索了通过梯度下降学习梯度下降的学习方法，其中我们看到了 RNN 如何用作优化器来优化基础网络。 后来，我们将优化视为快速学习的模型，其中我们使用 LSTM 作为元学习器，以在快速学习环境中进行优化。
+我们首先了解了元学习是什么，以及元学习中如何使用单发，少发和零发学习。 我们了解到，支持集和查询集更像是火车集和测试集，但每个类中都有`k`个数据点。 我们还看到了`n`-方式 k 射击的含义。 后来，我们了解了不同类型的元学习技术。 然后，我们探索了通过梯度下降学习梯度下降的学习方法，其中我们看到了 RNN 如何用作优化器来优化基础网络。 后来，我们将优化视为快速学习的模型，其中我们使用 LSTM 作为元学习器，以在快速学习环境中进行优化。

 在下一章中，我们将学习称为 Siamese 网络的基于度量的元学习算法，并且将了解如何使用 Siamese 网络执行面部和音频识别。


--- a/new/handson-meta-learn-py/02.md
+++ b/new/handson-meta-learn-py/02.md
@@ -12,7 +12,7 @@

 # 什么是连体网络？

-连体网络是神经网络的一种特殊类型，它是最简单且使用最广泛的单发学习算法之一。 正如我们在上一章中学到的，单次学习是一种技术，其中我们每个班级仅从一个训练示例中学习。 因此，在每个类别中没有很多数据点的应用程序中主要使用连体网络。 例如，假设我们要为我们的组织建立一个人脸识别模型，并且在组织中有大约 500 个人在工作。 如果我们想从头开始使用**卷积神经网络**（ **CNN** ）建立人脸识别模型，那么我们需要这 500 人中的许多人来训练网络并获得良好的图像 准确性。 但是显然，我们不会为这 500 个人提供很多图像，因此除非有足够的数据点，否则使用 CNN 或任何深度学习算法构建模型都是不可行的。 因此，在这种情况下，我们可以求助于复杂的单次学习算法，例如连体网络，该算法可以从更少的数据点进行学习。
+连体网络是神经网络的一种特殊类型，它是最简单且使用最广泛的单发学习算法之一。 正如我们在上一章中学到的，单次学习是一种技术，其中我们每个班级仅从一个训练示例中学习。 因此，在每个类别中没有很多数据点的应用程序中主要使用连体网络。 例如，假设我们要为我们的组织建立一个人脸识别模型，并且在组织中有大约 500 个人在工作。 如果我们想从头开始使用**卷积神经网络**（**CNN**）建立人脸识别模型，那么我们需要这 500 人中的许多人来训练网络并获得良好的图像 准确性。 但是显然，我们不会为这 500 个人提供很多图像，因此除非有足够的数据点，否则使用 CNN 或任何深度学习算法构建模型都是不可行的。 因此，在这种情况下，我们可以求助于复杂的单次学习算法，例如连体网络，该算法可以从更少的数据点进行学习。

 但是，连体网络如何工作？ 连体网络基本上由两个对称的神经网络组成，它们共享相同的权重和结构，并且都使用能量函数`E`最终结合在一起。 我们的连体网络的目标是了解两个输入值是相似还是相异。 假设我们有两个图像 **X <sub>1</sub>** 和`X2`，我们想了解两个图像是相似还是相异。

@@ -80,7 +80,7 @@

 ![](img/adbe22c0-decf-4c78-803e-dbd84d4ef58b.png)

-一旦我们将数据与它们的标签配对在一起，就可以训练我们的连体网络。 从图像对中，我们将一个图像馈入网络 A，将另一个图像馈入网络 B。这两个网络的作用仅仅是提取特征向量。 因此，我们使用具有 **rec** **固定线性单位**（ **ReLU** ）激活的两个卷积层来提取特征。 一旦了解了特征，就将来自两个网络的合成特征向量馈入能量函数，以测量相似度。 我们使用欧几里得距离作为我们的能量函数。 因此，我们通过提供图像对来训练我们的网络，以了解它们之间的语义相似性。 现在，我们将逐步看到这一点。
+一旦我们将数据与它们的标签配对在一起，就可以训练我们的连体网络。 从图像对中，我们将一个图像馈入网络 A，将另一个图像馈入网络 B。这两个网络的作用仅仅是提取特征向量。 因此，我们使用具有 **rec** **固定线性单位**（**ReLU**）激活的两个卷积层来提取特征。 一旦了解了特征，就将来自两个网络的合成特征向量馈入能量函数，以测量相似度。 我们使用欧几里得距离作为我们的能量函数。 因此，我们通过提供图像对来训练我们的网络，以了解它们之间的语义相似性。 现在，我们将逐步看到这一点。

 为了更好地理解，您可以检查完整的代码，该代码可以在 Jupyter Notebook 中找到，[并在此处进行解释](https://github.com/sudharsan13296/Hands-On-Meta-Learning-With-Python/blob/master/02.%20Face%20and%20Audio%20Recognition%20using%20Siamese%20Networks/2.4%20Face%20Recognition%20Using%20Siamese%20Network.ipynb)。

@@ -421,7 +421,7 @@ IPython.display.Audio("data/audio/Dogs/dog_barking_0.wav")
 IPython.display.Audio("data/audio/Cats/cat_13.wav")
 ```

-那么，如何将这些原始音频馈送到我们的网络？ 我们如何从原始音频中提取有意义的功能？ 众所周知，神经网络仅接受向量化输入，因此我们需要将音频转换为特征向量。 我们该怎么做？ 嗯，我们可以通过几种机制生成音频的嵌入。 这样的流行机制之一是**梅尔频率倒谱系数**（ **MFCC** ）。 MFCC 使用对数功率谱在频率的非线性梅尔尺度上的线性余弦变换来转换音频的短期功率谱。 要了解有关 MFCC 的更多信息，[请查看此不错的教程](http://practicalcryptography.com/miscellaneous/machine-learning/guide-mel-frequency-cepstral-coefficients-mfccs/)。
+那么，如何将这些原始音频馈送到我们的网络？ 我们如何从原始音频中提取有意义的功能？ 众所周知，神经网络仅接受向量化输入，因此我们需要将音频转换为特征向量。 我们该怎么做？ 嗯，我们可以通过几种机制生成音频的嵌入。 这样的流行机制之一是**梅尔频率倒谱系数**（**MFCC**）。 MFCC 使用对数功率谱在频率的非线性梅尔尺度上的线性余弦变换来转换音频的短期功率谱。 要了解有关 MFCC 的更多信息，[请查看此不错的教程](http://practicalcryptography.com/miscellaneous/machine-learning/guide-mel-frequency-cepstral-coefficients-mfccs/)。

 我们将使用`librosa`库中的 MFCC 函数来生成音频嵌入。 因此，我们定义了一个名为`audio2vector`的函数，该函数在给定音频文件的情况下返回音频嵌入：


--- a/new/handson-meta-learn-py/03.md
+++ b/new/handson-meta-learn-py/03.md
@@ -49,17 +49,17 @@

 原型网络的算法如下所示：

-1.  假设我们有数据集 *D* ，其中包含 *{（x <sub>1</sub> y <sub>1</sub> ），（x <sub>2</sub> ， y <sub>2</sub> ），...（x <sub>n</sub> ，y <sub>n</sub> ）}* 其中 *x* 是特征， *y* 是类别标签。
-2.  由于我们进行了间歇式训练，因此我们从数据集中 *D* 中随机抽取每个类别的 *n* 个数据点数，并准备了支持集 *S* 。
-3.  同样，我们选择 *n* 个数据点，并准备我们的查询集 *Q* 。
+1.  假设我们有数据集`D`，其中包含 *{（x <sub>1</sub> y <sub>1</sub> ），（x <sub>2</sub> ， y <sub>2</sub> ），...（x <sub>n</sub> ，y <sub>n</sub> ）}* 其中`x`是特征，`y`是类别标签。
+2.  由于我们进行了间歇式训练，因此我们从数据集中`D`中随机抽取每个类别的`n`个数据点数，并准备了支持集`S`。
+3.  同样，我们选择`n`个数据点，并准备我们的查询集`Q`。
 4.  我们使用嵌入函数 *f <sub>∅</sub>（）*来学习数据点在支持集中的嵌入。 嵌入功能可以是任何特征提取器，例如，用于图像的卷积网络和用于文本的 LSTM 网络。
 5.  一旦获得每个数据点的嵌入，就可以通过获取每个类下数据点的平均嵌入来计算每个类的原型：

 ![](img/4fc41dda-0243-4e99-9b90-d2f7e6f321a8.png)

 6.  同样，我们学习查询集嵌入。
-7.  我们计算查询集嵌入和类原型之间的欧几里德距离 *d* 。
-8.  我们通过在距离 *d* 上应用 softmax 来预测查询集类别的概率 *p <sub>∅</sub>（y = k | x）*：
+7.  我们计算查询集嵌入和类原型之间的欧几里德距离`d`。
+8.  我们通过在距离`d`上应用 softmax 来预测查询集类别的概率 *p <sub>∅</sub>（y = k | x）*：

 ![](img/b3e00903-8a06-4a64-a492-1cd538d442db.png)

@@ -387,7 +387,7 @@ for epoch in range(num_epochs):
 *   **半径分量：**如果我们使用协方差矩阵的半径分量，则我们的协方差矩阵的维数将为 1，因为半径只是一个整数。
 *   **对角分量**：如果我们使用协方差矩阵的对角分量，则我们的协方差矩阵的维数将与嵌入矩阵的维数相同。

-此外，我们使用协方差矩阵的逆矩阵来代替直接使用协方差矩阵。 我们可以使用以下任何一种方法将原始协方差矩阵转换为逆协方差矩阵。 令 *S <sub>原始</sub>* 为协方差矩阵， *S* 为逆协方差矩阵：
+此外，我们使用协方差矩阵的逆矩阵来代替直接使用协方差矩阵。 我们可以使用以下任何一种方法将原始协方差矩阵转换为逆协方差矩阵。 令 *S <sub>原始</sub>* 为协方差矩阵，`S`为逆协方差矩阵：

 *   *S = 1 + Softplus（S <sub>原始</sub>）*
 *   *S = 1 + S 型（S <sub>原始</sub>）*
@@ -492,7 +492,7 @@ elif inverse_transform_type == "other":

 ![](img/adf16b20-81b8-4cf0-a203-699da2707fd4.png)

-在该方程式中，![](img/46370dcd-e39e-4828-9304-9552d23ecaf6.png)是逆协方差矩阵的对角线，![](img/3d239ea2-586f-48aa-bb1f-d180b2231f60.png)表示嵌入，上标 *c* 表示类别。
+在该方程式中，![](img/46370dcd-e39e-4828-9304-9552d23ecaf6.png)是逆协方差矩阵的对角线，![](img/3d239ea2-586f-48aa-bb1f-d180b2231f60.png)表示嵌入，上标`c`表示类别。

 在为每个类计算原型之后，我们学习了查询点的嵌入。 令![](img/6e6803c0-fc44-4fe0-ba29-bb7be3d92971.png)为查询点的嵌入。 然后，我们计算查询点嵌入和类原型之间的距离，如下所示：

@@ -506,17 +506,17 @@ elif inverse_transform_type == "other":

 现在，我们将通过逐步了解它来更好地理解高斯原型网络：

-1.  假设我们有一个数据集， *D = {（（x <sub>1</sub> ，y <sub>1</sub> ，），（x <sub>2</sub> ，y <sub>2 [ <sub>i</sub> ，y <sub>i</sub> }}</sub>* ，其中 *x* 是特征， *y* 是标签。 假设我们有一个二进制标签，这意味着我们只有两个类， *0* 和 *1* 。 我们将对数据点 *D* 中的每个类进行随机抽样，而不用替换它们，并创建我们的支持集 *S* 。
-2.  同样，我们按类随机抽取数据点，然后创建查询集 *Q* 。
+1.  假设我们有一个数据集， *D = {（（x <sub>1</sub> ，y <sub>1</sub> ，），（x <sub>2</sub> ，y <sub>2 [ <sub>i</sub> ，y <sub>i</sub> }}</sub>* ，其中`x`是特征，`y`是标签。 假设我们有一个二进制标签，这意味着我们只有两个类，`0`和`1`。 我们将对数据点`D`中的每个类进行随机抽样，而不用替换它们，并创建我们的支持集`S`。
+2.  同样，我们按类随机抽取数据点，然后创建查询集`Q`。
 3.  我们会将支持集传递给我们的嵌入函数 *f（）*。 嵌入函数将为我们的支持集以及协方差矩阵生成嵌入。
 4.  我们计算协方差矩阵的逆。
 5.  我们如下计算支持集中每个类的原型：

 ![](img/242c7e0b-a5d4-4bb0-849b-135dc2ce6e66.png)

-在该等式中，![](img/5be43069-8bde-464f-8338-1f5d61e8f10c.png)是逆协方差矩阵的对角线，![](img/0d4938f7-97d6-479e-8158-a3b469a73000.png)表示支持集的嵌入，上标 *c* 表示类别。
+在该等式中，![](img/5be43069-8bde-464f-8338-1f5d61e8f10c.png)是逆协方差矩阵的对角线，![](img/0d4938f7-97d6-479e-8158-a3b469a73000.png)表示支持集的嵌入，上标`c`表示类别。

-6.  在计算支持集中每个类的原型之后，我们学习了查询集 *Q* 的嵌入。 假设 *x'*是查询点的嵌入。
+6.  在计算支持集中每个类的原型之后，我们学习了查询集`Q`的嵌入。 假设 *x'*是查询点的嵌入。
 7.  我们计算查询点嵌入与类原型的距离，如下所示：

 ![](img/53bbc979-6829-4074-a1c2-f8f227bbcda5.png)
@@ -531,17 +531,17 @@ elif inverse_transform_type == "other":

 考虑一下我们的数据集包含一些未标记数据点的情况：我们如何计算这些未标记数据点的类原型？

-假设我们有一个支持集![](img/799afc48-e234-444c-9fd3-d0fddf7cef2d.png)，其中 *x* 是要素， *y* 是标签，还有一个查询集![](img/dcd39ef8-0799-42f6-8633-9060b071cd55.png)。 伴随着这些，我们还有另外一个称为未标记集 *R* 的集合，在这里，我们只有未标记的例子![](img/29cb497c-f7e5-47a6-99a2-2dbc4cf34aa4.png)。
+假设我们有一个支持集![](img/799afc48-e234-444c-9fd3-d0fddf7cef2d.png)，其中`x`是要素，`y`是标签，还有一个查询集![](img/dcd39ef8-0799-42f6-8633-9060b071cd55.png)。 伴随着这些，我们还有另外一个称为未标记集`R`的集合，在这里，我们只有未标记的例子![](img/29cb497c-f7e5-47a6-99a2-2dbc4cf34aa4.png)。

 那么，我们该如何处理这个未标记的集呢？

-首先，我们将使用支持集中给出的所有示例来计算类原型。 接下来，我们使用软 k 均值并为 *R* 中的未标记示例分配类别-也就是说，我们通过计算类原型之间的欧式距离来为 *R 中的未标记示例分配类别 和未标记的示例。*
+首先，我们将使用支持集中给出的所有示例来计算类原型。 接下来，我们使用软 k 均值并为`R`中的未标记示例分配类别-也就是说，我们通过计算类原型之间的欧式距离来为 *R 中的未标记示例分配类别 和未标记的示例。*

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

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

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

 # 概要


--- a/new/handson-meta-learn-py/04.md
+++ b/new/handson-meta-learn-py/04.md
@@ -82,7 +82,7 @@

 # 损失函数

-关系网络的损失函数是什么？ 我们将使用**均方误差**（ **MSE** ）作为损失函数。 尽管这是一个分类问题，而 MSE 并不是分类问题的标准度量，但关系网络的作者表示，由于我们正在预测关系得分，因此可以将其视为回归问题。 尽管如此，对于基本事实，我们只能自动生成 *{0，1}* 目标。
+关系网络的损失函数是什么？ 我们将使用**均方误差**（**MSE**）作为损失函数。 尽管这是一个分类问题，而 MSE 并不是分类问题的标准度量，但关系网络的作者表示，由于我们正在预测关系得分，因此可以将其视为回归问题。 尽管如此，对于基本事实，我们只能自动生成 *{0，1}* 目标。

 因此，我们的损失函数可以表示为：

@@ -261,7 +261,7 @@ Episode 900: loss 0.250

 匹配网络是 Google 的 DeepMind 团队发布的另一种简单高效的一次性学习算法。 它甚至可以为数据集中未观察到的类生成标签。

-假设我们有一个支持集 *S，*，其中包含 *K* 示例作为![](img/7de9a941-8801-4363-ac4e-f9ae0c13a716.png)。 给定查询点（一个新的看不见的示例）![](img/9385cadf-442c-46da-b498-a613372648fc.png)时，匹配网络通过将其与支持集进行比较来预测![](img/f3d60daa-f8f6-4be2-b246-984bea7eb4e2.png)的类别。
+假设我们有一个支持集 *S，*，其中包含`K`示例作为![](img/7de9a941-8801-4363-ac4e-f9ae0c13a716.png)。 给定查询点（一个新的看不见的示例）![](img/9385cadf-442c-46da-b498-a613372648fc.png)时，匹配网络通过将其与支持集进行比较来预测![](img/f3d60daa-f8f6-4be2-b246-984bea7eb4e2.png)的类别。

 我们可以将其定义为![](img/d9ccc420-177f-4115-a8e1-7d65897c692a.png)，其中![](img/318eca5d-7d4f-4d93-828d-f0444520e952.png)是参数化神经网络，![](img/ed201434-5cfd-4a61-bdb5-ec02a9901af6.png)是查询点的预测类，![](img/d3aaea41-a25b-424c-a540-b245800d4613.png)和![](img/3755650d-21aa-4377-b997-5d69dbfa2ec9.png)是支持集。 ![](img/d9ccc420-177f-4115-a8e1-7d65897c692a.png)将返回![](img/d31b51a8-0ee8-494b-b91f-81873448c0c4.png)属于数据集中每个类别的概率。 然后，我们选择![](img/2af6be12-a8d4-4452-8df2-a5fec999a883.png)的类别作为可能性最高的类别。 但是，这到底如何工作？ 如何计算此概率？ 让我们现在看看。

@@ -410,7 +410,7 @@ class Matching_network():
        self.query_label = tf.placeholder(tf.int32, [None, ])
 ```

-假设我们的支持集和查询集包含图片。 在将此原始图像提供给嵌入函数之前，首先，我们将使用卷积网络从图像中提取特征，然后将支持集和查询集的提取特征提供给 *g* 的嵌入函数 和 *f* 。
+假设我们的支持集和查询集包含图片。 在将此原始图像提供给嵌入函数之前，首先，我们将使用卷积网络从图像中提取特征，然后将支持集和查询集的提取特征提供给`g`的嵌入函数 和`f`。

 因此，我们将定义一个名为`image_encoder`的函数，该函数用于对图像中的特征进行编码。 我们使用具有最大池化操作的四层卷积网络作为图像编码器：

@@ -438,7 +438,7 @@ class Matching_network():
        return tf.reshape(net, [-1, 1 * 1 * 64])
 ```

-现在，我们定义嵌入功能； 我们已经看到在*嵌入函数*部分中如何定义嵌入函数 *f* 和 *g* 。 因此，我们可以直接定义它们如下：
+现在，我们定义嵌入功能； 我们已经看到在*嵌入函数*部分中如何定义嵌入函数`f`和`g`。 因此，我们可以直接定义它们如下：

 ```py
 #embedding function for extracting support set embeddings
@@ -507,7 +507,7 @@ class Matching_network():
     g_embedding = self.g(support_set_image_encoded) 
 ```

-同样，我们还将使用嵌入函数 *f* 了解查询集的嵌入内容：
+同样，我们还将使用嵌入函数`f`了解查询集的嵌入内容：

 ```py
    f_embedding = self.f(query_image_encoded, g_embedding) 

--- 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 执行复制任务。

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

@@ -22,7 +22,7 @@ NTM 是一种有趣的算法，能够存储和检索内存中的信息。 NTM 
 NTM 的重要组成部分如下：

 *   **控制器**：这基本上是前馈神经网络或递归神经网络。 它从内存中读取和写入。
-*   **内存**：我们将在其中存储信息的存储矩阵或存储库，或简称为存储。 内存基本上是由内存单元组成的二维矩阵。 存储器矩阵包含 *N* 行和 *M* 列。 使用控制器，我们可以从内存中访问内容。 因此，控制器从外部环境接收输入，并通过与存储矩阵进行交互来发出响应。
+*   **内存**：我们将在其中存储信息的存储矩阵或存储库，或简称为存储。 内存基本上是由内存单元组成的二维矩阵。 存储器矩阵包含`N`行和`M`列。 使用控制器，我们可以从内存中访问内容。 因此，控制器从外部环境接收输入，并通过与存储矩阵进行交互来发出响应。
 *   **读写头**：读写头是包含必须从其读取和写入的存储器地址的指针。

 好的，但是我们如何从内存中访问信息？ 我们是否可以通过指定行索引和列索引来访问内存中的信息？ 我们可以。 但是问题在于，如果我们按索引访问信息，则无法使用梯度下降来训练 NTM，因为我们无法计算索引的梯度。 因此，NTM 的作者定义了使用控制器进行读写的模糊操作。 模糊操作将在某种程度上与内存中的所有元素进行交互。 基本上，它是一种关注机制，主要关注内存中对读/写很重要的特定位置，而忽略了对其他位置的关注。 因此，我们使用特殊的读取和写入操作来确定要聚焦在存储器上的哪个位置。 我们将在接下来的部分中探索更多有关读写操作的信息。
@@ -33,15 +33,15 @@ NTM 的重要组成部分如下：

 # 读取操作

-读取操作从内存中读取一个值。 但是，由于我们的存储矩阵中有许多存储块，我们需要选择从存储器中读取哪一个？ 这由权重向量确定。 权重向量指定内存中哪个区域比其他区域更重要。 我们使用一种注意力机制来获得该权重向量。 我们将在接下来的部分中进一步探讨如何精确计算此权重向量。 权重向量已归一化，这意味着其值的范围从零到一，并且值的总和等于一。 下图显示了长度的权重向量 *N* ：
+读取操作从内存中读取一个值。 但是，由于我们的存储矩阵中有许多存储块，我们需要选择从存储器中读取哪一个？ 这由权重向量确定。 权重向量指定内存中哪个区域比其他区域更重要。 我们使用一种注意力机制来获得该权重向量。 我们将在接下来的部分中进一步探讨如何精确计算此权重向量。 权重向量已归一化，这意味着其值的范围从零到一，并且值的总和等于一。 下图显示了长度的权重向量`N`：

 ![](img/53982af6-a5b7-4b34-bf95-f2fdb6fb121e.png)

-让我们用 *w <sub>t</sub>* 表示归一化权重向量，其中下标 *t，*表示时间， *w <sub>t</sub> （i ）*表示权重向量中的元素，其索引为 *i，*和时间 *t* ：
+让我们用 *w <sub>t</sub>* 表示归一化权重向量，其中下标 *t，*表示时间， *w <sub>t</sub> （i ）*表示权重向量中的元素，其索引为 *i，*和时间`t`：

 ![](img/3785fb36-a7c4-401d-a42f-9b505f26a800.png)

-我们的存储矩阵由 *N* 行和 *M* 列组成，如下图所示。 让我们将 *t* 时的存储矩阵表示为 *M <sub>t</sub>* ：
+我们的存储矩阵由`N`行和`M`列组成，如下图所示。 让我们将`t`时的存储矩阵表示为 *M <sub>t</sub>* ：

 ![](img/3f50d7d5-cd0c-4e69-b381-d1f21dbb1683.png)

@@ -53,7 +53,7 @@ NTM 的重要组成部分如下：

 ![](img/a274afdc-2759-43bc-8fe0-c3516401b0ab.png)

-如上图所示，我们具有 *N* 行和 *M* 列的存储矩阵，大小为 *N* 的权重向量包含 所有 *N* 个位置。 执行这两个的线性组合，我们得到长度为 *M* 的读取向量。
+如上图所示，我们具有`N`行和`M`列的存储矩阵，大小为`N`的权重向量包含 所有`N`个位置。 执行这两个的线性组合，我们得到长度为`M`的读取向量。

 # 写操作

@@ -67,7 +67,7 @@ NTM 的重要组成部分如下：

 即，![](img/f7d6e7e3-a785-47aa-ad6b-4f4a05fed752.png)。

-但这如何工作？ 仅当索引为 *i* 的权重元素和擦除元素都为 1 时，存储器中的特定元素才会被设置为 0，换言之，被擦除； 否则，它将保留自己的价值。 例如，查看下图。 首先，我们将权重向量![](img/3bbfa27c-00fd-429b-a740-87abdd4860b4.png)和擦除向量![](img/1b7b8f56-f4ca-4c6e-bf34-a1063b93351e.png)相乘：
+但这如何工作？ 仅当索引为`i`的权重元素和擦除元素都为 1 时，存储器中的特定元素才会被设置为 0，换言之，被擦除； 否则，它将保留自己的价值。 例如，查看下图。 首先，我们将权重向量![](img/3bbfa27c-00fd-429b-a740-87abdd4860b4.png)和擦除向量![](img/1b7b8f56-f4ca-4c6e-bf34-a1063b93351e.png)相乘：

 ![](img/367864fc-07bb-46fa-9d44-9331803a5ab7.png)

@@ -104,7 +104,7 @@ NTM 的重要组成部分如下：

 ![](img/05e054c0-4540-4830-9db1-359c3e2f2ba1.png)

-也就是说，密钥向量![](img/9e1cd03c-9808-4d5d-a46b-660b2558504c.png)和存储矩阵![](img/cb025cd6-4607-4512-be51-e5a9bb7372f8.png)之间的余弦相似度乘以密钥强度![](img/6927ea0a-bb10-4b95-a08b-467c6eb178c0.png)。 ![](img/a9ad52e5-2c92-4cbd-a981-b37f9382fadc.png)中的上标 *c* 表示它们是基于内容的权重。 代替直接使用它，我们对权重应用 softmax。 因此，我们的最终权重如下：
+也就是说，密钥向量![](img/9e1cd03c-9808-4d5d-a46b-660b2558504c.png)和存储矩阵![](img/cb025cd6-4607-4512-be51-e5a9bb7372f8.png)之间的余弦相似度乘以密钥强度![](img/6927ea0a-bb10-4b95-a08b-467c6eb178c0.png)。 ![](img/a9ad52e5-2c92-4cbd-a981-b37f9382fadc.png)中的上标`c`表示它们是基于内容的权重。 代替直接使用它，我们对权重应用 softmax。 因此，我们的最终权重如下：

 ![](img/a2609108-50cd-476d-b757-fe14244827f8.png)

@@ -661,7 +661,7 @@ MANN 使用一种称为最少最近访问的新寻址方案。 顾名思义，

 ![](img/c820a84a-3694-4a00-af7b-8442b29b3142.png)

-但是，与 NTM 不同，我们在这里不使用键强度![](img/34015b39-fbe2-4901-9e42-63bd1c13f7af.png)。 ![](img/b83f722d-0a81-46ed-ad74-81f2f7ffeddc.png)中的上标 *r* 表示它是读取的权重向量。 我们最终的权重向量是权重上的 softmax，即：
+但是，与 NTM 不同，我们在这里不使用键强度![](img/34015b39-fbe2-4901-9e42-63bd1c13f7af.png)。 ![](img/b83f722d-0a81-46ed-ad74-81f2f7ffeddc.png)中的上标`r`表示它是读取的权重向量。 我们最终的权重向量是权重上的 softmax，即：

 ![](img/72b85ed0-fa1d-43a9-a6e8-e275cf545633.png)

@@ -781,7 +781,7 @@ M_ = prev_M * tf.expand_dims(1\. - tf.one_hot(prev_indices[:, -1], self.memory_s

 我们看到了神经图灵机如何从内存中存储和检索信息，以及它如何使用不同的寻址机制（例如基于位置和基于内容的寻址）来读写信息。 我们还学习了如何使用 TensorFlow 实施 NTM 以执行复制任务。 然后，我们了解了 MANN 以及 MANN 与 NTM 的不同之处。 我们还了解了 MANN 如何使用最近最少使用的访问方法来克服 NTM 的缺点。

-在下一章中，我们将学习**模型不可知元学习**（ **MAML** ）以及如何在监督和强化学习环境中使用它。
+在下一章中，我们将学习**模型不可知元学习**（**MAML**）以及如何在监督和强化学习环境中使用它。

 # 问题


--- 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**）。

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

@@ -22,7 +22,7 @@ MAML 的基本思想是找到一个更好的初始参数，以便具有良好的

 在 MAML 中，我们尝试通过学习类似任务的分布来找到这些最佳权重。 因此，对于新任务，我们不必从随机初始化的权重开始，而是可以从最佳权重开始，这将花费较少的梯度步骤来达到收敛，并且不需要更多的数据点来进行训练。

-让我们简单地了解一下 MAML； 假设我们有三个相关任务： *T <sub>1</sub>* ， *T <sub>2</sub>* 和 *T <sub>3</sub>* 。 首先，我们随机初始化模型参数θ。 我们针对任务 *T <sub>1</sub>* 训练我们的网络。 然后，我们尝试通过梯度下降使损失 *L* 最小化。 通过找到最佳参数![](img/6ceb5cff-7e6a-4cdb-aa6a-a1ba6ba88da4.png)，我们将损失降至最低。 同样，对于任务 *T <sub> 2 </sub>* 和 *T <sub> 3，</sub>* ，我们将以随机初始化的模型参数θ开始，并最小化 通过梯度下降找到正确的参数集来降低损耗。 假设![](img/1d306d76-9f72-42f2-ac26-c7fff1febc33.png)和![](img/c520bed1-592c-4703-9463-23aded0b6320.png)是任务的最佳参数，分别是 *T <sub> 2 </sub>* 和 *T <sub> 3 </sub>* 。
+让我们简单地了解一下 MAML； 假设我们有三个相关任务： *T <sub>1</sub>* ， *T <sub>2</sub>* 和 *T <sub>3</sub>* 。 首先，我们随机初始化模型参数θ。 我们针对任务 *T <sub>1</sub>* 训练我们的网络。 然后，我们尝试通过梯度下降使损失`L`最小化。 通过找到最佳参数![](img/6ceb5cff-7e6a-4cdb-aa6a-a1ba6ba88da4.png)，我们将损失降至最低。 同样，对于任务 *T <sub> 2 </sub>* 和 *T <sub> 3，</sub>* ，我们将以随机初始化的模型参数θ开始，并最小化 通过梯度下降找到正确的参数集来降低损耗。 假设![](img/1d306d76-9f72-42f2-ac26-c7fff1febc33.png)和![](img/c520bed1-592c-4703-9463-23aded0b6320.png)是任务的最佳参数，分别是 *T <sub> 2 </sub>* 和 *T <sub> 3 </sub>* 。

 如下图所示，我们以随机初始化的参数θ开始每个任务，并通过为每个任务 *T []查找最佳参数![](img/a3a92659-0f83-4f2d-9541-216b0c3a832f.png)，![](img/818fb5dd-6d77-4129-a7e1-455e20dfbbbc.png)和![](img/352adb75-2cbf-4cd9-82be-53687d3668fb.png)来使损失最小化。 HTG4] 1* ， *T <sub> 2 </sub>* 和 *T <sub> 3 </sub>* 分别为：

@@ -40,7 +40,7 @@ MAML 的基本思想是找到一个更好的初始参数，以便具有良好的

 # MAML 算法

-现在，我们对 MAML 有了基本的了解，我们将详细探讨它。 假设我们有一个由[θ]参数化的模型 *f* ，即 *f <sub>θ</sub>（）-*，我们在任务上有一个分布 *p（ T）*。 首先，我们用一些随机值初始化参数θ。 接下来，我们从任务分配中抽样一些任务 *T <sub>i</sub>* ，即 *T <sub>i</sub> 〜p（T）* 。 假设我们采样了五个任务， *T = {T <sub>1</sub> ，T <sub>2</sub> ，T <sub>3</sub> ，T <sub>4</sub> ， T <sub>5</sub> }* ，然后，对于每个任务 *T <sub>i</sub>* ，我们对 *k* 数据点进行采样并训练模型。 我们通过计算损耗![](img/3d88d9b8-922d-4c47-be41-9aa01c0890d1.png)来做到这一点，并使用梯度下降来使损耗最小化，并找到使损耗最小的最佳参数集：
+现在，我们对 MAML 有了基本的了解，我们将详细探讨它。 假设我们有一个由[θ]参数化的模型`f`，即 *f <sub>θ</sub>（）-*，我们在任务上有一个分布 *p（ T）*。 首先，我们用一些随机值初始化参数θ。 接下来，我们从任务分配中抽样一些任务 *T <sub>i</sub>* ，即 *T <sub>i</sub> 〜p（T）* 。 假设我们采样了五个任务， *T = {T <sub>1</sub> ，T <sub>2</sub> ，T <sub>3</sub> ，T <sub>4</sub> ， T <sub>5</sub> }* ，然后，对于每个任务 *T <sub>i</sub>* ，我们对`k`数据点进行采样并训练模型。 我们通过计算损耗![](img/3d88d9b8-922d-4c47-be41-9aa01c0890d1.png)来做到这一点，并使用梯度下降来使损耗最小化，并找到使损耗最小的最佳参数集：

 ![](img/a353f3ca-1b7a-42e4-ade6-149f8bcef645.png)

@@ -89,22 +89,22 @@ MAML 非常擅长寻找最佳初始参数，对吗？ 现在，我们将看到

 现在，让我们一步一步地了解 MAML 如何在监督学习中使用：

-1.  假设我们有一个由参数θ参数化的模型 *f* ，并且在任务 *p（T）*上有分布。 首先，我们随机初始化模型参数θ。
+1.  假设我们有一个由参数θ参数化的模型`f`，并且在任务 *p（T）*上有分布。 首先，我们随机初始化模型参数θ。
 2.  我们从任务分配中抽取一些任务 *T <sub>i</sub>* ，即 *T <sub>i</sub> 〜p（T）*。 假设我们采样了三个任务，然后 *T = {T <sub>1</sub> ，T <sub>2</sub> ，T <sub>3</sub> }。*

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

 ![](img/037ef61e-e595-4eb7-8fd1-00f6fce23823.png) ![](img/259b87df-9fd2-430a-9a11-1718a717f16f.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)。
+现在，我们在![](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)。

 4.  **外循环**：我们在测试集（元训练集）中执行元优化-也就是说，在这里，我们尝试使测试集![](img/2f4b00f9-eb54-4e0e-97be-b475e472bc0e.png)中的损失最小化。 我们通过计算相对于上一步中计算出的最佳参数![](img/9a13cd53-4697-4c04-a7a0-bcb22352c8a3.png)的梯度来最小化损耗，并使用我们的测试集（元训练集）更新随机初始化的参数θ：

 ![](img/a3ffe590-934d-4652-9c3a-c1159b5bd84e.png)

-5.  对于 *n* 次迭代，我们重复步骤 2 到步骤 5。 下图为您提供了监督学习中的 MAML 概述：
+5.  对于`n`次迭代，我们重复步骤 2 到步骤 5。 下图为您提供了监督学习中的 MAML 概述：

 ![](img/3c683de1-98dc-46b2-903a-0c23d98a278d.png)

@@ -183,7 +183,7 @@ def __init__(self):
        self.num_tasks = 10
 ```

-以下是每个任务中需要的样本数量（即镜头数量）和数据点数量[ *k* ）：
+以下是每个任务中需要的样本数量（即镜头数量）和数据点数量[`k`）：

 ```py
        self.num_samples = 10
@@ -278,7 +278,7 @@ def __init__(self):
            meta_gradient = np.zeros(self.theta.shape)
 ```

-然后，我们对 *k* 个数据点进行采样，并准备用于元训练的测试集（元训练集），即![](img/9996d31b-a601-4a11-864a-3e1b2a258d92.png)：
+然后，我们对`k`个数据点进行采样，并准备用于元训练的测试集（元训练集），即![](img/9996d31b-a601-4a11-864a-3e1b2a258d92.png)：

 ```py
            for i in range(self.num_tasks):
@@ -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，我们尝试找到可在各个任务之间推广的最佳参数θ。

@@ -457,11 +457,11 @@ 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 <sub>y</sub> ， <sub>t</sub> ）*表示对状态`x`具有作用`a`的奖励 时间`t`和 *t = 1* 至`H`表示我们的时间步长，其中`H`是地平线-我们的最终时间步长。

-假设我们有一个由θ参数化的模型 *f* ，也就是 *f <sub>θ</sub>（）-*和任务的分布 *p（T）*。 首先，我们用一些随机值初始化参数θ。 接下来，我们从任务分布中抽样一些任务 *T <sub>i</sub>* ： *T <sub>i</sub> 〜p（T）*。
+假设我们有一个由θ参数化的模型`f`，也就是 *f <sub>θ</sub>（）-*和任务的分布 *p（T）*。 首先，我们用一些随机值初始化参数θ。 接下来，我们从任务分布中抽样一些任务 *T <sub>i</sub>* ： *T <sub>i</sub> 〜p（T）*。

-然后，对于每个任务，我们对 *k* 轨迹进行采样，并构建训练和测试集：![](img/e590c719-123b-47d3-ade9-8b029a120a29.png)。 我们的数据集基本上包含诸如观察和动作之类的轨迹信息。 通过执行梯度下降，我们将训练集![](img/053891aa-7ee7-4eea-b202-6e099579beb1.png)上的损耗降至最低，并找到最佳参数θ'：
+然后，对于每个任务，我们对`k`轨迹进行采样，并构建训练和测试集：![](img/e590c719-123b-47d3-ade9-8b029a120a29.png)。 我们的数据集基本上包含诸如观察和动作之类的轨迹信息。 通过执行梯度下降，我们将训练集![](img/053891aa-7ee7-4eea-b202-6e099579beb1.png)上的损耗降至最低，并找到最佳参数θ'：

 ![](img/8232779e-e0ae-4bc6-bf06-a8c6b7cae174.png)

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

 # 对抗式元学习

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

 # 固定 GSM

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

 现在，我们已经了解了什么是对抗性样本以及如何生成对抗性样本，我们将看到如何在元学习中使用这些对抗性样本。 我们使用干净样本和对抗样本训练元学习模型。 但是，需要使用对抗样本训练模型吗？ 它有助于我们找到鲁棒的模型参数θ。 干净样本和对抗样本均在算法的内部和外部循环中使用，并且同样有助于更新模型参数。 ADML 使用干净样本和对抗样本之间的这种变化的相关性来获得更好，更健壮的模型参数初始化，从而使我们的参数对对抗样本变得健壮，并且可以很好地推广到新任务。

-因此，当我们有任务分配 *p（T），*时，我们从任务分配中采样了一批任务 *T <sub>i</sub>* ，对于每个任务，我们 对 *k* 个数据点进行采样，并准备我们的训练和测试集。
+因此，当我们有任务分配 *p（T），*时，我们从任务分配中采样了一批任务 *T <sub>i</sub>* ，对于每个任务，我们 对`k`个数据点进行采样，并准备我们的训练和测试集。

 在 ADML 中，我们将训练集和测试集的干净样本和对抗样本采样为![](img/2cdd113e-7439-432d-8469-6d5014933ed9.png)，![](img/c4a103f2-f17b-4a6d-9a50-81514b88ac52.png)，![](img/0797f4ac-6973-43f0-8f00-e1d1fad9966a.png)和![](img/ef37ed36-19f5-48e0-982d-dc714c70372e.png)。

@@ -626,7 +626,7 @@ class ADML(object):
        self.num_tasks = 2
 ```

-我们初始化每个任务中需要的多个样本（即多个镜头）和多个数据点（ *k* ）：
+我们初始化每个任务中需要的多个样本（即多个镜头）和多个数据点（`k`）：

 ```py
        self.num_samples = 10
@@ -697,7 +697,7 @@ class ADML(object):
            for i in range(self.num_tasks):
 ```

-我们对 *k* 个数据点进行采样，并准备我们的训练数据。 首先，我们采样干净的数据点，即![](img/804ae1b1-b239-4c98-81c4-ad87aac36c23.png)：
+我们对`k`个数据点进行采样，并准备我们的训练数据。 首先，我们采样干净的数据点，即![](img/804ae1b1-b239-4c98-81c4-ad87aac36c23.png)：

 ```py
                XTrain_clean, YTrain_clean = sample_points(self.num_samples)
@@ -1030,16 +1030,16 @@ Sampling Next Batch of Tasks

 现在，让我们逐步了解 CAML 的工作原理：

-1.  假设我们有一个由参数θ参数化的模型 *f* ，并且在任务 *p（T）*上有分布。 首先，我们随机初始化模型参数θ。 我们还初始化了上下文参数*∅ <sub>0</sub> = 0* 。
+1.  假设我们有一个由参数θ参数化的模型`f`，并且在任务 *p（T）*上有分布。 首先，我们随机初始化模型参数θ。 我们还初始化了上下文参数*∅ <sub>0</sub> = 0* 。
 2.  现在，我们从任务分配中抽样一些任务 *T <sub>i</sub>* ，即 *T <sub>i</sub> 〜p（T）* 。

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

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

 ![](img/d8c2040c-3280-4bc7-ab30-e71b3122a7c5.png)

-现在，我们将上下文参数设置为 *0* ：
+现在，我们将上下文参数设置为`0`：

 ![](img/4a3e6241-1225-4448-a074-cda1923b5af7.png)

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

 ![](img/8678f5bc-f53e-4588-955b-c1f3ba3d1763.png)

-5.  对 *n* 次迭代重复步骤 2 到步骤 4。
+5.  对`n`次迭代重复步骤 2 到步骤 4。

 # 概要


--- a/new/handson-meta-learn-py/07.md
+++ b/new/handson-meta-learn-py/07.md
@@ -13,7 +13,7 @@

 # 元 SGD

-假设我们有一些任务 *T* 。 我们使用通过某些参数![](img/5c20a779-c9f4-4e11-9a82-68fe83c02e3e.png)参数化的模型![](img/9670d018-0d08-4017-a549-49379d263198.png)，并训练模型以最大程度地减少损失。 我们使用梯度下降使损失最小化，并找到模型的最佳参数![](img/9a6aa57a-7f18-47ab-aa8e-282e95c99006.png)。
+假设我们有一些任务`T`。 我们使用通过某些参数![](img/5c20a779-c9f4-4e11-9a82-68fe83c02e3e.png)参数化的模型![](img/9670d018-0d08-4017-a549-49379d263198.png)，并训练模型以最大程度地减少损失。 我们使用梯度下降使损失最小化，并找到模型的最佳参数![](img/9a6aa57a-7f18-47ab-aa8e-282e95c99006.png)。

 让我们回想一下梯度下降的更新规则：

@@ -37,7 +37,7 @@

 但是有什么区别呢？ 此处![](img/0c9c227e-7c5b-4467-bb45-3c16d494b0dd.png)不仅是一个标量小值，而且是一个向量。 我们以与![](img/4ad95f85-44b6-4852-92c9-9f18e95b7505.png)相同的形状随机初始化![](img/9b62f32c-e348-45ba-80e5-445d1dbff951.png)。我们将![](img/43ea5798-8854-4051-854b-e48591f816fa.png)称为初始参数，将![](img/43e72daa-a973-4a68-9b65-6e6d748adcc8.png)称为自适应项。 因此，自适应项![](img/69f916a6-cf0f-4282-9e58-3aa2b23a2f0c.png)表示更新方向，其长度成为学习率。 我们在![](img/7519efe9-9038-4cb5-8b3f-a44b2dba9c9b.png)方向而不是在梯度方向![](img/6eea2d49-e2db-4b57-9f63-6b34580768bc.png)上更新我们的值，并且在自适应项中隐式地实现了我们的学习率。

-因此，在 Meta-SGD 中，我们不会使用较小的标量值来初始化学习率![](img/ec484259-3736-4c6f-a6f7-20fb53fe5075.png)。 相反，我们使用与![](img/ee550292-f8a9-4069-9207-0474131d4115.png)相同形状的随机值来初始化学习率，并与![](img/ee550292-f8a9-4069-9207-0474131d4115.png)一起学习它们。 我们采样了一些任务，并且对于每个任务，我们采样了一些 *k* 数据点，并使用梯度下降使损失最小化，但是我们的更新方程式变为：
+因此，在 Meta-SGD 中，我们不会使用较小的标量值来初始化学习率![](img/ec484259-3736-4c6f-a6f7-20fb53fe5075.png)。 相反，我们使用与![](img/ee550292-f8a9-4069-9207-0474131d4115.png)相同形状的随机值来初始化学习率，并与![](img/ee550292-f8a9-4069-9207-0474131d4115.png)一起学习它们。 我们采样了一些任务，并且对于每个任务，我们采样了一些`k`数据点，并使用梯度下降使损失最小化，但是我们的更新方程式变为：

 ![](img/9d597f2d-4624-40a2-ae28-031223f68120.png)

@@ -58,7 +58,7 @@
 1.  假设我们有一个由参数![](img/9cf0ec88-a60c-4bf2-af61-49661212585c.png)参数化的模型![](img/7f4f3094-62fc-4b94-878a-3627b1f6e078.png)，并且在任务![](img/1c9b8667-e8ea-4ee5-aa0a-ccaaea4be325.png)上有一个分布。 首先，我们随机初始化模型参数![](img/e16783f5-e10a-419a-b478-7a8ac4f2d225.png)，并随机初始化![](img/98a33218-adb9-4ac6-8f52-388c828f6230.png)形状与![](img/e16783f5-e10a-419a-b478-7a8ac4f2d225.png)相同的形状。

 2.  我们从任务分配中抽样一些任务![](img/222a8a7f-fba4-4725-be33-385a056f6bb0.png)：![](img/81894e55-9002-43ab-a57b-8068d1a6953f.png)。 假设我们已经采样了三个任务，然后是![](img/0e17b1e3-e48a-4b01-b1d2-d6992a0c521b.png)。
-3.  **内循环**：对于任务（![](img/7526f902-17e6-4a57-97ac-5220ec3e548d.png)）中的每个任务（![](img/668bc816-145e-484e-8fce-52ffa0a46513.png)），我们对 *k* 数据点进行采样，并准备训练和测试数据集：
+3.  **内循环**：对于任务（![](img/7526f902-17e6-4a57-97ac-5220ec3e548d.png)）中的每个任务（![](img/668bc816-145e-484e-8fce-52ffa0a46513.png)），我们对`k`数据点进行采样，并准备训练和测试数据集：

 ![](img/43092ce7-fca2-4bc4-9d78-bc9c03d11d46.png)

@@ -66,7 +66,7 @@

 现在，我们在![](img/a8afb953-fc65-4a5c-b264-9eb11dd52860.png)上应用了一种监督学习算法，使用梯度下降法计算并最小化了损失，并获得了最佳参数![](img/6f074b7c-44b9-420d-b5df-f6f54b8abb93.png)：![](img/bd5ccd0b-c4a6-42c9-b238-a9360a2e008e.png)。

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

@@ -74,7 +74,7 @@

 ![](img/dfaf2f2a-37a7-40d5-aa03-98dd38e140d8.png)

-5.  对于 *n* 次迭代，我们重复步骤 2 到步骤 4。
+5.  对于`n`次迭代，我们重复步骤 2 到步骤 4。

 # 从头开始构建 Meta-SGD

@@ -192,13 +192,13 @@ class MetaSGD(object):
           for i in range(self.num_tasks):
 ```

-我们对 *k* 个数据点进行采样，并准备训练集：
+我们对`k`个数据点进行采样，并准备训练集：

 ```py
                XTrain, YTrain = sample_points(self.num_samples)
 ```

-然后，我们使用单层网络预测 *y* 的值：
+然后，我们使用单层网络预测`y`的值：

 ```py
                a = np.matmul(XTrain, self.theta)
@@ -230,13 +230,13 @@ class MetaSGD(object):
            for i in range(self.num_tasks):
 ```

-我们对 *k* 个数据点进行采样，并准备用于元训练![](img/766a1f45-c58c-455f-9f73-80d44ade283f.png)的测试集：
+我们对`k`个数据点进行采样，并准备用于元训练![](img/766a1f45-c58c-455f-9f73-80d44ade283f.png)的测试集：

 ```py
                XTest, YTest = sample_points(10)
 ```

-然后，我们预测 *y* 的值：
+然后，我们预测`y`的值：

 ```py
                a = np.matmul(XTest, self.theta_[i])
@@ -420,13 +420,13 @@ Sampling Next Batch of Tasks

 ![](img/b3f712f9-4eb4-4484-94d3-2143b9f88b95.png)

-5.  对于 *n* 次迭代，我们重复步骤 2 到步骤 4。
+5.  对于`n`次迭代，我们重复步骤 2 到步骤 4。

 # 爬虫

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

@@ -449,16 +449,16 @@ Sampling Next Batch of Tasks
 爬行动物是一种简单而有效的算法。 爬行动物可以实现串行和批处理版本。 在串行版本中，我们仅从任务分发中抽样一个任务，而在批处理版本中，我们对一批任务进行抽样并尝试找到最佳参数。 我们将看到 Reptile 的串行版本如何工作。 爬行动物所涉及的步骤顺序如下：

 1.  假设我们有任务![](img/1024a056-8186-4c04-96dd-c60de2fd985b.png)的分布，并且我们随机初始化模型参数![](img/91b92f8b-de9b-42fc-866c-4aef6f620f33.png)。
-2.  现在我们从任务分配![](img/a7a4e492-c505-4001-bd7c-48007efbf0f1.png)中抽取任务 *T* 。
-3.  对于采样的任务![](img/74294e6f-18cf-4fe3-9c4b-befd244b225b.png)，我们对 *k* 个数据点进行采样，并准备我们的数据集 *D：* ![](img/9a665997-81e6-4ef5-8350-1f65d5f05d82.png)。 我们的数据集基本上包含 *x* 特征和 *y* 标签。 现在，我们通过对某些 *n* 迭代次数执行随机梯度下降来最大程度地减少数据集中的损失。 在对采样任务 *T，*执行 *n* 次迭代的 SGD 之后，我们将获得最佳参数![](img/0cdf1434-1ce7-4a95-9b2b-fba9f7385576.png)。
+2.  现在我们从任务分配![](img/a7a4e492-c505-4001-bd7c-48007efbf0f1.png)中抽取任务`T`。
+3.  对于采样的任务![](img/74294e6f-18cf-4fe3-9c4b-befd244b225b.png)，我们对`k`个数据点进行采样，并准备我们的数据集 *D：* ![](img/9a665997-81e6-4ef5-8350-1f65d5f05d82.png)。 我们的数据集基本上包含`x`特征和`y`标签。 现在，我们通过对某些`n`迭代次数执行随机梯度下降来最大程度地减少数据集中的损失。 在对采样任务 *T，*执行`n`次迭代的 SGD 之后，我们将获得最佳参数![](img/0cdf1434-1ce7-4a95-9b2b-fba9f7385576.png)。
 4.  我们在更接近先前步骤中获得的最佳参数![](img/141894b2-a04b-437c-9c95-5d5383e843db.png)的方向上更新了随机初始化的参数![](img/b4401cb9-039f-41b0-8fc8-1e763d8a62ea.png)如下：![](img/2b8e090c-d4e8-4fa2-8944-112842f649a5.png)。
-5.  对于 *n* 迭代次数，我们重复步骤 2 到步骤 4。
+5.  对于`n`迭代次数，我们重复步骤 2 到步骤 4。

 # 使用爬行动物进行正弦波回归

 在上一节中，我们了解了爬行动物的工作原理。 现在，我们将从头开始对 Reptile 进行编码，从而更好地理解它。 假设我们有一个任务集合，每个任务的目标是在给定一些输入的情况下使正弦波的输出回归。 那是什么意思呢？

-假设 *y =幅度* sin（x + phase）*。 我们算法的目标是学习在给定 *x* 的情况下对 *y* 的值进行回归。 幅度的值在 0.1 到 5.0 之间随机选择，相位的值在 0 到![](img/21218cec-890b-4d1e-bca2-5f739aa42d55.png)之间随机选择。 因此，对于每个任务，我们仅采样 10 个数据点并训练网络-也就是说，对于每个任务，我们仅采样 10 个*（x，y）*对。 让我们看一下代码并详细查看它。
+假设 *y =幅度* sin（x + phase）*。 我们算法的目标是学习在给定`x`的情况下对`y`的值进行回归。 幅度的值在 0.1 到 5.0 之间随机选择，相位的值在 0 到![](img/21218cec-890b-4d1e-bca2-5f739aa42d55.png)之间随机选择。 因此，对于每个任务，我们仅采样 10 个数据点并训练网络-也就是说，对于每个任务，我们仅采样 10 个*（x，y）*对。 让我们看一下代码并详细查看它。

 [您还可以在此处查看 Jupyter Notebook 中提供的代码，并提供说明](https://github.com/sudharsan13296/Hands-On-Meta-Learning-With-Python/blob/master/07.%20Meta-SGD%20and%20Reptile%20Algorithms/7.7%20Sine%20wave%20Regression%20Using%20Reptile.ipynb)。

@@ -607,7 +607,7 @@ with tf.Session() as sess:
            old_w1, old_b1, old_w2, old_b2 = sess.run([w1, b1, w2, b2,])
 ```

-然后，我们对 *x* 和 *y* 进行采样：
+然后，我们对`x`和`y`进行采样：

 ```py
            x_sample, y_sample = sample_points(num_samples)

--- a/new/handson-meta-learn-py/08.md
+++ b/new/handson-meta-learn-py/08.md
@@ -47,7 +47,7 @@

 ![](img/bf3a2201-8469-4802-8e8b-1a77b6c35ad8.png)

-假设我们抽样了一批任务。 然后，对于批处理中的每个任务，我们对 *k* 个数据点进行采样，计算损失，更新梯度，并找到每个任务的最佳参数![](img/0e057c74-bf55-427f-80f8-ad8f9c980161.png)。 与此同时，我们还将每个任务的梯度更新向量存储在![](img/d3270793-e1ed-4c1b-9cf5-0749201fb690.png)中。 可以计算为![](img/885389fb-9c2a-4a41-9600-270f46c23850.png)。
+假设我们抽样了一批任务。 然后，对于批处理中的每个任务，我们对`k`个数据点进行采样，计算损失，更新梯度，并找到每个任务的最佳参数![](img/0e057c74-bf55-427f-80f8-ad8f9c980161.png)。 与此同时，我们还将每个任务的梯度更新向量存储在![](img/d3270793-e1ed-4c1b-9cf5-0749201fb690.png)中。 可以计算为![](img/885389fb-9c2a-4a41-9600-270f46c23850.png)。

 因此，![](img/db1dd637-56c6-490d-85ef-047f78be9815.png)任务的权重是![](img/af4e2919-4e2b-47f7-9060-12e4f5b1b242.png)和![](img/6c387c39-bc77-4e18-88f0-48060009e4d3.png)的内积之和除以归一化因子。 归一化因子与![](img/d2497d95-29c0-40d4-8073-ccda9852f5d2.png)和![](img/a7fa1fc1-556f-40dd-af23-15f759a7dca7.png)的内积成正比。

@@ -80,7 +80,7 @@ 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)

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

 与此同时，我们还将梯度更新向量存储为：![](img/931d62e5-10ae-41ee-bac0-841f7c7237e0.png)。

-因此，对于每个任务，我们对 *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)。
+因此，对于每个任务，我们对`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.  **外循环：**现在，在执行元优化之前，我们将按以下方式计算权重：

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

 ![](img/9460948f-613a-4058-b2b7-674db9b719bc.png)

-5.  对于 *n* 次迭代，我们重复步骤 2 至 5。
+5.  对于`n`次迭代，我们重复步骤 2 至 5。

 # 使用 MAML 构建梯度一致性算法

@@ -209,7 +209,7 @@ class GradientAgreement_MAML(object):
            for i in range(self.num_tasks):
 ```

-我们对 *k* 个数据点进行采样，并准备我们的火车组![](img/5de96cd5-ee46-4140-9dc7-cfe42401d367.png)：
+我们对`k`个数据点进行采样，并准备我们的火车组![](img/5de96cd5-ee46-4140-9dc7-cfe42401d367.png)：

 ```py
                XTrain, YTrain = sample_points(self.num_samples)
@@ -269,7 +269,7 @@ class GradientAgreement_MAML(object):
            weighted_gradient = np.zeros(self.theta.shape)
 ```

-对于任务数量，我们对 *k* 个数据点进行采样，并准备测试集![](img/594ea09a-7bac-45ee-a809-9421fd932510.png)：
+对于任务数量，我们对`k`个数据点进行采样，并准备测试集![](img/594ea09a-7bac-45ee-a809-9421fd932510.png)：

 ```py
            for i in range(self.num_tasks):

--- 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)

@@ -56,13 +56,13 @@

 ![](img/4837d9cf-809d-4be2-8c73-c12293eb7b75.png)

-因此，对于每个任务，我们对 *k* 个数据点进行采样，准备火车数据集，最大程度地减少损失，并获得最佳参数。 由于我们采样了三个任务，因此我们将拥有三个最佳参数：![](img/de966d2a-a176-4b36-a6c9-4c928e2a3a35.png)。
+因此，对于每个任务，我们对`k`个数据点进行采样，准备火车数据集，最大程度地减少损失，并获得最佳参数。 由于我们采样了三个任务，因此我们将拥有三个最佳参数：![](img/de966d2a-a176-4b36-a6c9-4c928e2a3a35.png)。

 4.  **外循环**：我们执行元优化。 在这里，我们尝试将元训练集![](img/9dde3f06-abe2-4303-a505-a94eb4017a07.png)的损失降到最低。 我们通过计算相对于最佳参数![](img/ce7470af-d88a-44fd-ace8-73d294dcea1f.png)的梯度来最小化损耗，并更新随机初始化的参数![](img/540af493-facf-4dd2-ac10-fe1ff5fbe181.png)； 与此同时，我们将添加熵项。 因此，我们最终的元目标变为：

 ![](img/a72d7d87-f941-421f-91ca-4f53cabe1474.png)

-5.  对于 *n* 次迭代，我们重复步骤 2 至 4。
+5.  对于`n`次迭代，我们重复步骤 2 至 4。

 # 不平等最小化

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

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

 ![](img/ff9be565-f478-4bfc-b3ec-38271235a9c2.png)

-因此，对于每个任务，我们对 *k* 个数据点进行采样，准备火车数据集，最大程度地减少损失，并获得最佳参数。 由于我们采样了三个任务，因此我们将拥有三个最佳参数-![](img/ad5ca2f5-3b9b-4896-9752-5da6e27b1681.png)。
+因此，对于每个任务，我们对`k`个数据点进行采样，准备火车数据集，最大程度地减少损失，并获得最佳参数。 由于我们采样了三个任务，因此我们将拥有三个最佳参数-![](img/ad5ca2f5-3b9b-4896-9752-5da6e27b1681.png)。

 4.  **外循环**：现在，我们执行元优化。 在这里，我们尝试使训练集![](img/ccaa8c2b-480b-4fcf-a962-f82fd363bbba.png)的损失最小化。 我们通过计算相对于最佳参数![](img/4ad97e1f-c0a1-4f40-b2a6-9ac9968a5e03.png)的梯度来最小化损耗，并更新随机初始化的参数![](img/6239621b-d5be-4ea4-b7ad-d4f027cf412c.png)； 与此同时，我们将添加熵项。 因此，我们最终的元目标变为：

 ![](img/40971ffd-4f20-4f81-875b-0210f012fa71.png)

-5.  对于 *n* 次迭代，我们重复步骤 2 至 4。
+5.  对于`n`次迭代，我们重复步骤 2 至 4。

 # 元模仿学习

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

 但是模仿学习并不像听起来那样简单。 机器人将花费大量时间和演示来学习目标并确定正确的策略。 因此，我们将以演示（训练数据）的先验经验丰富机器人，从而不必完全从头学习每种技能。 增强机器人的先验经验有助于其快速学习。 因此，要学习多种技能，我们需要为每种技能收集演示-也就是说，我们需要为机器人添加特定于任务的演示数据。

-但是，如何使我们的机器人从单个演示中快速学习一项任务呢？ 我们可以在这里使用元学习吗？ 我们可以重用演示数据并从几个相关任务中学习以快速学习新任务吗？ 因此，我们将元学习和模仿学习相结合，形成**元模仿学习**（ **MIL** ）。 借助 MIL，我们可以利用其他各种任务的演示数据，仅需一个演示就可以快速学习新任务。 因此，我们仅需演示一个新任务就可以找到正确的策略。
+但是，如何使我们的机器人从单个演示中快速学习一项任务呢？ 我们可以在这里使用元学习吗？ 我们可以重用演示数据并从几个相关任务中学习以快速学习新任务吗？ 因此，我们将元学习和模仿学习相结合，形成**元模仿学习**（**MIL**）。 借助 MIL，我们可以利用其他各种任务的演示数据，仅需一个演示就可以快速学习新任务。 因此，我们仅需演示一个新任务就可以找到正确的策略。

 对于 MIL，我们可以使用我们已经看到的任何元学习算法。 我们将使用 MAML 作为元学习算法，该算法与可以通过梯度下降训练的任何算法兼容，并且将使用策略梯度作为找到正确策略的算法。 在策略梯度中，我们使用某些参数![](img/4c09345a-d68c-473f-aeaf-d7cf2fc0ba08.png)直接优化参数化策略![](img/86a2f626-a0c6-4686-b066-44e96bdb0c88.png)。

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

 ![](img/23c259ec-0245-4c0b-846f-d9d902a53025.png)

-5.  对 *n* 次迭代重复步骤 2 到 4。
+5.  对`n`次迭代重复步骤 2 到 4。

 # 仙人掌

@@ -173,15 +173,15 @@ MIL 中涉及的步骤如下：

 为每个数据点生成嵌入后，我们如何找到它们的标签？ 天真的和简单的方法是将我们的数据集![](img/efb551d7-c112-4992-b003-1dd78cc551e8.png)划分为具有某些随机超平面的![](img/86c57502-6afc-49c1-9c87-a2600c9e32bd.png)分区，然后我们可以将数据集的每个这些分区子集视为一个单独的类。

-但是这种方法的问题在于，由于我们使用的是随机超平面，因此我们的类可能包含完全不同的嵌入，并且还将相关的嵌入保留在不同的类中。 因此，我们可以使用聚类算法来代替使用随机超平面对数据集进行分区。 我们使用 k 均值聚类作为我们的聚类算法来划分数据集。 我们对多个迭代运行 k-means 聚类，并获得 *k* 聚类（分区）。
+但是这种方法的问题在于，由于我们使用的是随机超平面，因此我们的类可能包含完全不同的嵌入，并且还将相关的嵌入保留在不同的类中。 因此，我们可以使用聚类算法来代替使用随机超平面对数据集进行分区。 我们使用 k 均值聚类作为我们的聚类算法来划分数据集。 我们对多个迭代运行 k-means 聚类，并获得`k`聚类（分区）。

-我们可以将每个群集视为一个单独的类。 下一个是什么？ 我们如何生成任务？ 假设由于集群，我们有五个集群。 我们从这五个群集中采样 *n* 个群集。 然后，我们从每个 *n* 簇中抽取 *r* 数据点，而无需替换； 这可以表示为![](img/6a9e5f14-0445-4602-ac00-d0df3e5e36e4.png)。 之后，我们对 n 个单任务特定标签![](img/00168235-d01e-4cbe-8fee-3546881db321.png)进行了排列，以为 n 个采样聚类的每一个分配标签。 因此，现在我们有一个数据点![](img/6a9e5f14-0445-4602-ac00-d0df3e5e36e4.png)和一个标签![](img/00168235-d01e-4cbe-8fee-3546881db321.png)。
+我们可以将每个群集视为一个单独的类。 下一个是什么？ 我们如何生成任务？ 假设由于集群，我们有五个集群。 我们从这五个群集中采样`n`个群集。 然后，我们从每个`n`簇中抽取`r`数据点，而无需替换； 这可以表示为![](img/6a9e5f14-0445-4602-ac00-d0df3e5e36e4.png)。 之后，我们对 n 个单任务特定标签![](img/00168235-d01e-4cbe-8fee-3546881db321.png)进行了排列，以为 n 个采样聚类的每一个分配标签。 因此，现在我们有一个数据点![](img/6a9e5f14-0445-4602-ac00-d0df3e5e36e4.png)和一个标签![](img/00168235-d01e-4cbe-8fee-3546881db321.png)。

-最后，我们可以将任务 *T* 定义为![](img/63421732-5fd9-40a0-ac04-cd0eb01560d7.png)。
+最后，我们可以将任务`T`定义为![](img/63421732-5fd9-40a0-ac04-cd0eb01560d7.png)。

 # 学习在概念空间中学习

-现在，我们将看到如何使用深度元学习在概念空间中元学习。 首先，我们如何进行元学习？ 我们在每个任务中抽样一批相关任务和一些 *k* 数据点，并训练我们的元学习者。 我们可以将深度学习的力量与元学习结合起来，而不仅仅是使用我们的原始元学习技术进行培训。 因此，当我们对一批任务以及每个任务中的一些 *k* 数据点进行采样时，我们将使用深度神经网络学习每个 *k* 数据点的表示形式，然后 对这些表示进行元学习。
+现在，我们将看到如何使用深度元学习在概念空间中元学习。 首先，我们如何进行元学习？ 我们在每个任务中抽样一批相关任务和一些`k`数据点，并训练我们的元学习者。 我们可以将深度学习的力量与元学习结合起来，而不仅仅是使用我们的原始元学习技术进行培训。 因此，当我们对一批任务以及每个任务中的一些`k`数据点进行采样时，我们将使用深度神经网络学习每个`k`数据点的表示形式，然后 对这些表示进行元学习。

 我们的框架包含三个组件：

@@ -262,9 +262,9 @@ MIL 中涉及的步骤如下：
 ![](img/76b2ce9c-02ba-48f5-ab5a-1368c500918c.png)

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

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

 # 概要


--- a/new/handson-meta-learn-py/10.md
+++ b/new/handson-meta-learn-py/10.md
@@ -3,20 +3,20 @@
 # 第 1 章：元学习简介

 1.  元学习产生了一种通用的 AI 模型，该模型可以学习执行各种任务，而无需从头开始进行培训。 我们使用几个数据点在各种相关任务上训练我们的元学习模型，因此对于新的但相关的任务，该模型可以利用从先前任务中学到的知识而不必从头开始进行训练。
-2.  从更少的数据点学习称为**少镜头学习**或 **k 镜头学习**，其中 *k* 表示在每个类别中数据点的数量 数据集。
-3.  为了使我们的模型从一些数据点中学习，我们将以相同的方式对其进行训练。 因此，当我们有一个数据集 *D* 时，我们从数据集中存在的每个类中采样一些数据点，并将其称为支持集。
+2.  从更少的数据点学习称为**少镜头学习**或 **k 镜头学习**，其中`k`表示在每个类别中数据点的数量 数据集。
+3.  为了使我们的模型从一些数据点中学习，我们将以相同的方式对其进行训练。 因此，当我们有一个数据集`D`时，我们从数据集中存在的每个类中采样一些数据点，并将其称为支持集。
 4.  我们从与支持集不同的每个类中采样不同的数据点，并将其称为查询集。
 5.  在基于度量的元学习设置中，我们将学习适当的度量空间。 假设我们要找出两个图像之间的相似性。 在基于度量的设置中，我们使用一个简单的神经网络，该网络从两个图像中提取特征并通过计算这两个图像的特征之间的距离来查找相似性。
-6.  我们以**情景式**训练模型； 也就是说，在每个情节中，我们从数据集 *D* 中采样一些数据点，并准备我们的支持集并在支持集上学习。 因此，在一系列事件中，我们的模型将学习如何从较小的数据集中学习。
+6.  我们以**情景式**训练模型； 也就是说，在每个情节中，我们从数据集`D`中采样一些数据点，并准备我们的支持集并在支持集上学习。 因此，在一系列事件中，我们的模型将学习如何从较小的数据集中学习。

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

-1.  连体网络是神经网络的一种特殊类型，它是最简单，最常用的单次学习算法之一。 连体网络基本上由两个对称的神经网络组成，它们具有相同的权重和架构，并最终通过能量函数 *E* 结合在一起。
+1.  连体网络是神经网络的一种特殊类型，它是最简单，最常用的单次学习算法之一。 连体网络基本上由两个对称的神经网络组成，它们具有相同的权重和架构，并最终通过能量函数`E`结合在一起。
 2.  The contrastive loss function can be expressed as follows: 

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

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

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

@@ -53,7 +53,7 @@
 1.  NTM 是一种有趣的算法，能够存储和检索内存中的信息。 NTM 的想法是通过外部存储器来增强神经网络-也就是说，它不是使用隐藏状态作为存储器，而是使用外部存储器来存储和检索信息。
 2.  控制器基本上是前馈神经网络或递归神经网络。 它从内存读取和写入。
 3.  读头和写头是包含其必须读取和写入的内存地址的指针。
-4.  内存矩阵或内存库，或者简称为内存，是我们存储信息的地方。 内存基本上是由内存单元组成的二维矩阵。 内存矩阵包含 *N* 行和 *M* 列。 使用控制器，我们可以从内存中访问内容。 因此，控制器从外部环境接收输入，并通过与存储矩阵进行交互来发出响应。
+4.  内存矩阵或内存库，或者简称为内存，是我们存储信息的地方。 内存基本上是由内存单元组成的二维矩阵。 内存矩阵包含`N`行和`M`列。 使用控制器，我们可以从内存中访问内容。 因此，控制器从外部环境接收输入，并通过与存储矩阵进行交互来发出响应。
 5.  基于位置的寻址和基于内容的寻址是 NTM 中使用的不同类型的寻址机制。

 6.  插值门用于决定是否应使用上一时间步获得的权重![](img/4d019a10-dd88-4397-9657-bfda92442c2e.png)或使用通过基于内容的寻址获得的权重![](img/0cf1683e-10a9-4409-a114-4a9aec56b0db.png)。

--- a/new/handson-rl-py/01.md
+++ b/new/handson-rl-py/01.md
 # 强化学习导论

-强化学习（ **RL** ）是机器学习的一个分支，其中学习是通过与环境交互来进行的。 这是面向目标的学习，不教导学习者采取什么行动； 相反，学习者从其行动的结果中学习。 随着各种算法的迅速发展，它是**人工智能**（ **AI** ）中最活跃的研究领域之一。
+强化学习（**RL**）是机器学习的一个分支，其中学习是通过与环境交互来进行的。 这是面向目标的学习，不教导学习者采取什么行动； 相反，学习者从其行动的结果中学习。 随着各种算法的迅速发展，它是**人工智能**（**AI**）中最活跃的研究领域之一。

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

@@ -75,7 +75,7 @@ RL 的元素在以下各节中显示。

 # 代理环境接口

-代理是指一次执行 *A* <sub class="calibre24">*t*</sub> ，， *t* 移动的动作的软件代理。 从一种状态 *S* <sub class="calibre24">*t*</sub> ，到另一种状态 *S* <sub class="calibre24">*t + 1*</sub> 。 基于行为，特工从环境中获得数值奖励 *R* 。 最终，RL 就是寻找可以增加数值奖励的最佳行动：
+代理是指一次执行`A`<sub class="calibre24">`t`</sub> ，，`t`移动的动作的软件代理。 从一种状态`S`<sub class="calibre24">`t`</sub> ，到另一种状态`S`<sub class="calibre24">*t + 1*</sub> 。 基于行为，特工从环境中获得数值奖励`R`。 最终，RL 就是寻找可以增加数值奖励的最佳行动：

 ![](img/00008.gif)

@@ -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
 # OpenAI 和 TensorFlow 入门

-OpenAI 是由 Elon Musk 和 Sam Altman 创立的非营利性，开源**人工智能**（ **AI** ）研究公司，旨在构建通用 AI。 他们是由顶级行业领导者和顶尖公司赞助的。 OpenAI 具有 Gym 和 Universe 两种样式，我们可以使用它们模拟现实环境，构建**强化学习**（ **RL** ）算法，并在这些环境中测试我们的代理。 TensorFlow 是 Google 的开源机器学习库，已广泛用于数值计算。 在接下来的章节中，我们将使用 OpenAI 和 TensorFlow 来构建和评估强大的 RL 算法。
+OpenAI 是由 Elon Musk 和 Sam Altman 创立的非营利性，开源**人工智能**（**AI**）研究公司，旨在构建通用 AI。 他们是由顶级行业领导者和顶尖公司赞助的。 OpenAI 具有 Gym 和 Universe 两种样式，我们可以使用它们模拟现实环境，构建**强化学习**（**RL**）算法，并在这些环境中测试我们的代理。 TensorFlow 是 Google 的开源机器学习库，已广泛用于数值计算。 在接下来的章节中，我们将使用 OpenAI 和 TensorFlow 来构建和评估强大的 RL 算法。

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


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

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

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

@@ -32,7 +32,7 @@

 ![](img/00093.jpeg)

-让我们考虑一个圆的半径是一半，而正方形的边是 *1* ，因此我们可以替换为：
+让我们考虑一个圆的半径是一半，而正方形的边是`1`，因此我们可以替换为：

 ![](img/00094.jpeg)

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

 # 蒙特卡洛预测

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

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

-值函数基本上是状态 *S* 与策略*π*的预期收益。 在这里，我们使用均值回报代替预期回报。
+值函数基本上是状态`S`与策略*π*的预期收益。 在这里，我们使用均值回报代替预期回报。

 因此，在蒙特卡洛预测中，我们通过取均值回报而不是期望回报来近似值函数。

@@ -339,7 +339,7 @@ states, _, rewards = generate_episode(policy, env)
 returns = 0
 ```

-2.  然后，对于每个步骤，我们将奖励存储到变量 *R* 中，并声明为 *S* ，然后将收益计算为奖励总和：
+2.  然后，对于每个步骤，我们将奖励存储到变量`R`中，并声明为`S`，然后将收益计算为奖励总和：

 ```py
 for t in range(len(states) - 1, -1, -1):
@@ -497,7 +497,7 @@ plot_blackjack(value, axes[0], axes[1])

 估计动作值比估计状态值更直观，因为状态值根据我们选择的策略而变化。 例如，在二十一点游戏中，假设我们处于某些纸牌为 20 的状态。该状态的价值是什么？ 这完全取决于政策。 如果我们选择政策作为命中目标，那将不是一个好的状态，而且此状态的价值非常低。 但是，如果我们选择我们的政策作为立场，那肯定是一个好的国家。因此，国家的价值取决于我们选择的政策。 因此，估计操作的值而不是状态的值更为重要。

-我们如何估算作用值？ 还记得我们在第 3 章，“马尔可夫决策过程和动态规划”中学习的 *Q* 函数吗？ 表示为 *Q（s，a）*的 *Q* 函数用于确定特定状态下的动作有多好。 它基本上指定了状态-动作对。
+我们如何估算作用值？ 还记得我们在第 3 章，“马尔可夫决策过程和动态规划”中学习的`Q`函数吗？ 表示为 *Q（s，a）*的`Q`函数用于确定特定状态下的动作有多好。 它基本上指定了状态-动作对。

 但是，这里出现了探索的问题。如果我们还没有处于状态状态值，我们如何知道状态状态值？ 如果我们不采取所有可能的措施探索所有州，我们可能会错过丰厚的回报。

@@ -507,11 +507,11 @@ plot_blackjack(value, axes[0], axes[1])

 MC-ES 算法非常简单，如下所示：

-*   我们首先使用一些随机值初始化 *Q* 函数和策略，然后我们初始化返回到空列表的过程
+*   我们首先使用一些随机值初始化`Q`函数和策略，然后我们初始化返回到空列表的过程
 *   然后，我们以随机初始化的策略开始
 *   然后，我们计算该情节中发生的所有唯一状态操作对的收益，并将收益附加到我们的收益清单中
 *   我们只为唯一的状态-动作对计算返回值，因为同一状态-动作对多次出现在情节中，并且没有多余的信息点
-*   然后，我们对返回列表中的返回值取平均值，然后将该值分配给我们的 *Q* 函数
+*   然后，我们对返回列表中的返回值取平均值，然后将该值分配给我们的`Q`函数

 *   最后，我们将为一个状态选择一个最佳策略，为该状态选择具有最大 *Q（s，a）*的操作
 *   我们将永久重复整个过程，或者重复进行多次，以便涵盖所有不同的状态和动作对
@@ -568,36 +568,36 @@ def epsilon_greedy_policy(state, epsilon):
 3.  我们使用随机策略π生成情节。
 4.  我们将情节中发生的每个状态操作对的返回存储到返回列表中。

-5.  然后，我们对返回列表中的返回值取平均值，然后将该值分配给 *Q* 函数。
-6.  现在，由ε决定由状态 *s* 选择动作*和*的可能性。
-7.  如果概率为 1-ε，我们将选择最大 *Q* 值的动作。
+5.  然后，我们对返回列表中的返回值取平均值，然后将该值分配给`Q`函数。
+6.  现在，由ε决定由状态`s`选择动作*和*的可能性。
+7.  如果概率为 1-ε，我们将选择最大`Q`值的动作。
 8.  如果概率为ε，我们将探索不同的动作。

 # 脱离政策的蒙特卡洛控制

 非政策性蒙特卡洛是另一种有趣的蒙特卡洛控制方法。 在这种方法中，我们有两种策略：一种是行为策略，另一种是目标策略。 在非策略方法中，代理遵循一项策略，但与此同时，它会尝试学习和改进另一种策略。 代理遵循的策略称为行为策略，代理尝试评估和改进的策略称为目标策略。 行为与目标策略完全无关。 行为策略探索所有可能的状态和动作，这就是为什么将行为策略称为软策略，而将目标策略称为贪心策略（它选择具有最大值的策略）的原因。

-我们的目标是为目标策略π估计 *Q* 函数，但我们的代理使用完全不同的策略（称为行为策略![](img/00106.jpeg)）进行操作。 我们现在能做什么？ 我们可以通过使用![](img/00108.jpeg)中发生的常见事件来估计![](img/00107.jpeg)的值。 我们如何估算这两个政策之间的共同点？ 我们使用一种称为重要性抽样的新技术。 这是一种在给定来自另一个分布的样本的情况下从一个分布估计值的技术。
+我们的目标是为目标策略π估计`Q`函数，但我们的代理使用完全不同的策略（称为行为策略![](img/00106.jpeg)）进行操作。 我们现在能做什么？ 我们可以通过使用![](img/00108.jpeg)中发生的常见事件来估计![](img/00107.jpeg)的值。 我们如何估算这两个政策之间的共同点？ 我们使用一种称为重要性抽样的新技术。 这是一种在给定来自另一个分布的样本的情况下从一个分布估计值的技术。

 重要抽样有两种类型：

 *   普通重要性抽样
 *   加权重要性抽样

-在普通重要性抽样中，我们基本上采用行为策略和目标策略获得的收益之比，而在加权重要性抽样中，我们采用加权平均值，而 *C* 是权重的累加和。
+在普通重要性抽样中，我们基本上采用行为策略和目标策略获得的收益之比，而在加权重要性抽样中，我们采用加权平均值，而`C`是权重的累加和。

 让我们一步一步看一下：

-1.  首先，我们将 *Q（s，a）*初始化为随机值，并将 *C（s，a）*初始化为 *0* ，权重 *w* 为 *1* 。
-2.  然后我们选择目标策略，这是一个贪婪策略。 这意味着它将从 *Q* 表中选取具有最大值的策略。
+1.  首先，我们将 *Q（s，a）*初始化为随机值，并将 *C（s，a）*初始化为`0`，权重`w`为`1`。
+2.  然后我们选择目标策略，这是一个贪婪策略。 这意味着它将从`Q`表中选取具有最大值的策略。

 3.  我们选择行为政策。 行为策略不是贪婪的，它可以选择任何状态-行为对。
 4.  然后，我们开始我们的情节，并根据我们的行为政策在*或*状态下执行*和*动作，并存储奖励。 我们重复此操作直到情节结束。
 5.  现在，对于情节中的每个州，我们执行以下操作：
-    1.  我们将计算回报 *G* 。 我们知道回报是折扣奖励的总和： *G =折扣因子* G +奖励*。
+    1.  我们将计算回报`G`。 我们知道回报是折扣奖励的总和： *G =折扣因子* G +奖励*。
    2.  然后我们将 *C（s，a）*更新为 *C（s，a）= C（s，a）+ w。*
    3.  我们更新 *Q（s，a）*：![](img/00109.jpeg)。
-    4.  我们更新 *w* ：![](img/00110.jpeg)的值。
+    4.  我们更新`w`：![](img/00110.jpeg)的值。

 # 概要


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

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

 在本章中，您将学习：

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

 # TD 学习

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

 # TD 预测

@@ -28,7 +28,7 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo 

 你注意到了吗？ 由于我们将实际值和预测值之差作为![](img/00114.jpeg)，因此实际上是一个错误。 我们可以称其为 TD 错误。 在多次迭代中，我们将尝试最小化此错误。

-让我们通过前面几章中的冰湖示例来了解 TD 预测。 接下来显示的是冰冻的湖泊环境。 首先，对于所有状态，我们将值函数初始化为 *0* ，就像在 *V（S）*中将其初始化为 *0* 一样，如以下状态值图所示 ：
+让我们通过前面几章中的冰湖示例来了解 TD 预测。 接下来显示的是冰冻的湖泊环境。 首先，对于所有状态，我们将值函数初始化为`0`，就像在 *V（S）*中将其初始化为`0`一样，如以下状态值图所示 ：

 ![](img/00115.jpeg)

@@ -76,10 +76,10 @@ 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* ，直到达到终端状态
+4.  重复步骤`3`和`4`，直到达到终端状态

 # TD 控制

@@ -90,21 +90,21 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo 

 # Q 学习

-现在，我们将研究称为 Q 学习的非常流行的非政策性 TD 控制算法。 Q 学习是一种非常简单且广泛使用的 TD 算法。 在控制算法中，我们不在乎状态值。 在这里，在 Q 学习中，我们关心的是状态-动作值对-在状态 *S* 下执行动作 *A* 的效果。
+现在，我们将研究称为 Q 学习的非常流行的非政策性 TD 控制算法。 Q 学习是一种非常简单且广泛使用的 TD 算法。 在控制算法中，我们不在乎状态值。 在这里，在 Q 学习中，我们关心的是状态-动作值对-在状态`S`下执行动作`A`的效果。

-我们将根据以下公式更新 *Q* 值：
+我们将根据以下公式更新`Q`值：

 ![](img/00121.jpeg)

 前面的公式与 TD 预测更新规则相似，只是有一点点差异。 我们将逐步详细介绍这一点。 Q 学习涉及的步骤如下：

-1.  首先，我们将 *Q* 函数初始化为一些任意值
+1.  首先，我们将`Q`函数初始化为一些任意值
 2.  我们使用 epsilon-greedy 策略（![](img/00122.jpeg)）从某个州采取了一项行动，并将其移至新的州
-3.  我们通过遵循更新规则来更新先前状态的 *Q* 值：
+3.  我们通过遵循更新规则来更新先前状态的`Q`值：

 ![](img/00123.jpeg)

-4.  重复步骤 *2* 和 *3* ，直到达到终端状态
+4.  重复步骤`2`和`3`，直到达到终端状态

 现在，我们将使用不同的步骤来理解算法。

@@ -116,21 +116,21 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo 

 ![](img/00125.jpeg)

-现在，我们已经对状态**（3,2）**执行了向下操作，并使用 epsilon-greedy 策略达到了新状态**（4,2）**，我们如何更新 使用我们的更新规则的先前状态**（3,2）**的值？ 这很简单。 查看 *Q* 表，如下所示：
+现在，我们已经对状态**（3,2）**执行了向下操作，并使用 epsilon-greedy 策略达到了新状态**（4,2）**，我们如何更新 使用我们的更新规则的先前状态**（3,2）**的值？ 这很简单。 查看`Q`表，如下所示：

 ![](img/00126.jpeg)

-让我们将 alpha 视为 *0.1* ，并将折现因子视为 *1* ：
+让我们将 alpha 视为 *0.1* ，并将折现因子视为`1`：

 ![](img/00127.jpeg)

 *Q（（3,2）下）= Q（（3,2），下）+ 0.1（0.3 +1 最大[Q（（4,2）作用）]-Q（（3,2）， 下）*

-我们可以说具有向下作用的状态**（3,2）**的值，例如 *Q（（3,2），向下）*的值为 **0.8** *Q* 表中的]。
+我们可以说具有向下作用的状态**（3,2）**的值，例如 *Q（（3,2），向下）*的值为 **0.8**`Q`表中的]。

 状态**（4,2）**的最大值 *Q（（4,2），操作）*是什么？ 我们仅研究了三个动作（**向上**，**向下**和右**正确**），因此我们将仅基于这些动作来获取最大值。 （此处，我们将不执行 epsilon 贪婪策略；我们仅选择具有最大值的操作。）

-因此，基于先前的 *Q* 表，我们可以将值替换为：
+因此，基于先前的`Q`表，我们可以将值替换为：

 *Q（（3,2），向下）= 0.8 + 0.1（0.3 + 1 max [0.3，0.5，0.8]-0.8）*

@@ -150,7 +150,7 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo 

 *Q（（4,2），right）= Q（（4,2），right）+ 0.1（0.3 +1 max [Q（（4,3）action）]-Q（（4,2） ，右）*

-如果您查看下面的 *Q* 表，对于状态**（4,3）**，我们仅探讨了两个操作（**向上**和**向下**），因此我们仅根据这些操作得出最大值。 （这里，我们将不执行 epsilon-greedy 策略；我们只选择具有最大值的操作）：
+如果您查看下面的`Q`表，对于状态**（4,3）**，我们仅探讨了两个操作（**向上**和**向下**），因此我们仅根据这些操作得出最大值。 （这里，我们将不执行 epsilon-greedy 策略；我们只选择具有最大值的操作）：

 *Q（（4,2），右）= Q（（4,2），右）+ 0.1（0.3 +1 max [（Q（4,3），上），（Q（4,3） ，down）]-Q（（4,2），right）*

@@ -160,13 +160,13 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo 

 = 0.78

-查看下面的 *Q* 表：
+查看下面的`Q`表：

 ![](img/00129.jpeg)

 现在我们将状态 *Q（（4,2），right）*的值更新为 *0.78* 。

-因此，这就是我们在 Q 学习中获得状态作用值的方式。 为了决定采取什么行动，我们使用 epsilon-greedy 策略，并在更新 *Q* 值时，我们只选择最大的行动； 这是流程图：
+因此，这就是我们在 Q 学习中获得状态作用值的方式。 为了决定采取什么行动，我们使用 epsilon-greedy 策略，并在更新`Q`值时，我们只选择最大的行动； 这是流程图：

 ![](img/00130.gif)

@@ -214,7 +214,7 @@ for s in range(env.observation_space.n):
        q[(s,a)] = 0.0
 ```

-我们将通过 Q 学习更新规则定义用于更新 Q 表的函数； 如果您看下面的函数，您将看到我们采取的状态/动作对具有最大值的动作并将其存储在`qa`变量中。 然后，我们通过更新规则更新先前状态的 *Q* 值，如下所示：
+我们将通过 Q 学习更新规则定义用于更新 Q 表的函数； 如果您看下面的函数，您将看到我们采取的状态/动作对具有最大值的动作并将其存储在`qa`变量中。 然后，我们通过更新规则更新先前状态的`Q`值，如下所示：

 ![](img/00132.jpeg)

@@ -339,21 +339,21 @@ env.close()

 # 萨尔萨

-**状态-动作-奖励-状态-动作**（ **SARSA** ）是一种策略上的 TD 控制算法。 就像我们在 Q 学习中所做的一样，这里我们也关注状态-动作值，而不是状态-值对。 在 SARSA 中，我们根据以下更新规则更新 Q 值：
+**状态-动作-奖励-状态-动作**（**SARSA**）是一种策略上的 TD 控制算法。 就像我们在 Q 学习中所做的一样，这里我们也关注状态-动作值，而不是状态-值对。 在 SARSA 中，我们根据以下更新规则更新 Q 值：

 ![](img/00133.jpeg)

 在前面的等式中，您可能会注意到，没有最大的 *Q（s'，a'）*，就像在 Q 学习中一样。 这里只是 *Q（s'，a'）*。 我们可以通过执行一些步骤来详细了解这一点。 SARSA 涉及的步骤如下：

-1.  首先，我们将 *Q* 值初始化为一些任意值
+1.  首先，我们将`Q`值初始化为一些任意值
 2.  我们通过 epsilon-greedy 策略（![](img/00134.jpeg)）选择一个动作，然后从一种状态转移到另一种状态
-3.  我们遵循更新规则![](img/00135.jpeg)来更新 *Q* 值的先前状态，其中 *a'*是由ε贪婪策略（![](img/00136.jpeg)）选择的操作
+3.  我们遵循更新规则![](img/00135.jpeg)来更新`Q`值的先前状态，其中 *a'*是由ε贪婪策略（![](img/00136.jpeg)）选择的操作

 现在，我们将逐步了解算法。 让我们考虑相同的冰冻湖的例子。 假设我们处于**（4,2）**状态。 我们根据 epsilon-greedy 政策决定采取的措施。 假设我们使用概率为 1- epsilon 并选择最佳操作，即**对**：

 ![](img/00137.jpeg)

-现在，我们在状态**（4,2）**下执行了**右**动作之后，就处于**（4,3）**状态。 我们如何更新先前状态**（4,2）**的值？ 让我们将 alpha 设为 *0.1* ，将奖励设为 *0.3* 和折扣系数 *1* ：
+现在，我们在状态**（4,2）**下执行了**右**动作之后，就处于**（4,3）**状态。 我们如何更新先前状态**（4,2）**的值？ 让我们将 alpha 设为 *0.1* ，将奖励设为 *0.3* 和折扣系数`1`：

 ![](img/00138.jpeg)


--- a/new/handson-rl-py/06.md
+++ b/new/handson-rl-py/06.md
 # 多武装强盗问题

-在前面的章节中，我们学习了**强化学习**（ **RL** ）的基本概念和几种 RL 算法，以及如何将 RL 问题建模为 **Markov Decision 处理**（ **MDP** ）。 我们还看到了用于解决 MDP 的不同的基于模型和无模型的算法。 在本章中，我们将看到 RL 中的经典问题之一，称为**多臂匪**（ **MAB** ）问题。 我们将看到什么是 MAB 问题，以及如何使用不同的算法解决该问题，然后了解如何使用 MAB 识别将接收大部分点击的正确广告横幅。 我们还将学习广泛用于构建推荐系统的上下文强盗。
+在前面的章节中，我们学习了**强化学习**（**RL**）的基本概念和几种 RL 算法，以及如何将 RL 问题建模为 **Markov Decision 处理**（**MDP**）。 我们还看到了用于解决 MDP 的不同的基于模型和无模型的算法。 在本章中，我们将看到 RL 中的经典问题之一，称为**多臂匪**（**MAB**）问题。 我们将看到什么是 MAB 问题，以及如何使用不同的算法解决该问题，然后了解如何使用 MAB 识别将接收大部分点击的正确广告横幅。 我们还将学习广泛用于构建推荐系统的上下文强盗。

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

@@ -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 <sub class="calibre24">t</sub>* ，即从投币游戏机中拉出一条手臂并获得奖励 *r <sub class="calibre24">t</sub>* <sub class="calibre24">和</sub>，我们代理商的目标是使累积奖励最大化。

 我们将手臂 *Q（a）*的值定义为通过拉动手臂获得的平均奖励：

@@ -31,7 +31,7 @@ MAB 如下所示：

 ![](img/00145.jpeg)

-我们代理人的目标是找到最佳手臂，并最大程度地减少后悔，这可以定义为了解 *k* 哪个手臂是最佳手臂的代价。 现在，我们如何找到最好的手臂？ 我们应该探索所有武器还是选择已经给予我们最大累积奖励的武器？ 这就是勘探与开发的困境。 现在，我们将看到如何使用以下各种探索策略来解决这个难题：
+我们代理人的目标是找到最佳手臂，并最大程度地减少后悔，这可以定义为了解`k`哪个手臂是最佳手臂的代价。 现在，我们如何找到最好的手臂？ 我们应该探索所有武器还是选择已经给予我们最大累积奖励的武器？ 这就是勘探与开发的困境。 现在，我们将看到如何使用以下各种探索策略来解决这个难题：

 *   厄普西隆贪婪政策
 *   Softmax 探索
@@ -211,7 +211,7 @@ The optimal arm is 3

 # 置信区间上限算法

-通过 epsilon-greedy 和 softmax 探索，我们以概率探索了随机动作。 随机动作对于探索各种武器很有用，但也可能导致我们尝试无法给我们带来丰厚回报的动作。 我们也不想错过实际上是好的武器，但在最初的回合中却给出了差的奖励。 因此，我们使用一种称为**上置信界上限**（ **UCB** ）的新算法。 它基于面对不确定性时称为乐观的原则。
+通过 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 的机器进行探索。

@@ -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`武器的平均回报，也就是说，我们从*每个武器中提取`n`个样本 ] k* 武装并计算`k`分布。 这些初始分布将与真实分布不同，因此我们将其称为先验分布：

 ![](img/00155.gif)

@@ -316,7 +316,7 @@ The optimal arm is 1

 现在，我们将看到 TS 如何帮助我们选择最佳手臂。 TS 中涉及的步骤如下：

-1.  从每个 *k* 分布中采样一个值，并将该值用作先验平均值。
+1.  从每个`k`分布中采样一个值，并将该值用作先验平均值。
 2.  选择具有最高先验均值的手臂并观察奖励。
 3.  使用观察到的奖励来修改先前的分配。


--- a/new/handson-rl-py/07.md
+++ b/new/handson-rl-py/07.md
 # 深度学习基础

-到目前为止，我们已经了解了**强化学习**（ **RL** ）的工作原理。 在接下来的章节中，我们将学习**深度强化学习**（ **DRL** ），它是深度学习和 RL 的结合。 DRL 在 RL 社区引起了很多关注，并且对解决许多 RL 任务产生了严重影响。 要了解 DRL，我们需要在深度学习方面有坚实的基础。 深度学习实际上是机器学习的一个子集，并且全都与神经网络有关。 深度学习已经存在了十年，但是之所以现在如此流行，是因为计算的进步和海量数据的可用性。 拥有如此庞大的数据量，深度学习算法将胜过所有经典的机器学习算法。 因此，在本章中，我们将学习几种深度学习算法，例如**递归神经网络**（ **RNN** ），**长短期记忆**（ **LSTM** ）和**卷积神经网络**（ **CNN** ）算法及其应用。
+到目前为止，我们已经了解了**强化学习**（**RL**）的工作原理。 在接下来的章节中，我们将学习**深度强化学习**（**DRL**），它是深度学习和 RL 的结合。 DRL 在 RL 社区引起了很多关注，并且对解决许多 RL 任务产生了严重影响。 要了解 DRL，我们需要在深度学习方面有坚实的基础。 深度学习实际上是机器学习的一个子集，并且全都与神经网络有关。 深度学习已经存在了十年，但是之所以现在如此流行，是因为计算的进步和海量数据的可用性。 拥有如此庞大的数据量，深度学习算法将胜过所有经典的机器学习算法。 因此，在本章中，我们将学习几种深度学习算法，例如**递归神经网络**（**RNN**），**长短期记忆**（**LSTM**）和**卷积神经网络**（**CNN**）算法及其应用。

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

 *   人工神经元
-*   **人工神经网络**（ **ANN** ）
+*   **人工神经网络**（**ANN**）
 *   建立神经网络对手写数字进行分类
 *   RNN
 *   LSTM
@@ -19,17 +19,17 @@

 ![](img/00159.gif)

-现在，人工神经元如何工作？ 假设我们有三个输入， *x <sub class="calibre24">1</sub>* ， *x <sub class="calibre24">2</sub>* 和 *x <sub class="calibre24">3，</sub>* 预测输出 *y* 。 这些输入乘以权重，即 *w <sub class="calibre24">1</sub>* ， *w <sub class="calibre24">2</sub>* 和 *w <sub class="calibre24">3，</sub>* 和 *x <sub class="calibre24">1</sub> .w <sub class="calibre24">1</sub>* + *x <sub class="calibre24">2</sub> .w <sub class="calibre24">2</sub>* + *x <sub class="calibre24">3</sub> .w <sub class="calibre24">3</sub>* 。 但是，为什么我们将这些输入乘以权重？ 因为在计算输出 *y* 时，所有输入都不是同等重要的。 假设 *x <sub class="calibre24">2</sub>* 在计算输出方面比其他两个输入更为重要。 然后，为 *w <sub class="calibre24">2</sub>* 分配较高的值，而不是为其他两个权重分配较高的值。 因此，将权重乘以输入后， *x <sub class="calibre24">2</sub>* 的值将比其他两个输入值高。 在将输入与权重相乘后，我们将它们求和，然后添加一个称为 bias *b* 的值。 因此， *z =（x1.w1 + x2.w2 + x3.w3）+ b，*即：
+现在，人工神经元如何工作？ 假设我们有三个输入， *x <sub class="calibre24">1</sub>* ， *x <sub class="calibre24">2</sub>* 和 *x <sub class="calibre24">3，</sub>* 预测输出`y`。 这些输入乘以权重，即 *w <sub class="calibre24">1</sub>* ， *w <sub class="calibre24">2</sub>* 和 *w <sub class="calibre24">3，</sub>* 和 *x <sub class="calibre24">1</sub> .w <sub class="calibre24">1</sub>* + *x <sub class="calibre24">2</sub> .w <sub class="calibre24">2</sub>* + *x <sub class="calibre24">3</sub> .w <sub class="calibre24">3</sub>* 。 但是，为什么我们将这些输入乘以权重？ 因为在计算输出`y`时，所有输入都不是同等重要的。 假设 *x <sub class="calibre24">2</sub>* 在计算输出方面比其他两个输入更为重要。 然后，为 *w <sub class="calibre24">2</sub>* 分配较高的值，而不是为其他两个权重分配较高的值。 因此，将权重乘以输入后， *x <sub class="calibre24">2</sub>* 的值将比其他两个输入值高。 在将输入与权重相乘后，我们将它们求和，然后添加一个称为 bias`b`的值。 因此， *z =（x1.w1 + x2.w2 + x3.w3）+ b，*即：

 ![](img/00160.jpeg)

-*z* 看起来不像线性回归方程吗？ 不仅仅是直线方程吗？ *z = mx + b* 。
+`z`看起来不像线性回归方程吗？ 不仅仅是直线方程吗？ *z = mx + b* 。

-其中 *m* 是权重（系数）， *x* 是输入， *b* 是偏差（截距）。 嗯，是。 那么神经元和线性回归有什么区别？ 在神经元中，我们通过应用称为激活或传递函数的函数 *f（）*向结果 *z，*引入非线性。 因此，我们的输出为 *y = f（z）*。 下图显示了一个人工神经元：
+其中`m`是权重（系数），`x`是输入，`b`是偏差（截距）。 嗯，是。 那么神经元和线性回归有什么区别？ 在神经元中，我们通过应用称为激活或传递函数的函数 *f（）*向结果 *z，*引入非线性。 因此，我们的输出为 *y = f（z）*。 下图显示了一个人工神经元：

 ![](img/00161.gif)

-在神经元中，我们将输入 *x* 乘以权重 *w，*，并在应用激活函数 *f（z）之前加上偏差 *b* 。* 得出此结果，并预测输出 *y* 。
+在神经元中，我们将输入`x`乘以权重 *w，*，并在应用激活函数 *f（z）之前加上偏差`b`。* 得出此结果，并预测输出`y`。

 # 人工神经网络

@@ -59,19 +59,19 @@

 激活函数用于在神经网络中引入非线性。 我们将激活函数应用于权重乘以并加到偏差上的输入，即 *f（z），*其中 *z =（输入*权重）+偏差*。 激活功能有以下几种：

-*   **Sigmoid 函数**：Sigmoid 函数是最常用的激活函数之一。 它在 *0* 和 *1* 之间缩放值。 可以将 S 形函数定义为![](img/00163.jpeg)。 当我们将此功能应用于 *z* 时，值将在 0 到 *1* 的范围内缩放。 这也称为逻辑函数。 它是 S 形，如下图所示：
+*   **Sigmoid 函数**：Sigmoid 函数是最常用的激活函数之一。 它在`0`和`1`之间缩放值。 可以将 S 形函数定义为![](img/00163.jpeg)。 当我们将此功能应用于`z`时，值将在 0 到`1`的范围内缩放。 这也称为逻辑函数。 它是 S 形，如下图所示：

 ![](img/00164.gif)

-*   **双曲正切函数**：与 S 型函数不同，双曲正切函数在 *-1* 和 *+1* 之间缩放值。 双曲正切函数可以定义为![](img/00165.jpeg)。 当我们将此功能应用于 *z* 时，这些值将在 *-1* 至 *+1* 的范围内缩放。 它也是 S 形，但居中为零，如下图所示：
+*   **双曲正切函数**：与 S 型函数不同，双曲正切函数在 *-1* 和 *+1* 之间缩放值。 双曲正切函数可以定义为![](img/00165.jpeg)。 当我们将此功能应用于`z`时，这些值将在 *-1* 至 *+1* 的范围内缩放。 它也是 S 形，但居中为零，如下图所示：

 ![](img/00166.gif)

-*   **ReLU 功能**：ReLU 也称为整流线性单位。 它是使用最广泛的激活功能之一。 ReLU 函数可以定义为![](img/00167.jpeg)，即当 *z* 小于 0 且 *f（z）*为![](img/00167.jpeg) f（z）为 0 时。 当 z 大于或等于 *0* 时，等于 *z* ：
+*   **ReLU 功能**：ReLU 也称为整流线性单位。 它是使用最广泛的激活功能之一。 ReLU 函数可以定义为![](img/00167.jpeg)，即当`z`小于 0 且 *f（z）*为![](img/00167.jpeg) f（z）为 0 时。 当 z 大于或等于`0`时，等于`z`：

 ![](img/00168.gif)

-*   **Softmax 函数**：softmax 函数实际上是 S 型函数的推广。 它通常应用于网络的最后一层，同时执行多类分类任务。 它给出了每个类别作为输出的概率，因此 softmax 值的总和将始终等于 *1* 。 可以定义为![](img/00169.jpeg)。
+*   **Softmax 函数**：softmax 函数实际上是 S 型函数的推广。 它通常应用于网络的最后一层，同时执行多类分类任务。 它给出了每个类别作为输出的概率，因此 softmax 值的总和将始终等于`1`。 可以定义为![](img/00169.jpeg)。

 # 深入研究 ANN

@@ -135,7 +135,7 @@

 现在，让我们从数学上看一下。 现在，我们将讨论很多有趣的数学运算，因此戴上微积分帽并按照以下步骤操作。 因此，我们有两个权重，一个是 *w <sub class="calibre24">xh</sub>* ，对输入权重是隐藏的，另一个是 *w <sub class="calibre24">hy</sub>* ， 隐藏以输出权重。 我们需要根据我们的权重更新规则来更新这些权重。 为此，首先，我们需要计算成本函数相对于权重的导数。

-由于我们正在反向传播，也就是说，从输出层到输入层，我们的第一权重将是 *w <sub class="calibre24">hy</sub>* 。 因此，现在我们需要计算 *J* 相对于 *w <sub class="calibre24">hy</sub>* 的导数。 我们如何计算导数？ 回想一下我们的成本函数![](img/00183.jpeg)。 我们无法直接计算导数，因为 *J* 中没有 *w <sub class="calibre24"> hy </sub>* 项。
+由于我们正在反向传播，也就是说，从输出层到输入层，我们的第一权重将是 *w <sub class="calibre24">hy</sub>* 。 因此，现在我们需要计算`J`相对于 *w <sub class="calibre24">hy</sub>* 的导数。 我们如何计算导数？ 回想一下我们的成本函数![](img/00183.jpeg)。 我们无法直接计算导数，因为`J`中没有 *w <sub class="calibre24"> hy </sub>* 项。

 回顾如下给出的前向传播方程：

@@ -161,7 +161,7 @@

 我们将所有这些替换为第一个方程式（1）。

-现在，我们需要针对下一个权重 *w <sub class="calibre24">xh</sub>* 来计算 *J* 的导数。 同样，我们无法直接根据 *J* 计算 *w <sub class="calibre24">xh</sub>* 的导数，因为我们没有任何 *w <sub class="calibre24">xh</sub> [ *J* 中的 HTG15]术语。 因此，我们需要使用链式规则； 再次回顾我们的前向传播步骤：*
+现在，我们需要针对下一个权重 *w <sub class="calibre24">xh</sub>* 来计算`J`的导数。 同样，我们无法直接根据`J`计算 *w <sub class="calibre24">xh</sub>* 的导数，因为我们没有任何 *w <sub class="calibre24">xh</sub> [`J`中的 HTG15]术语。 因此，我们需要使用链式规则； 再次回顾我们的前向传播步骤：*

 ![](img/00184.jpeg)

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

 我们如何使我们的网络记住整个句子以正确预测下一个单词？ 这是 RNN 发挥作用的地方。 RNN 不仅基于当前输入，而且还基于先前的隐藏状态来预测输出。 您可能想知道为什么 RNN 必须基于当前输入和先前的隐藏状态来预测输出，以及为什么它不能仅使用当前输入和先前的输入而不是当前输入和先前的隐藏状态来预测输出 。 这是因为前一个输入将存储有关前一个单词的信息，而前一个隐藏状态将捕获有关整个句子的信息，也就是说，前一个隐藏状态将存储上下文。 因此，基于当前输入和先前的隐藏状态而不是仅基于当前输入和先前的输入来预测输出非常有用。

-RNN 是一种特殊类型的神经网络，广泛应用于顺序数据。 换句话说，它适用于排序重要的数据。 简而言之，RNN 有一个存储先前信息的存储器。 它广泛应用于各种**自然语言处理**（ **NLP** ）任务，例如机器翻译，情感分析等。 它也适用于时间序列数据，例如股票市场数据。 仍然不清楚 RNN 到底是什么？ 查看下图，该图显示了正常神经网络和 RNN 的比较：
+RNN 是一种特殊类型的神经网络，广泛应用于顺序数据。 换句话说，它适用于排序重要的数据。 简而言之，RNN 有一个存储先前信息的存储器。 它广泛应用于各种**自然语言处理**（**NLP**）任务，例如机器翻译，情感分析等。 它也适用于时间序列数据，例如股票市场数据。 仍然不清楚 RNN 到底是什么？ 查看下图，该图显示了正常神经网络和 RNN 的比较：

 ![](img/00212.gif)

@@ -427,11 +427,11 @@ RNN 是一种特殊类型的神经网络，广泛应用于顺序数据。 换句

 ![](img/00218.jpeg)

-在前面的示例中，![](img/00219.jpeg)是时间 *t* 时的实际单词，![](img/00220.jpeg)是时间 *t* 时的预测单词。 由于我们将整个序列作为训练样本，因此总损失将是每个时间步的损失总和。
+在前面的示例中，![](img/00219.jpeg)是时间`t`时的实际单词，![](img/00220.jpeg)是时间`t`时的预测单词。 由于我们将整个序列作为训练样本，因此总损失将是每个时间步的损失总和。

 # 通过时间反向传播

-现在，我们如何训练 RNN？ 就像我们训练了正常的神经网络一样，我们可以使用反向传播来训练 RNN。 但是在 RNN 中，由于所有时间步长都具有依赖性，因此每个输出的梯度将不仅取决于当前时间步长，还取决于先前时间步长。 我们将此**反向传播称为时间**（ **BPTT** ）。 它与反向传播基本相同，不同之处在于它应用了 RNN。 要查看它如何在 RNN 中发生，让我们考虑一下 RNN 的展开版本，如下图所示：
+现在，我们如何训练 RNN？ 就像我们训练了正常的神经网络一样，我们可以使用反向传播来训练 RNN。 但是在 RNN 中，由于所有时间步长都具有依赖性，因此每个输出的梯度将不仅取决于当前时间步长，还取决于先前时间步长。 我们将此**反向传播称为时间**（**BPTT**）。 它与反向传播基本相同，不同之处在于它应用了 RNN。 要查看它如何在 RNN 中发生，让我们考虑一下 RNN 的展开版本，如下图所示：

 ![](img/00221.gif)

@@ -473,7 +473,7 @@ LSTM 单元称为内存，它们负责存储信息。 但是信息必须在存
    *哈利是一位出色的歌手。 他住在纽约。 Zayn 还是一位出色的歌手。*
    因此，在“遗忘门”从单元状态中删除信息之后，输入门将确定存储器中必须包含哪些信息。 在此，由于通过遗忘门从单元状态中删除了关于哈利的信息，因此输入门决定用关于 Zayn 的信息来更新单元状态。

-*   **输出门**：该输出门负责确定一次从单元状态 *t* 应该显示什么信息。 现在，考虑以下句子：
+*   **输出门**：该输出门负责确定一次从单元状态`t`应该显示什么信息。 现在，考虑以下句子：
    *Zayn 的首张专辑取得了巨大的成功。 恭喜 ____* 。
    在这里，*表示祝贺*是用于形容名词的形容词。 输出层将预测 *Zayn* （名词），以填补空白。

@@ -978,8 +978,8 @@ conv2 = maxpool2d(conv2)
 经过两个带卷积和池化操作的卷积层后，我们的输入图像将从 28 * 28 * 1 降采样为 7 * 7 * 1。 我们需要先平整该输出，然后再将其馈送到完全连接的层。 然后，第二个卷积层的结果将被馈送到完全连接的层中，我们将其与权重相乘，添加偏差并应用 ReLU 激活：

 ```py
-x_flattened = tf.reshape(conv2, [-1, 7*7*64])
-w_fc = tf.Variable(tf.random_normal([7*7*64,1024]))
+x_flattened = tf.reshape(conv2, [-1, 7`7`64])
+w_fc = tf.Variable(tf.random_normal([7`7`64,1024]))
 b_fc = tf.Variable(tf.random_normal([1024]))
 fc = tf.nn.relu(tf.matmul(x_flattened,w_fc)+ b_fc)
 ```

--- a/new/handson-rl-py/08.md
+++ b/new/handson-rl-py/08.md
 # 带有 Deep Q Network 的 Atari Games

-**深度 Q 网络**（ **DQN** ）是非常流行且广泛使用的**深度强化学习**（ **DRL** ）算法之一。 实际上，它在发布之后，在**强化学习**（ **RL** ）社区周围引起了很多轰动。 该算法由 Google 的 DeepMind 的研究人员提出，在玩任何 Atari 游戏时，只要将游戏屏幕作为输入，就可以达到人类水平的结果。
+**深度 Q 网络**（**DQN**）是非常流行且广泛使用的**深度强化学习**（**DRL**）算法之一。 实际上，它在发布之后，在**强化学习**（**RL**）社区周围引起了很多轰动。 该算法由 Google 的 DeepMind 的研究人员提出，在玩任何 Atari 游戏时，只要将游戏屏幕作为输入，就可以达到人类水平的结果。

 在本章中，我们将探讨 DQN 的工作原理，并学习如何通过仅将游戏屏幕作为输入来构建可玩任何 Atari 游戏的 DQN。 我们将研究 DQN 体系结构的一些改进，例如双重 DQN 和决斗网络体系结构。

 在本章中，您将学习：

-*   **深度 Q 网络**（ **DQN** ）
+*   **深度 Q 网络**（**DQN**）
 *   DQN 的体系结构
 *   建立代理来玩 Atari 游戏
 *   双 DQN
@@ -14,9 +14,9 @@

 # 什么是深度 Q 网络？

-在继续之前，首先让我们回顾一下 Q 函数。 什么是 Q 函数？ Q 函数（也称为状态动作值函数）指定*和*在 *s* 状态下的状态。 因此，我们将每个状态下所有可能动作的值存储在一个称为 Q 表的表中，并选择一个状态下具有最大值的动作作为最佳动作。 还记得我们是如何学习这个 Q 函数的吗？ 我们使用了 Q 学习，这是一种非政策性的时差学习算法，用于估算 Q 函数。 我们在第 5 章和*时间差异学习中对此进行了研究。*
+在继续之前，首先让我们回顾一下 Q 函数。 什么是 Q 函数？ Q 函数（也称为状态动作值函数）指定*和*在`s`状态下的状态。 因此，我们将每个状态下所有可能动作的值存储在一个称为 Q 表的表中，并选择一个状态下具有最大值的动作作为最佳动作。 还记得我们是如何学习这个 Q 函数的吗？ 我们使用了 Q 学习，这是一种非政策性的时差学习算法，用于估算 Q 函数。 我们在第 5 章和*时间差异学习中对此进行了研究。*

-到目前为止，我们已经看到了状态数量有限且动作有限的环境，并且我们对所有可能的状态动作对进行了详尽搜索，以找到最佳 Q 值。 想想一个环境，我们有很多状态，并且在每个状态下，我们都有很多动作可以尝试。 仔细检查每个状态下的所有操作将非常耗时。 更好的方法是使用某些参数![](img/00240.jpeg)将 *Q* 函数近似为![](img/00241.jpeg)。 我们可以使用权重为![](img/00242.jpeg)的神经网络来估计每种状态下所有可能动作的 *Q* 值。 当我们使用神经网络来近似 *Q* 函数时，我们可以称其为 Q 网络。 好的，但是我们如何训练网络，我们的目标功能是什么？ 回顾我们的 Q 学习更新规则：
+到目前为止，我们已经看到了状态数量有限且动作有限的环境，并且我们对所有可能的状态动作对进行了详尽搜索，以找到最佳 Q 值。 想想一个环境，我们有很多状态，并且在每个状态下，我们都有很多动作可以尝试。 仔细检查每个状态下的所有操作将非常耗时。 更好的方法是使用某些参数![](img/00240.jpeg)将`Q`函数近似为![](img/00241.jpeg)。 我们可以使用权重为![](img/00242.jpeg)的神经网络来估计每种状态下所有可能动作的`Q`值。 当我们使用神经网络来近似`Q`函数时，我们可以称其为 Q 网络。 好的，但是我们如何训练网络，我们的目标功能是什么？ 回顾我们的 Q 学习更新规则：

 ![](img/00243.jpeg)。

@@ -28,7 +28,7 @@

 其中![](img/00248.jpeg)。

-我们更新权重，并通过梯度下降使损失最小化。 简而言之，在 DQN 中，我们使用神经网络作为函数逼近器来逼近 *Q* 函数，并且通过梯度下降使误差最小化。
+我们更新权重，并通过梯度下降使损失最小化。 简而言之，在 DQN 中，我们使用神经网络作为函数逼近器来逼近`Q`函数，并且通过梯度下降使误差最小化。

 # DQN 的体系结构

@@ -50,7 +50,7 @@ DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧

 # 体验重播

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

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

@@ -64,13 +64,13 @@ DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧

 ![](img/00252.jpeg)

-我们使用相同的 Q 函数来计算目标值和预测值。 在前面的公式中，您可以看到相同的权重![](img/00253.jpeg)用于目标 *Q* 和预测的 *Q* 。 由于同一网络正在计算预测值和目标值，因此两者之间可能会有很大差异。
+我们使用相同的 Q 函数来计算目标值和预测值。 在前面的公式中，您可以看到相同的权重![](img/00253.jpeg)用于目标`Q`和预测的`Q`。 由于同一网络正在计算预测值和目标值，因此两者之间可能会有很大差异。

 为避免此问题，我们使用称为目标网络的单独网络来计算目标值。 因此，我们的损失函数变为：

 ![](img/00254.jpeg)

-您可能会注意到目标 *Q* 的参数是![](img/00255.jpeg)而不是![](img/00256.jpeg)。 我们的实际 Q 网络用于预测 *Q* 值，它通过使用梯度下降来学习![](img/00257.jpeg)的正确权重。 将目标网络冻结几个时间步，然后通过从实际 Q 网络复制权重来更新目标网络权重。 冻结目标网络一段时间，然后使用实际的 Q 网络权重更新其权重，以稳定训练。
+您可能会注意到目标`Q`的参数是![](img/00255.jpeg)而不是![](img/00256.jpeg)。 我们的实际 Q 网络用于预测`Q`值，它通过使用梯度下降来学习![](img/00257.jpeg)的正确权重。 将目标网络冻结几个时间步，然后通过从实际 Q 网络复制权重来更新目标网络权重。 冻结目标网络一段时间，然后使用实际的 Q 网络权重更新其权重，以稳定训练。

 # 削减奖励

@@ -80,15 +80,15 @@ DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧

 现在，我们将了解 DQN 的整体工作方式。 DQN 涉及的步骤如下：

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

 # 建立代理来玩 Atari 游戏

@@ -392,9 +392,9 @@ with tf.Session() as sess:

 # 双 DQN

-深度 Q 学习非常酷，对吗？ 它已经普及了玩任何 Atari 游戏的学习。 但是 DQN 的问题在于，它倾向于高估 *Q* 值。 这是因为 *Q* 学习方程式中的最大值算子。 max 运算符在选择和评估动作时使用相同的值。 那是什么意思 假设我们处于*处于*状态，并且我们有五个动作 *a <sub class="calibre24">1</sub>* 至 *a <sub class="calibre24">5</sub>* 。 假设 *a <sub class="calibre24">3</sub>* 是最好的动作。 当我们估计状态为 *s* 的所有这些动作的 *Q* 值时，估计的 *Q* 值会有些杂音并且与实际值有所不同。 由于这种噪声，动作 *a <sub class="calibre24">2</sub>* 会比最佳动作 *a <sub class="calibre24">3</sub>* 获得更高的值。 现在，如果我们选择最佳动作作为具有最大值的动作，则最终将选择次优动作 *a <sub class="calibre24">2</sub>* 而不是最佳动作 *a <sub class="calibre24">3</sub>* 。
+深度 Q 学习非常酷，对吗？ 它已经普及了玩任何 Atari 游戏的学习。 但是 DQN 的问题在于，它倾向于高估`Q`值。 这是因为`Q`学习方程式中的最大值算子。 max 运算符在选择和评估动作时使用相同的值。 那是什么意思 假设我们处于*处于*状态，并且我们有五个动作 *a <sub class="calibre24">1</sub>* 至 *a <sub class="calibre24">5</sub>* 。 假设 *a <sub class="calibre24">3</sub>* 是最好的动作。 当我们估计状态为`s`的所有这些动作的`Q`值时，估计的`Q`值会有些杂音并且与实际值有所不同。 由于这种噪声，动作 *a <sub class="calibre24">2</sub>* 会比最佳动作 *a <sub class="calibre24">3</sub>* 获得更高的值。 现在，如果我们选择最佳动作作为具有最大值的动作，则最终将选择次优动作 *a <sub class="calibre24">2</sub>* 而不是最佳动作 *a <sub class="calibre24">3</sub>* 。

-我们可以通过具有两个单独的 *Q* 函数来解决此问题，每个函数都是独立学习的。 一个 *Q* 功能用于选择一个动作，另一个 *Q* 功能用于评估一个动作。 我们可以通过调整 DQN 的目标功能来实现。 调用 DQN 的目标函数：
+我们可以通过具有两个单独的`Q`函数来解决此问题，每个函数都是独立学习的。 一个`Q`功能用于选择一个动作，另一个`Q`功能用于评估一个动作。 我们可以通过调整 DQN 的目标功能来实现。 调用 DQN 的目标函数：

 ![](img/00268.jpeg)

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

 ![](img/00269.jpeg)

-在前面的公式中，我们有两个 *Q* 函数，每个函数具有不同的权重。 因此，权重为![](img/00270.jpeg)的 *Q* 函数用于选择操作，权重为![](img/00271.jpeg)的其他 *Q* 函数用于评估操作。 我们还可以切换这两个 *Q* 功能的角色。
+在前面的公式中，我们有两个`Q`函数，每个函数具有不同的权重。 因此，权重为![](img/00270.jpeg)的`Q`函数用于选择操作，权重为![](img/00271.jpeg)的其他`Q`函数用于评估操作。 我们还可以切换这两个`Q`功能的角色。

 # 优先体验重播

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

 ![](img/00273.jpeg)

-![](img/00274.jpeg)是转换的优先级 *i* ，![](img/00275.jpeg)是转换的 TD 误差 *i* ，而![](img/00276.jpeg)只是一些正常数，可确保每次转换 具有非零优先级。 当![](img/00277.jpeg)为零时，添加![](img/00278.jpeg)将使转换具有优先级而不是零优先级。 但是，转换的优先级要比![](img/00279.jpeg)不为零的转换低。 指数![](img/00280.jpeg)表示使用的优先级数量。 当![](img/00281.jpeg)为零时，则仅是均匀情况。
+![](img/00274.jpeg)是转换的优先级`i`，![](img/00275.jpeg)是转换的 TD 误差`i`，而![](img/00276.jpeg)只是一些正常数，可确保每次转换 具有非零优先级。 当![](img/00277.jpeg)为零时，添加![](img/00278.jpeg)将使转换具有优先级而不是零优先级。 但是，转换的优先级要比![](img/00279.jpeg)不为零的转换低。 指数![](img/00280.jpeg)表示使用的优先级数量。 当![](img/00281.jpeg)为零时，则仅是均匀情况。

 现在，我们可以使用以下公式将此优先级转换为概率：

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

 ![](img/00283.jpeg)

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

 # 决斗网络架构

-我们知道 *Q* 函数指定代理在状态*或*下执行动作*和*有多好，而值函数则指定有多好 使代理处于*或*状态。 现在，我们引入一个称为优势函数的新函数，该函数可以定义为值函数和优势函数之间的差。 优势功能指定与其他动作相比，代理执行一个动作*和*有多好。
+我们知道`Q`函数指定代理在状态*或*下执行动作*和*有多好，而值函数则指定有多好 使代理处于*或*状态。 现在，我们引入一个称为优势函数的新函数，该函数可以定义为值函数和优势函数之间的差。 优势功能指定与其他动作相比，代理执行一个动作*和*有多好。

-因此，值函数指定状态的优劣，而优势函数指定动作的优劣。 如果我们将价值功能和优势功能结合起来会发生什么？ 这将告诉我们代理在状态*或*实际上是我们的 *Q* 功能下执行动作*和*有多好。 因此，我们可以像![](img/00285.jpeg)中那样将 *Q* 函数定义为值函数和优势函数的和。
+因此，值函数指定状态的优劣，而优势函数指定动作的优劣。 如果我们将价值功能和优势功能结合起来会发生什么？ 这将告诉我们代理在状态*或*实际上是我们的`Q`功能下执行动作*和*有多好。 因此，我们可以像![](img/00285.jpeg)中那样将`Q`函数定义为值函数和优势函数的和。

 现在，我们将看到决斗网络体系结构是如何工作的。 下图显示了对决 DQN 的体系结构：

@@ -445,7 +445,7 @@ with tf.Session() as sess:
 *   当我们在状态中有大量动作时，并且估计每个动作的值并不是很重要时，第一个流与值函数流中一样有用。
 *   与优势功能流一样，第二个流在网络必须决定优先选择哪个操作的情况下很有用

-聚合器层合并这两个流的值，并产生 *Q* 函数。 因此，决斗网络比标准 DQN 体系结构更有效，更健壮。
+聚合器层合并这两个流的值，并产生`Q`函数。 因此，决斗网络比标准 DQN 体系结构更有效，更健壮。

 # 概要


--- a/new/handson-rl-py/09.md
+++ b/new/handson-rl-py/09.md
 # 用深度循环 Q 网络玩世界末日

-在上一章中，我们介绍了如何使用**深度 Q 网络**（ **DQN** ）构建代理以玩 Atari 游戏。 我们利用神经网络来逼近 Q 函数，使用了**卷积神经网络**（ **CNN** ）来理解输入游戏画面，并利用过去的四个游戏画面来更好地理解 当前的游戏状态。 在本章中，我们将学习如何利用**递归神经网络**（ **RNN** ）来提高 DQN 的性能。 我们还将研究**马尔可夫决策过程**（ **MDP** ）的部分可观察之处，以及如何使用**深度递归 Q 网络**（ **DRQN** ）。 接下来，我们将学习如何构建一个代理来使用 DRQN 玩《毁灭战士》游戏。 最后，我们将看到 DRQN 的一种变体，称为**深度注意力循环 Q 网络**（ **DARQN** ），它增强了 DRQN 体系结构的注意力机制。
+在上一章中，我们介绍了如何使用**深度 Q 网络**（**DQN**）构建代理以玩 Atari 游戏。 我们利用神经网络来逼近 Q 函数，使用了**卷积神经网络**（**CNN**）来理解输入游戏画面，并利用过去的四个游戏画面来更好地理解 当前的游戏状态。 在本章中，我们将学习如何利用**递归神经网络**（**RNN**）来提高 DQN 的性能。 我们还将研究**马尔可夫决策过程**（**MDP**）的部分可观察之处，以及如何使用**深度递归 Q 网络**（**DRQN**）。 接下来，我们将学习如何构建一个代理来使用 DRQN 玩《毁灭战士》游戏。 最后，我们将看到 DRQN 的一种变体，称为**深度注意力循环 Q 网络**（**DARQN**），它增强了 DRQN 体系结构的注意力机制。

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

@@ -12,15 +12,15 @@

 # DRQN

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

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

 ![](img/00287.jpeg)

-为了克服这个问题，我们将不仅仅考虑当前的游戏屏幕，而将使用过去的四个游戏屏幕来了解球的方向和速度。 这就是我们在 DQN 中看到的。 我们将过去的四个游戏屏幕以及当前的游戏屏幕作为输入输入到卷积层，并接收该状态下所有可能动作的 Q 值。 但是，您认为仅使用过去的四个屏幕将有助于我们了解不同的环境吗？ 在某些环境下，我们甚至可能需要过去的 100 个游戏屏幕来更好地了解当前游戏状态。 但是，堆叠过去的 *n* 游戏画面会减慢我们的训练过程，而且还会增加我们的体验重播缓冲区的大小。
+为了克服这个问题，我们将不仅仅考虑当前的游戏屏幕，而将使用过去的四个游戏屏幕来了解球的方向和速度。 这就是我们在 DQN 中看到的。 我们将过去的四个游戏屏幕以及当前的游戏屏幕作为输入输入到卷积层，并接收该状态下所有可能动作的 Q 值。 但是，您认为仅使用过去的四个屏幕将有助于我们了解不同的环境吗？ 在某些环境下，我们甚至可能需要过去的 100 个游戏屏幕来更好地了解当前游戏状态。 但是，堆叠过去的`n`游戏画面会减慢我们的训练过程，而且还会增加我们的体验重播缓冲区的大小。

-因此，只要需要，我们就可以利用 RNN 的优势来理解和保留有关先前状态的信息。 在第 7 章和*深度学习基础知识中，*我们了解了如何将**长短期记忆循环神经网络**（ **LSTM RNN** ）用于 通过保留，忘记和更新所需的信息来生成文本以及了解文本的上下文。 我们将通过扩展 LSTM 层来修改 DQN 体系结构，以了解先前的信息。 在 DQN 架构中，我们用 LSTM RNN 替换了第一卷积后全连接层。 这样，我们也可以解决部分可观察性的问题，因为现在我们的代理可以记住过去的状态并可以改进策略。
+因此，只要需要，我们就可以利用 RNN 的优势来理解和保留有关先前状态的信息。 在第 7 章和*深度学习基础知识中，*我们了解了如何将**长短期记忆循环神经网络**（**LSTM RNN**）用于 通过保留，忘记和更新所需的信息来生成文本以及了解文本的上下文。 我们将通过扩展 LSTM 层来修改 DQN 体系结构，以了解先前的信息。 在 DQN 架构中，我们用 LSTM RNN 替换了第一卷积后全连接层。 这样，我们也可以解决部分可观察性的问题，因为现在我们的代理可以记住过去的状态并可以改进策略。

 # DRQN 的体系结构

@@ -28,9 +28,9 @@

 ![](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 <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 时，我们通过时间的反向传播来训练我们的网络。

-等待。 体验重播缓冲区如何？ 在 DQN 中，为避免相关的体验，我们使用了体验重播，该体验存储了游戏的过渡，并使用了随机的一组体验来训练网络。 对于 DRQN，我们将整个情节存储在体验缓冲区中，并从随机的情节批次中随机采样 *n* 个步骤。 因此，通过这种方式，我们既可以适应随机化，又可以适应另一种实际的体验。
+等待。 体验重播缓冲区如何？ 在 DQN 中，为避免相关的体验，我们使用了体验重播，该体验存储了游戏的过渡，并使用了随机的一组体验来训练网络。 对于 DRQN，我们将整个情节存储在体验缓冲区中，并从随机的情节批次中随机采样`n`个步骤。 因此，通过这种方式，我们既可以适应随机化，又可以适应另一种实际的体验。

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

@@ -577,7 +577,7 @@ DARQN 的体系结构如下所示：
 注意有两种类型：

 *   **软关注**：我们知道，卷积层产生的特征图将作为输入提供给关注层，然后生成上下文向量。 轻描淡写地，这些上下文向量只是卷积层产生的所有输出（特征图）的加权平均值。 根据功能的相对重要性选择权重。
-*   **刻苦关注**：刻苦关注，根据某些位置选择策略*π*，我们仅关注图像在特定时间步长 *t* 上的特定位置。 该策略由神经网络表示，其权重是策略参数，网络的输出是位置选择概率。 但是，硬注意力不比软注意力好多少。
+*   **刻苦关注**：刻苦关注，根据某些位置选择策略*π*，我们仅关注图像在特定时间步长`t`上的特定位置。 该策略由神经网络表示，其权重是策略参数，网络的输出是位置选择概率。 但是，硬注意力不比软注意力好多少。

 # 概要


--- a/new/handson-rl-py/10.md
+++ b/new/handson-rl-py/10.md
 # 异步优势演员评论网络

-在前面的章节中，我们已经看到了**深度 Q 网络**（ **DQN** ）多么酷，以及它如何成功地推广了学习玩具有人类水平性能的 Atari 系列游戏的方法 。 但是我们面临的问题是它需要大量的计算能力和训练时间。 因此，Google 的 DeepMind 引入了一种称为**异步优势演员批判**（ **A3C** ）的新算法，该算法在其他深度强化学习算法中占主导地位，因为它需要较少的计算能力和训练时间。 A3C 的主要思想是，它使用多个代理并行学习并汇总其整体经验。 在本章中，我们将了解 A3C 网络如何工作。 接下来，我们将学习如何使用 A3C 构建代理以推动一座山。
+在前面的章节中，我们已经看到了**深度 Q 网络**（**DQN**）多么酷，以及它如何成功地推广了学习玩具有人类水平性能的 Atari 系列游戏的方法 。 但是我们面临的问题是它需要大量的计算能力和训练时间。 因此，Google 的 DeepMind 引入了一种称为**异步优势演员批判**（**A3C**）的新算法，该算法在其他深度强化学习算法中占主导地位，因为它需要较少的计算能力和训练时间。 A3C 的主要思想是，它使用多个代理并行学习并汇总其整体经验。 在本章中，我们将了解 A3C 网络如何工作。 接下来，我们将学习如何使用 A3C 构建代理以推动一座山。

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

@@ -35,15 +35,15 @@ A3C 网络风起云涌，并接管了 DQN。 除了前面提到的优点之外

 # A3C 如何运作

-首先，辅助代理重置全局网络，然后它们开始与环境进行交互。 每个工人遵循不同的勘探策略以学习最佳策略。 然后，他们计算价值和政策损失，然后计算损失的梯度并将梯度更新到全球网络。 随着工作人员代理开始重置全局网络并重复相同的过程，该循环继续进行。 在查看价值和政策损失函数之前，我们将了解优势函数的计算方式。 众所周知，优点是 *Q* 函数和值函数之间的区别：
+首先，辅助代理重置全局网络，然后它们开始与环境进行交互。 每个工人遵循不同的勘探策略以学习最佳策略。 然后，他们计算价值和政策损失，然后计算损失的梯度并将梯度更新到全球网络。 随着工作人员代理开始重置全局网络并重复相同的过程，该循环继续进行。 在查看价值和政策损失函数之前，我们将了解优势函数的计算方式。 众所周知，优点是`Q`函数和值函数之间的区别：

 ![](img/00293.jpeg)

-由于我们实际上并未直接在 A3C 中计算 *Q* 值，因此我们将折现收益用作 *Q* 值的估算值。 折现收益 *R* 可以写为：
+由于我们实际上并未直接在 A3C 中计算`Q`值，因此我们将折现收益用作`Q`值的估算值。 折现收益`R`可以写为：

 ![](img/00294.jpeg)

-我们将折价收益 *R* 替换为 *Q* 函数，如下所示：
+我们将折价收益`R`替换为`Q`函数，如下所示：

 ![](img/00295.jpeg)


--- a/new/handson-rl-py/11.md
+++ b/new/handson-rl-py/11.md
 # 政策梯度和优化

-在最后三章中，我们学习了各种深度强化学习算法，例如**深度 Q 网络**（ **DQN** ），**深度递归 Q 网络**（[HTG6 DRQN ）和**异步优势演员评论家**（ **A3C** ）网络。 在所有算法中，我们的目标是找到正确的策略，以便我们能够最大化回报。 我们使用 Q 函数来找到最佳策略，因为 Q 函数告诉我们哪个动作是在某种状态下执行的最佳动作。 您认为我们不使用 Q 函数就能直接找到最优策略吗？ 是。 我们可以。 在策略梯度方法中，我们无需使用 Q 函数就可以找到最优策略。
+在最后三章中，我们学习了各种深度强化学习算法，例如**深度 Q 网络**（**DQN**），**深度递归 Q 网络**（[HTG6 DRQN ）和**异步优势演员评论家**（**A3C**）网络。 在所有算法中，我们的目标是找到正确的策略，以便我们能够最大化回报。 我们使用 Q 函数来找到最佳策略，因为 Q 函数告诉我们哪个动作是在某种状态下执行的最佳动作。 您认为我们不使用 Q 函数就能直接找到最优策略吗？ 是。 我们可以。 在策略梯度方法中，我们无需使用 Q 函数就可以找到最优策略。

 在本章中，我们将详细了解政策梯度。 我们还将研究不同类型的策略梯度方法，例如深度确定性策略梯度，然后是最新的策略优化方法，例如信任区域策略优化和近端策略优化。

@@ -9,13 +9,13 @@
 *   政策梯度
 *   使用政策梯度的月球着陆器
 *   深度确定性政策梯度
-*   使用`d`**深度确定性策略梯度**（ **DDPG** ）摆动
+*   使用`d`**深度确定性策略梯度**（**DDPG**）摆动
 *   信任区域政策优化
 *   近端政策优化

 # 政策梯度

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

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

@@ -226,24 +226,24 @@ class PolicyGradient:

 与 DQN 相似，这里我们使用体验缓冲区，通过采样少量的经验来训练 Actor 和 Critic 网络。 我们还使用单独的目标 Actor 和 Critic 网络来计算损失。

-例如，在 Pong 游戏中，我们将具有不同比例的不同特征，例如位置，速度等。 因此，我们以所有要素都处于相同比例的方式来缩放要素。 我们使用一种称为批归一化的方法来缩放要素。 它将所有特征归一化以具有单位均值和方差。 我们如何探索新的行动？ 在连续环境中，将有 *n* 个动作。 为了探索新动作，我们在 Actor 网络产生的动作中添加了一些噪声 *N* 。 我们使用称为 Ornstein-Uhlenbeck 随机过程的过程来生成此噪声。
+例如，在 Pong 游戏中，我们将具有不同比例的不同特征，例如位置，速度等。 因此，我们以所有要素都处于相同比例的方式来缩放要素。 我们使用一种称为批归一化的方法来缩放要素。 它将所有特征归一化以具有单位均值和方差。 我们如何探索新的行动？ 在连续环境中，将有`n`个动作。 为了探索新动作，我们在 Actor 网络产生的动作中添加了一些噪声`N`。 我们使用称为 Ornstein-Uhlenbeck 随机过程的过程来生成此噪声。

 现在，我们将详细介绍 DDPG 算法。

 假设我们有两个网络：Actor 网络和 Critic 网络。 我们用输入为状态的![](img/00312.jpeg)表示 Actor 网络
-，并以![](img/00313.jpeg)作为 Actor 网络权重的结果进行操作。 我们将 Critic 网络表示为![](img/00314.jpeg)，它将输入作为状态和动作并返回 *Q* 值，其中![](img/00315.jpeg)是 Critic 网络权重。
+，并以![](img/00313.jpeg)作为 Actor 网络权重的结果进行操作。 我们将 Critic 网络表示为![](img/00314.jpeg)，它将输入作为状态和动作并返回`Q`值，其中![](img/00315.jpeg)是 Critic 网络权重。

 同样，我们将 Actor 网络和 Critic 网络的目标网络分别定义为![](img/00316.jpeg)和![](img/00317.jpeg)，其中![](img/00318.jpeg)和![](img/00319.jpeg)是目标 Actor 和 Critic 网络的权重。

 我们使用策略梯度更新 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)

-其中 *M* 是来自重播缓冲区的用于训练的样本数。 我们使用根据此损耗 *L* 计算出的梯度来更新评论网络的权重。
+其中`M`是来自重播缓冲区的用于训练的样本数。 我们使用根据此损耗`L`计算出的梯度来更新评论网络的权重。

 同样，我们使用策略梯度更新策略网络权重。 然后，我们在目标网络中更新 Actor 和 Critic 网络的权重。 我们会缓慢更新目标网络的权重，从而提高稳定性。 它称为软替换：

@@ -529,9 +529,9 @@ for i in range(no_of_episodes):

 # 信任区域政策优化

-在了解**信任区域策略优化**（ **TRPO** ）之前，我们需要了解受约束的策略优化。 我们知道，在 RL 代理商中，通过反复试验来学习，以使报酬最大化。 为了找到最佳政策，我们的代理商将探索所有不同的行动，并选择能获得良好回报的行动。 在探索不同的动作时，我们的代理商很有可能也会探索不良的动作。 但是最大的挑战是，当我们允许代理商在现实世界中学习以及奖励功能设计不当时。 例如，考虑一个学习走路而没有遇到任何障碍的特工。 如果代理商被任何障碍物击中，它将获得负奖励；而如果没有被任何障碍物击中，则将获得正奖励。 为了找出最佳策略，代理会探索不同的操作。 代理还采取行动，例如撞到障碍物以检查它是否给出了良好的回报。 但这对我们的经纪人来说并不安全； 当代理在现实环境中学习时，这尤其不安全。 因此，我们介绍了基于约束的学习。 我们设置一个阈值，如果碰到障碍物的可能性小于该阈值，则我们认为我们的代理人是安全的，否则我们认为我们的代理人是不安全的。 添加了约束以确保我们的代理位于安全区域内。
+在了解**信任区域策略优化**（**TRPO**）之前，我们需要了解受约束的策略优化。 我们知道，在 RL 代理商中，通过反复试验来学习，以使报酬最大化。 为了找到最佳政策，我们的代理商将探索所有不同的行动，并选择能获得良好回报的行动。 在探索不同的动作时，我们的代理商很有可能也会探索不良的动作。 但是最大的挑战是，当我们允许代理商在现实世界中学习以及奖励功能设计不当时。 例如，考虑一个学习走路而没有遇到任何障碍的特工。 如果代理商被任何障碍物击中，它将获得负奖励；而如果没有被任何障碍物击中，则将获得正奖励。 为了找出最佳策略，代理会探索不同的操作。 代理还采取行动，例如撞到障碍物以检查它是否给出了良好的回报。 但这对我们的经纪人来说并不安全； 当代理在现实环境中学习时，这尤其不安全。 因此，我们介绍了基于约束的学习。 我们设置一个阈值，如果碰到障碍物的可能性小于该阈值，则我们认为我们的代理人是安全的，否则我们认为我们的代理人是不安全的。 添加了约束以确保我们的代理位于安全区域内。

-在 TRPO 中，我们迭代地改进了该策略，并施加了一个约束，以使旧策略和新策略之间的 **Kullback-Leibler** （ **KL** ）差异要小于某个常数。 ![](img/00326.jpeg)。 该约束称为信任区域约束。
+在 TRPO 中，我们迭代地改进了该策略，并施加了一个约束，以使旧策略和新策略之间的 **Kullback-Leibler**（**KL**）差异要小于某个常数。 ![](img/00326.jpeg)。 该约束称为信任区域约束。

 那么什么是 KL 分歧？ KL 散度告诉我们两个概率分布如何彼此不同。 由于我们的政策是针对行动的概率分布，因此 KL 差异告诉我们新政策与旧政策有多远。 为什么我们必须使旧策略和新策略之间的距离保持小于恒定值![](img/00327.jpeg)？ 因为我们不希望我们的新政策与旧政策脱节。 因此，我们施加了约束以使新策略接近旧策略。 同样，为什么我们必须保持旧政策呢？ 当新政策与旧政策相距甚远时，它将影响代理的学习绩效，并导致完全不同的学习行为。 简而言之，在 TRPO 中，我们朝着改善政策的方向迈出了一步，即使报酬最大化，但我们还应确保满足信任区域约束。 [它使用共轭梯度下降](http://www.idi.ntnu.no/~elster/tdt24/tdt24-f09/cg.pdf)优化网络参数![](img/00328.jpeg)，同时满足约束条件。 该算法保证了单调策略的改进，并且在各种连续环境中也取得了出色的效果。

@@ -574,7 +574,7 @@ Kakade 和 Langford 从（1）得出以下方程式：

 ![](img/00358.jpeg) ----（2）

-*C* 是惩罚系数，等于![](img/00359.jpeg)，![](img/00360.jpeg)表示旧政策与新政策之间的 KL 分歧。
+`C`是惩罚系数，等于![](img/00359.jpeg)，![](img/00360.jpeg)表示旧政策与新政策之间的 KL 分歧。

 如果我们仔细观察前面的方程式（2），我们会注意到，只要右侧最大化，我们的预期长期回报![](img/00361.jpeg)就会单调增加。

@@ -586,7 +586,7 @@ Kakade 和 Langford 从（1）得出以下方程式：

 ![](img/00364.jpeg) ----（4）

-由于我们知道两个相同策略之间的 KL 差异为 *0* ，我们可以这样写：
+由于我们知道两个相同策略之间的 KL 差异为`0`，我们可以这样写：

 ![](img/00365.jpeg) ----（5）

@@ -598,7 +598,7 @@ Kakade 和 Langford 从（1）得出以下方程式：

 ![](img/00370.jpeg)

-但是，在前面的公式中具有惩罚系数 *C* 将导致步长非常小，从而减慢了更新速度。 因此，我们对 KL 分歧的旧策略和新策略施加了约束，即信任区域约束，这将有助于我们找到最佳步长：
+但是，在前面的公式中具有惩罚系数`C`将导致步长非常小，从而减慢了更新速度。 因此，我们对 KL 分歧的旧策略和新策略施加了约束，即信任区域约束，这将有助于我们找到最佳步长：

 ![](img/00371.jpeg)

@@ -610,7 +610,7 @@ Kakade 和 Langford 从（1）得出以下方程式：

 ![](img/00373.jpeg)

-扩展 *L* 的值，我们得到以下信息：
+扩展`L`的值，我们得到以下信息：

 ![](img/00374.jpeg)

@@ -628,13 +628,13 @@ Kakade 和 Langford 从（1）得出以下方程式：

 # 近端政策优化

-现在，我们将看另一种策略优化算法，称为**近端策略优化**（ **PPO** ）。 它是对 TRPO 的改进，由于其性能，已成为解决许多复杂 RL 问题的默认 RL 算法。 它是 OpenAI 的研究人员为克服 TRPO 的缺点而提出的。 回忆一下 TRPO 的替代目标函数。 这是一个约束优化问题，我们在其中施加了一个约束-新旧政策之间的平均 KL 差异应小于![](img/00382.jpeg)。 但是 TRPO 的问题在于，它需要大量计算能力才能计算共轭梯度以执行约束优化。
+现在，我们将看另一种策略优化算法，称为**近端策略优化**（**PPO**）。 它是对 TRPO 的改进，由于其性能，已成为解决许多复杂 RL 问题的默认 RL 算法。 它是 OpenAI 的研究人员为克服 TRPO 的缺点而提出的。 回忆一下 TRPO 的替代目标函数。 这是一个约束优化问题，我们在其中施加了一个约束-新旧政策之间的平均 KL 差异应小于![](img/00382.jpeg)。 但是 TRPO 的问题在于，它需要大量计算能力才能计算共轭梯度以执行约束优化。

 因此，PPO 通过将约束更改为惩罚项来修改 TRPO 的目标函数，因此我们不想执行共轭梯度。 现在，让我们看看 PPO 的工作原理。 我们将![](img/00383.jpeg)定义为新旧政策之间的概率比。 因此，我们可以将目标函数编写为：

 ![](img/00384.jpeg)

-*L <sup class="calibre123">CPI</sup>* 表示保守策略迭代。 但是最大化 *L* 会导致无限制地进行大量策略更新。 因此，我们通过添加惩罚项来重新定义我们的目标函数，该惩罚项会惩罚较大的政策更新。 现在目标函数变为：
+*L <sup class="calibre123">CPI</sup>* 表示保守策略迭代。 但是最大化`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 <sub class="calibre24">1</sub>* 和 *c <sub class="calibre24">2</sub>* 是系数，![](img/00403.jpeg)是实际值和目标值函数之间的平方误差损失，即 是![](img/00404.jpeg)和`S`是熵加。

 # 概要


--- a/new/handson-rl-py/12.md
+++ b/new/handson-rl-py/12.md
 # Capstone 项目–使用 DQN 进行赛车

-在最后几章中，我们通过使用神经网络逼近 q 函数来了解 Deep Q 学习的工作原理。 在此之后，我们看到了**深层 Q 网络**（ **DQN** ）的各种改进，例如 Double Q 学习，决斗网络体系结构和深度递归 Q 网络。 我们已经了解了 DQN 如何利用重播缓冲区来存储座席的经验，并使用缓冲区中的小批样本来训练网络。 我们还实现了用于玩 Atari 游戏的 DQN 和一个用于玩 Doom 游戏的**深度循环 Q 网络**（ **DRQN** ）。 在本章中，让我们进入对决 DQN 的详细实现，它与常规 DQN 基本相同，除了最终的完全连接层将分解为两个流，即值流和优势流，而这些流 两个流将合并在一起以计算 Q 函数。 我们将看到如何训练决斗的 DQN 来赢得赛车比赛的代理商。
+在最后几章中，我们通过使用神经网络逼近 q 函数来了解 Deep Q 学习的工作原理。 在此之后，我们看到了**深层 Q 网络**（**DQN**）的各种改进，例如 Double Q 学习，决斗网络体系结构和深度递归 Q 网络。 我们已经了解了 DQN 如何利用重播缓冲区来存储座席的经验，并使用缓冲区中的小批样本来训练网络。 我们还实现了用于玩 Atari 游戏的 DQN 和一个用于玩 Doom 游戏的**深度循环 Q 网络**（**DRQN**）。 在本章中，让我们进入对决 DQN 的详细实现，它与常规 DQN 基本相同，除了最终的完全连接层将分解为两个流，即值流和优势流，而这些流 两个流将合并在一起以计算 Q 函数。 我们将看到如何训练决斗的 DQN 来赢得赛车比赛的代理商。

 在本章中，您将学习如何实现以下内容：

@@ -192,10 +192,10 @@ class QNetworkDueling(QNetwork):
            self.stride3 = 1

            # Two fully connected layer
-            self.W_fc4a = self.weight_variable([7*7*64, 512])  
+            self.W_fc4a = self.weight_variable([7`7`64, 512])  
            self.B_fc4a = self.bias_variable([512])

-            self.W_fc4b = self.weight_variable([7*7*64, 512])
+            self.W_fc4b = self.weight_variable([7`7`64, 512])
            self.B_fc4b = self.bias_variable([512])

            # Value stream
@@ -227,7 +227,7 @@ class QNetworkDueling(QNetwork):
            self.h_conv3 = tf.nn.relu( tf.nn.conv2d(self.h_conv2, self.W_conv3, strides=[1, self.stride3, self.stride3, 1], padding='VALID') + self.B_conv3 )

            # Flatten the convolutional output
-            self.h_conv3_flat = tf.reshape(self.h_conv3, [-1, 7*7*64])
+            self.h_conv3_flat = tf.reshape(self.h_conv3, [-1, 7`7`64])

            # Fully connected layer
            self.h_fc4a = tf.nn.relu(tf.matmul(self.h_conv3_flat, self.W_fc4a) + self.B_fc4a)
@@ -599,9 +599,9 @@ import tensorflow as tf
 ```py
 ENV_NAME = 'Seaquest-v0'
 TOTAL_FRAMES = 20000000 
-MAX_TRAINING_STEPS = 20*60*60/3
+MAX_TRAINING_STEPS = 20 * 60 * 60 / 3
 TESTING_GAMES = 30
-MAX_TESTING_STEPS = 5*60*60/3
+MAX_TESTING_STEPS = 5 * 60 * 60 / 3
 TRAIN_AFTER_FRAMES = 50000
 epoch_size = 50000 
 MAX_NOOP_START = 30

--- a/new/handson-rl-py/13.md
+++ b/new/handson-rl-py/13.md
@@ -4,7 +4,7 @@

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

-*   **想象力增强剂**（ **I2A** ）
+*   **想象力增强剂**（**I2A**）
 *   向人的偏好学习
 *   从演示中进行深度 Q 学习
 *   后视经验重播
@@ -27,7 +27,7 @@ I2A 的体系结构如下：

 ![](img/00409.gif)

-推出编码器分为两层：想象未来和编码器。 想象未来是想象力发生的地方。 看上图。 想象未来由想象核心组成。 当将状态![](img/00410.jpeg)馈送到想象力核心时，我们得到了新状态![](img/00411.jpeg)和奖励![](img/00412.jpeg)，当我们将这个新状态![](img/00413.jpeg)馈给了下一个想象力核心时，我们得到了下一个新状态 状态![](img/00414.jpeg)和奖励![](img/00415.jpeg)。 当我们在某些 *n* 步骤中重复这些步骤时，我们会得到一个基本上是状态和奖励对的推出，然后我们使用诸如 LSTM 的编码器对该推广进行编码。 结果，我们得到了卷展编码。 这些推出编码实际上是描述未来想象路径的嵌入。 我们将针对未来不同的想象路径使用多个推出编码器，并使用聚合器来聚合此推出编码器。
+推出编码器分为两层：想象未来和编码器。 想象未来是想象力发生的地方。 看上图。 想象未来由想象核心组成。 当将状态![](img/00410.jpeg)馈送到想象力核心时，我们得到了新状态![](img/00411.jpeg)和奖励![](img/00412.jpeg)，当我们将这个新状态![](img/00413.jpeg)馈给了下一个想象力核心时，我们得到了下一个新状态 状态![](img/00414.jpeg)和奖励![](img/00415.jpeg)。 当我们在某些`n`步骤中重复这些步骤时，我们会得到一个基本上是状态和奖励对的推出，然后我们使用诸如 LSTM 的编码器对该推广进行编码。 结果，我们得到了卷展编码。 这些推出编码实际上是描述未来想象路径的嵌入。 我们将针对未来不同的想象路径使用多个推出编码器，并使用聚合器来聚合此推出编码器。

 等待。 想象力如何在**想象力核心**中发生？ **想象力核心**中实际上是什么？ 下图显示了单个**想象核心**：

@@ -60,13 +60,13 @@ I2A 的体系结构如下：
 3.  人员将检查视频剪辑，并了解代理在哪个视频剪辑中表现更好。 他们会将结果发送给奖励预测器。
 4.  现在，代理将从预测的奖励中接收这些信号，并根据人类的反馈设置其目标和奖励功能。

-轨迹是一系列观察和动作。 我们可以将轨迹段表示为![](img/00422.jpeg)，因此![](img/00423.jpeg)，其中 *o* 是观察值， *a* 是动作。 代理从环境接收观察并执行某些操作。 假设我们将交互序列存储在两个轨迹段中，即![](img/00424.jpeg)和![](img/00425.jpeg)。 现在，这两个轨迹已显示给人类。 如果人类更喜欢![](img/00426.jpeg)而不是![](img/00427.jpeg)，那么代理的目标是产生人类所喜欢的轨迹，并相应地设置奖励功能。 这些轨迹段以![](img/00428.jpeg)的形式存储在数据库中； 如果人类更喜欢![](img/00429.jpeg)而不是![](img/00430.jpeg)，则![](img/00431.jpeg)设置为更喜欢![](img/00432.jpeg)。 如果没有一条轨迹是可取的，则两条轨迹都将从数据库中删除。 如果两者均首选，则将![](img/00433.jpeg)设置为统一。
+轨迹是一系列观察和动作。 我们可以将轨迹段表示为![](img/00422.jpeg)，因此![](img/00423.jpeg)，其中`o`是观察值，`a`是动作。 代理从环境接收观察并执行某些操作。 假设我们将交互序列存储在两个轨迹段中，即![](img/00424.jpeg)和![](img/00425.jpeg)。 现在，这两个轨迹已显示给人类。 如果人类更喜欢![](img/00426.jpeg)而不是![](img/00427.jpeg)，那么代理的目标是产生人类所喜欢的轨迹，并相应地设置奖励功能。 这些轨迹段以![](img/00428.jpeg)的形式存储在数据库中； 如果人类更喜欢![](img/00429.jpeg)而不是![](img/00430.jpeg)，则![](img/00431.jpeg)设置为更喜欢![](img/00432.jpeg)。 如果没有一条轨迹是可取的，则两条轨迹都将从数据库中删除。 如果两者均首选，则将![](img/00433.jpeg)设置为统一。

 您可以在[这个页面](https://youtu.be/oC7Cw3fu3gU)上查看视频，以了解算法的工作原理。

 # 从演示中进行深度 Q 学习

-我们已经了解了很多有关 DQN 的知识。 我们从香草 DQN 开始，然后看到了各种改进，例如双重 DQN，决斗的网络体系结构和优先级的体验重播。 我们还学会了构建 DQN 来玩 Atari 游戏。 我们将代理与环境的交互存储在体验缓冲区中，并使代理从这些经验中学习。 但是问题是，我们花了很多培训时间来提高性能。 对于在模拟环境中学习，这很好，但是当我们让代理在现实环境中学习时，会引起很多问题。 为了克服这个问题，谷歌公司 DeepMind 的研究人员在演示（ **DQfd** ）的基础上，对 DQN 进行了改进，称为**深度 Q 学习。**
+我们已经了解了很多有关 DQN 的知识。 我们从香草 DQN 开始，然后看到了各种改进，例如双重 DQN，决斗的网络体系结构和优先级的体验重播。 我们还学会了构建 DQN 来玩 Atari 游戏。 我们将代理与环境的交互存储在体验缓冲区中，并使代理从这些经验中学习。 但是问题是，我们花了很多培训时间来提高性能。 对于在模拟环境中学习，这很好，但是当我们让代理在现实环境中学习时，会引起很多问题。 为了克服这个问题，谷歌公司 DeepMind 的研究人员在演示（**DQfd**）的基础上，对 DQN 进行了改进，称为**深度 Q 学习。**

 如果我们已经有了一些演示数据，则可以将这些演示直接添加到体验重播缓冲区中。 例如，考虑一个学习玩 Atari 游戏的特工。 如果我们已经有了一些演示数据来告诉我们的代理，哪个状态更好，哪个动作可以提供良好的回报，那么代理可以直接使用此数据进行学习。 即使是少量的演示，也可以提高座席的表现并最大程度地减少培训时间。 由于演示的数据将直接添加到优先体验重放缓冲区中，因此代理可以从演示数据中使用的数据量以及代理可以从其自己的交互中用于学习的数据量将由优先体验重放来控制 缓冲，因为经验将被优先考虑。

@@ -76,7 +76,7 @@ DQfd 中的损失函数将是各种损失的总和。 为了防止我们的代

 # 后视经验重播

-我们已经了解了如何在 DQN 中使用体验重播来避免相关体验。 此外，我们了解到，优先体验重播是对香草体验重播的一种改进，因为它优先考虑 TD 错误的每个体验。 现在，我们将研究由 OpenAI 研究人员提出的一种用于处理稀疏奖励的名为**后视经验回放**（ **HER** ）的新技术。 您还记得如何学习骑自行车吗？ 第一次尝试时，您将无法正确平衡自行车。 您可能多次无法正确平衡。 但是，所有这些失败并不意味着您没有学到任何东西。 失败会教你如何不平衡自行车。 即使您没有学会骑自行车（目标），您也学习了一个不同的目标，即，您学会了如何不平衡自行车。 这是我们人类学习的方式，对吗？ 我们从失败中学习，这就是事后回顾经验的想法。
+我们已经了解了如何在 DQN 中使用体验重播来避免相关体验。 此外，我们了解到，优先体验重播是对香草体验重播的一种改进，因为它优先考虑 TD 错误的每个体验。 现在，我们将研究由 OpenAI 研究人员提出的一种用于处理稀疏奖励的名为**后视经验回放**（**HER**）的新技术。 您还记得如何学习骑自行车吗？ 第一次尝试时，您将无法正确平衡自行车。 您可能多次无法正确平衡。 但是，所有这些失败并不意味着您没有学到任何东西。 失败会教你如何不平衡自行车。 即使您没有学会骑自行车（目标），您也学习了一个不同的目标，即，您学会了如何不平衡自行车。 这是我们人类学习的方式，对吗？ 我们从失败中学习，这就是事后回顾经验的想法。

 让我们考虑本文中给出的相同示例。 如图所示，查看 FetchSlide 环境。 在这种环境下的目标是移动机械臂并在桌子上滑动冰球以击中目标，这是一个红色的小圆圈（来自[的图表 https://blog.openai.com/ingredients-for-robotics-research /](https://blog.openai.com/ingredients-for-robotics-research/) ）：

@@ -90,7 +90,7 @@ DQfd 中的损失函数将是各种损失的总和。 为了防止我们的代

 # 分层强化学习

-RL 的问题在于它无法在大量状态空间和动作下很好地扩展，最终导致维度的诅咒。 **分层强化学习**（ **HRL** ）被提出来解决维数的诅咒，其中我们将大问题解压缩为层次结构中的小子问题。 假设代理商的目标是从学校到达家中。 在这里，问题被分解为一组子目标，例如从学校大门出来，预定出租车等。
+RL 的问题在于它无法在大量状态空间和动作下很好地扩展，最终导致维度的诅咒。 **分层强化学习**（**HRL**）被提出来解决维数的诅咒，其中我们将大问题解压缩为层次结构中的小子问题。 假设代理商的目标是从学校到达家中。 在这里，问题被分解为一组子目标，例如从学校大门出来，预定出租车等。

 HRL 中使用了不同的方法，例如状态空间分解，状态抽象和时间抽象。 在状态空间分解中，我们将状态空间分解为不同的子空间，并尝试在较小的子空间中解决问题。 分解状态空间还可以加快探查速度，因为代理程序不希望探究整个状态空间。 在状态抽象中，代理会忽略与在当前状态空间中实现当前子任务无关的变量。 在时间抽象中，将动作序列和动作集分组，这将单个步骤分为多个步骤。

@@ -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* 的预期立即回报：
+如果动作*和*是原始动作，那么我们可以将![](img/00450.jpeg)定义为在`s`状态下执行动作`a`的预期立即回报：

 ![](img/00451.jpeg)

@@ -135,7 +135,7 @@ MAXQ 值函数分解是 HRL 中最常用的算法之一。 让我们看看 MAXQ

 ![](img/00452.jpeg)-（1）

-我们将状态动作值函数 *Q* 表示如下：
+我们将状态动作值函数`Q`表示如下：

 ![](img/00453.jpeg)-（2）


--- a/new/handson-rl-py/14.md
+++ b/new/handson-rl-py/14.md
@@ -2,7 +2,7 @@

 # 第 1 章

-1.  强化学习（ **RL** ）是机器学习的一个分支，其中学习是通过与环境交互来进行的。
+1.  强化学习（**RL**）是机器学习的一个分支，其中学习是通过与环境交互来进行的。
 2.  与其他 ML 范例不同，RL 通过训练和错误方法工作。
 3.  代理是做出明智决策的软件程序，它们基本上是 RL 的学习者。
 4.  策略函数指定在每个状态下要执行的操作，而值函数指定每个状态的值。
@@ -65,7 +65,7 @@

 # 第七章

-1.  在神经元中，我们通过应用称为激活或传递函数的函数 *f（）*将非线性引入结果 *z* 。 请参阅*人工神经元*部分。
+1.  在神经元中，我们通过应用称为激活或传递函数的函数 *f（）*将非线性引入结果`z`。 请参阅*人工神经元*部分。
 2.  激活函数用于引入非线性。
 3.  我们计算成本函数相对于权重的梯度以最小化误差。
 4.  RNN 不仅基于当前输入，而且还基于先前的隐藏状态来预测输出。
@@ -75,7 +75,7 @@

 # 第八章

-1.  **深度 Q 网络**（ **DQN** ）是用于逼近 Q 函数的神经网络。
+1.  **深度 Q 网络**（**DQN**）是用于逼近 Q 函数的神经网络。
 2.  经验重播用于删除座席经验之间的相关性。
 3.  当我们使用同一网络来预测目标值和预测值时，会有很多差异，因此我们使用单独的目标网络。
 4.  由于最大运算符，DQN 高估了 Q 值。
@@ -85,7 +85,7 @@

 # 第九章

-1.  DRQN 利用**递归神经网络**（ **RNN** ），其中 DQN 利用香草神经网络。
+1.  DRQN 利用**递归神经网络**（**RNN**），其中 DQN 利用香草神经网络。
 2.  当可以部分观察 MDP 时，不使用 DQN。
 3.  请参阅*带有 DRQN* 的厄运部分。
 4.  与 DRQN 不同，DARQN 利用注意力机制。
@@ -109,7 +109,7 @@
 3.  Actor 网络的作用是通过调整参数来确定状态中的最佳动作，而 Critic 的作用是评估 Actor 产生的动作。

 4.  请参阅*部分，信任区域策略优化*
-5.  我们迭代地改进了该策略，并施加了一个约束，即旧策略和新策略之间的 **Kullback-Leibler** （ **KL** ）差异要小于某个常数。 该约束称为信任区域约束。
+5.  我们迭代地改进了该策略，并施加了一个约束，即旧策略和新策略之间的 **Kullback-Leibler**（**KL**）差异要小于某个常数。 该约束称为信任区域约束。
 6.  PPO 通过将约束更改为惩罚项来修改 TRPO 的目标函数，因此我们不想执行共轭梯度。

 # 第十二章
@@ -128,7 +128,7 @@
 2.  想象力核心由执行想象力的政策网络和环境模型组成。
 3.  代理人反复从人类那里获得反馈，并根据人类的喜好改变目标。
 4.  DQfd 使用一些演示数据进行培训，因为 DQN 并未预先使用任何演示数据。
-5.  请参阅**后见之明体验回放**（ **HER** ）部分。
+5.  请参阅**后见之明体验回放**（**HER**）部分。

-6.  提出了**分层强化学习**（ **HRL** ），以解决维数诅咒，其中我们将大问题解压缩为层次结构中的小子问题
+6.  提出了**分层强化学习**（**HRL**），以解决维数诅咒，其中我们将大问题解压缩为层次结构中的小子问题
 7.  我们试图在 RL 中找到给定奖励函数的最优策略，而在逆向强化学习中，给出最优策略并找到奖励函数
\ No newline at end of file
--- a/new/intel-proj-py/00.md
+++ b/new/intel-proj-py/00.md
@@ -12,7 +12,7 @@

 第 2 章，“迁移学习”涵盖了如何使用迁移学习来检测人眼中糖尿病性视网膜病变的情况以及确定视网膜病变的严重程度。 我们将探索 CNN，并学习如何使用能够在人眼眼底图像中检测出糖尿病性视网膜病变的 CNN 训练模型。

-第 3 章，“神经机器翻译”涵盖了**递归神经网络**（ **RNN** ）体系结构的基础。 我们还将学习三种不同的机器翻译系统：基于规则的机器翻译，统计机器翻译和神经机器翻译。
+第 3 章，“神经机器翻译”涵盖了**递归神经网络**（**RNN**）体系结构的基础。 我们还将学习三种不同的机器翻译系统：基于规则的机器翻译，统计机器翻译和神经机器翻译。

 第 4 章，“在 GAN 中使用 GAN” 进行时尚行业中的样式迁移，说明如何创建智能 AI 模型以生成具有与给定手袋相似样式的鞋子，反之亦然。 我们将使用 Vanilla GAN 通过 GAN 的定制版本（例如 DiscoGAN 和 CycleGAN）来实施项目。


--- a/new/intel-proj-py/01.md
+++ b/new/intel-proj-py/01.md
--- a/new/intel-proj-py/02.md
+++ b/new/intel-proj-py/02.md
@@ -5,7 +5,7 @@
 我们将在本章中涉及的与迁移学习有关的一些关键主题如下：

 *   使用迁移学习来检测人眼中的糖尿病性视网膜病变状况，并确定视网膜病变的严重程度
-*   探索可用于训练可检测人眼眼底图像中的糖尿病性视网膜病变的**卷积神经网络**（ **CNN** ）的高级预训练卷积神经体系结构
+*   探索可用于训练可检测人眼眼底图像中的糖尿病性视网膜病变的**卷积神经网络**（**CNN**）的高级预训练卷积神经体系结构
 *   查看实际实施 CNN 所需的不同图像预处理步骤
 *   学习制定适合当前问题的成本函数
 *   定义适当的度量标准以衡量训练模型的性能
@@ -36,11 +36,11 @@
 *   人工神经网络的成本面是非凸的； 因此，它需要一组良好的初始权重才能实现合理的收敛。
 *   人工神经网络具有很多参数，因此，它们需要大量数据进行训练。 不幸的是，对于许多项目而言，可用于训练神经网络的特定数据不足，而该项目旨在解决的问题非常复杂，需要神经网络解决方案。

-在这两种情况下，迁移学习都可以解决。 如果我们使用在大量标记数据上训练的预训练模型，例如 ImageNet 或 CIFAR，则涉及迁移学习的问题将具有很好的初始权重来开始训练; 然后可以根据现有数据对这些权重进行微调。 同样，为了避免在较少的数据量上训练复杂的模型，我们可能希望从预先训练的神经网络中提取复杂的特征，然后使用这些特征来训练相对简单的模型，例如 SVM 或逻辑模型 回归模型。 举个例子，如果我们正在研究图像分类问题，并且已经有一个预先训练的模型（例如，基于 1,000 个 ImageNet 的`VGG16`网络），我们可以通过`VGG16`的权重传递训练数据 并从最后一个池化层提取特征。 如果我们有 *m* 个训练数据点，则可以使用等式![](img/139dc334-8e37-42cb-a0b1-1b0365f4800f.png)，其中 *x* 是特征向量， *y* 是输出类。 然后，我们可以从预先训练的`VGG16`网络中得出复杂的特征，例如向量 *h* ，如下所示：
+在这两种情况下，迁移学习都可以解决。 如果我们使用在大量标记数据上训练的预训练模型，例如 ImageNet 或 CIFAR，则涉及迁移学习的问题将具有很好的初始权重来开始训练; 然后可以根据现有数据对这些权重进行微调。 同样，为了避免在较少的数据量上训练复杂的模型，我们可能希望从预先训练的神经网络中提取复杂的特征，然后使用这些特征来训练相对简单的模型，例如 SVM 或逻辑模型 回归模型。 举个例子，如果我们正在研究图像分类问题，并且已经有一个预先训练的模型（例如，基于 1,000 个 ImageNet 的`VGG16`网络），我们可以通过`VGG16`的权重传递训练数据 并从最后一个池化层提取特征。 如果我们有`m`个训练数据点，则可以使用等式![](img/139dc334-8e37-42cb-a0b1-1b0365f4800f.png)，其中`x`是特征向量，`y`是输出类。 然后，我们可以从预先训练的`VGG16`网络中得出复杂的特征，例如向量`h`，如下所示：

 ![](img/bb55e155-7677-4ae6-8bf9-9998e72422ab.png)

-此处 *W* 是经过预训练的`VGG16`网络的权重集，直到最后一个池化层。
+此处`W`是经过预训练的`VGG16`网络的权重集，直到最后一个池化层。

 然后我们可以使用经过转换的训练数据点集![](img/080334e1-6154-4fa1-8842-facd28520bd6.png)来构建相对简单的模型。

@@ -72,7 +72,7 @@

 ![](img/654757ad-de20-47fc-9b3f-a320446f607c.png)

-此处， *c* 是正确分类的样本数， *N* 是评估样本的总数。
+此处，`c`是正确分类的样本数，`N`是评估样本的总数。

 与 Kaggle 标准相比，我们还将使用**二次加权 kappa** 统计信息确定模型的质量，并确定模型的性能基准。 二次加权 kappa 定义如下：

@@ -84,9 +84,9 @@

 在上式中，以下内容适用：

-*   *N* 代表类别数
-*   *O <sub>ij</sub>* 表示已被预测为 *i* 类的图像数量，其中图像的实际类别为 *j*
-*   *E <sub>ij</sub>* 表示预测类别为 *i* 的预期观察次数，而实际类别为 *j* ，假设 预测班和实际班
+*`N`代表类别数
+*   *O <sub>ij</sub>* 表示已被预测为`i`类的图像数量，其中图像的实际类别为`j`
+*   *E <sub>ij</sub>* 表示预测类别为`i`的预期观察次数，而实际类别为`j`，假设 预测班和实际班

 为了更好地了解 kappa 指标组件，让我们看一下苹果和橘子的二进制分类。 假设预测类和实际类的混淆矩阵如下图所示：

@@ -102,7 +102,7 @@

 如果您熟悉两个类别变量之间的独立性卡方检验，则假设类别变量之间具有独立性，则列联表中每个单元格中的预期计数都是基于相同的公式计算的。

-可以从混淆矩阵中直接追踪模型的观测计数，该模型预测的真实标签为*橙色*时，预测的*苹果*等于 *5* ，如下所示：
+可以从混淆矩阵中直接追踪模型的观测计数，该模型预测的真实标签为*橙色*时，预测的*苹果*等于`5`，如下所示：

 ![](img/f6d73ecf-a072-4064-9b92-8e880c0080e6.png)

@@ -122,17 +122,17 @@
 *   **严重的糖尿病性视网膜病变**：[0 0 0 1 0] <sup>T</sup>
 *   **糖尿病性增生性视网膜病变**：[0 0 0 0 1] <sup>T</sup>

-Softmax 将是表示输出层中不同类别的概率的最佳激活函数，而每个数据点的分类交叉熵损失之和将是优化的最佳损失。 对于具有输出标签向量 *y* 和 *p* 的预测概率的单个数据点，交叉熵损失由以下公式给出：
+Softmax 将是表示输出层中不同类别的概率的最佳激活函数，而每个数据点的分类交叉熵损失之和将是优化的最佳损失。 对于具有输出标签向量`y`和`p`的预测概率的单个数据点，交叉熵损失由以下公式给出：

 ![](img/8058232c-897d-4cec-9a2d-768e01646985.png)

 这里是![](img/a33a501b-e7a0-493e-a5d8-a72cb436bd4c.png)和![](img/e843ff33-9d4b-47d4-87c5-76825a0c42d5.png)。

-同样， *M* 训练数据点上的平均损耗可以表示为：
+同样，`M`训练数据点上的平均损耗可以表示为：

 ![](img/79a945ed-f72e-486f-9b76-d6a9a3ec21f2.png)

-在训练过程中，小批量的梯度基于*（2）*给出的平均对数损失，其中 *M* 是所选的批量大小。 对于我们将结合验证准确性进行监视的验证日志丢失， *M* 是验证集数据点的数量。 由于我们将在每个折叠中进行 **K 折叠交叉验证**，因此在每个折叠中我们将具有不同的验证数据集。
+在训练过程中，小批量的梯度基于*（2）*给出的平均对数损失，其中`M`是所选的批量大小。 对于我们将结合验证准确性进行监视的验证日志丢失，`M`是验证集数据点的数量。 由于我们将在每个折叠中进行 **K 折叠交叉验证**，因此在每个折叠中我们将具有不同的验证数据集。

 现在我们已经定义了训练方法，损失函数和验证指标，让我们继续进行数据探索和建模。

@@ -204,7 +204,7 @@ def get_im_cv2(path,dim=224):

 ![](img/1fe912fc-2dba-41b7-abe9-03443e5a0be2.png)

-在这种情况下，转换向量 *b，*为零。 通过选择一个非零 *b* ，我们可以得到旋转和平移。
+在这种情况下，转换向量 *b，*为零。 通过选择一个非零`b`，我们可以得到旋转和平移。

 例如，下图显示了视网膜的照片，然后是旋转 90 度的同一张照片：

@@ -220,7 +220,7 @@ def get_im_cv2(path,dim=224):

 ![](img/73d49d1a-f974-40f0-9638-6ee27f574016.png)

-例如，对于垂直方向上五个像素位置和水平方向上三个像素位置的平移，我们可以使用 *b = [5 3] <sup>T</sup>* 和 *M* 作为单位矩阵。
+例如，对于垂直方向上五个像素位置和水平方向上三个像素位置的平移，我们可以使用 *b = [5 3] <sup>T</sup>* 和`M`作为单位矩阵。

 以下是沿图像的宽度和高度按 24 个像素位置对视网膜进行的图像平移：

@@ -234,7 +234,7 @@ def get_im_cv2(path,dim=224):

 ![](img/f7892eff-50fc-4cf8-a629-271ad0cd18e3.png)

-这里， *S <sub>v</sub>* 表示沿垂直方向的比例因子， *S <sub>h</sub>* 表示沿水平方向的比例因子（请参见 *图 2.6* 为插图）。 我们还可以选择通过具有非零转换向量 *b* 来跟随转换的缩放：
+这里， *S <sub>v</sub>* 表示沿垂直方向的比例因子， *S <sub>h</sub>* 表示沿水平方向的比例因子（请参见 *图 2.6* 为插图）。 我们还可以选择通过具有非零转换向量`b`来跟随转换的缩放：

 ![](img/3b758265-dbb1-48fb-a744-4a08fef9ce08.png)


--- a/new/intel-proj-py/03.md
+++ b/new/intel-proj-py/03.md
--- a/new/intel-proj-py/05.md
+++ b/new/intel-proj-py/05.md
@@ -29,7 +29,7 @@

 # 视频字幕中的 CNN 和 LSTM

-视频减去音频后，可以认为是按顺序排列的图像集合。 可以使用针对特定图像分类问题训练的卷积神经网络（例如 **ImageNet** ）从这些图像中提取重要特征。 预训练网络的最后一个完全连接层的激活可用于从视频的顺序采样图像中得出特征。 从视频顺序采样图像的频率速率取决于视频中内容的类型，可以通过训练进行优化。
+视频减去音频后，可以认为是按顺序排列的图像集合。 可以使用针对特定图像分类问题训练的卷积神经网络（例如 **ImageNet**）从这些图像中提取重要特征。 预训练网络的最后一个完全连接层的激活可用于从视频的顺序采样图像中得出特征。 从视频顺序采样图像的频率速率取决于视频中内容的类型，可以通过训练进行优化。

 下图（*图 5.1* ）说明了用于从视频中提取特征的预训练神经网络：

@@ -37,7 +37,7 @@

 图 5.1：使用预训练的神经网络提取视频图像特征

-从上图可以看出，从视频中顺序采样的图像经过预训练的卷积神经网络，并且最后一个完全连接层中的 **`4,096`** 单元的激活为 输出。 如果将 *t* 时的视频图像表示为 *x <sub>t</sub>* ，并且最后一个完全连接层的输出表示为 *f <sub>t</sub> ∈R <sup>4096</sup>* ，然后 *f <sub>t =</sub> f <sub>w</sub> （x <sub>t</sub> ）* [ <sub>。</sub> 此处， *W* 表示直到最后一个完全连接层的卷积神经网络的权重。
+从上图可以看出，从视频中顺序采样的图像经过预训练的卷积神经网络，并且最后一个完全连接层中的 **`4,096`** 单元的激活为 输出。 如果将`t`时的视频图像表示为 *x <sub>t</sub>* ，并且最后一个完全连接层的输出表示为 *f <sub>t</sub> ∈R <sup>4096</sup>* ，然后 *f <sub>t =</sub> f <sub>w</sub> （x <sub>t</sub> ）* [ <sub>。</sub> 此处，`W`表示直到最后一个完全连接层的卷积神经网络的权重。

 这些系列的输出功能 *f <sub>1，</sub> f <sub>2，...。 。 。 。 。</sub> f <sub>t。 。 。</sub> f <sub>N</sub>* 可以作为递归神经网络的输入，该神经网络学习根据输入特征生成文本标题，如下图所示（*图 5.2* ]）：

@@ -61,15 +61,15 @@

 图 5.3：序列到序列视频字幕网络架构

-序列到序列模型通过像以前一样通过预训练的卷积神经网络处理视频图像帧，最后一个完全连接层的输出激活被视为要馈送到后续 LSTM 的特征。 如果我们在时间步 *t* 表示预训练卷积神经网络的最后一个完全连接层的输出激活为 *f <sub>t</sub> ∈R <sup>4096</sup>* ，那么我们将为视频中的 *N* 个图像帧使用 *N* 个这样的特征向量。 这些 *N* 个特征向量 *f1，f2，...。 。 。 。 。 f <sub>t</sub> 。 。 。 f <sub>N</sub>* 依次输入 LSTM，以生成文本标题。
+序列到序列模型通过像以前一样通过预训练的卷积神经网络处理视频图像帧，最后一个完全连接层的输出激活被视为要馈送到后续 LSTM 的特征。 如果我们在时间步`t`表示预训练卷积神经网络的最后一个完全连接层的输出激活为 *f <sub>t</sub> ∈R <sup>4096</sup>* ，那么我们将为视频中的`N`个图像帧使用`N`个这样的特征向量。 这些`N`个特征向量 *f1，f2，...。 。 。 。 。 f <sub>t</sub> 。 。 。 f <sub>N</sub>* 依次输入 LSTM，以生成文本标题。

-背靠背有两个 LSTM，LSTM 中的序列数是来自视频的图像帧数与字幕词汇表中文本字幕的最大长度之和。 如果在视频的 *N* 个图像帧上训练网络，并且词汇表中的最大文本标题长度为 *M* ，则 LSTM 在*（N + M）上训练[* 时间步长。 在 *N* 个时间步中，第一个 LSTM 处理特征向量 *f1，f2，...。 。 。 。 。 f <sub>t</sub> 。 。 。 f <sub>N</sub>* 依次生成，并将其生成的隐藏状态馈送到第二 LSTM。 在这些 *N* 个时间步中，第二个 LSTM 不需要文本输出目标。 如果我们将第一个 LSTM 在时间步 *t* 的隐藏状态表示为 *h <sub>t</sub>* ，则对于第二个 LSTM，第一个 *N [* 时间步长为 *h <sub>t</sub>* 。 请注意，从 N + 1 时间步长到第一个 LSTM 的输入是零填充的，因此该输入对 *t [ *h <sub>t</sub>* 没有隐藏状态的影响。 > N* 。 请注意，这并不保证 t > N 的隐藏状态 *h <sub>t</sub>* 总是相同的。 实际上，我们可以选择在任何时间步长 *t >中将 *h <sub>t</sub>* 作为 *h <sub>T</sub>* 送入第二个 LSTM。 ] N.*
+背靠背有两个 LSTM，LSTM 中的序列数是来自视频的图像帧数与字幕词汇表中文本字幕的最大长度之和。 如果在视频的`N`个图像帧上训练网络，并且词汇表中的最大文本标题长度为`M`，则 LSTM 在*（N + M）上训练[* 时间步长。 在`N`个时间步中，第一个 LSTM 处理特征向量 *f1，f2，...。 。 。 。 。 f <sub>t</sub> 。 。 。 f <sub>N</sub>* 依次生成，并将其生成的隐藏状态馈送到第二 LSTM。 在这些`N`个时间步中，第二个 LSTM 不需要文本输出目标。 如果我们将第一个 LSTM 在时间步`t`的隐藏状态表示为 *h <sub>t</sub>* ，则对于第二个 LSTM，第一个 *N [* 时间步长为 *h <sub>t</sub>* 。 请注意，从 N + 1 时间步长到第一个 LSTM 的输入是零填充的，因此该输入对 *t [ *h <sub>t</sub>* 没有隐藏状态的影响。 > N* 。 请注意，这并不保证 t > N 的隐藏状态 *h <sub>t</sub>* 总是相同的。 实际上，我们可以选择在任何时间步长 *t >中将 *h <sub>t</sub>* 作为 *h <sub>T</sub>* 送入第二个 LSTM。 ] N.*

-从*（N + 1）*时间步长开始，第二个 LSTM 需要文本输出目标。 在任何时间步长 *t > N* 的输入是 *[h <sub>t</sub> ，w <sub>t-1</sub> ]* ，其中 *h <sub>t</sub>* 是第一个 LSTM 在时间步 *t* 的隐藏状态，而 *w <sub>t-1</sub>* 是 时间步*（t-1）*中的文本标题词。
+从*（N + 1）*时间步长开始，第二个 LSTM 需要文本输出目标。 在任何时间步长 *t > N* 的输入是 *[h <sub>t</sub> ，w <sub>t-1</sub> ]* ，其中 *h <sub>t</sub>* 是第一个 LSTM 在时间步`t`的隐藏状态，而 *w <sub>t-1</sub>* 是 时间步*（t-1）*中的文本标题词。

 在*（N + 1）*时间步长处，馈送到第二 LSTM 的单词 *w <sub>N</sub>* 是由`<bos>`表示的句子的开头。 一旦生成句子符号`<eos>`的结尾，就训练网络停止生成标题词。 总而言之，两个 LSTM 的设置方式是，一旦它们处理完所有视频图像帧特征 *![](img/8ad769e2-57c1-4581-98e1-7c7f70a12413.png)* ，它们便开始产生文本标题词。

-处理时间步 *t > N* 的第二个 LSTM 输入的另一种方法是只喂 *[w <sub>t-1</sub> ]* 而不是 HTG6] [h <sub>t</sub> ，w <sub>t-1</sub> ] ，并在时间步 *T* 传递第一个 LSTM 的隐藏状态和单元状态。 *[h <sub>T</sub> ，c <sub>T</sub> ]* 到第二个 LSTM 的初始隐藏和细胞状态。 这样的视频字幕网络的体系结构可以说明如下（请参见*图 5.4* ）：
+处理时间步 *t > N* 的第二个 LSTM 输入的另一种方法是只喂 *[w <sub>t-1</sub> ]* 而不是 HTG6] [h <sub>t</sub> ，w <sub>t-1</sub> ] ，并在时间步`T`传递第一个 LSTM 的隐藏状态和单元状态。 *[h <sub>T</sub> ，c <sub>T</sub> ]* 到第二个 LSTM 的初始隐藏和细胞状态。 这样的视频字幕网络的体系结构可以说明如下（请参见*图 5.4* ）：

 ![](img/f2805f4e-f512-4272-8988-4c3b2b73a400.png)

@@ -89,7 +89,7 @@

 # 处理视频图像以创建 CNN 功能

-从指定位置下载数据后，下一个任务是处理视频图像帧，以从预训练的卷积神经网络的最后完全连接的层中提取特征。 我们使用在 ImageNet 上预训练的`VGG16`卷积神经网络。 我们将激活从`VGG16`的最后一个完全连接的层中取出。 由于`VGG16`的最后一个完全连接的层具有`4096`单位，因此每个时间步 *t* 的特征向量 *f <sub>t</sub>* 为`4096`， *f <sub>t</sub> ∈R <sup>4096</sup>* 的维向量。
+从指定位置下载数据后，下一个任务是处理视频图像帧，以从预训练的卷积神经网络的最后完全连接的层中提取特征。 我们使用在 ImageNet 上预训练的`VGG16`卷积神经网络。 我们将激活从`VGG16`的最后一个完全连接的层中取出。 由于`VGG16`的最后一个完全连接的层具有`4096`单位，因此每个时间步`t`的特征向量 *f <sub>t</sub>* 为`4096`， *f <sub>t</sub> ∈R <sup>4096</sup>* 的维向量。

 在通过`VGG16`处理视频中的图像之前，需要从视频中对其进行采样。 我们从视频中采样图像，使每个视频具有`80`帧。 处理来自`VGG16`的`80`图像帧后，每个视频将具有`80`特征向量 *f1，f2，...。 。 。 。 。 f <sub>t</sub> 。 。 。 f <sub>80</sub>* 。 这些功能将被馈送到 LSTM 以生成文本序列。 我们在 Keras 中使用了预训练的`VGG16`模型。 我们创建一个`VideoCaptioningPreProcessing`类，该类首先通过函数`video_to_frames`从每个视频中提取`80`视频帧作为图像，然后通过功能`extract_feats_pretrained_cnn`中的预训练`VGG16`卷积神经网络处理这些视频帧。 。

@@ -261,11 +261,11 @@ def get_clean_caption_data(self,text_path,feat_path):

 # 建立模型

-在本节中，说明了核心模型构建练习。 我们首先为文本标题的词汇表中的单词定义一个嵌入层，然后是两个 LSTM。 权重`self.encode_W`和`self.encode_b`用于减少卷积神经网络中特征 *f <sub>t</sub>* 的尺寸。 对于第二个 LSTM（LSTM 2），在任何时间步长处的其他输入之一 *t > N* 是前一个单词 *w <sub>t-1</sub>* 从第一个 LSTM（LSTM 1）输出 *h <sub>t</sub>* 。 将 *w* <sub>*t-1*</sub> 嵌入的单词送入 LSTM 2，而不是原始的一个热编码矢量。 对于第一个 N `(self.video_lstm_step)`，LSTM 1 处理来自 CNN 的输入特征 *f <sub>t</sub>* ，以及输出隐藏状态 *<sup>h <sub>t [</sub></sup> （输出 1）*被馈送到 LSTM2。在此编码阶段，LSTM 2 不会接收任何单词 *w <sub>t-1</sub>* 作为 输入。
+在本节中，说明了核心模型构建练习。 我们首先为文本标题的词汇表中的单词定义一个嵌入层，然后是两个 LSTM。 权重`self.encode_W`和`self.encode_b`用于减少卷积神经网络中特征 *f <sub>t</sub>* 的尺寸。 对于第二个 LSTM（LSTM 2），在任何时间步长处的其他输入之一 *t > N* 是前一个单词 *w <sub>t-1</sub>* 从第一个 LSTM（LSTM 1）输出 *h <sub>t</sub>* 。 将`w`<sub>*t-1*</sub> 嵌入的单词送入 LSTM 2，而不是原始的一个热编码矢量。 对于第一个 N `(self.video_lstm_step)`，LSTM 1 处理来自 CNN 的输入特征 *f <sub>t</sub>* ，以及输出隐藏状态 *<sup>h <sub>t [</sub></sup> （输出 1）*被馈送到 LSTM2。在此编码阶段，LSTM 2 不会接收任何单词 *w <sub>t-1</sub>* 作为 输入。

-从*（N + 1）*时间步长，我们进入解码阶段，在此阶段，连同 *<sup>h <sub>t</sub></sup> （输出 1）* 从 LSTM 1 开始，先前的时间步字嵌入矢量 *w <sub>t-1</sub>* 被馈送到 LSTM2。在这一阶段，没有输入到 LSTM 1，因为所有 特征 *f <sub>t</sub>* 在时间步 *N* 耗尽。 解码阶段的时间步长由`self.caption_lstm_step`确定。
+从*（N + 1）*时间步长，我们进入解码阶段，在此阶段，连同 *<sup>h <sub>t</sub></sup> （输出 1）* 从 LSTM 1 开始，先前的时间步字嵌入矢量 *w <sub>t-1</sub>* 被馈送到 LSTM2。在这一阶段，没有输入到 LSTM 1，因为所有 特征 *f <sub>t</sub>* 在时间步`N`耗尽。 解码阶段的时间步长由`self.caption_lstm_step`确定。

-现在，如果我们用函数 *f2，*表示 LSTM 2 的活动，则 *f <sub>2</sub> （h <sub>t，</sub> w <sub>t- 1</sub> ）= h <sub>2t</sub>* ，其中 *h <sub>2t</sub>* 是 LSTM 2 在时间步 *t* 的隐藏状态 ]。 该隐藏状态 *h <sub>2t</sub>* 在时间 *t* 时，通过 *softmax* 函数转换为输出单词的概率分布， 选择最高概率的单词作为下一个单词![](img/a18e98b6-e400-4784-9452-c7ab8bc9a7cc.png)：
+现在，如果我们用函数 *f2，*表示 LSTM 2 的活动，则 *f <sub>2</sub> （h <sub>t，</sub> w <sub>t- 1</sub> ）= h <sub>2t</sub>* ，其中 *h <sub>2t</sub>* 是 LSTM 2 在时间步`t`的隐藏状态 ]。 该隐藏状态 *h <sub>2t</sub>* 在时间`t`时，通过 *softmax* 函数转换为输出单词的概率分布， 选择最高概率的单词作为下一个单词![](img/a18e98b6-e400-4784-9452-c7ab8bc9a7cc.png)：

 ![](img/09b71b6c-5a27-49ae-965b-98e8810fbdb9.png) = ![](img/9ae080a8-cf15-45f5-ad50-b98244404366.png)

@@ -274,7 +274,7 @@ def get_clean_caption_data(self,text_path,feat_path):
 这些权重 *W <sub>ho</sub>* 和 *b，*在以下代码块中定义为`self.word_emb_W`和`self.word_emb_b`。 有关更多详细信息，请参考`build_model`功能。 为了方便解释，构建功能分为三部分。 构建模型有 3 个主要单元

 *   **定义阶段**：定义变量，标题词的嵌入层和序列到序列模型的两个 LSTM。
-*   **编码阶段**：在这一阶段中，我们将视频帧图像特征传递给 LSTM1 的时间步长，并将每个时间步长的隐藏状态传递给 LSTM2。此活动一直进行到时间步长 *] N* 其中 *N* 是从每个视频中采样的视频帧图像的数量。
+*   **编码阶段**：在这一阶段中，我们将视频帧图像特征传递给 LSTM1 的时间步长，并将每个时间步长的隐藏状态传递给 LSTM2。此活动一直进行到时间步长 *] N* 其中`N`是从每个视频中采样的视频帧图像的数量。
 *   **解码阶段**：在解码阶段，LSTM 2 开始生成文本字幕。 关于时间步骤，解码阶段从步骤 *N + 1* 开始。 从 LSTM 2 的每个时间步生成的单词将作为输入与 LSTM 1 的隐藏状态一起输入到下一个状态。

 # 模型变量的定义
@@ -332,7 +332,7 @@ def get_clean_caption_data(self,text_path,feat_path):

 在编码阶段，我们通过使它们经过 LSTM 1 的时间步长，依次处理每个视频图像帧特征（来自 CNN 最后一层）。视频图像帧的维数为`4096.`，然后再将这些高维视频帧特征向量馈入 LSTM 1，它们缩小为较小的`512.`

-LSTM 1 在每个时间步长处理视频帧图像并将隐藏状态传递给 LSTM 2，此过程一直持续到时间步长 *N* （`self.video_lstm_step`）。 编码器的代码如下：
+LSTM 1 在每个时间步长处理视频帧图像并将隐藏状态传递给 LSTM 2，此过程一直持续到时间步长`N`（`self.video_lstm_step`）。 编码器的代码如下：

 ```py
 probs = []
@@ -475,7 +475,7 @@ unk => A substitute for a word that is not included in the vocabulary

 ![](img/21a19e2b-fef3-4156-b1b2-8812e5a6b329.png)

-此处，![](img/6642a024-56d0-41c5-88a4-2f2bfe5820a2.png)是时间步长 *t* 时实际目标单词的一个热编码矢量，而![](img/3463c520-4df0-40bc-902b-27d871ed8803.png)是模型预测的概率矢量。
+此处，![](img/6642a024-56d0-41c5-88a4-2f2bfe5820a2.png)是时间步长`t`时实际目标单词的一个热编码矢量，而![](img/3463c520-4df0-40bc-902b-27d871ed8803.png)是模型预测的概率矢量。

 在训练期间的每个时期都会记录损失，以了解损失减少的性质。 这里要注意的另一件事是，我们正在使用 TensorFlow 的`tf.train.saver`函数保存经过训练的模型，以便我们可以恢复模型以进行推理。


--- a/new/intel-proj-py/06.md
+++ b/new/intel-proj-py/06.md
--- a/new/intel-proj-py/08.md
+++ b/new/intel-proj-py/08.md
@@ -73,7 +73,7 @@

 图 8.3：序列到序列模型

-与其将编码器最后一步的隐藏状态![](img/b280832c-087e-4ce5-99f0-9a205e376734.png)和单元状态![](img/4347c730-0027-498b-861c-83a9b8964b97.png)馈送到**解码器 LSTM** 的初始隐藏状态和单元状态，我们将隐藏状态![](img/6ab55e2d-1eb0-4ee6-a521-7bc8647608fc.png)馈入 解码器的每个输入步骤。 为了预测目标词 *w <sub> t </sub>* 在任何步骤 *t* 中，输入是先前的目标词 *w <sub> t-1 </sub>* ， *t-1* 和隐藏状态![](img/7468f056-f04e-453b-b511-e68a97fa151e.png)。
+与其将编码器最后一步的隐藏状态![](img/b280832c-087e-4ce5-99f0-9a205e376734.png)和单元状态![](img/4347c730-0027-498b-861c-83a9b8964b97.png)馈送到**解码器 LSTM** 的初始隐藏状态和单元状态，我们将隐藏状态![](img/6ab55e2d-1eb0-4ee6-a521-7bc8647608fc.png)馈入 解码器的每个输入步骤。 为了预测目标词 *w <sub> t </sub>* 在任何步骤`t`中，输入是先前的目标词 *w <sub> t-1 </sub>* ， *t-1* 和隐藏状态![](img/7468f056-f04e-453b-b511-e68a97fa151e.png)。

 # Twitter 上的客户支持

@@ -171,9 +171,9 @@ def words_to_indices(self,sent):

 RNN 的 LSTM 版本用于构建序列到序列模型。 这是因为 LSTM 在记住长文本序列中的长期依存关系方面效率更高。 LSTM 体系结构中的三个门使它能够有效地记住长期序列。 基本的 RNN 无法记住长期依赖关系，因为与其架构相关的梯度问题逐渐消失。

-在此模型中，我们使用两个 LSTM。 第一个 LSTM 将输入推文编码为上下文向量。 该上下文向量不过是编码器 LSTM 的最后一个隐藏状态![](img/88e131cf-cc81-4f08-bb73-0bbb27ce18ed.png)， *n* 是隐藏状态向量的维。 输入推文![](img/ee42536a-7091-4d15-8ec9-ef97ead2b272.png)作为单词索引序列被馈送到编码器 LSTM， *k* 就是输入推文的序列长度。 这些单词索引在馈送到 LSTM 之前已映射到单词嵌入 *w∈R <sup> m </sup>* 。 单词嵌入包含在一个嵌入矩阵中 *[W∈R <sup>m x N</sup> ]，*，其中 *N* 表示词汇表中单词的数量。
+在此模型中，我们使用两个 LSTM。 第一个 LSTM 将输入推文编码为上下文向量。 该上下文向量不过是编码器 LSTM 的最后一个隐藏状态![](img/88e131cf-cc81-4f08-bb73-0bbb27ce18ed.png)，`n`是隐藏状态向量的维。 输入推文![](img/ee42536a-7091-4d15-8ec9-ef97ead2b272.png)作为单词索引序列被馈送到编码器 LSTM，`k`就是输入推文的序列长度。 这些单词索引在馈送到 LSTM 之前已映射到单词嵌入 *w∈R <sup> m </sup>* 。 单词嵌入包含在一个嵌入矩阵中 *[W∈R <sup>m x N</sup> ]，*，其中`N`表示词汇表中单词的数量。

-第二个 LSTM 用作解码器。 它试图将编码器 LSTM 创建的上下文向量![](img/4c8e1ab3-3b4e-4061-b674-5cbd46748052.png)解码为有意义的响应。 作为此方法的一部分，我们在每个时间步中将上下文向量与前一个单词一起馈入以生成当前单词。 在第一步中，我们没有任何先前的词可用于条件 LSTM，因此我们使用代理`START`词开始从解码器 LSTM 生成词序列的过程。 在推论过程中，我们在当前时间步输入前一个单词的方式与训练过程中使用的方法不同。 在训练中，由于我们在每个时间步都知道 *apriori* 之前的单词，因此相应地输入它们没有任何问题。 但是，在推论期间，由于我们在当前时间步上没有实际的前一个单词，因此会反馈前一个时间步上的预测单词。 每个时间步 *t* 的隐藏状态![](img/99084dfb-e5ab-4074-ad44-01bb8d36b1d3.png)在最终的最大 softmax *N* 之前通过几个完全连接的层馈送。 在此 softmax 层中获得最大概率的单词是时间步长的预测单词。 然后将这个字输入到下一步的输入，即解码器 LSTM 的步骤 *t + 1* 。
+第二个 LSTM 用作解码器。 它试图将编码器 LSTM 创建的上下文向量![](img/4c8e1ab3-3b4e-4061-b674-5cbd46748052.png)解码为有意义的响应。 作为此方法的一部分，我们在每个时间步中将上下文向量与前一个单词一起馈入以生成当前单词。 在第一步中，我们没有任何先前的词可用于条件 LSTM，因此我们使用代理`START`词开始从解码器 LSTM 生成词序列的过程。 在推论过程中，我们在当前时间步输入前一个单词的方式与训练过程中使用的方法不同。 在训练中，由于我们在每个时间步都知道 *apriori* 之前的单词，因此相应地输入它们没有任何问题。 但是，在推论期间，由于我们在当前时间步上没有实际的前一个单词，因此会反馈前一个时间步上的预测单词。 每个时间步`t`的隐藏状态![](img/99084dfb-e5ab-4074-ad44-01bb8d36b1d3.png)在最终的最大 softmax`N`之前通过几个完全连接的层馈送。 在此 softmax 层中获得最大概率的单词是时间步长的预测单词。 然后将这个字输入到下一步的输入，即解码器 LSTM 的步骤 *t + 1* 。

 Keras 中的`TimeDistributed`函数允许在解码器 LSTM 的每个时间步长获得预测的有效实现，如以下代码所示：

@@ -255,7 +255,7 @@ Keras 中的`TimeDistributed`函数允许在解码器 LSTM 的每个时间步长

 ![](img/81b811e5-db95-4cf3-9d09-b9a0c7bff88e.png)

-标签![](img/4c028cd4-d57a-489b-996e-b927c42f77cb.png)代表目标单词的一个热编码版本。 仅对应于实际单词的标签为 *1* ； 其余为*零*。 术语 *Pi* 表示实际目标单词是由 *i* 索引的单词的概率。 为了获得每个输入/输出推特对的总损耗 *C* ，我们需要对解码器 LSTM 的所有时间步长上的损耗求和。 由于词汇量可能会变得很大，因此在每个时间步骤中为目标标签创建一个热编码矢量![](img/870f6ff9-07dd-4ab8-8a31-f3ab8701361c.png)会很昂贵。 `sparse_categorical_crossentropy`损失在这里变得非常有益，因为我们不需要将目标单词转换为一个热编码矢量，而只需输入目标单词的索引作为目标标签即可。
+标签![](img/4c028cd4-d57a-489b-996e-b927c42f77cb.png)代表目标单词的一个热编码版本。 仅对应于实际单词的标签为`1`； 其余为*零*。 术语 *Pi* 表示实际目标单词是由`i`索引的单词的概率。 为了获得每个输入/输出推特对的总损耗`C`，我们需要对解码器 LSTM 的所有时间步长上的损耗求和。 由于词汇量可能会变得很大，因此在每个时间步骤中为目标标签创建一个热编码矢量![](img/870f6ff9-07dd-4ab8-8a31-f3ab8701361c.png)会很昂贵。 `sparse_categorical_crossentropy`损失在这里变得非常有益，因为我们不需要将目标单词转换为一个热编码矢量，而只需输入目标单词的索引作为目标标签即可。

 # 训练模型


--- a/new/intel-proj-py/09.md
+++ b/new/intel-proj-py/09.md
 # 通过强化学习的自主无人驾驶汽车

-在过去的几年中，增强学习已经真正兴起，在增强学习中，代理通过与环境的交互来学习决策。 这是当今人工智能和机器学习中最热门的主题之一，并且这一领域的研究正在快速发展。 在**强化学习**（ **RL** ）中，代理将他们的行动和经验转化为学习，以便将来做出更好的决策。
+在过去的几年中，增强学习已经真正兴起，在增强学习中，代理通过与环境的交互来学习决策。 这是当今人工智能和机器学习中最热门的主题之一，并且这一领域的研究正在快速发展。 在**强化学习**（**RL**）中，代理将他们的行动和经验转化为学习，以便将来做出更好的决策。

-增强学习不属于有监督或无监督的机器学习范式，因为它本身就是一个领域。 在监督学习中，我们尝试学习一个映射 *F：X→Y* ，将输入 *X* 映射到输出 *Y* ，而在强化学习中，主体学习 通过反复试验采取最佳行动。 当业务代表执行任务出色时，将分配奖励，而当业务代表执行不好时，则要支付罚款。 代理试图吸收这些信息，并学会在类似的情况下不重复这些错误。 代理人所处的这些条件称为状态。 *图 9.1* 显示了强化学习框架中环境中代理的交互作用：
+增强学习不属于有监督或无监督的机器学习范式，因为它本身就是一个领域。 在监督学习中，我们尝试学习一个映射 *F：X→Y* ，将输入`X`映射到输出`Y`，而在强化学习中，主体学习 通过反复试验采取最佳行动。 当业务代表执行任务出色时，将分配奖励，而当业务代表执行不好时，则要支付罚款。 代理试图吸收这些信息，并学会在类似的情况下不重复这些错误。 代理人所处的这些条件称为状态。 *图 9.1* 显示了强化学习框架中环境中代理的交互作用：

 ![](img/9d2d1715-a781-4b00-9312-09d3cd27cc1b.png)

@@ -18,7 +18,7 @@

 # 马尔可夫决策过程

-任何强化学习问题都可以看作是**马尔可夫决策过程**，我们在第 1 章和*基于人工智能的系统基础*中进行了简要介绍。 为了您的利益，我们将再次详细研究。 在马尔可夫决策过程中，我们有一个与环境交互的主体。 在任何给定的情况下， *t* 代理处于多种状态之一：*（s <sup>（t）</sup> = s）∈S* 。 根据主体的动作*（a <sup>（t）</sup> = a）∈A* 处于状态 *s <sup>（t）</sup>* 具有新状态*（s <sup>（t + 1）</sup> = s <sup>'</sup>* *）∈S* 。 在这里， *S* 表示代理可能会暴露的所有状态，而 *A* 则表示代理可以参与的可能动作。
+任何强化学习问题都可以看作是**马尔可夫决策过程**，我们在第 1 章和*基于人工智能的系统基础*中进行了简要介绍。 为了您的利益，我们将再次详细研究。 在马尔可夫决策过程中，我们有一个与环境交互的主体。 在任何给定的情况下，`t`代理处于多种状态之一：*（s <sup>（t）</sup> = s）∈S* 。 根据主体的动作*（a <sup>（t）</sup> = a）∈A* 处于状态 *s <sup>（t）</sup>* 具有新状态*（s <sup>（t + 1）</sup> = s <sup>'</sup>* *）∈S* 。 在这里，`S`表示代理可能会暴露的所有状态，而`A`则表示代理可以参与的可能动作。

 您现在可能想知道座席如何采取行动。 应该是随机的还是基于启发式的？ 好吧，这取决于代理与相关环境的交互程度。 在初始阶段，代理可能会采取随机行动，因为他们不了解环境。 但是，一旦代理与环境进行了足够的交互（基于奖励和惩罚），代理就会了解在给定状态下采取哪种适当的措施。 类似于人们倾向于采取有益于长期奖励的行动一样，RL 代理商也采取行动，最大限度地提高了长期奖励。

@@ -36,9 +36,9 @@

 现在，我们拥有定义马尔可夫决策过程所需的一切。 马尔可夫决策过程是一个系统，其特征在于以下四个要素：

-*   一组状态 *S*
-*   一组动作 *A*
-*   一组奖励 *R*
+*   一组状态`S`
+*   一组动作`A`
+*   一组奖励`R`
 *   状态转移概率 *P（s <sup>（t + 1）</sup> = s <sup>'</sup> / s <sup>（t）</sup> = s，<sup>（t）</sup> = a）：*

 ![](img/069318ed-1b83-4093-8484-4209e97c18f5.png)
@@ -49,11 +49,11 @@

 对于 RL 代理做出决定，重要的是代理学习 Q 值函数。 可以通过 **Bellman 方程**迭代地学习 Q 值函数。 当代理开始与环境交互时，它以随机状态 *s <sup>（0）</sup>* 和每个状态动作对的 Q 值的随机状态开始。 代理的动作在某种程度上也是随机的，因为它没有状态 Q 值来做出明智的决策。 对于每个采取的行动，环境将根据哪个代理开始建立 Q 值表并随着时间的推移而改善而返回奖励。

-在任何暴露状态 *s <sup>（t）</sup>* 处于迭代状态 *t* 时，代理会采取行动 *a <sup>（t）</sup>* ，以最大化其长期回报。 Q 表保存长期奖励值，因此选择的 *a <sup>（t）</sup>* 将基于以下启发式：
+在任何暴露状态 *s <sup>（t）</sup>* 处于迭代状态`t`时，代理会采取行动 *a <sup>（t）</sup>* ，以最大化其长期回报。 Q 表保存长期奖励值，因此选择的 *a <sup>（t）</sup>* 将基于以下启发式：

 ![](img/aaa2e551-be26-48e5-92f2-f4c6eb370dbc.png)

-Q 值表也通过迭代 *t* 进行索引，因为代理只能查看到目前为止的 Q 表构建，随着代理与环境的交互作用会越来越大。
+Q 值表也通过迭代`t`进行索引，因为代理只能查看到目前为止的 Q 表构建，随着代理与环境的交互作用会越来越大。

 根据动作*，<sup>（t）</sup>* 会向环境呈现给代理以奖励 *r <sup>（t）</sup>* 和新状态 *s <sup>（t + 1）</sup>* 。 代理将更新 Q 表，以使其长期预期总收益最大化。 长期奖励 *r <sup>'（t）</sup>* 可以写成如下：

@@ -75,19 +75,19 @@ 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），*，而在右侧图中，对于 每个状态*，*我们学习与每个动作*和*有关的 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>）*的元组形式存储在重播缓冲区中。 可以从此重播缓冲区采样迷你批处理以训练网络。 首先，重播缓冲区是随机存储的。

 # 制定成本函数

-使用体系结构比较容易，在该体系结构中，可以获取网络馈给的给定状态的所有动作的 Q 值。 在*的右侧图 9.3* 中也进行了说明。 我们将让代理与环境交互并收集状态和奖励，以此为基础我们将学习 Q 函数。 实际上，网络会通过将给定状态 *s* 的所有动作![](img/e80900f0-58f0-404b-b333-9afac7b951bd.png)的预测 Q 值与目标 Q 值的预测 Q 值最小化来学习 Q 函数。 每个训练记录都是一个元组*（s <sup>（t）</sup>，<sup>（t）</sup>，r <sup>（t）</sup>，s <sup>（t + 1）</sup>）*。
+使用体系结构比较容易，在该体系结构中，可以获取网络馈给的给定状态的所有动作的 Q 值。 在*的右侧图 9.3* 中也进行了说明。 我们将让代理与环境交互并收集状态和奖励，以此为基础我们将学习 Q 函数。 实际上，网络会通过将给定状态`s`的所有动作![](img/e80900f0-58f0-404b-b333-9afac7b951bd.png)的预测 Q 值与目标 Q 值的预测 Q 值最小化来学习 Q 函数。 每个训练记录都是一个元组*（s <sup>（t）</sup>，<sup>（t）</sup>，r <sup>（t）</sup>，s <sup>（t + 1）</sup>）*。

-请记住，要根据网络本身计算目标 Q 值。 让我们考虑一个事实，即网络是由*W∈R <sup>d</sup>* 权重参数化的，对于给定状态的每个动作，我们学习从状态到 Q 值的映射。 对于 *n* 组动作![](img/cf95e427-278f-4b63-ada8-cbc875aa51af.png)，网络将预测与每个动作有关的 *i* Q 值。 映射函数可以表示如下：
+请记住，要根据网络本身计算目标 Q 值。 让我们考虑一个事实，即网络是由*W∈R <sup>d</sup>* 权重参数化的，对于给定状态的每个动作，我们学习从状态到 Q 值的映射。 对于`n`组动作![](img/cf95e427-278f-4b63-ada8-cbc875aa51af.png)，网络将预测与每个动作有关的`i`Q 值。 映射函数可以表示如下：

 ![](img/1d914f16-68c7-46e4-bacd-426a6451178e.png)

-在给定状态 *s <sup>（t）</sup>* 的情况下，此映射用于预测 Q 值，并且此预测![](img/97e96b85-ec2f-4e7e-9a65-7f9e3a443693.png)用于我们要最小化的成本函数。 这里要考虑的唯一技术是，我们只需要获取与实例 *t* 上观察到的动作 *a <sup>（t）</sup>* 相对应的预测 Q 值。
+在给定状态 *s <sup>（t）</sup>* 的情况下，此映射用于预测 Q 值，并且此预测![](img/97e96b85-ec2f-4e7e-9a65-7f9e3a443693.png)用于我们要最小化的成本函数。 这里要考虑的唯一技术是，我们只需要获取与实例`t`上观察到的动作 *a <sup>（t）</sup>* 相对应的预测 Q 值。

 我们可以基于下一个状态 *s <sup>（t + 1）</sup>* 使用相同的映射来构建目标 Q 值。 如上一节所述，对 Q 值的候选更新如下：

@@ -105,7 +105,7 @@ Q 值表也通过迭代 *t* 进行索引，因为代理只能查看到目前为

 # 双重深度 Q 学习

-深度 Q 学习的问题之一是我们使用相同的网络权重 *W* 估计目标和 Q 值。 结果，我们预测的 Q 值与目标 Q 值之间存在很大的相关性，因为它们都使用相同的权重变化。 这会使预测的 Q 值和目标 Q 值在训练的每个步骤中均发生偏移，从而导致振荡。
+深度 Q 学习的问题之一是我们使用相同的网络权重`W`估计目标和 Q 值。 结果，我们预测的 Q 值与目标 Q 值之间存在很大的相关性，因为它们都使用相同的权重变化。 这会使预测的 Q 值和目标 Q 值在训练的每个步骤中均发生偏移，从而导致振荡。

 为了稳定这一点，我们使用原始网络的副本来估算目标 Q 值，并在步骤中以特定间隔从原始网络复制目标网络的权重。 深度 Q 学习网络的这种变体称为**双重深度 Q 学习**，通常会导致稳定的训练。 下图*图 9.4A* 和*图 9.4B* 说明了双重深度 Q 学习的工作机制：

@@ -121,11 +121,11 @@ Q 值表也通过迭代 *t* 进行索引，因为代理只能查看到目前为

 **网络 B** 基本上是**网络 A** 的副本，因此它们共享相同的体系结构。 通常以指定的时间间隔将**网络 A** 的权重复制到**网络 B** 。 这是为了确保不使用同一组网络权重来预测 Q 值，也不会制定目标 Q 值，因为这会导致不稳定的训练。 给定单个训练元组*（s <sup>（t）</sup> = s，则<sup>（t）</sup> = a，r <sup>（t）</sup>* *= r，s <sup>（t + 1）</sup> = s <sup>'</sup>），* **网络 A** 给出状态为[ 对于所有可能的动作，HTG24] s <sup>（t）</sup> = s 。 由于我们知道实际动作 *a <sup>（t）</sup> = a* ，因此我们选择 Q 值 *Q <sup>（t）</sup>（s <sup>（t ）</sup> = s，<sup>（t）</sup> = a）*。 这将充当我们的预测 Q 值![](img/def6bacb-9f53-4d6f-9766-5f4a67d24943.png)。

-现在，计算目标要困难一些，因为它涉及到两个网络。 我们知道在步骤 *t* 的任何状态 *s <sup>（t）</sup>* 的候选 Q 值是即时奖励 *r <sup>（t）</sup>* 在时间 *t* 加上下一步的最大 Q 值*（t +1）*赋予新状态 *s <sup>（t + 1）[</sup>* 。 候选 Q 值可以表示为：
+现在，计算目标要困难一些，因为它涉及到两个网络。 我们知道在步骤`t`的任何状态 *s <sup>（t）</sup>* 的候选 Q 值是即时奖励 *r <sup>（t）</sup>* 在时间`t`加上下一步的最大 Q 值*（t +1）*赋予新状态 *s <sup>（t + 1）[</sup>* 。 候选 Q 值可以表示为：

 ![](img/b7a4a62e-cdc8-4476-8fa8-2dc532b1976c.png)

-当![](img/3324a291-28b5-4821-920a-394f71f7e4fe.png)是恒定折扣因子时就是这种情况。 奖励 *r* 已经是训练元组的一部分。 因此，我们唯一需要计算目标的是动作 *a <sup>'</sup>* ，该动作给出最大 Q 值，并将相应的 Q 值赋予相应的动作 *a <sup>'</sup>* 。 这个计算问题![](img/b1ae24ef-b42e-46c8-9bba-d3868b2e37ed.png)分为两个部分：
+当![](img/3324a291-28b5-4821-920a-394f71f7e4fe.png)是恒定折扣因子时就是这种情况。 奖励`r`已经是训练元组的一部分。 因此，我们唯一需要计算目标的是动作 *a <sup>'</sup>* ，该动作给出最大 Q 值，并将相应的 Q 值赋予相应的动作 *a <sup>'</sup>* 。 这个计算问题![](img/b1ae24ef-b42e-46c8-9bba-d3868b2e37ed.png)分为两个部分：

 *   **网络 A** 确定动作 *a <sup>'</sup>* ，该动作在状态 *s <sup>'</sup>* 下给出最大 Q 值。 但是，我们不会从**网络 A 中获取与 *a <sup>'</sup>* 和状态 *s <sup>'</sup>* 对应的 Q 值。** 。
 *   **网络 B** 用于提取 Q 值 *Q <sup>（tk）</sup>（s <sup>'</sup>，<sup>'</sup>）* 对应于状态 *s <sup>'</sup>* 和动作 *a <sup>'</sup>* 。

--- a/new/intel-proj-py/10.md
+++ b/new/intel-proj-py/10.md
@@ -26,7 +26,7 @@

 # 通过深度学习打破验证码

-随着**卷积神经网络**（ **CNN** ）在计算机视觉任务中的最新成功，在几分钟内打破基本的验证码是相对容易的任务。 因此，CAPTCHA 需要比过去有更多的发展。 在本章的第一部分中，我们将介绍使用具有深度学习框架的机器人自动检测到的基本验证码的漏洞。 我们将通过利用 GAN 创建更难以被机器人检测到的 CAPTCHA 进行跟进。
+随着**卷积神经网络**（**CNN**）在计算机视觉任务中的最新成功，在几分钟内打破基本的验证码是相对容易的任务。 因此，CAPTCHA 需要比过去有更多的发展。 在本章的第一部分中，我们将介绍使用具有深度学习框架的机器人自动检测到的基本验证码的漏洞。 我们将通过利用 GAN 创建更难以被机器人检测到的 CAPTCHA 进行跟进。

 # 生成基本的验证码

@@ -384,31 +384,31 @@ Evaluation file written at: /home/santanu/ML_DS_Catalog-/captcha/evaluation.csv

 # 通过对抗学习生成验证码

-在本节中，我们将通过生成的对抗网络来创建验证码。 我们将生成类似于**街景门牌号码**数据集（ **SVHN** 数据集）中的图像。 想法是将这些 GAN 生成的图像用作验证码。 仅当我们训练 GAN 时，它们才容易从噪声分布中采样。 这将减轻通过更复杂的方法创建验证码的需要。 它也将为验证码中使用的 SVHN 街道号提供一些变化。
+在本节中，我们将通过生成的对抗网络来创建验证码。 我们将生成类似于**街景门牌号码**数据集（**SVHN** 数据集）中的图像。 想法是将这些 GAN 生成的图像用作验证码。 仅当我们训练 GAN 时，它们才容易从噪声分布中采样。 这将减轻通过更复杂的方法创建验证码的需要。 它也将为验证码中使用的 SVHN 街道号提供一些变化。

 SVHN 是一个现实世界的数据集，由于它在对象识别算法中的使用而在机器学习和深度学习领域中非常受欢迎。 顾名思义，该数据集包含从 Google Street View Images 获得的门牌号码的真实图像。 [可以从以下链接下载数据集](http://ufldl.stanford.edu/housenumbers/)。

 我们将使用调整后的门牌号数据集，其中图像已调整为尺寸`(32,32)`。 我们感兴趣的数据集是`train_32x32.mat`。

-通过这个**生成对抗网络**（ **GAN** ），我们将根据随机噪声生成房屋编号图像，并且生成的图像将与 SVHN 数据集中的图像非常相似。
+通过这个**生成对抗网络**（**GAN**），我们将根据随机噪声生成房屋编号图像，并且生成的图像将与 SVHN 数据集中的图像非常相似。

-回顾一下，在 GAN 中，我们有一个生成器（ *G* ）和一个鉴别器（ *D* ），它们针对损失函数彼此玩零和极小极大游戏。 随着时间的流逝，生成器和鉴别器的工作都会越来越好，直到我们到达一个固定点为止，两者都无法进一步改善。 该固定点是相对于损失函数的鞍点。 对于我们的应用，发生器 G 会将给定分布 *P（z）*的噪声 *z* 转换为门牌号图像 *x* ，以使 *x ＝ G（z）*。
+回顾一下，在 GAN 中，我们有一个生成器（`G`）和一个鉴别器（`D`），它们针对损失函数彼此玩零和极小极大游戏。 随着时间的流逝，生成器和鉴别器的工作都会越来越好，直到我们到达一个固定点为止，两者都无法进一步改善。 该固定点是相对于损失函数的鞍点。 对于我们的应用，发生器 G 会将给定分布 *P（z）*的噪声`z`转换为门牌号图像`x`，以使 *x ＝ G（z）*。

-生成的图像通过鉴别器 *D* 传递，鉴别器 *D* 尝试检测此生成的图像 *x* 为伪造，并从 SVHN 数据集中检测真实的门牌号码图像为真实。 同时，生成器将尝试创建图像 *x = G（z）*，以使鉴别器发现图像是真实的。 如果我们将真实图像标记为`1`，而将生成器生成的伪图像标记为`0`，则鉴别器将尝试在给定两个类别的分类器网络中最小化二进制交叉熵损失。 鉴别符 *D* 所导致的损耗可以写成如下：
+生成的图像通过鉴别器`D`传递，鉴别器`D`尝试检测此生成的图像`x`为伪造，并从 SVHN 数据集中检测真实的门牌号码图像为真实。 同时，生成器将尝试创建图像 *x = G（z）*，以使鉴别器发现图像是真实的。 如果我们将真实图像标记为`1`，而将生成器生成的伪图像标记为`0`，则鉴别器将尝试在给定两个类别的分类器网络中最小化二进制交叉熵损失。 鉴别符`D`所导致的损耗可以写成如下：

 ![](img/ae36b54b-0a7c-4c94-8c4b-4e5209859d44.png)

-在前面的表达式中 *D（。）*是鉴别函数，其输出表示将图像标记为实数的可能性。 *P <sub>z</sub> （z）*表示随机变量噪声 *z，*的分布，而 *P <sub>X</sub> （x）*表示真实门牌号图像的分布。 *G（。）*和 *D（。）*分别表示生成器网络功能和鉴别器网络功能。 这些参数可以通过网络的权重进行参数化，而网络的权重是我们为表示法的混乱而方便地跳过的。 如果我们用![](img/bf0dd083-8c73-4b7f-95bf-2dac7251d52d.png)表示发生器网络权重的参数，用![](img/5040a2b3-84b1-4d41-b866-77a741f6e3a4.png)表示鉴别器网络的权重，则鉴别器将学会使*（1）*相对于![](img/0aebd653-012b-4821-85d9-4cecc73c4091.png)的损失最小化，而 发电机将旨在使*（1）*与![](img/3803843a-e64f-4153-85e0-fea7a07d2755.png)的损失相同。 我们可以将*（1）*中优化的损耗称为效用函数，发生器和鉴别器都在参数方面进行了优化。 实用函数 *U* 可以根据生成器和鉴别器的参数来编写，如下所示：
+在前面的表达式中 *D（。）*是鉴别函数，其输出表示将图像标记为实数的可能性。 *P <sub>z</sub> （z）*表示随机变量噪声 *z，*的分布，而 *P <sub>X</sub> （x）*表示真实门牌号图像的分布。 *G（。）*和 *D（。）*分别表示生成器网络功能和鉴别器网络功能。 这些参数可以通过网络的权重进行参数化，而网络的权重是我们为表示法的混乱而方便地跳过的。 如果我们用![](img/bf0dd083-8c73-4b7f-95bf-2dac7251d52d.png)表示发生器网络权重的参数，用![](img/5040a2b3-84b1-4d41-b866-77a741f6e3a4.png)表示鉴别器网络的权重，则鉴别器将学会使*（1）*相对于![](img/0aebd653-012b-4821-85d9-4cecc73c4091.png)的损失最小化，而 发电机将旨在使*（1）*与![](img/3803843a-e64f-4153-85e0-fea7a07d2755.png)的损失相同。 我们可以将*（1）*中优化的损耗称为效用函数，发生器和鉴别器都在参数方面进行了优化。 实用函数`U`可以根据生成器和鉴别器的参数来编写，如下所示：

 ![](img/e18dcc4f-da73-459c-ae45-a767f0e05be9.png)

-从博弈论的角度来看，生成器 *G* 和鉴别器 *D* 相互之间具有效用函数![](img/e4cfe9c2-a699-4f77-aa39-5d245b600128.png)的零和最小极大值游戏，并且最小极大值游戏的优化问题可以 然后表示为：
+从博弈论的角度来看，生成器`G`和鉴别器`D`相互之间具有效用函数![](img/e4cfe9c2-a699-4f77-aa39-5d245b600128.png)的零和最小极大值游戏，并且最小极大值游戏的优化问题可以 然后表示为：

 ![](img/b7879b3d-3991-4996-9a1e-a84f53d47c9c.png)

 ![](img/fa0742bb-8c7c-4eb0-9813-fd83336d1417.png)

-在参数空间中的某个点上，如果某个函数相对于某些参数而言是局部最大值，而对于其余参数而言是局部最小值，则该点称为**鞍点**。 因此，![](img/8195fdac-2bca-4575-94d8-7a5f5a223980.png)给出的点将成为效用函数![](img/4998ceaf-7b5f-455d-9cf7-080b90db54d2.png)的鞍点。 该鞍点是极小极大零和博弈的纳什均衡，对于生成器和鉴别器正在优化的效用，![](img/12eece45-0064-4857-9805-e36cd04fc28c.png)参数是最佳的。 就当前问题而言，生成器 *G* 会产生最困难的验证码，供鉴别器以![](img/2d483818-35f8-4b1c-85b9-c307097f6576.png)作为其参数进行检测。 同样，鉴别器最适合以![](img/525612b3-2ac2-4437-84d0-e054ce9fa1eb.png)作为参数来检测伪造的验证码。
+在参数空间中的某个点上，如果某个函数相对于某些参数而言是局部最大值，而对于其余参数而言是局部最小值，则该点称为**鞍点**。 因此，![](img/8195fdac-2bca-4575-94d8-7a5f5a223980.png)给出的点将成为效用函数![](img/4998ceaf-7b5f-455d-9cf7-080b90db54d2.png)的鞍点。 该鞍点是极小极大零和博弈的纳什均衡，对于生成器和鉴别器正在优化的效用，![](img/12eece45-0064-4857-9805-e36cd04fc28c.png)参数是最佳的。 就当前问题而言，生成器`G`会产生最困难的验证码，供鉴别器以![](img/2d483818-35f8-4b1c-85b9-c307097f6576.png)作为其参数进行检测。 同样，鉴别器最适合以![](img/525612b3-2ac2-4437-84d0-e054ce9fa1eb.png)作为参数来检测伪造的验证码。

 具有鞍点的最简单功能是 *x <sup>2</sup> -y <sup>2</sup>* ，鞍点是原点：`(0,0)`。

@@ -418,11 +418,11 @@ SVHN 是一个现实世界的数据集，由于它在对象识别算法中的使

 ![](img/ddf54bf8-41b6-4210-92af-e3c4f8ac7d3f.png)

-为了最大化目标函数，我们通常使用梯度上升，而为了最小化成本函数，我们使用梯度下降。 前面的优化问题可以分为两部分：生成器和鉴别器分别通过梯度上升和梯度下降依次优化效用函数。 在优化过程中的任何步骤 *t* 上，鉴别器都将通过使实用程序最小化来尝试移至新状态，如下所示：
+为了最大化目标函数，我们通常使用梯度上升，而为了最小化成本函数，我们使用梯度下降。 前面的优化问题可以分为两部分：生成器和鉴别器分别通过梯度上升和梯度下降依次优化效用函数。 在优化过程中的任何步骤`t`上，鉴别器都将通过使实用程序最小化来尝试移至新状态，如下所示：

 ![](img/c113c328-2c94-47ed-80d2-1f63f3820b12.png)

-替代地，生成器将尝试最大化相同的效用。 由于鉴别符 *D* 没有生成器的任何参数，因此实用程序的第二项不会影响生成器的优化。 可以这样表示：
+替代地，生成器将尝试最大化相同的效用。 由于鉴别符`D`没有生成器的任何参数，因此实用程序的第二项不会影响生成器的优化。 可以这样表示：

 ![](img/ee7b47ef-5a40-4a4c-8dcc-57425720a85a.png)

@@ -445,7 +445,7 @@ SVHN 是一个现实世界的数据集，由于它在对象识别算法中的使
 ```py
 def generator(input_dim,alpha=0.2):
    model = Sequential()
-    model.add(Dense(input_dim=input_dim, output_dim=4*4*512))
+    model.add(Dense(input_dim=input_dim, output_dim=4`4`512))
    model.add(Reshape(target_shape=(4,4,512)))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha))
@@ -580,7 +580,7 @@ def train(dest_train,outdir,
                d.save_weights('discriminator', True)
 ```

-`Adam`优化器用于两个网络的优化。 要注意的一件事是，仅需要对网络`g_d`进行编译，以仅针对发生器 *G* 的参数来优化损耗。 因此，我们需要禁用网络`g_d`中鉴别器 *D* 的参数训练。
+`Adam`优化器用于两个网络的优化。 要注意的一件事是，仅需要对网络`g_d`进行编译，以仅针对发生器`G`的参数来优化损耗。 因此，我们需要禁用网络`g_d`中鉴别器`D`的参数训练。

 我们可以使用以下功能来禁用或启用对网络参数的学习：


--- a/new/master-pred-anal-sklearn-tf/1.md
+++ b/new/master-pred-anal-sklearn-tf/1.md
@@ -134,7 +134,7 @@ import pandas as pd

 # KNN 模型

-**K 最近邻居**（[ **KNN** ）模型不是整体学习模型，但在简单模型中表现最佳：
+**K 最近邻居**（[ **KNN**）模型不是整体学习模型，但在简单模型中表现最佳：

 ![](img/49b9ce91-a006-4b09-b2e9-021e1ca3a76e.png)


--- a/new/master-pred-anal-sklearn-tf/2.md
+++ b/new/master-pred-anal-sklearn-tf/2.md
@@ -23,7 +23,7 @@

 # K 折交叉验证

-在 k 折交叉验证中，我们基本上会进行多次交叉验证。 因此，在 k 倍交叉验证中，我们将数据集划分为 *k* 个相等大小的样本。 在许多 *k* 子样本中，保留了一个子样本作为用于测试模型的验证数据，其余 *k-1* 子样本用作训练数据。 然后，此交叉验证过程重复 *k* 次，每个 *k* 子样本中的每一个仅被使用一次作为验证数据。 然后可以将 *k* 结果平均，以产生单个估计。
+在 k 折交叉验证中，我们基本上会进行多次交叉验证。 因此，在 k 倍交叉验证中，我们将数据集划分为`k`个相等大小的样本。 在许多`k`子样本中，保留了一个子样本作为用于测试模型的验证数据，其余 *k-1* 子样本用作训练数据。 然后，此交叉验证过程重复`k`次，每个`k`子样本中的每一个仅被使用一次作为验证数据。 然后可以将`k`结果平均，以产生单个估计。

 以下屏幕截图显示了 5 倍交叉验证的直观示例（ *k = 5* ）：

@@ -37,11 +37,11 @@
 2.  我们将第二部分用于测试，其余部分用于培训，然后使用它来获得评估指标的第二估计。
 3.  我们将第三部分用于测试，将其余部分用于培训，依此类推。 这样，我们获得了评估指标的五种估计。

-在 k 倍交叉验证中，观察到评估矩阵的 *k* 估计后，取其平均值。 这将使我们可以更好地估计模型的性能。 因此，我们可以通过 k 倍交叉验证获得 *n* 个估计数，而不是仅对这一评估指标进行一次估计，然后取平均值，以获得对性能的更好估计。 该模型。
+在 k 倍交叉验证中，观察到评估矩阵的`k`估计后，取其平均值。 这将使我们可以更好地估计模型的性能。 因此，我们可以通过 k 倍交叉验证获得`n`个估计数，而不是仅对这一评估指标进行一次估计，然后取平均值，以获得对性能的更好估计。 该模型。

 如此处所示，k 折交叉验证方法的优势在于它不仅可以用于模型评估，而且还可以用于超参数调整。

-在此验证方法中， *k* 的公共值为 5 和 10。
+在此验证方法中，`k`的公共值为 5 和 10。

 以下是 k 折交叉验证的变体：

@@ -118,7 +118,7 @@ from sklearn.model_selection import cross_validate

 在这里，我们传递`X`对象和`y`对象。

-*   我们提供了一组我们要评估的模型和数据集指标。 在这种情况下，使用`mean_squared_error`函数和`r2`指标进行评估，如前面的代码所示。 在这里，我们在`cv`中传递 *k* 的值。 因此，在这种情况下，我们将进行十倍交叉验证。
+*   我们提供了一组我们要评估的模型和数据集指标。 在这种情况下，使用`mean_squared_error`函数和`r2`指标进行评估，如前面的代码所示。 在这里，我们在`cv`中传递`k`的值。 因此，在这种情况下，我们将进行十倍交叉验证。

 我们从此`cross_validate`函数获得的输出将是带有相应矩阵的字典。 为了更好地理解，将输出转换为数据帧。 以下屏幕快照显示了用于可视化数据框和数据框输出中的分数的代码：

@@ -382,4 +382,4 @@ RF_tunned_test_mse = mean_squared_error(y_pred=RF_classifier.predict(X_test), y_

 然后，我们讨论了超参数调整。 我们遇到了详尽的网格搜索方法，该方法用于执行超参数调整。 我们再次使用`diamond`数据集实施了超参数调整。 我们还比较了调整后的模型和未调整的模型，发现调整后的参数使模型的性能优于未调整的模型。

-在下一章中，我们将研究特征选择方法，降维和**主成分分析**（ **PCA** ）以及特征工程。 我们还将学习一种通过特征工程改进模型的方法。
\ No newline at end of file
+在下一章中，我们将研究特征选择方法，降维和**主成分分析**（**PCA**）以及特征工程。 我们还将学习一种通过特征工程改进模型的方法。
\ No newline at end of file
--- a/new/master-pred-anal-sklearn-tf/3.md
+++ b/new/master-pred-anal-sklearn-tf/3.md
@@ -33,7 +33,7 @@

 # 递归特征消除

-识别重要特征并删除我们认为对模型不重要的特征的过程称为**递归特征消除**（ **RFE** ）。 RFE 也可以应用在`scikit-learn`中，我们可以使用此技术来计算系数，例如线性，逻辑回归，或使用模型来计算**特征重要性**。 随机森林模型为我们提供了这些特征重要性指标。 因此，对于既不计算系数也不计算特征重要性的模型，则无法使用这些方法。 例如，对于 KNN 模型，您不能应用 RFE 技术，因为这首先要预先定义要在模型中使用的功能。 使用所有特征，此方法将拟合模型，然后基于系数或特征重要性，消除最不重要的特征。 在所选的一组特征上递归地重复此过程，直到最终达到所需的要选择的特征数量。
+识别重要特征并删除我们认为对模型不重要的特征的过程称为**递归特征消除**（**RFE**）。 RFE 也可以应用在`scikit-learn`中，我们可以使用此技术来计算系数，例如线性，逻辑回归，或使用模型来计算**特征重要性**。 随机森林模型为我们提供了这些特征重要性指标。 因此，对于既不计算系数也不计算特征重要性的模型，则无法使用这些方法。 例如，对于 KNN 模型，您不能应用 RFE 技术，因为这首先要预先定义要在模型中使用的功能。 使用所有特征，此方法将拟合模型，然后基于系数或特征重要性，消除最不重要的特征。 在所选的一组特征上递归地重复此过程，直到最终达到所需的要选择的特征数量。

 有以下几种方法可以选择模型中的重要功能：

@@ -147,7 +147,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记

 # 降维和 PCA

-降维方法是通过获取一组主变量来减少所考虑要素数量的过程。 **主成分分析**（ **PCA** ）技术是用于降维的最重要技术。 在这里，我们将讨论为什么需要降维，并且还将在`scikit-learn`中看到如何执行 PCA 技术。
+降维方法是通过获取一组主变量来减少所考虑要素数量的过程。 **主成分分析**（**PCA**）技术是用于降维的最重要技术。 在这里，我们将讨论为什么需要降维，并且还将在`scikit-learn`中看到如何执行 PCA 技术。

 这些是在进行预测分析时拥有大量功能的原因：


--- a/new/master-pred-anal-sklearn-tf/4.md
+++ b/new/master-pred-anal-sklearn-tf/4.md
 # 人工神经网络和 TensorFlow 简介

-在本章中，我们将介绍**人工神经网络**（ **ANN** ），它们基本上是受活脑和感知器启发的计算模型，而感知器是 ANN 的基础。 我们还将讨论构建深度神经网络模型时要考虑的所有要素。 然后，我们将讨论 TensorFlow，这是我们将用来创建这些深度神经网络模型的库。 最后，我们将讨论我们需要了解的有关 TensorFlow 的核心概念，以便使用这些库概念，例如变量，占位符，会话，图形以及其他对于使用此库必不可少的概念。
+在本章中，我们将介绍**人工神经网络**（**ANN**），它们基本上是受活脑和感知器启发的计算模型，而感知器是 ANN 的基础。 我们还将讨论构建深度神经网络模型时要考虑的所有要素。 然后，我们将讨论 TensorFlow，这是我们将用来创建这些深度神经网络模型的库。 最后，我们将讨论我们需要了解的有关 TensorFlow 的核心概念，以便使用这些库概念，例如变量，占位符，会话，图形以及其他对于使用此库必不可少的概念。

 以下是随着我们的前进将涉及的主题：

@@ -13,7 +13,7 @@

 人工神经网络是受生物学启发的计算模型，可用于训练计算机使用数据执行任务。 这些模型是机器学习模型的广泛类别的一部分。 这些模型与其他模型之间的区别在于，这些模型基于称为**人工神经元**的连接单元的集合。

-人工神经网络的类型很多，在本书中，我们将使用一种特定的类型，称为**多层感知器**（ **MLP** ）。 请注意，人工神经网络的变化更多。 这些是机器学习模型，我们可以将它们用于分类和回归任务，但实际上，我们可以扩展这些模型，并将其应用于其他非常特定的任务，例如计算机视觉，语音识别和机器翻译。 这些模型是令人兴奋且不断发展的深度学习领域的基础，在过去的几年中，它在许多领域都取得了成功。
+人工神经网络的类型很多，在本书中，我们将使用一种特定的类型，称为**多层感知器**（**MLP**）。 请注意，人工神经网络的变化更多。 这些是机器学习模型，我们可以将它们用于分类和回归任务，但实际上，我们可以扩展这些模型，并将其应用于其他非常特定的任务，例如计算机视觉，语音识别和机器翻译。 这些模型是令人兴奋且不断发展的深度学习领域的基础，在过去的几年中，它在许多领域都取得了成功。

 # 感知器

@@ -33,7 +33,7 @@

 因此，如果数量大于`0`，则此模型的预测将为`1`或默认值；如果数量小于或等于`0`，则此模型的预测将为`0`或非默认值。 。 `b`值也称为阈值或偏差。

-通常，如果我们具有 *n* 个功能，那么我们的感知器将类似于以下屏幕截图：
+通常，如果我们具有`n`个功能，那么我们的感知器将类似于以下屏幕截图：

 ![](img/7938be7f-8c64-4cdd-9d93-b6ba65e4d5a6.png)

@@ -79,7 +79,7 @@

 # 深度神经网络模型的要素

-**深层神经网络**（ **DNN** ）的动机是相似的，这里的问题是，如果不使用一个隐藏层，那么如果我们使用多个隐藏层怎么办？ 因此，在这种情况下，我们的模型将类似于以下内容：
+**深层神经网络**（**DNN**）的动机是相似的，这里的问题是，如果不使用一个隐藏层，那么如果我们使用多个隐藏层怎么办？ 因此，在这种情况下，我们的模型将类似于以下内容：

 ![](img/0d594d3c-f5ca-4433-af2c-1299e12ae028.png)

@@ -103,7 +103,7 @@

 这只是一个经验法则。 但是，有更多正式的方法可以选择隐藏层的数量和神经元的数量，研究人员一直在努力寻找更好的方法来选择这些值。

-*   **激活功能**：激活功能是在隐藏层的每个神经元中使用的功能。 有很多选择。 **乙状结肠**是开发这些模型时使用的第一个功能，但随后研究人员发现使用此功能存在许多问题，因此他们提出了其他激活功能，例如**整流线性单元**（ **ReLU** ），**双曲正切**，**泄漏 ReLU** 以及我们将在进行中的示例中使用的其他一些选择。
+*   **激活功能**：激活功能是在隐藏层的每个神经元中使用的功能。 有很多选择。 **乙状结肠**是开发这些模型时使用的第一个功能，但随后研究人员发现使用此功能存在许多问题，因此他们提出了其他激活功能，例如**整流线性单元**（**ReLU**），**双曲正切**，**泄漏 ReLU** 以及我们将在进行中的示例中使用的其他一些选择。

 *   **优化算法**：这是用于学习网络权重的算法。 您选择的每种算法都有不同的超参数，建模者需要您选择它们。 训练这些网络的最基本算法是**梯度下降**。 但是，梯度下降的速度可能很慢并且存在一些问题，因此研究人员提出了其他算法，例如**动量优化器**， **AdaGrad** ， **RMSProp** 和 **亚当**矩算法。 在 TensorFlow 中，我们可以选择很多算法，包括亚当矩算法，而这实际上是我们将在示例中使用的算法。
 *   **损失函数**：此函数将产生将由优化器最小化的数量。 损失函数的选择取决于问题。 如果我们正在做回归问题，则可以选择均方误差或均对均方误差。 对于分类问题，有更多选择，例如交叉熵，平方损失和铰链损失。 这类似于反复试验。 有时候，一个损失函数会解决您的问题，有时却不会。 因此，这就是为什么您必须考虑许多不同的损失函数的原因。 但是，请记住，损失函数将产生数量，该数量将用于优化算法，以调整将成为网络一部分的不同感知器的不同权重。 因此，这是将产生数量的函数，优化器的目标是使该数量尽可能小。

--- a/new/master-pred-anal-sklearn-tf/5.md
+++ b/new/master-pred-anal-sklearn-tf/5.md
@@ -7,7 +7,7 @@ TensorFlow 是 **Google Brain Team** 开发的开源库。 它用于大型机器
 在本章中，我们将介绍以下主题：

 *   使用 TensorFlow 进行预测
-*   **深度神经网络**（ **DNN** ）的回归
+*   **深度神经网络**（**DNN**）的回归
 *   DNN 分类

 # 使用 TensorFlow 进行预测
@@ -274,7 +274,7 @@ y = tf.placeholder(y_train.dtype)

 # 指数线性单位激活函数

-**指数线性单位**（ **ELU** ）函数是 ReLU 函数的相对较新的修改。 它看起来与 ReLU 函数非常相似，但是具有非常不同的数学特性。 以下屏幕截图显示了 ELU 功能：
+**指数线性单位**（**ELU**）函数是 ReLU 函数的相对较新的修改。 它看起来与 ReLU 函数非常相似，但是具有非常不同的数学特性。 以下屏幕截图显示了 ELU 功能：

 ![](img/1e4604f6-28a4-4da0-9faa-de706a4da045.png)


--- a/new/whats-new-tf2/1.md
+++ b/new/whats-new-tf2/1.md
 # TensorFlow 2.0 入门

-本书旨在使读者熟悉 **TensorFlow 2.0** （ **TF 2.0** ）中引入的新功能，并在构建机器学习应用程序时使您发挥其潜力。 本章概述了 TF 2.0 中新的体系结构和 API 级别的变化。 我们将介绍 TF 2.0 的安装和设置，并将比较有关 **TensorFlow 1.x** （ **TF 1.x** ）的更改，例如 Keras API 和 Layer API。 我们还将涵盖丰富的扩展，例如 TensorFlow 概率，Tensor2Tensor，参差不齐的 Tensors，以及新的针对损失函数的自定义训练逻辑。 本章还总结了对图层 API 和其他 API 的更改。
+本书旨在使读者熟悉 **TensorFlow 2.0**（**TF 2.0**）中引入的新功能，并在构建机器学习应用程序时使您发挥其潜力。 本章概述了 TF 2.0 中新的体系结构和 API 级别的变化。 我们将介绍 TF 2.0 的安装和设置，并将比较有关 **TensorFlow 1.x**（**TF 1.x**）的更改，例如 Keras API 和 Layer API。 我们还将涵盖丰富的扩展，例如 TensorFlow 概率，Tensor2Tensor，参差不齐的 Tensors，以及新的针对损失函数的自定义训练逻辑。 本章还总结了对图层 API 和其他 API 的更改。

 以下主题将...


--- a/new/whats-new-tf2/2.md
+++ b/new/whats-new-tf2/2.md
 # Keras 默认集成和急切执行

-本章涵盖了两个高级 **TensorFlow 2.0** （ **TF 2.0** ）API，即 Keras 和 Estimators。 本章重点关注惰性评估和渴望执行的概念，重点介绍如何在 **TensorFlow 1.x** （ **TF 1.x** ）和 TF 2.0 中评估基础计算图之间的差异 。 本章还提供了有关使用诸如 Keras 之类的高级 API 构建自定义模型（使用自定义低级操作）的详细指南。
+本章涵盖了两个高级 **TensorFlow 2.0**（**TF 2.0**）API，即 Keras 和 Estimators。 本章重点关注惰性评估和渴望执行的概念，重点介绍如何在 **TensorFlow 1.x**（**TF 1.x**）和 TF 2.0 中评估基础计算图之间的差异 。 本章还提供了有关使用诸如 Keras 之类的高级 API 构建自定义模型（使用自定义低级操作）的详细指南。

 本章将涵盖以下主题：

@@ -57,7 +57,7 @@ Keras 大致采用了我们刚刚讨论的抽象范式，以帮助用户使用

 该 API 的主要组件是`tf.keras.Sequential`。

-这对于简单，连续的图层组合很有用。 假设您有一个 *n* 层神经网络。 假设这些层定义为`[layer_1, layer_2, …. , layer_n]`。
+这对于简单，连续的图层组合很有用。 假设您有一个`n`层神经网络。 假设这些层定义为`[layer_1, layer_2, …. , layer_n]`。

 请注意，这些层中的每一层都是 Keras 层，如前所述。 对于我们的实现，这意味着该层对象将是`tf.keras.layers`中公开的层之一，或者是对基础 Keras 层实现进行子类化的用户定义层。

@@ -73,7 +73,7 @@ my_model.add(layer_1)
 my_model.add(layer_n)
 ```

-假设您要建立一个描述完全连接的神经网络的模型（也称为**多层感知器**（ **MLP** ）），以对具有五个属性的一维记录进行二进制分类。 我们的模型包括四个完全连接的层。 纯粹出于说明目的，我们假设每个完全连接的层包含 10 个节点或神经元。 这些层中的每一层都使用**整流线性单元**（ **ReLU** ）激活功能。 最终输出通过`softmax`层获取。 可以在相应层的构造函数中定义特定于层的自定义。 实现此模型的代码如下：
+假设您要建立一个描述完全连接的神经网络的模型（也称为**多层感知器**（**MLP**）），以对具有五个属性的一维记录进行二进制分类。 我们的模型包括四个完全连接的层。 纯粹出于说明目的，我们假设每个完全连接的层包含 10 个节点或神经元。 这些层中的每一层都使用**整流线性单元**（**ReLU**）激活功能。 最终输出通过`softmax`层获取。 可以在相应层的构造函数中定义特定于层的自定义。 实现此模型的代码如下：

 ```py
 model = tf.keras.Sequential()
@@ -138,7 +138,7 @@ model_using_generator = tf.keras.Sequential(layers=get_layers(10))

 **训练模型**指的是为不同网络组件学习权重的过程，这些过程在给定的一组示例中将损失函数降至最低。 简而言之，训练神经网络意味着找到网络价值的最佳组合。 如您所知，培训过程也与评估和预测过程紧密相关。 借助抽象的强大功能，Keras 提供了强大的高级界面来实现和管理端到端的培训过程。 让我们看一下它为使用顺序和功能性 API 创建的模型提供的训练 API。 它为此阶段提供的一些功能如下：

-*   `model.compile()`：此功能用于配置训练过程。 用户指定详细信息，例如优化器的类型（以及超参数（如果有的话）），损失函数的类型以及要评估的指标。 这些也是可以使用 TensorBoard 可视化的指标。 下面的示例代码片段描述了一个带有**随机梯度下降**（ **SGD** ）优化器，`CategoricalCrossentropy`损失函数和记录`Accuracy`指标的样本训练配置：
+*   `model.compile()`：此功能用于配置训练过程。 用户指定详细信息，例如优化器的类型（以及超参数（如果有的话）），损失函数的类型以及要评估的指标。 这些也是可以使用 TensorBoard 可视化的指标。 下面的示例代码片段描述了一个带有**随机梯度下降**（**SGD**）优化器，`CategoricalCrossentropy`损失函数和记录`Accuracy`指标的样本训练配置：

 ```py
 model.compile(
@@ -406,7 +406,7 @@ TF 2.0 旨在通过更改评估和计算基础计算图的方式来解决此问

 **急切执行**可以理解为与延迟加载相反。 在此，数量的值一定义就立即计算，而不必等到它被调用。 这意味着当实际请求数量时，该值从内存中返回，而不是从头开始计算。 这有助于最小化返回查询结果所需的时间，因为用户不必等待计算值所花费的时间。

-可以通过添加两个常量的简单操作来说明两者之间的区别： *a* 和 *b* 。 首先，让我们看一下 2.0 之前的 TensorFlow 版本。 这些要求用户定义一个计算图，然后使用会话来运行和评估该图。 这可以理解为延迟加载的示例。 让我们看一下以下代码片段，以获得更好的主意：
+可以通过添加两个常量的简单操作来说明两者之间的区别：`a`和`b`。 首先，让我们看一下 2.0 之前的 TensorFlow 版本。 这些要求用户定义一个计算图，然后使用会话来运行和评估该图。 这可以理解为延迟加载的示例。 让我们看一下以下代码片段，以获得更好的主意：

 ```py
 # Define constants

--- a/new/whats-new-tf2/3.md
+++ b/new/whats-new-tf2/3.md
 # 设计和构建输入数据管道

-本章将概述如何构建复杂的输入数据管道，以使用由`TFRecords`组成的`tf.data` API 来以最常见的格式（例如 CSV 文件，图像，文本等）提取大型训练/推理数据集。 和`tf.data.Dataset`方法。 您还将获得有关协议缓冲区，协议消息以及如何使用 **TensorFlow 2.0** （ **TF 2.0** ）中的`TFRecords`和`tf.Example`方法实现的一般概念。 本章还说明了在数据的混洗，批处理和预取方面使用`tf.data.Dataset`方法的最佳实践，并针对 TF 2.0 提供了建议。 最后，我们将讨论内置的 TensorFlow 数据集...
+本章将概述如何构建复杂的输入数据管道，以使用由`TFRecords`组成的`tf.data` API 来以最常见的格式（例如 CSV 文件，图像，文本等）提取大型训练/推理数据集。 和`tf.data.Dataset`方法。 您还将获得有关协议缓冲区，协议消息以及如何使用 **TensorFlow 2.0**（**TF 2.0**）中的`TFRecords`和`tf.Example`方法实现的一般概念。 本章还说明了在数据的混洗，批处理和预取方面使用`tf.data.Dataset`方法的最佳实践，并针对 TF 2.0 提供了建议。 最后，我们将讨论内置的 TensorFlow 数据集...

 # 技术要求

-您应该了解标准数据格式，例如 CSV 文件，图像（PNG 和 JPG）和 ASCII 文本格式。 不用说，本书的大多数章节都假定您了解基本的机器学习概念，Python 编程，`numpy` Python 模块，并且您已使用 TensorFlow 创建了一些机器学习模型。 尽管不是必需的，但熟悉 **TensorFlow 1.x** （ **TF 1.x** ）版本的`tf.data` API 会有所帮助。 即使您没有`tf.data` API 的先验知识，您也应该发现本章可以自学以了解它们。
+您应该了解标准数据格式，例如 CSV 文件，图像（PNG 和 JPG）和 ASCII 文本格式。 不用说，本书的大多数章节都假定您了解基本的机器学习概念，Python 编程，`numpy` Python 模块，并且您已使用 TensorFlow 创建了一些机器学习模型。 尽管不是必需的，但熟悉 **TensorFlow 1.x**（**TF 1.x**）版本的`tf.data` API 会有所帮助。 即使您没有`tf.data` API 的先验知识，您也应该发现本章可以自学以了解它们。

 本章中的某些主题需要 Python 模块，例如`argparse`和`tqdm`，这些模块已在本书的 GitHub 存储库中列出。 可在[这个页面](https://github.com/PacktPublishing/What-s-New-in-TensorFlow-2.0/tree/master/Chapter03)中获得本章的代码。

 # 设计和构建数据管道

-训练**机器学习**（ **ML** ）模型和**深度神经网络**（ **DNN** ）时，最重要的要求之一 从给定的样本空间中具有分布的大型训练数据集（通常是未知的，我们在 ML 或 DNN 训练中了解到），以便 ML 模型和 DNN 可以从给定的训练数据中学习，并很好地推广到看不见的未来或分离出来的测试数据。 此外，通常与训练集分布来自同一来源的验证数据集对于微调模型超参数至关重要。 在许多情况下，开发人员会从可用的数据（无论是少量还是大量）入手，以训练机器学习模型，包括大容量的深度学习...
+训练**机器学习**（**ML**）模型和**深度神经网络**（**DNN**）时，最重要的要求之一 从给定的样本空间中具有分布的大型训练数据集（通常是未知的，我们在 ML 或 DNN 训练中了解到），以便 ML 模型和 DNN 可以从给定的训练数据中学习，并很好地推广到看不见的未来或分离出来的测试数据。 此外，通常与训练集分布来自同一来源的验证数据集对于微调模型超参数至关重要。 在许多情况下，开发人员会从可用的数据（无论是少量还是大量）入手，以训练机器学习模型，包括大容量的深度学习...

 # 原始数据

@@ -28,7 +28,7 @@ ML 模型训练的数据准备的关键特征之一是能够将现有数据分

 # 创建 TFRecords

-TFRecords 的创建是输入数据管道的核心，因此您可以创建`tf.data.Dataset`对象。 值得注意的是，您可以直接使用原始数据创建数据集，而无需创建 **TFRecords** （将在下一部分中进行说明）。 但是，推荐的方法是首先从原始（拆分）数据创建 **TFRecords** ，然后将其用于数据集管道。 这是 TF 2.0 输入数据管道设计的关键部分。 下图显示了 **TFRecords** 的创建流程：
+TFRecords 的创建是输入数据管道的核心，因此您可以创建`tf.data.Dataset`对象。 值得注意的是，您可以直接使用原始数据创建数据集，而无需创建 **TFRecords**（将在下一部分中进行说明）。 但是，推荐的方法是首先从原始（拆分）数据创建 **TFRecords** ，然后将其用于数据集管道。 这是 TF 2.0 输入数据管道设计的关键部分。 下图显示了 **TFRecords** 的创建流程：

 ![](img/41f35661-5631-45f1-8c96-42505714c4a3.png)

@@ -39,7 +39,7 @@ TFRecords 的创建是输入数据管道的核心，因此您可以创建`tf.dat
 *   `TFRecord`格式，用于存储二进制记录或数据序列。
 *   [协议缓冲区](https://developers.google.com/protocol-buffers/)是跨平台的，并且具有跨语言库，用于以协议消息的形式对结构化数据进行有效的序列化。
 *   协议消息是信息的小型逻辑记录，其中包含一系列名称/值对。
-*   `tf.Example`是一种灵活的协议消息（也称为`protobuf`），旨在与 TensorFlow 一起使用。 **TensorFlow Extended** （ **TFX** ）是 TF 2.0 中的另一个重要功能，用于部署生产级 ML 管道，我们将在第 5 章中进行学习，[ *模型推理管道–多平台部署*。
+*   `tf.Example`是一种灵活的协议消息（也称为`protobuf`），旨在与 TensorFlow 一起使用。 **TensorFlow Extended**（**TFX**）是 TF 2.0 中的另一个重要功能，用于部署生产级 ML 管道，我们将在第 5 章中进行学习，[ “模型推理管道–多平台部署”。

 请注意，在 TF 2.0 中，`tf.Examples`已在诸如 [TFX](https://www.tensorflow.org/tfx/) 的所有 TensorFlow 高级 API 中使用。。

@@ -61,7 +61,7 @@ TFRecords 的创建是输入数据管道的核心，因此您可以创建`tf.dat

 # tf.data 数据集对象创建

-如我们前面提到的，`tf.data` API 集提供了从原始数据构建复杂而有效的输入数据管道的工具。 例如，输入管道可以从分布式文件系统的图像文件构建。 如果您使用的是**自然语言处理**（ **NLP** ）模块，也可以从原始文本数据构建它。 下图显示了`tf.dataset`对象创建的流程：
+如我们前面提到的，`tf.data` API 集提供了从原始数据构建复杂而有效的输入数据管道的工具。 例如，输入管道可以从分布式文件系统的图像文件构建。 如果您使用的是**自然语言处理**（**NLP**）模块，也可以从原始文本数据构建它。 下图显示了`tf.dataset`对象创建的流程：

 ![](img/1afeb47b-4688-432f-8b53-be33a927f643.png)


--- a/new/whats-new-tf2/4.md
+++ b/new/whats-new-tf2/4.md
@@ -37,9 +37,9 @@ TensorFlow 1.x 已建议为其高级 API 集使用`tf.estimator` API，该 API 
 *   无监督学习，对没有标签的数据进行分组和聚类
 *   强化学习，其中存在一种环境，代理可以通过该环境通过采取行动并从环境中获取反馈（奖励）来学习实现预期目标

-生成模型和判别模型可以与这三种机器学习技术一起使用。 生成模型尝试从具有未知分布的给定数据集中凭经验学习模式和分布，并可能使用学习的模型来生成新数据，就好像它来自同一分布。 一些流行的生成模型是高斯混合模型，隐马尔可夫模型，贝叶斯网络（例如朴素贝叶斯）等。 生成对抗模型是 2014 年非常流行的生成模型，由于其强大的成功和潜力而备受关注。 除了仅学习可用于无监督学习的分布之外，生成模型还可以用于执行分类或预测任务（有监督学习），该任务使用样本 *x* 的条件概率， 通过使用朴素贝叶斯定理计算概率 *P（y | x）*，属于 *y* 类。 与生成模型相反，判别模型用于直接学习条件概率 *P（y | x）*，用于回归，分类和其他类型的监督学习问题。 深度神经网络可用于构建生成模型或判别模型。
+生成模型和判别模型可以与这三种机器学习技术一起使用。 生成模型尝试从具有未知分布的给定数据集中凭经验学习模式和分布，并可能使用学习的模型来生成新数据，就好像它来自同一分布。 一些流行的生成模型是高斯混合模型，隐马尔可夫模型，贝叶斯网络（例如朴素贝叶斯）等。 生成对抗模型是 2014 年非常流行的生成模型，由于其强大的成功和潜力而备受关注。 除了仅学习可用于无监督学习的分布之外，生成模型还可以用于执行分类或预测任务（有监督学习），该任务使用样本`x`的条件概率， 通过使用朴素贝叶斯定理计算概率 *P（y | x）*，属于`y`类。 与生成模型相反，判别模型用于直接学习条件概率 *P（y | x）*，用于回归，分类和其他类型的监督学习问题。 深度神经网络可用于构建生成模型或判别模型。

-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 提供了丰富的 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 中得到了体现，如下图所示：

@@ -570,7 +570,7 @@ for num_units in HP_NUM_UNITS.domain.values:

 # 假设工具

-TensorFlow 2.0 引入了一个非常强大的工具，即**假设工具**（ **WIT** ），该工具可在 TensorBoard 仪表板内部提供易于使用的界面。 但是，仅当使用 TensorFlow Serving 为模型提供服务时，才可以使用 WIT。 在第 5 章，*模型推理管道–* *多平台部署*中解释了 TensorFlow Serving。 另外，为了使用 WIT，推理数据集必须为`TFRecords`格式。
+TensorFlow 2.0 引入了一个非常强大的工具，即**假设工具**（**WIT**），该工具可在 TensorBoard 仪表板内部提供易于使用的界面。 但是，仅当使用 TensorFlow Serving 为模型提供服务时，才可以使用 WIT。 在第 5 章，*模型推理管道–* *多平台部署*中解释了 TensorFlow Serving。 另外，为了使用 WIT，推理数据集必须为`TFRecords`格式。

 WIT 的某些功能是可以将具有相同工作流程的多个模型进行比较，推理结果的可视化，基于相似度的数据排列以及通过编辑数据点执行模型的敏感性分析的能力。


--- a/new/whats-new-tf2/5.md
+++ b/new/whats-new-tf2/5.md
@@ -8,10 +8,10 @@

 为了运行本章中给出的代码摘录，您将需要以下硬件和软件：

-*   **TensorFlow 2.0** （ **TF 2.0** ）或更高版本（CPU 或 GPU 版本都足够）
+*   **TensorFlow 2.0**（**TF 2.0**）或更高版本（CPU 或 GPU 版本都足够）
 *   Python 3.4+（当前，TensorFlow 支持的最高 Python 版本是 3.6）
 *   NumPy（如果不是由 TensorFlow 自动安装）
-*   Docker（请参阅第 1 章和 *TensorFlow 2.0 入门*，有关如何安装 Docker 的详细信息）
+*   Docker（请参阅第 1 章和 “TensorFlow 2.0 入门”，有关如何安装 Docker 的详细信息）
 *   [curl](https://curl.haxx.se/docs/install.html)
 *   具有命令行界面的 Linux 计算机

@@ -43,7 +43,7 @@ import tensorflow as tf

 # 了解核心数据流模型

-在我们研究`SavedModel`格式的细微差别之前，重要的是要首先了解 TensorFlow 模型的真正含义。 对于初学者，TensorFlow 实施数据流编程范例。 在这种范式下，程序被建模为在不同计算操作之间流动的数据*的有向图*。 这意味着每个节点代表一个操作（或计算），边代表数据。 输入边缘将代表该节点的输入，而输出边缘将对应于计算节点产生的输出。 为了说明这个想法，让我们看一下`tf.add()`操作的（粗略）数据流表示形式。 如下图所示，输入边对应于 x 和 y 的输入。 输出边缘 z（ **x + y** ）对应于节点的输出，在这种特定情况下，该输出恰好是输入的总和：**
+在我们研究`SavedModel`格式的细微差别之前，重要的是要首先了解 TensorFlow 模型的真正含义。 对于初学者，TensorFlow 实施数据流编程范例。 在这种范式下，程序被建模为在不同计算操作之间流动的数据*的有向图*。 这意味着每个节点代表一个操作（或计算），边代表数据。 输入边缘将代表该节点的输入，而输出边缘将对应于计算节点产生的输出。 为了说明这个想法，让我们看一下`tf.add()`操作的（粗略）数据流表示形式。 如下图所示，输入边对应于 x 和 y 的输入。 输出边缘 z（**x + y**）对应于节点的输出，在这种特定情况下，该输出恰好是输入的总和：**

 ![](img/2e09fd48-ab43-4546-8eab-1df5c1dae380.png)

@@ -58,7 +58,7 @@ import tensorflow as tf

 # tf.function API

-正如我们在第 1 章中看到的那样， *TensorFlow 2.0* 和[入门第 2 章](2.html)， *Keras 默认集成和急切执行*，渴望 默认情况下启用执行是 TF 2.0 中引入的主要更改之一。 第 1 章和 *TensorFlow 2.0 入门*还简要提到了 TF 2.0 与 Python 编程语言更紧密地结合在一起。 此更改的核心是低级`tf.function` API。 实际上，这是通过使用户能够从 Python 函数创建 TensorFlow 图而将 TensorFlow 1.x 的功能与渴望执行的优点相结合。 它既可以用作可调用函数，也可以用作装饰器。 在本节中，我们将简要介绍一下如何在每个人中使用它。
+正如我们在第 1 章中看到的那样， *TensorFlow 2.0* 和[入门第 2 章](2.html)， “Keras 默认集成和急切执行”，渴望 默认情况下启用执行是 TF 2.0 中引入的主要更改之一。 第 1 章和 “TensorFlow 2.0 入门”还简要提到了 TF 2.0 与 Python 编程语言更紧密地结合在一起。 此更改的核心是低级`tf.function` API。 实际上，这是通过使用户能够从 Python 函数创建 TensorFlow 图而将 TensorFlow 1.x 的功能与渴望执行的优点相结合。 它既可以用作可调用函数，也可以用作装饰器。 在本节中，我们将简要介绍一下如何在每个人中使用它。

 # tf.autograph 函数

@@ -171,7 +171,7 @@ ls -ax ./square/1

 # SavedModel 命令行界面

-`SavedModel` **命令行界面**（ **CLI** ）是非常方便的工具，可用于分析各种`SavedModel`实例并运行它们。 它在调试磁盘上的模型时非常有用，并且可以在不读取，编写或修改任何代码的情况下使用。 在本节中，我们将简要介绍如何安装此工具，使用它分析图的不同组件并运行计算图。
+`SavedModel` **命令行界面**（**CLI**）是非常方便的工具，可用于分析各种`SavedModel`实例并运行它们。 它在调试磁盘上的模型时非常有用，并且可以在不读取，编写或修改任何代码的情况下使用。 在本节中，我们将简要介绍如何安装此工具，使用它分析图的不同组件并运行计算图。

 该工具与 TensorFlow 二进制文件捆绑在一起。 如果您通过从源代码构建 TensorFlow 来安装它，则必须单独安装它。 有关安装说明，请参见[这里](https://www.tensorflow.org/beta/guide/saved_model#details_of_the_savedmodel_command_line_interface)。

@@ -248,7 +248,7 @@ Result for output key output_0:

 # TensorFlow 服务

-**TensorFlow 服务**是 **TensorFlow Extended** （ **TFX** ）平台的组成部分。 顾名思义，它旨在用于服务于机器学习模型。 简而言之，它是专为生产环境设计的高性能服务系统。 TensorFlow Serving 的一个重要特征是它向下游用户公开了一致的 API，而与所服务模型的实际内容无关。 这使得快速进行实验和重新部署变得容易，而无需对其余软件堆栈进行任何其他更改。 它附带对 TensorFlow 模型的内置支持，并且可以扩展为服务于其他类型的模型。
+**TensorFlow 服务**是 **TensorFlow Extended**（**TFX**）平台的组成部分。 顾名思义，它旨在用于服务于机器学习模型。 简而言之，它是专为生产环境设计的高性能服务系统。 TensorFlow Serving 的一个重要特征是它向下游用户公开了一致的 API，而与所服务模型的实际内容无关。 这使得快速进行实验和重新部署变得容易，而无需对其余软件堆栈进行任何其他更改。 它附带对 TensorFlow 模型的内置支持，并且可以扩展为服务于其他类型的模型。

 在本节中，我们将详细介绍 TensorFlow 服务。 从基本的安装和设置开始，以下小节通过一系列动手示例描述如何设置服务器来为`SavedModel`服务。 我们还将简要介绍 TensorFlow Serving 提供的一些关键 API。

@@ -258,7 +258,7 @@ Result for output key output_0:

 如果容器映像对您不起作用，请在[这个页面](https://www.tensorflow.org/tfx/serving/setup)上获取其他安装 TensorFlow Serving 方法的摘要。

-使用 Docker 设置 TensorFlow 服务涉及一个简单的步骤。 但是，此步骤需要将 Docker 安装在主机上。 有关设置 Docker 的说明，请参阅第 1 章， *TensorFlow 2.0 入门*或本章的*技术要求*部分。 您需要做的就是拉相关的 Docker 映像以...
+使用 Docker 设置 TensorFlow 服务涉及一个简单的步骤。 但是，此步骤需要将 Docker 安装在主机上。 有关设置 Docker 的说明，请参阅第 1 章， “TensorFlow 2.0 入门”或本章的*技术要求*部分。 您需要做的就是拉相关的 Docker 映像以...

 # 设置并运行推理服务器


--- a/new/whats-new-tf2/6.md
+++ b/new/whats-new-tf2/6.md
 # AIY 项目和 TensorFlow Lite

-本章详细介绍如何在低功耗嵌入式系统（例如边缘设备，移动系统（例如 Android，iOS 和 Raspberry））上部署经过训练的 **TensorFlow 2.0** （ **TF2.0** ）模型 Pi），Edge TPU 和 NVIDIA Jetson Nano。 本章还介绍了自己动手工具包的训练和部署模型，例如 Google **人工智能自己的**（ **AIY** ）工具包。 本章涵盖的其他主题是如何将经过训练的 **TensorFlow** （ **TF** ）模型转换为 **TensorFlow Lite** （[ **TFLite** ）模型，主要区别 他们之间，以及两者的优势。
+本章详细介绍如何在低功耗嵌入式系统（例如边缘设备，移动系统（例如 Android，iOS 和 Raspberry））上部署经过训练的 **TensorFlow 2.0**（**TF2.0**）模型 Pi），Edge TPU 和 NVIDIA Jetson Nano。 本章还介绍了自己动手工具包的训练和部署模型，例如 Google **人工智能自己的**（**AIY**）工具包。 本章涵盖的其他主题是如何将经过训练的 **TensorFlow**（**TF**）模型转换为 **TensorFlow Lite**（[ **TFLite**）模型，主要区别 他们之间，以及两者的优势。

 本章与前几章略有不同，从某种意义上说，它只是对 TF2.0 的更广泛关注的介绍。 也就是说，硬件领域...

@@ -165,7 +165,7 @@ Google 为语音和视觉应用发布了自己的制造商套件，称为 AIY。

 语音工具包提供了构建自然语言处理器并将其连接到 Google Assistant 或 Cloud Speech-to-Text 服务的功能。 该套件随附 Raspberry Pi Zero，以及定制设计的语音引擎盖和用于音频功能的扬声器。 该套件还随附可插入 Pi 的 SD 卡，以及用于许多最常见应用程序的大量演示，示例和摘要。 它还带有一个在设备上运行 Google Assistant 并将其转变为智能家居设备的应用程序。

-要开始使用语音工具包，请按照[这个页面](https://aiyprojects.withgoogle.com/voice/#assembly-guide)上的说明构建设备。 该设备设计合理，易于组装和设置。 要设置设备，可以使用计算机或手机。 该套件的设置非常简单，可以通过**安全外壳**（ **SSH** ）或 HDMI 连接来完成。 完成后，可以运行许多演示来进一步了解和探索该工具包，例如前面提到的 Google Assistant 应用程序。
+要开始使用语音工具包，请按照[这个页面](https://aiyprojects.withgoogle.com/voice/#assembly-guide)上的说明构建设备。 该设备设计合理，易于组装和设置。 要设置设备，可以使用计算机或手机。 该套件的设置非常简单，可以通过**安全外壳**（**SSH**）或 HDMI 连接来完成。 完成后，可以运行许多演示来进一步了解和探索该工具包，例如前面提到的 Google Assistant 应用程序。

 语音工具包可以完成的一些事情包括创建自定义语音用户界面和使用助手控制 IoT 设备。


--- a/new/whats-new-tf2/7.md
+++ b/new/whats-new-tf2/7.md
 # 从 TensorFlow 1.x 迁移到 2.0

-本章将介绍如何将 **TensorFlow 1.x** （ **TF 1.x** ）代码转换为 **TensorFlow 2.0** （ **TF 2.0** ） 代码有两种方式。 第一种方法是使用更新脚本，该脚本会更改大多数 TF 1.x 代码，以便可以在 TF 2.0 中运行。 但是，这仅将所有`tf.x` API 调用转换为`tf.compat.v1.x`格式。 另一种方法是，考虑到对库所做的核心更改，将 TF 1.x 代码转换为惯用的 TF2.0 代码。 我们将讨论 TF 1.x 和 TF 2.0 之间的概念差异，它们之间的兼容性标准以及我们在语法和语义上进行迁移的方式。 我们还将展示从 TF 1.x 到 TF 2.0 的语法和语义迁移的几个示例，我们将通过它们提供参考和将来的信息。
+本章将介绍如何将 **TensorFlow 1.x**（**TF 1.x**）代码转换为 **TensorFlow 2.0**（**TF 2.0**） 代码有两种方式。 第一种方法是使用更新脚本，该脚本会更改大多数 TF 1.x 代码，以便可以在 TF 2.0 中运行。 但是，这仅将所有`tf.x` API 调用转换为`tf.compat.v1.x`格式。 另一种方法是，考虑到对库所做的核心更改，将 TF 1.x 代码转换为惯用的 TF2.0 代码。 我们将讨论 TF 1.x 和 TF 2.0 之间的概念差异，它们之间的兼容性标准以及我们在语法和语义上进行迁移的方式。 我们还将展示从 TF 1.x 到 TF 2.0 的语法和语义迁移的几个示例，我们将通过它们提供参考和将来的信息。

 本章将涵盖以下主题：


--- a/new/whats-new-tf2/pt1.md
+++ b/new/whats-new-tf2/pt1.md
@@ -4,5 +4,5 @@

 本节包含以下章节：

-*   第 1 章和 *TensorFlow 2.0 入门*
-*   第 2 章和 *Keras 默认集成和急切执行*
\ No newline at end of file
+*   第 1 章“TensorFlow 2.0 入门”
+*   第 2 章“Keras 默认集成和急切执行”
\ No newline at end of file
--- a/new/whats-new-tf2/pt2.md
+++ b/new/whats-new-tf2/pt2.md
@@ -4,5 +4,5 @@

 本节包含以下章节：

-*   第 3 章和*设计和构建输入数据管道*
-*   第 4 章，*模型训练和 TensorBoard 的使用*
\ No newline at end of file
+*   第 3 章，“设计和构建输入数据管道”
+*   第 4 章，“模型训练和 TensorBoard 的使用”
\ No newline at end of file
--- a/new/whats-new-tf2/pt3.md
+++ b/new/whats-new-tf2/pt3.md
@@ -4,5 +4,5 @@

 本节包含以下章节：

-*   第 5 章和*模型推理管道–多平台部署*
-*   第 6 章， *AIY 项目和 TensorFlow Lite*
\ No newline at end of file
+*   第 5 章，“模型推理管道–多平台部署”
+*   第 6 章，“AIY 项目和 TensorFlow Lite”
\ No newline at end of file
--- a/new/whats-new-tf2/pt4.md
+++ b/new/whats-new-tf2/pt4.md
 # 第 4 节：TensorFlow 2.0-迁移，摘要

-本书的本部分将以高级方式总结 **TensorFlow 2.0** （ **TF 2.0** ）的使用，以及与以前版本相比 TF 2.0 的兼容性差异。 如果您使用过 **TensorFlow 1.x** （ **TF 1.x** ），则本书的这一部分将重点介绍如何迁移到 TF 2.0。 尽管有一个将 TF 1.x 代码转换为 TF 2.0 的迁移 API，但它只是进行语法到语法的转换。 本部分还将深入指导您完成从语义上将 TF 1.x 代码转换为 TF 2.0 所需的代码级更改。
+本书的本部分将以高级方式总结 **TensorFlow 2.0**（**TF 2.0**）的使用，以及与以前版本相比 TF 2.0 的兼容性差异。 如果您使用过 **TensorFlow 1.x**（**TF 1.x**），则本书的这一部分将重点介绍如何迁移到 TF 2.0。 尽管有一个将 TF 1.x 代码转换为 TF 2.0 的迁移 API，但它只是进行语法到语法的转换。 本部分还将深入指导您完成从语义上将 TF 1.x 代码转换为 TF 2.0 所需的代码级更改。

 本节包含以下章节：

-*   第 7 章和*从 TensorFlow 1.x 迁移到 2.0*
\ No newline at end of file
+*   第 7 章和“从 TensorFlow 1.x 迁移到 2.0”
\ No newline at end of file