2021-01-16 12:25:23

new/dl-pt-workshop/0.md

@@ -16,9 +16,9 @@
 
 ## 关于各章
 
-“第 1 章”，“深度学习和 PyTorch 简介”，介绍了深度学习及其应用以及 PyTorch 的主要语法。 本章还显示了如何定义网络体系结构和训练模型。
+“第 1 章”，“深度学习和 PyTorch 简介”，介绍了深度学习及其应用以及 PyTorch 的主要语法。 本章还显示了如何定义网络架构和训练模型。
 
-“第 2 章”，“神经网络的构建基块”，引入了神经网络的概念，并解释了当今的三种主要网络架构：人工神经网络，卷积神经网络和循环神经网络。 对于每种体系结构，都提供了训练过程和各层的说明。
+“第 2 章”，“神经网络的构建基块”，引入了神经网络的概念，并解释了当今的三种主要网络架构：人工神经网络，卷积神经网络和循环神经网络。 对于每种架构，都提供了训练过程和各层的说明。
 
 “第 3 章”，“使用 DNN 的分类问题”，引入了要使用人工神经网络解决的现实数据问题。 探索了数据集的预处理以及定义和训练模型的过程，并通过使用误差分析提高了模型的准确性。
 

new/dl-pt-workshop/1.md

@@ -75,7 +75,7 @@ PyTorch 于 2017 年 1 月首次向公众发布。它使用 **GPU** 的功能来
 
 GPU 最初是为了加速图形渲染中的计算而开发的，尤其是对于视频游戏等。 但是，由于它们能够帮助加快任何领域的计算速度，包括深度学习计算，它们最近变得越来越受欢迎。
 
-有几种平台可以将变量分配给计算机的 GPU，其中**计算统一设备体系结构**（**CUDA**）是最常用的平台之一。 CUDA 是 Nvidia 开发的计算平台，由于使用 GPU 来执行计算，因此可以加快计算密集型程序的速度。
+有几种平台可以将变量分配给计算机的 GPU，其中**计算统一设备架构**（**CUDA**）是最常用的平台之一。 CUDA 是 Nvidia 开发的计算平台，由于使用 GPU 来执行计算，因此可以加快计算密集型程序的速度。
 
 在 PyTorch 中，可以通过使用`torch.cuda`包将变量分配给 CUDA，如以下代码片段所示：
 
@@ -224,7 +224,7 @@ example_2 = torch.randint(low=0, high=2, \
 
 ## 使用 PyTorch 的优势
 
-如今有几个库可用于开发深度学习解决方案，那么为什么要使用 PyTorch？ 答案是 PyTorch 是一个动态库，它允许用户极大的灵活性来开发可适应特定数据问题的复杂体系结构。
+如今有几个库可用于开发深度学习解决方案，那么为什么要使用 PyTorch？ 答案是 PyTorch 是一个动态库，它允许用户极大的灵活性来开发可适应特定数据问题的复杂架构。
 
 PyTorch 已被许多研究人员和人工智能开发人员采用，这使其成为机器学习工程师工具包中的重要工具。
 
@@ -293,15 +293,15 @@ AttributeError: 'NoneType' object has no attribute 'data'
 
 考虑到已经解决了棘手的部分（梯度的计算），仅`autograd`库可用于构建简单的神经网络。 但是，这种方法可能很麻烦，因此引入了`nn`模块。
 
-`nn`模块是一个完整的 PyTorch 模块，用于创建和训练神经网络，该神经网络通过使用不同的元素，可以进行简单而复杂的开发。 例如，`Sequential()`容器可轻松创建遵循一系列预定义模块（或层）的网络体系结构，而无需太多的定义网络体系结构的知识。
+`nn`模块是一个完整的 PyTorch 模块，用于创建和训练神经网络，该神经网络通过使用不同的元素，可以进行简单而复杂的开发。 例如，`Sequential()`容器可轻松创建遵循一系列预定义模块（或层）的网络架构，而无需太多的定义网络架构的知识。
 
 注意
 
-在随后的章节中将进一步解释可用于每种神经网络体系结构的不同层。
+在随后的章节中将进一步解释可用于每种神经网络架构的不同层。
 
 该模块还具有定义损失函数以评估模型的能力，以及将在本书中讨论的许多更高级的功能。
 
-只需几行就可以完成将神经网络体系结构构建为一系列预定义模块的过程，如下所示：
+只需几行就可以完成将神经网络架构构建为一系列预定义模块的过程，如下所示：
 
 ```py
 import torch.nn as nn
@@ -314,7 +314,7 @@ loss_funct = nn.MSELoss()
 
 首先，导入模块。 然后，定义模型架构。 `input_units`表示输入数据包含的要素数量，`hidden_​​units`表示隐藏层的节点数量， `output_units`表示 输出层的节点。
 
-从前面的代码中可以看出，网络的体系结构包含一个隐藏层，其后是 ReLU 激活功能和一个输出层，然后是一个 S 型激活功能，从而使其成为两层网络。
+从前面的代码中可以看出，网络的架构包含一个隐藏层，其后是 ReLU 激活功能和一个输出层，然后是一个 S 型激活功能，从而使其成为两层网络。
 
 最后，损失函数定义为**均方误差**（**MSE**）。
 
@@ -324,9 +324,9 @@ loss_funct = nn.MSELoss()
 
 要创建不遵循现有模块顺序的模型，请使用**自定义**`nn`模块。 我们将在本书后面介绍这些内容。
 
-## 练习 1.02：定义单层体系结构
+## 练习 1.02：定义单层架构
 
-在本练习中，我们将使用 PyTorch 的`nn`模块为单层神经网络定义模型，并定义损失函数以评估模型。 这将是起点，以便您能够构建更复杂的网络体系结构来解决实际数据问题。 执行以下步骤以完成本练习：
+在本练习中，我们将使用 PyTorch 的`nn`模块为单层神经网络定义模型，并定义损失函数以评估模型。 这将是起点，以便您能够构建更复杂的网络架构来解决实际数据问题。 执行以下步骤以完成本练习：
 
 1.  Import **torch** as well as the **nn** module from PyTorch:
 
@@ -394,7 +394,7 @@ loss_funct = nn.MSELoss()
 
     您也可以通过[这里](https://packt.live/2YOVPws)在线运行此示例。 您必须执行整个笔记本才能获得所需的结果。
 
-您已经成功定义了单层网络体系结构。
+您已经成功定义了单层网络架构。
 
 ### PyTorch 优化软件包
 
@@ -449,7 +449,7 @@ for i in range(100):
 
 注意
 
-对于本练习，请使用与上一个练习相同的 Jupyter Notebook（*练习 1.02* ，*定义单层体系结构*）。
+对于本练习，请使用与上一个练习相同的 Jupyter Notebook（*练习 1.02* ，*定义单层架构*）。
 
 在本练习中，我们将使用 PyTorch 的`optim`包，学习如何从上一练习中训练单层网络。 考虑到我们将使用虚拟数据作为输入，训练网络不会解决数据问题，但是将其用于学习目的。 执行以下步骤以完成本练习：
 
@@ -546,7 +546,7 @@ for i in range(100):
 
     要切片 pandas DataFrame，请使用 pandas 的`iloc`方法。 要了解有关此方法的更多信息，请访问[这里](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iloc.html)。
 
-4.  定义模型的体系结构，并将其存储在名为`model`的变量中。 记住要创建一个单层模型。
+4.  定义模型的架构，并将其存储在名为`model`的变量中。 记住要创建一个单层模型。
 5.  定义要使用的损失函数。 在这种情况下，请使用 MSE 损失功能。
 6.  定义模型的优化器。 在这种情况下，请使用 Adam 优化器，并将学习率设为`0.01`。
 7.  对 100 次迭代运行优化，保存每次迭代的损失值。 每 10 次迭代打印一次损失值。
@@ -562,8 +562,8 @@ for i in range(100):
 
 随着深度学习解决方案的普及，已经开发了许多深度学习库。 其中，最新的一种是 PyTorch。 PyTorch 使用 C ++后端，这有助于加快计算速度，同时具有 Python 前端，以使该库易于使用。
 
-它使用张量存储数据，这些数据是 n 阶矩阵状结构，可以在 GPU 上运行以加快处理速度。 它提供了三个主要元素，这些元素对于创建复杂的神经网络体系结构非常有用。
+它使用张量存储数据，这些数据是 n 阶矩阵状结构，可以在 GPU 上运行以加快处理速度。 它提供了三个主要元素，这些元素对于创建复杂的神经网络架构非常有用。
 
-`autograd`库可以计算函数的导数，这些导数用作优化模型权重和偏差的梯度。 此外，`nn`模块可帮助您轻松地将模型的体系结构定义为一系列预定义的模块，并确定用于测量模型的损失函数。 最后，考虑到先前计算的梯度，`optim`包用于选择用于更新参数的优化算法。
+`autograd`库可以计算函数的导数，这些导数用作优化模型权重和偏差的梯度。 此外，`nn`模块可帮助您轻松地将模型的架构定义为一系列预定义的模块，并确定用于测量模型的损失函数。 最后，考虑到先前计算的梯度，`optim`包用于选择用于更新参数的优化算法。
 
 在下一章中，我们将学习神经网络的构建块。 我们将介绍三种类型的学习过程以及三种最常见的神经网络类型。 对于每个神经网络，我们将学习网络架构的结构以及训练过程的工作方式。 最后，我们将了解数据准备的重要性并解决回归数据问题。
\ No newline at end of file

new/dl-pt-workshop/2.md

@@ -2,19 +2,19 @@
 
 概述
 
-本章介绍了神经网络的主要组成部分，并解释了当今的三种主要神经网络体系结构。 此外，它解释了训练任何人工智能模型之前数据准备的重要性，并最终解释了解决回归数据问题的过程。 在本章的最后，您将牢固地掌握不同网络体系结构及其不同应用程序的学习过程。
+本章介绍了神经网络的主要组成部分，并解释了当今的三种主要神经网络架构。 此外，它解释了训练任何人工智能模型之前数据准备的重要性，并最终解释了解决回归数据问题的过程。 在本章的最后，您将牢固地掌握不同网络架构及其不同应用程序的学习过程。
 
 # 简介
 
 在上一章中，已经解释了为什么深度学习如今变得如此流行，并且 PyTorch 被介绍为开发深度学习解决方案的最受欢迎的库之一。 尽管已解释了使用 PyTorch 构建神经网络的主要语法，但在本章中，我们将进一步探讨神经网络的概念。
 
-尽管神经网络理论是在几十年前发展起来的，但是自从感知器概念演变成神经网络理论以来，最近就已经创建了不同的体系结构来解决不同的数据问题。 这部分是由于在现实生活中的数据问题（例如文本，音频和图像）中可以找到不同的数据格式。
+尽管神经网络理论是在几十年前发展起来的，但是自从感知器概念演变成神经网络理论以来，最近就已经创建了不同的架构来解决不同的数据问题。 这部分是由于在现实生活中的数据问题（例如文本，音频和图像）中可以找到不同的数据格式。
 
-本章的目的是深入探讨神经网络及其主要优点和缺点的主题，以便您了解何时以及如何使用它们。 然后，我们将解释最流行的神经网络体系结构的构建块：**人工神经网络**（**ANN**），**卷积神经网络**（**CNN**）和**循环神经网络**（**RNN**）。
+本章的目的是深入探讨神经网络及其主要优点和缺点的主题，以便您了解何时以及如何使用它们。 然后，我们将解释最流行的神经网络架构的构建块：**人工神经网络**（**ANN**），**卷积神经网络**（**CNN**）和**循环神经网络**（**RNN**）。
 
 接下来，将通过解决现实生活中的回归问题来说明建立有效模型的过程。 这包括准备要馈送到神经网络的数据（也称为数据预处理），定义要使用的神经网络架构以及评估模型的性能，目的是确定如何对其进行改进以实现最佳性能。 最佳解决方案。
 
-上述过程将使用将在本章中讨论的一种神经网络体系结构来完成，同时考虑到每个数据问题的解决方案应使用对所讨论的数据类型表现最佳的体系结构进行。 其他架构将在后续章节中使用，以解决更复杂的数据问题，这些问题涉及使用图像和文本序列作为输入数据。
+上述过程将使用将在本章中讨论的一种神经网络架构来完成，同时考虑到每个数据问题的解决方案应使用对所讨论的数据类型表现最佳的架构进行。 其他架构将在后续章节中使用，以解决更复杂的数据问题，这些问题涉及使用图像和文本序列作为输入数据。
 
 注意
 
@@ -98,7 +98,7 @@ Rosenblatt 还介绍了权重的概念（`w`1，`w`2，…，`w`n），这些数
 
 一般而言，神经网络由多个神经元组成，其中每个神经元都会计算线性函数以及激活函数，以根据某些输入得出输出（激活函数旨在打破线性关系，这将是 稍后在本章中有更详细的说明）。 该输出与权重相关联，该权重代表其重要性级别，并将在下一层中用于计算。
 
-而且，这些计算是在整个网络体系结构中进行的，直到达到最终输出为止。 与地面实况相比，此输出用于确定网络的性能，然后将其用于调整网络的不同参数以重新开始计算过程。
+而且，这些计算是在整个网络架构中进行的，直到达到最终输出为止。 与地面实况相比，此输出用于确定网络的性能，然后将其用于调整网络的不同参数以重新开始计算过程。
 
 考虑到这一点，神经网络的训练过程可以看作是迭代过程，该过程在网络的各个层中前进和后退以达到最佳结果，如下图所示（损失函数将在后面介绍） 在这一章当中）：
 
@@ -108,7 +108,7 @@ Rosenblatt 还介绍了权重的概念（`w`1，`w`2，…，`w`n），这些数
 
 ### 正向传播
 
-这是从左到右遍历网络体系结构的过程，同时使用输入数据执行计算以得出可以与基本事实进行比较的预测。 这意味着网络中的每个神经元都会根据与之关联的权重和偏差来转换输入数据（初始数据或从上一层接收的数据），并将输出发送到下一层，直到最后一层 达到并做出预测。
+这是从左到右遍历网络架构的过程，同时使用输入数据执行计算以得出可以与基本事实进行比较的预测。 这意味着网络中的每个神经元都会根据与之关联的权重和偏差来转换输入数据（初始数据或从上一层接收的数据），并将输出发送到下一层，直到最后一层 达到并做出预测。
 
 注意
 
@@ -194,7 +194,7 @@ Rosenblatt 还介绍了权重的概念（`w`1，`w`2，…，`w`n），这些数
 
 ### 向后传播
 
-训练过程的最后一步包括在网络体系结构中从右向左移动以计算损耗函数相对于每一层的权重和偏差的偏导数（也称为梯度），以便更新这些 参数（权重和偏差），以便在下一个迭代步骤中，损失函数较低。
+训练过程的最后一步包括在网络架构中从右向左移动以计算损耗函数相对于每一层的权重和偏差的偏导数（也称为梯度），以便更新这些 参数（权重和偏差），以便在下一个迭代步骤中，损失函数较低。
 
 优化算法的最终目标是找到损失函数达到最小可能值的全局最小值，如下图所示：
 
@@ -286,11 +286,11 @@ Rosenblatt 还介绍了权重的概念（`w`1，`w`2，…，`w`n），这些数
 
 CNN 创建的模型使用神经元的子组来识别图像的不同方面。 这些组应该能够相互通信，以便它们可以一起形成完整的图像。
 
-考虑到这一点，CNN 的体系结构中的层划分了它们的识别任务。 第一层专注于琐碎的模式，而网络末端的层则使用该信息来揭示更复杂的模式。
+考虑到这一点，CNN 的架构中的层划分了它们的识别任务。 第一层专注于琐碎的模式，而网络末端的层则使用该信息来揭示更复杂的模式。
 
 例如，当识别图片中的人脸时，前几层专注于寻找将一个特征与另一个特征分开的边缘。 接下来，后续层强调面部的某些特征，例如鼻子。 最后，最后两层使用此信息将人的整个面孔放在一起。
 
-当遇到某些特征时激活一组神经元的想法是通过使用过滤器（内核）来实现的，过滤器（内核）是 CNN 架构的主要组成部分之一。 但是，它们不是体系结构中存在的唯一元素，这就是为什么在此将对 CNN 的所有组件进行简要说明的原因：
+当遇到某些特征时激活一组神经元的想法是通过使用过滤器（内核）来实现的，过滤器（内核）是 CNN 架构的主要组成部分之一。 但是，它们不是架构中存在的唯一元素，这就是为什么在此将对 CNN 的所有组件进行简要说明的原因：
 
 注意
 
@@ -344,9 +344,9 @@ CNN 创建的模型使用神经元的子组来识别图像的不同方面。 这
 
 3.  **Fully connected layers**: Finally, considering that the network would be of no use if it was only capable of detecting a set of features without having the capability of classifying them into a class label, fully connected layers are used at the end of CNNs to take the features that were detected by the previous layer (known as the feature map) and output the probability of that group of features belonging to a class label, which is used to make the final prediction.
 
-    像人工神经网络一样，全连接层使用感知器根据给定的输入来计算输出。 此外，至关重要的是要提到 CNN 在体系结构的末尾通常具有不止一个全连接层。
+    像人工神经网络一样，全连接层使用感知器根据给定的输入来计算输出。 此外，至关重要的是要提到 CNN 在架构的末尾通常具有不止一个全连接层。
 
-通过组合所有这些概念，可以获得 CNN 的常规体系结构。 每个类型可以有任意数量的层，每个卷积层可以具有任意数量的滤镜（每个滤镜用于特定任务）。 此外，池化层应具有与上一个卷积层相同数量的过滤器，如下图所示：
+通过组合所有这些概念，可以获得 CNN 的常规架构。 每个类型可以有任意数量的层，每个卷积层可以具有任意数量的滤镜（每个滤镜用于特定任务）。 此外，池化层应具有与上一个卷积层相同数量的过滤器，如下图所示：
 
 ![Figure 2.24: Diagram of the CNN architecture ](img/B15778_02_24.jpg)
 
@@ -374,7 +374,7 @@ RNN 允许以输入序列，输出序列或什至同时以两种形式处理数
 
 1.  一个不需要解决 RNN 的典型模型。 它具有固定的输入和固定的输出。 例如，这可以指图像分类。
 2.  该模型接受输入并产生一系列输出。 例如，以接收图像作为输入的模型； 输出应为图像标题。
-3.  与前面的模型相反，该模型采用一系列输入并产生单个结果。 在情感分析问题上可以看到这种类型的体系结构，其中输入是要分析的句子，输出是句子后面的预测情感。
+3.  与前面的模型相反，该模型采用一系列输入并产生单个结果。 在情感分析问题上可以看到这种类型的架构，其中输入是要分析的句子，输出是句子后面的预测情感。
 4.  最后的两个模型采用一系列输入，并返回一系列输出，不同之处在于第一个模型同时分析输入并生成输出。 例如，当视频的每个帧都被单独标记时。 另一方面，第二个多对多模型分析整个输入集，以生成输出集。 语言翻译就是一个例子，在进行实际翻译之前，需要先理解一种语言的整个句子。
 
 # 数据准备
@@ -766,7 +766,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
 
 一般而言，可以使用 scikit-learn（不适用于深度学习）之类的库在非常简单的级别上构建神经网络，该库可以为您执行所有数学运算而没有很大的灵活性，或者可以在非常复杂的级别上实现 通过从头开始编码训练过程的每个步骤，或使用更强大的框架，可以提供极大的灵活性。
 
-PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可以将两个近似值放在同一位置。 正如我们前面提到的，它具有一个神经网络模块，该模块被构建为允许使用顺序容器对简单体系结构进行简单的预定义实现，同时允许创建自定义模块，从而为构建非常复杂的体系结构的过程引入灵活性 。
+PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可以将两个近似值放在同一位置。 正如我们前面提到的，它具有一个神经网络模块，该模块被构建为允许使用顺序容器对简单架构进行简单的预定义实现，同时允许创建自定义模块，从而为构建非常复杂的架构的过程引入灵活性 。
 
 在本节中，我们将讨论使用顺序容器开发深度神经网络，以揭开其复杂性。 不过，在本书的后续章节中，我们将继续研究更复杂和抽象的应用程序，而这些应用程序也可以非常轻松地实现。
 
@@ -776,7 +776,7 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
 
 注意
 
-在随后的章节中将解释用于其他类型的体系结构（例如 CNN 和 RNN）的模块。
+在随后的章节中将解释用于其他类型的架构（例如 CNN 和 RNN）的模块。
 
 *   **线性层**：这将线性变换应用于输入数据，同时保持内部张量来容纳权重和偏差。 它接收输入样本的大小（数据集的要素数量或上一层的输出数量），输出样本的大小（当前层中的单位数量，即输出数量） ），以及是否在训练过程中使用偏差张量（默认设置为`True`）作为参数。
 *   **Activation functions**: They receive the output from the linear layer as input in order to break the linearity. There are several activation functions, as explained previously, that can be added to the sequential container. The most commonly used ones are explained here:
@@ -794,7 +794,7 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
 
 ## 练习 2.05：使用 PyTorch 构建深度神经网络
 
-在本练习中，我们将使用 PyTorch 库定义四层深度神经网络的体系结构，然后将使用我们在先前练习中准备的数据集对其进行训练。 请执行以下步骤：
+在本练习中，我们将使用 PyTorch 库定义四层深度神经网络的架构，然后将使用我们在先前练习中准备的数据集对其进行训练。 请执行以下步骤：
 
 注意
 
@@ -903,7 +903,7 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
 
 在本活动中，我们将创建并训练一个神经网络来解决我们在上一活动中提到的回归问题。 让我们看一下场景。
 
-您继续在唱片公司工作，在看到您准备好数据集的出色工作后，您的老板已经信任您定义网络体系结构以及使用准备好的数据集进行训练的任务。 执行以下步骤以完成此活动：
+您继续在唱片公司工作，在看到您准备好数据集的出色工作后，您的老板已经信任您定义网络架构以及使用准备好的数据集进行训练的任务。 执行以下步骤以完成此活动：
 
 注意
 
@@ -911,7 +911,7 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
 
 1.  导入所需的库。
 2.  从目标中为我们在上一个活动中创建的所有三组数据拆分功能。 将 DataFrame 转换为张量。
-3.  定义网络的体系结构。 随意尝试层数和每层单位数的不同组合。
+3.  定义网络的架构。 随意尝试层数和每层单位数的不同组合。
 4.  定义损失函数和优化器算法。
 5.  使用循环对训练网络进行 3,000 个迭代步骤。
 6.  通过对测试集的第一个实例执行预测并将其与基本事实进行比较来测试模型。
@@ -934,6 +934,6 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
 
 该过程的最终目标是通过更新网络每个神经元中每个输入值所伴随的权重和偏差来最小化损失函数。 这可以通过迭代过程来实现，该过程可能要花费几分钟，几小时甚至几周的时间，具体取决于数据问题的性质。
 
-还讨论了三种主要类型的神经网络的主要体系结构：人工神经网络，卷积神经网络和循环神经网络。 第一个用于解决传统的分类或回归问题，第二个由于具有解决计算机视觉问题（例如图像分类）的能力而广受欢迎，第三个可按顺序处理数据，这对于 语言翻译等任务。
+还讨论了三种主要类型的神经网络的主要架构：人工神经网络，卷积神经网络和循环神经网络。 第一个用于解决传统的分类或回归问题，第二个由于具有解决计算机视觉问题（例如图像分类）的能力而广受欢迎，第三个可按顺序处理数据，这对于 语言翻译等任务。
 
 在下一章中，将讨论解决回归问题和分类数据问题之间的主要区别。 您还将学习如何解决分类数据问题，以及如何改善其性能以及如何部署模型。
\ No newline at end of file

new/dl-pt-workshop/3.md

@@ -2,11 +2,11 @@
 
 总览
 
-在本章中，我们将看一个银行业中的实际例子，以解决分类数据问题。 您将学习如何利用 PyTorch 的自定义模块来定义网络体系结构并训练模型。 您还将探索错误分析的概念，以提高模型的性能。 最后，您将研究部署模型的不同方法，以便将来使用它。 到本章结束时，您将对该过程有深刻的了解，以便可以使用**深度神经网络**（**DNN**）在 PyTorch 中。
+在本章中，我们将看一个银行业中的实际例子，以解决分类数据问题。 您将学习如何利用 PyTorch 的自定义模块来定义网络架构并训练模型。 您还将探索错误分析的概念，以提高模型的性能。 最后，您将研究部署模型的不同方法，以便将来使用它。 到本章结束时，您将对该过程有深刻的了解，以便可以使用**深度神经网络**（**DNN**）在 PyTorch 中。
 
 # 简介
 
-在上一章中，我们了解了 DNN 的构建块，并回顾了三种最常见的体系结构的特征。 此外，我们学习了如何使用 DNN 解决回归问题。
+在上一章中，我们了解了 DNN 的构建块，并回顾了三种最常见的架构的特征。 此外，我们学习了如何使用 DNN 解决回归问题。
 
 在本章中，我们将使用 DNN 解决分类任务，其目的是从一系列选项中预测结果。
 
@@ -312,13 +312,13 @@ final_data.to_csv("dccc_prepared.csv", index=False)
 
 ## 好的架构
 
-如本章所述，了解当前的数据问题对于确定神经网络的一般拓扑非常重要。 同样，常规分类问题并不需要与计算机视觉相同的网络体系结构。
+如本章所述，了解当前的数据问题对于确定神经网络的一般拓扑非常重要。 同样，常规分类问题并不需要与计算机视觉相同的网络架构。
 
 修改并准备好数据后，考虑到在确定隐藏层数或每层中的单元数方面没有正确答案，最好的方法是从初始架构开始（可以进行改进） 以提高性能）。
 
-这一点很重要，因为有时需要使用大量参数进行调整，可能难以承诺某些事情并开始开发解决方案。 但是，考虑到这一点，在训练神经网络时，有几种方法可以确定一旦对初始体系结构进行了训练和测试，就需要改进哪些内容。 实际上，将您的数据集分为三个子集的全部原因是允许使用一组训练数据集，使用另一组测量和微调模型，最后使用一组模型测量最终模型的性能。 最终未使用过的子集。
+这一点很重要，因为有时需要使用大量参数进行调整，可能难以承诺某些事情并开始开发解决方案。 但是，考虑到这一点，在训练神经网络时，有几种方法可以确定一旦对初始架构进行了训练和测试，就需要改进哪些内容。 实际上，将您的数据集分为三个子集的全部原因是允许使用一组训练数据集，使用另一组测量和微调模型，最后使用一组模型测量最终模型的性能。 最终未使用过的子集。
 
-考虑到所有这些，将解释以下一组惯例和经验法则，以帮助决策过程定义 ANN 的初始体系结构：
+考虑到所有这些，将解释以下一组惯例和经验法则，以帮助决策过程定义 ANN 的初始架构：
 
 *   **输入层**：这很简单； 只有一个输入层，其单位数量取决于训练数据的形状。 具体来说，输入层中的单位数应等于输入数据包含的要素数。
 *   **Hidden layer**: Hidden layers can vary in quantity. ANNs can have one hidden layer, more, or none. To choose the right number, it is important to consider the following:
@@ -334,7 +334,7 @@ final_data.to_csv("dccc_prepared.csv", index=False)
 
 ## PyTorch 自定义模块
 
-自定义模块由 PyTorch 的开发团队创建，以为用户提供更大的灵活性。 与我们在前几章中探讨的**顺序**容器相反，每当需要构建更复杂的模型体系结构，或者希望进一步控制每一层中的计算时，都应使用自定义模块 。
+自定义模块由 PyTorch 的开发团队创建，以为用户提供更大的灵活性。 与我们在前几章中探讨的**顺序**容器相反，每当需要构建更复杂的模型架构，或者希望进一步控制每一层中的计算时，都应使用自定义模块 。
 
 这并不意味着定制模块方法只能在这种情况下使用。 相反，一旦您学会了使用这两种方法，则选择较简单的数据问题时使用哪个方法（**顺序**容器或自定义模块）就成为优先考虑的问题。
 
@@ -351,7 +351,7 @@ model = nn.Sequential(nn.Linear(D_i, D_h), \
 
 此处，`D_i`表示输入尺寸（输入数据中的特征），`D_h`表示隐藏尺寸（隐藏层中的节点数），`D_o`是指输出尺寸。
 
-使用自定义模块，可以构建等效的网络体系结构，如下所示：
+使用自定义模块，可以构建等效的网络架构，如下所示：
 
 ```py
 import torch
@@ -374,9 +374,9 @@ class Classifier(torch.nn.Module):
 
 对于本章中的练习和活动，您将需要安装 Python 3.7，Jupyter 6.0，Matplotlib 3.1，PyTorch 1.3，NumPy 1.17，scikit-learn 0.21，Pandas 0.25 和 Flask 1.1。
 
-## 练习 3.01：使用自定义模块定义模型的体系结构
+## 练习 3.01：使用自定义模块定义模型的架构
 
-使用前面解释的理论，我们将使用定制模块的语法定义模型的体系结构：
+使用前面解释的理论，我们将使用定制模块的语法定义模型的架构：
 
 1.  Open a Jupyter Notebook and import the required libraries:
 
@@ -430,15 +430,15 @@ class Classifier(torch.nn.Module):
 
     您也可以通过[这里](https://packt.live/2BrUWkD)在线运行此示例。 您必须执行整个笔记本才能获得所需的结果。
 
-这样，您就可以使用 PyTorch 的自定义模块成功构建神经网络体系结构。 现在，您可以继续学习有关训练深度学习模型的过程。
+这样，您就可以使用 PyTorch 的自定义模块成功构建神经网络架构。 现在，您可以继续学习有关训练深度学习模型的过程。
 
 ## 定义损失函数并训练模型
 
-重要的是要提到，交叉熵损失函数要求网络的输出是原始的（在通过使用`softmax`激活函数获得概率之前），这就是为什么通常会发现 用于分类问题的神经网络体系结构，而没有针对输出层的激活功能。 此外，为了通过这种方法进行预测，必须在训练模型后将`softmax`激活函数应用于网络的输出。
+重要的是要提到，交叉熵损失函数要求网络的输出是原始的（在通过使用`softmax`激活函数获得概率之前），这就是为什么通常会发现 用于分类问题的神经网络架构，而没有针对输出层的激活功能。 此外，为了通过这种方法进行预测，必须在训练模型后将`softmax`激活函数应用于网络的输出。
 
 解决此问题的另一种方法是对输出层使用`log_softmax`激活函数。 这样，损失函数可以定义为负对数似然损失（`nn.NLLLoss`）。 最后，可以通过从网络输出中获取指数来获得属于每个类别标签的一组要素的概率。 这是本章活动中将使用的方法。
 
-一旦定义了模型体系结构，下一步将是对负责根据训练数据进行模型训练的部分进行编码，并在训练和验证集上测量其性能。
+一旦定义了模型架构，下一步将是对负责根据训练数据进行模型训练的部分进行编码，并在训练和验证集上测量其性能。
 
 按照我们讨论的这些逐步说明进行操作的代码如下：
 
@@ -454,7 +454,7 @@ batch_size = 100
 
 接下来，循环的第一个**用于遍历我们之前定义的时期数。**
 
-请记住，**时期**是指整个数据集通过网络体系结构前后传递的次数。`batch_size`是指单个批量（数据集的一部分）中训练示例的数量。 最后，**迭代**是指完成一个时期所需的批处理数量。
+请记住，**时期**是指整个数据集通过网络架构前后传递的次数。`batch_size`是指单个批量（数据集的一部分）中训练示例的数量。 最后，**迭代**是指完成一个时期所需的批处理数量。
 
 第二个`for`循环遍历总数据集的每个批量，直到完成一个纪元为止。 在此循环中，发生以下计算：
 
@@ -478,7 +478,7 @@ batch_size = 100
 
     注意
 
-    以下代码段不会自行运行。 您将需要加载一个数据集并将其划分为不同的集合，并定义和实例化一个网络体系结构。 还需要定义损失函数和优化算法（在本章前面的部分中进行了说明）。
+    以下代码段不会自行运行。 您将需要加载一个数据集并将其划分为不同的集合，并定义和实例化一个网络架构。 还需要定义损失函数和优化算法（在本章前面的部分中进行了说明）。
 
     ```py
     train_losses, dev_losses, \
@@ -670,7 +670,7 @@ batch_size = 100
 
 注意
 
-为此活动使用其他 Jupyter Notebook。 在那里，您将再次加载数据集并执行与上一个活动中类似的步骤，不同之处在于，将多次执行训练过程以训练不同的体系结构和训练时间。
+为此活动使用其他 Jupyter Notebook。 在那里，您将再次加载数据集并执行与上一个活动中类似的步骤，不同之处在于，将多次执行训练过程以训练不同的架构和训练时间。
 
 1.  导入与上一个活动相同的库。
 2.  加载数据并从目标拆分要素。 接下来，使用 60:20:20 的分割比例将数据分割为三个子集（训练，验证和测试）。 最后，将验证和测试集转换为 PyTorch 张量，就像在上一个活动中一样。
@@ -678,12 +678,12 @@ batch_size = 100
 
     注意
 
-    没有正确的方法来选择首先执行哪个测试，因此要有创造性和分析性。 如果模型体系结构中的更改减少或消除了高偏差但引入了高方差，则应考虑保留这些更改，但增加措施以应对高方差。
+    没有正确的方法来选择首先执行哪个测试，因此要有创造性和分析性。 如果模型架构中的更改减少或消除了高偏差但引入了高方差，则应考虑保留这些更改，但增加措施以应对高方差。
 
 4.  绘制两组数据的损失和准确性。
 5.  使用性能最佳的模型，对测试集进行预测（在微调过程中不应使用该预测）。 通过计算该组模型的准确性，将预测结果与真实情况进行比较。
 
-预期输出：通过模型体系结构和此处定义的参数获得的精度应为 80% 左右。
+预期输出：通过模型架构和此处定义的参数获得的精度应为 80% 左右。
 
 注意
 
@@ -724,7 +724,7 @@ batch_size = 100
 
     第一个参数指的是我们之前创建的字典，第二个参数是要使用的文件名。
 
-3.  使用您选择的文本编辑器，创建一个 Python 文件，该文件导入 PyTorch 库并包含创建模型的网络体系结构的类。 这样做是为了使您可以方便地将模型加载到新的工作表中，而无需使用用于训练模型的工作表。
+3.  使用您选择的文本编辑器，创建一个 Python 文件，该文件导入 PyTorch 库并包含创建模型的网络架构的类。 这样做是为了使您可以方便地将模型加载到新的工作表中，而无需使用用于训练模型的工作表。
 4.  To load the model, let's create a function that will perform three main actions:
 
     ```py
@@ -738,7 +738,7 @@ batch_size = 100
     model = load_model_checkpoint("checkpoint.pth")
     ```
 
-    该函数将输入保存的模型文件（检查点）的路径作为输入。 首先，加载检查点。 接下来，使用保存在 Python 文件中的网络体系结构实例化模型。 在这里， `final_model`指的是应该已经导入到新工作表中的 Python 文件的名称，而`Classifier()`指的是该文件中保存的类的名称。 该模型将具有随机初始化的参数。 最后，将来自检查点的参数加载到模型中。
+    该函数将输入保存的模型文件（检查点）的路径作为输入。 首先，加载检查点。 接下来，使用保存在 Python 文件中的网络架构实例化模型。 在这里， `final_model`指的是应该已经导入到新工作表中的 Python 文件的名称，而`Classifier()`指的是该文件中保存的类的名称。 该模型将具有随机初始化的参数。 最后，将来自检查点的参数加载到模型中。
 
     调用时，此函数将返回已训练的模型，该模型现在可用于进一步的训练或执行推理。
 
@@ -911,7 +911,7 @@ prediction = traced_script(input)
 该活动将使用三个 Jupyter 笔记本。 首先，我们将使用上一个活动中的同一笔记本来保存最终模型。 接下来，我们将打开一个新的笔记本，该笔记本将用于加载保存的模型。 最后，将使用第三个笔记本创建 API。
 
 1.  打开用于“活动 3.02”和“提高模型表现”的 Jupyter 笔记本。
-2.  复制包含最佳性能模型的体系结构的类，并将其保存在 Python 文件中。 确保导入 PyTorch 所需的库和模块。 将其命名为`final_model.py`。
+2.  复制包含最佳性能模型的架构的类，并将其保存在 Python 文件中。 确保导入 PyTorch 所需的库和模块。 将其命名为`final_model.py`。
 3.  在 Jupyter 笔记本中，保存性能最佳的模型。 确保保存与输入单元有关的信息以及模型参数。 将其命名为`checkpoint.pth`。
 4.  打开一个新的 Jupyter 笔记本。
 5.  导入 PyTorch 以及我们在“步骤 2”中创建的 Python 文件。
@@ -952,9 +952,9 @@ prediction = traced_script(input)
 
 本章使用来自台湾一家银行的真实数据集，目的是预测客户是否会拖欠付款。 本章通过解释定义任何数据问题的内容，原因和方式以及分析手头的数据以对其进行最佳利用的重要性，开始开发针对此问题的解决方案。
 
-根据问题定义准备好数据后，我们就探索了定义“良好”体系结构的想法。 即使可以考虑一些经验法则，但主要的收获还是要构建一个初始架构而又不去想太多，以便获得一些可用于执行误差分析以改善模型性能的结果。
+根据问题定义准备好数据后，我们就探索了定义“良好”架构的想法。 即使可以考虑一些经验法则，但主要的收获还是要构建一个初始架构而又不去想太多，以便获得一些可用于执行误差分析以改善模型性能的结果。
 
-误差分析的思想需要在训练和验证集上分析模型的误差率，以便确定模型是遭受更大的偏差还是承受更大的偏差。 然后，对模型的这种诊断将用于更改模型的体系结构和一些学习参数，这将导致性能的提高。
+误差分析的思想需要在训练和验证集上分析模型的误差率，以便确定模型是遭受更大的偏差还是承受更大的偏差。 然后，对模型的这种诊断将用于更改模型的架构和一些学习参数，这将导致性能的提高。
 
 最后，我们探索了使用最佳性能模型的三种主要方法。 第一种方法是保存模型，然后将其重新加载到任何编码平台中，以便我们可以继续训练或执行推理。 第二种方法主要用于将模型投入生产，并通过使用 PyTorch 的 JIT 模块来实现，该模块创建可以在 C ++上运行的模型的序列化表示。 最后，第三种方法包括创建一个可供其他程序访问的 API，以便它可以向模型发送信息或从模型接收信息。
 

new/dl-pt-workshop/4.md

@@ -2,13 +2,13 @@
 
 总览
 
-本章介绍了训练**卷积神经网络**（**CNN**）的过程-也就是说，发生在不同层的计算通常可以在 CNN 体系结构中找到，其目的 训练过程。 您将学习如何通过对模型应用数据扩充和批处理规范化来改善计算机视觉模型的性能。 到本章末，您将能够使用 CNN 通过 PyTorch 解决图像分类问题。 这将是在计算机视觉领域实施其他解决方案的起点。
+本章介绍了训练**卷积神经网络**（**CNN**）的过程-也就是说，发生在不同层的计算通常可以在 CNN 架构中找到，其目的 训练过程。 您将学习如何通过对模型应用数据扩充和批处理规范化来改善计算机视觉模型的性能。 到本章末，您将能够使用 CNN 通过 PyTorch 解决图像分类问题。 这将是在计算机视觉领域实施其他解决方案的起点。
 
 # 简介
 
-在上一章中，解释了最传统的神经网络体系结构并将其应用于现实生活中的数据问题。 在本章中，我们将探讨 CNN 的不同概念，这些概念主要用于解决计算机视觉问题（即图像处理）。
+在上一章中，解释了最传统的神经网络架构并将其应用于现实生活中的数据问题。 在本章中，我们将探讨 CNN 的不同概念，这些概念主要用于解决计算机视觉问题（即图像处理）。
 
-即使当今所有神经网络领域都很流行，但 CNN 可能是所有神经网络体系结构中最流行的。 这主要是因为，尽管它们在许多领域中都可以使用，但是它们尤其擅长处理图像，并且技术的进步已使大量图像的收集和存储成为可能，从而可以解决当今使用图像处理各种挑战。 图像作为输入数据。
+即使当今所有神经网络领域都很流行，但 CNN 可能是所有神经网络架构中最流行的。 这主要是因为，尽管它们在许多领域中都可以使用，但是它们尤其擅长处理图像，并且技术的进步已使大量图像的收集和存储成为可能，从而可以解决当今使用图像处理各种挑战。 图像作为输入数据。
 
 从图像分类到物体检测，CNN 被用于诊断癌症患者和检测系统中的欺诈行为，以及用于构建将彻底改变未来的深思熟虑的自动驾驶汽车。
 
@@ -28,7 +28,7 @@ CNN 是处理图像数据问题时的理想架构。 但是，由于它们通常
 
 ## 为什么将 CNN 用于图像处理？
 
-图像是像素矩阵，那么为什么不将矩阵展平为矢量并使用传统的神经网络体系结构对其进行处理呢？ 答案是，即使使用最简单的图像，也存在一些像素相关性会改变图像的含义。 例如，猫眼，汽车轮胎甚至物体边缘的表示都是由以某种方式布置的几个像素构成的。 如果我们将图像展平，则这些依赖关系将丢失，传统模型的准确性也会丢失：
+图像是像素矩阵，那么为什么不将矩阵展平为矢量并使用传统的神经网络架构对其进行处理呢？ 答案是，即使使用最简单的图像，也存在一些像素相关性会改变图像的含义。 例如，猫眼，汽车轮胎甚至物体边缘的表示都是由以某种方式布置的几个像素构成的。 如果我们将图像展平，则这些依赖关系将丢失，传统模型的准确性也会丢失：
 
 ![Figure 4.1: Representation of a flattened matrix ](img/B15778_04_01.jpg)
 
@@ -63,7 +63,7 @@ CNN 能够捕获图像的空间相关性，因为它根据滤镜的大小将它
 
 ## CNN 的应用
 
-尽管 CNN 主要用于解决计算机视觉问题，但重要的是要提及它们解决其他学习问题的能力，主要是在分析数据序列方面。 例如，已知 CNN 在文本，音频和视频的序列上表现良好，有时与其他网络体系结构结合使用，或者通过将序列转换为可以由 CNN 处理的图像。 使用带有数据序列的 CNN 可以解决的一些特定数据问题包括文本的机器翻译，自然语言处理和视频帧标记等。
+尽管 CNN 主要用于解决计算机视觉问题，但重要的是要提及它们解决其他学习问题的能力，主要是在分析数据序列方面。 例如，已知 CNN 在文本，音频和视频的序列上表现良好，有时与其他网络架构结合使用，或者通过将序列转换为可以由 CNN 处理的图像。 使用带有数据序列的 CNN 可以解决的一些特定数据问题包括文本的机器翻译，自然语言处理和视频帧标记等。
 
 CNN 可以执行不同的任务，这些任务适用于所有监督学习问题。 但是，本章将重点介绍计算机视觉。 以下是对每个任务的简要说明，以及每个任务的真实示例。
 
@@ -261,7 +261,7 @@ CNN 可以执行不同的任务，这些任务适用于所有监督学习问题
 
 这样，您就成功地计算了从卷积层得出的矩阵的输出形状。
 
-在 PyTorch 中编码卷积层非常简单。 使用自定义模块，只需要创建**网络**类。 该类应包含定义网络体系结构（即网络层）的`__init__`方法和定义要对信息进行计算的`forward`方法。 穿过层，如以下代码片段所示：
+在 PyTorch 中编码卷积层非常简单。 使用自定义模块，只需要创建**网络**类。 该类应包含定义网络架构（即网络层）的`__init__`方法和定义要对信息进行计算的`forward`方法。 穿过层，如以下代码片段所示：
 
 ```py
 import torch.nn as nn
@@ -390,7 +390,7 @@ class CNN_network(nn.Module):
         return x
 ```
 
-可以看出，在`__init__`方法中将池化层（`MaxPool2d`）添加到网络体系结构中。 在这里，进入最大池层的参数从左到右分别是过滤器（`2`）和步幅（`2`）的大小。 接下来，更新了`forward`方法，以使信息通过新的合并层。
+可以看出，在`__init__`方法中将池化层（`MaxPool2d`）添加到网络架构中。 在这里，进入最大池层的参数从左到右分别是过滤器（`2`）和步幅（`2`）的大小。 接下来，更新了`forward`方法，以使信息通过新的合并层。
 
 同样，这里显示了一种同样有效的方法，其中使用了自定义模块和**顺序**容器：
 
@@ -413,7 +413,7 @@ class CNN_network(nn.Module):
 
 ### 全连接层
 
-在输入经过一组卷积和池化层之后，在网络体系结构的末尾定义一个或多个 FC 层。 来自第一 FC 层之前的层的输出数据从矩阵展平为向量，可以将其馈送到 FC 层（与传统神经网络的隐藏层相同）。
+在输入经过一组卷积和池化层之后，在网络架构的末尾定义一个或多个 FC 层。 来自第一 FC 层之前的层的输出数据从矩阵展平为向量，可以将其馈送到 FC 层（与传统神经网络的隐藏层相同）。
 
 这些 FC 层的主要目的是考虑先前层检测到的所有特征，以便对图像进行分类。
 
@@ -725,7 +725,7 @@ test_data = datasets.CIFAR10('data', train=False, download=True, \
 
 ## 使用 PyTorch 进行批量归一化
 
-在 PyTorch 中，考虑到有两种不同的类型，添加批归一化就像向网络体系结构添加新层一样简单，如下所述：
+在 PyTorch 中，考虑到有两种不同的类型，添加批归一化就像向网络架构添加新层一样简单，如下所述：
 
 *   `BatchNorm1d`：此层用于在二维或三维输入上实现批量标准化。 它从上一层接收输出节点的数量作为参数。 这通常在 FC 层上使用。
 *   `BatchNorm2d`：这将批量归一化应用于四维输入。 同样，它采用的参数是上一层输出节点的数量。 它通常在卷积层上使用，这意味着它接受的参数应等于上一层的通道数。
@@ -754,7 +754,7 @@ class CNN(nn.Module):
 
 ## 活动 4.03：实现批量标准化
 
-对于此活动，我们将在前一个活动的体系结构上实现批量归一化，以查看是否有可能进一步提高测试集上模型的性能。 让我们看一下以下情况。
+对于此活动，我们将在前一个活动的架构上实现批量归一化，以查看是否有可能进一步提高测试集上模型的性能。 让我们看一下以下情况。
 
 您在性能方面所做的最后改进使您的队友印象深刻，现在他们对您的期望更高。 他们要求您最后一次尝试改进模型，以使准确性提高到 80%。 请按照以下步骤完成此活动：
 
@@ -782,9 +782,9 @@ class CNN(nn.Module):
 
 # 摘要
 
-本章重点介绍 CNN，它由一种在计算机视觉问题上表现出色的神经网络体系结构组成。 我们首先说明了为何广泛使用 CNN 来处理图像数据集的主要原因，并介绍了可以通过使用它们解决的不同任务。
+本章重点介绍 CNN，它由一种在计算机视觉问题上表现出色的神经网络架构组成。 我们首先说明了为何广泛使用 CNN 来处理图像数据集的主要原因，并介绍了可以通过使用它们解决的不同任务。
 
-本章通过解释卷积层，池化层以及最后的 FC 层的性质，说明了网络体系结构的不同构建块。 在每个部分中，都包括对每个层目的的解释，以及可用于有效编码 PyTorch 中的体系结构的代码段。
+本章通过解释卷积层，池化层以及最后的 FC 层的性质，说明了网络架构的不同构建块。 在每个部分中，都包括对每个层目的的解释，以及可用于有效编码 PyTorch 中的架构的代码段。
 
 这导致引入了图像分类问题，该问题着重于对车辆和动物的图像进行分类。 这个问题的目的是将 CNN 的不同构建块付诸实践，以解决图像分类数据问题。
 

new/dl-pt-workshop/5.md

@@ -6,9 +6,9 @@
 
 # 简介
 
-上一章介绍了传统 CNN 的不同构建基块，以及一些改进其性能并减少训练时间的技术。 此处说明的体系结构虽然很典型，但并不是一成不变的，并且出现了许多 CNN 体系结构来解决不同的数据问题，这在计算机视觉领域最为普遍。
+上一章介绍了传统 CNN 的不同构建基块，以及一些改进其性能并减少训练时间的技术。 此处说明的架构虽然很典型，但并不是一成不变的，并且出现了许多 CNN 架构来解决不同的数据问题，这在计算机视觉领域最为普遍。
 
-这些体系结构的配置和学习任务各不相同。 如今，由牛津机器人学院的 Karen Simonyan 和 Andrew Zisserman 创建的**视觉几何组**（**VGG**）体系结构是一种非常流行的方法。 它是为对象识别而开发的，并由于网络所依赖的大量参数而达到了最先进的性能。 它在数据科学家中受欢迎的主要原因之一是训练后的模型的参数（权重和偏差）的可用性，这使研究人员无需训练即可使用它，并且模型具有出色的性能。
+这些架构的配置和学习任务各不相同。 如今，由牛津机器人学院的 Karen Simonyan 和 Andrew Zisserman 创建的**视觉几何组**（**VGG**）架构是一种非常流行的方法。 它是为对象识别而开发的，并由于网络所依赖的大量参数而达到了最先进的性能。 它在数据科学家中受欢迎的主要原因之一是训练后的模型的参数（权重和偏差）的可用性，这使研究人员无需训练即可使用它，并且模型具有出色的性能。
 
 在本章中，我们将使用这种经过预训练的模型来解决计算机视觉问题，该问题由于专门用于共享图像的社交媒体渠道的普及而特别著名。 它包括执行样式转换，以便使用一个图像的样式（颜色和纹理）以及另一个图像的内容（形状和对象）创建新图像。
 
@@ -43,7 +43,7 @@
 
     注意
 
-    VGG 网络有不同的版本，并且都使用不同数量的层。 为了区分不同的版本，术语是这样的，即首字母缩写处的破折号和数字代表该特定体系结构的层数。 在本章中，我们将使用网络的 19 层版本，即 VGG-19。
+    VGG 网络有不同的版本，并且都使用不同数量的层。 为了区分不同的版本，术语是这样的，即首字母缩写处的破折号和数字代表该特定架构的层数。 在本章中，我们将使用网络的 19 层版本，即 VGG-19。
 
     因此，可以使用 PyTorch 的**模型**子包加载预训练的模型，以执行样式转换任务，而无需训练大量图像的网络。
 
@@ -58,7 +58,7 @@
 
 5.  **参数更新**：此步骤使用渐变来更新模型的不同参数。
 
-# 使用 VGG-19 网络体系结构实现样式转移
+# 使用 VGG-19 网络架构实现样式转移
 
 VGG-19 是由 19 层组成的 CNN。 它使用 ImageNet 数据库中的数百万张图像进行了训练。 该网络能够将图像分类为 1,000 种不同的类别标签，其中包括大量的动物和不同的工具。
 
@@ -257,7 +257,7 @@ transforms.Compose([transforms.Normalize((-0.5/0.25, \
 
 像在许多其他框架中一样，PyTorch 有一个子程序包，其中包含不同的模型，这些模型先前已经过训练并可供公众使用。 考虑到从头开始训练神经网络非常耗时，这一点很重要。 从预先训练的模型开始可以帮助减少训练时间。 这意味着可以加载经过预训练的模型，以便我们可以使用它们的最终参数（应该是使损失函数最小的参数），而无需经过迭代过程。
 
-如前所述，用于执行样式转换任务的体系结构是 19 层 VGG 网络的体系结构，也称为 VGG-19。 在`torchvision`的`model`子程序包下提​​供了预训练的模型。 在 PyTorch 中保存的模型分为两部分：
+如前所述，用于执行样式转换任务的架构是 19 层 VGG 网络的架构，也称为 VGG-19。 在`torchvision`的`model`子程序包下提​​供了预训练的模型。 在 PyTorch 中保存的模型分为两部分：
 
 1.  `vgg19.features`：这包括网络的所有卷积和池化层以及参数。 这些层负责从图像中提取特征。 有些层专门用于样式功能（例如颜色），而另一些层则专门用于内容功能（例如边缘）。
 2.  `vgg19.classifier`: This refers to the linear layers (also known as fully connected layers) that are located at the end of the network, including their parameters. These layers are the ones that perform the classification of the image into one of the label classes, for instance, recognizing the type of animal in an image.
@@ -319,7 +319,7 @@ for param in model.parameters():
 
 ## 提取功能
 
-正如我们前面提到的，VGG-19 网络包含 19 个不同的层，包括卷积，池化和全连接层。 卷积层在每个池化层之前先进入堆栈，其中五个是整个体系结构中的堆栈数。
+正如我们前面提到的，VGG-19 网络包含 19 个不同的层，包括卷积，池化和全连接层。 卷积层在每个池化层之前先进入堆栈，其中五个是整个架构中的堆栈数。
 
 在样式转移领域，已经有不同的论文确定了对于识别内容和样式图像上的相关特征至关重要的那些层。 因此，常规上接受的是，每个堆栈的第一卷积层都能够提取样式特征，而仅第四堆栈的第二卷积层应用于提取内容特征。
 
@@ -362,7 +362,7 @@ for index, layer in model._modules.items():
 
 ## 练习 5.03：设置特征提取过程
 
-使用上一练习的网络体系结构和本章第一练习的图像，我们将创建几个函数，这些函数能够从输入图像中提取特征并为样式特征创建语法矩阵。
+使用上一练习的网络架构和本章第一练习的图像，我们将创建几个函数，这些函数能够从输入图像中提取特征并为样式特征创建语法矩阵。
 
 1.  打开上一个练习中的笔记本。
 2.  Print the architecture of the model we loaded in the previous exercise. This will help us identify the relevant layers so that we can perform the style transfer task:
@@ -680,4 +680,4 @@ style_features = features_extractor(style_img, model, \
 
 通过最小化总损耗的值来创建目标图像，这可以通过更新与目标图像有关的参数来完成。 尽管可以使用预先训练的网络，但获得理想目标图像的过程可能需要进行数千次迭代和相当多的时间。
 
-在下一章中，将说明不同的网络体系结构，以便使用文本数据序列解决数据问题。 RNN 是保存内存的神经网络体系结构，允许它们处理顺序数据。 它们通常用于解决与人类语言理解有关的问题。
\ No newline at end of file
+在下一章中，将说明不同的网络架构，以便使用文本数据序列解决数据问题。 RNN 是保存内存的神经网络架构，允许它们处理顺序数据。 它们通常用于解决与人类语言理解有关的问题。
\ No newline at end of file

new/dl-pt-workshop/6.md

@@ -2,15 +2,15 @@
 
 总览
 
-本章扩展了循环神经网络的概念。 您将了解**循环神经网络**（**RNN**）的学习过程以及它们如何存储内存。 本章将介绍**长短期记忆**（**LSTM**）网络体系结构，该体系结构使用短期和长期存储器来解决数据序列中的数据问题。 在本章的最后，您将牢固地掌握 RNN 以及如何解决**自然语言处理**（**NLP**）数据问题。
+本章扩展了循环神经网络的概念。 您将了解**循环神经网络**（**RNN**）的学习过程以及它们如何存储内存。 本章将介绍**长短期记忆**（**LSTM**）网络架构，该架构使用短期和长期存储器来解决数据序列中的数据问题。 在本章的最后，您将牢固地掌握 RNN 以及如何解决**自然语言处理**（**NLP**）数据问题。
 
 # 简介
 
-在前面的章节中，介绍了不同的网络体系结构-从可以同时解决分类和回归问题的传统 ANN 到主要用于通过执行对象分类，定位，检测和分段任务来解决计算机视觉问题的 CNN 。
+在前面的章节中，介绍了不同的网络架构-从可以同时解决分类和回归问题的传统 ANN 到主要用于通过执行对象分类，定位，检测和分段任务来解决计算机视觉问题的 CNN 。
 
-在最后一章中，我们将探讨 RNN 的概念并解决顺序数据问题。 这些网络体系结构能够保存上下文至关重要的顺序数据，这要归功于它们能够保存来自先前预测的信息（称为内存）。 这意味着，例如，当逐个单词分析句子时，RNN 在处理最后一个单词时可以保留有关该单词第一个单词的信息。
+在最后一章中，我们将探讨 RNN 的概念并解决顺序数据问题。 这些网络架构能够保存上下文至关重要的顺序数据，这要归功于它们能够保存来自先前预测的信息（称为内存）。 这意味着，例如，当逐个单词分析句子时，RNN 在处理最后一个单词时可以保留有关该单词第一个单词的信息。
 
-本章将探讨 LSTM 网络体系结构，它是一种 RNN，可以同时存储长期和短期内存，并且对于处理长数据序列（例如视频剪辑）特别有用。
+本章将探讨 LSTM 网络架构，它是一种 RNN，可以同时存储长期和短期内存，并且对于处理长数据序列（例如视频剪辑）特别有用。
 
 本章还将探讨 NLP 的概念。 NLP 指的是计算机与人类语言的交互，由于虚拟助手的兴起，如今这已成为热门话题，虚拟助手可以提供定制的客户服务。 本章将使用 NLP 进行情感分析，其中包括分析句子后面的含义。 这有助于根据客户评论了解客户对产品或服务的看法。
 
@@ -22,9 +22,9 @@
 
 就像人类不会每秒重新设置思想一样，旨在理解人类语言的神经网络也不应这样做。 这意味着，为了理解段落中甚至整个书中的每个单词，您或模型需要理解之前的单词，这可以帮助给可能具有不同含义的单词提供上下文。
 
-到目前为止，我们已经讨论了传统的神经网络无法执行此类任务，因此创建了 RNN 的概念和网络体系结构。 正如我们之前简要解释的那样，这些网络体系结构包含不同节点之间的环路。 这使信息可以在模型中保留更长的时间。 因此，来自模型的输出既成为预测又是存储器，当下一行已排序的文本通过模型时将使用该存储器。
+到目前为止，我们已经讨论了传统的神经网络无法执行此类任务，因此创建了 RNN 的概念和网络架构。 正如我们之前简要解释的那样，这些网络架构包含不同节点之间的环路。 这使信息可以在模型中保留更长的时间。 因此，来自模型的输出既成为预测又是存储器，当下一行已排序的文本通过模型时将使用该存储器。
 
-这个概念可以追溯到 1980 年代，尽管它只是在最近才变得流行，这要归功于技术的进步，这种进步导致机器的计算能力提高了，并允许数据的收集以及对概念的发展。 1990 年代的 LSTM RNN，增加了其应用范围。 由于 RNN 具有存储内部存储器的能力，因此它们是最有前途的网络体系结构之一，这使它们能够有效地处理数据序列并解决各种数据问题。
+这个概念可以追溯到 1980 年代，尽管它只是在最近才变得流行，这要归功于技术的进步，这种进步导致机器的计算能力提高了，并允许数据的收集以及对概念的发展。 1990 年代的 LSTM RNN，增加了其应用范围。 由于 RNN 具有存储内部存储器的能力，因此它们是最有前途的网络架构之一，这使它们能够有效地处理数据序列并解决各种数据问题。
 
 ## RNN 的应用
 
@@ -92,7 +92,7 @@
 
 注意
 
-传统 RNN 的内部记忆只是短期的。 但是，我们将探索一种能够在以后存储长期和短期内存的体系结构。
+传统 RNN 的内部记忆只是短期的。 但是，我们将探索一种能够在以后存储长期和短期内存的架构。
 
 通过使用来自先前预测的信息，网络将按照一系列有序数据进行训练，从而可以预测下一步。 这是通过将当前信息和上一步的输出合并为一个操作来实现的。 在下图中可以看到。 此操作的输出将成为预测，以及后续预测的输入的一部分：
 
@@ -267,7 +267,7 @@ for i in range(1, epochs+1):
 
     `target`变量应比`input`变量领先一步； 也就是说，`target`变量的第一个值应该是输入变量的第二个，依此类推，直到`target`变量的最后一个值（应该是最后一个`input`变量之外的一周）。
 
-5.  创建一个包含网络体系结构的类； 请注意，全连接层的输出大小应为 1。
+5.  创建一个包含网络架构的类； 请注意，全连接层的输出大小应为 1。
 6.  实例化包含模型的类函数。 输入输入大小，每个循环层中的神经元数（10）和循环层数（1）。
 7.  定义损失函数，优化算法和训练网络的时期数。 为此，请使用均方误差损失函数，Adam 优化器和 10,000 个纪元。
 8.  使用`for`循环通过遍历所有时期来执行训练过程。 在每个时期，都必须进行预测，以及随后的损失函数计算和网络参数优化。 然后，保存每个时期的损失。
@@ -358,7 +358,7 @@ for i in range(1, epochs+1):
 
 # PyTorch 中的 LSTM 网络
 
-在 PyTorch 中定义 LSTM 网络体系结构的过程与到目前为止我们讨论过的任何其他神经网络的过程相似。 但是，重要的是要注意，当处理与数字序列不同的数据序列时，需要进行一些预处理才能为网络提供它可以理解和处理的数据。
+在 PyTorch 中定义 LSTM 网络架构的过程与到目前为止我们讨论过的任何其他神经网络的过程相似。 但是，重要的是要注意，当处理与数字序列不同的数据序列时，需要进行一些预处理才能为网络提供它可以理解和处理的数据。
 
 考虑到这一点，我们需要解释训练模型的一般步骤，以便能够将文本数据作为输入并检索新的文本数据。 值得一提的是，并非严格要求此处说明的所有步骤，而是作为一个整体，它们为使用 LSTM 与文本数据结合在一起提供了干净且可重用的代码。
 
@@ -542,7 +542,7 @@ onehot = onehot_flat.reshape((batch.shape[0],\
 
 ## 构建架构
 
-与其他神经网络类似，可以在一行代码中轻松定义 LSTM 层。 但是，包含网络体系结构的类必须包含一个函数，该函数允许初始化隐藏状态和单元状态（即网络的两个内存）。 LSTM 网络体系结构的示例如下：
+与其他神经网络类似，可以在一行代码中轻松定义 LSTM 层。 但是，包含网络架构的类必须包含一个函数，该函数允许初始化隐藏状态和单元状态（即网络的两个内存）。 LSTM 网络架构的示例如下：
 
     ```py
     class LSTM(nn.Module):
@@ -583,7 +583,7 @@ onehot = onehot_flat.reshape((batch.shape[0],\
 
 ## 训练模型
 
-一旦定义了损失函数和优化算法，就该训练模型了。 这是通过采用与其他神经网络体系结构非常相似的方法来实现的，如以下代码片段所示：
+一旦定义了损失函数和优化算法，就该训练模型了。 这是通过采用与其他神经网络架构非常相似的方法来实现的，如以下代码片段所示：
 
 ```py
 # Step 1: for through epochs
@@ -685,7 +685,7 @@ while starter[-1] != "." and counter < 50:
 3.  创建一个变量，该变量包含数据集中未重复字符的列表。 然后，创建一个字典，将每个字符映射到一个整数，其中字符将是键，而整数将是值。
 4.  将数据集中的每个字母编码为成对的整数。 打印数据集的前 50 个编码字符和编码版本的总长度。
 5.  创建一个接受批处理并将其编码为单热点矩阵的函数。
-6.  创建一个定义网络体系结构的类。 该类应包含一个用于初始化 LSTM 层状态的附加函数。
+6.  创建一个定义网络架构的类。 该类应包含一个用于初始化 LSTM 层状态的附加函数。
 7.  请确定要从数据集中创建的批量数量，请记住每个批量应包含 100 个序列，每个批量的长度应为 50。接下来，将编码数据拆分为 100 个序列。
 8.  使用 256 作为隐藏单位数（总共两个循环层）实例化模型。
 9.  Define the loss function and the optimization algorithms. Use the Adam optimizer and the cross-entropy loss. Train the network for 20 epochs.
@@ -776,13 +776,13 @@ NLP 是**人工智能**（**AI**）的子字段，它通过使计算机能够理
 
 图 6.24：单词和数字的映射
 
-PyTorch 无需执行一次性编码，而是将单词嵌入单行代码，这些代码可以在包含网络体系结构的类中定义（将在下面进行解释）。
+PyTorch 无需执行一次性编码，而是将单词嵌入单行代码，这些代码可以在包含网络架构的类中定义（将在下面进行解释）。
 
 ## 构建架构
 
-同样，定义网络体系结构的过程与我们到目前为止研究的过程非常相似。 但是，正如我们前面提到的，网络还应包括一个嵌入层，该嵌入层将获取输入数据（已转换为数字表示形式）并为每个单词分配相关程度。 也就是说，这些值将在训练过程中更新，直到最相关的单词被加权更高为止。
+同样，定义网络架构的过程与我们到目前为止研究的过程非常相似。 但是，正如我们前面提到的，网络还应包括一个嵌入层，该嵌入层将获取输入数据（已转换为数字表示形式）并为每个单词分配相关程度。 也就是说，这些值将在训练过程中更新，直到最相关的单词被加权更高为止。
 
-以下是体系结构的示例：
+以下是架构的示例：
 
 ```py
 class LSTM(nn.Module):
@@ -801,7 +801,7 @@ class LSTM(nn.Module):
         return out, states
 ```
 
-如您所见，嵌入层将整个词汇表的长度以及用户设置的嵌入维度作为参数。 嵌入尺寸将是 LSTM 层的输入尺寸。 其余的体系结构将保持与以前相同。
+如您所见，嵌入层将整个词汇表的长度以及用户设置的嵌入维度作为参数。 嵌入尺寸将是 LSTM 层的输入尺寸。 其余的架构将保持与以前相同。
 
 ## 训练模型
 
@@ -859,8 +859,8 @@ RNN 的工作方式非常聪明。 网络不仅输出结果，而且还输出一
 
 当处理涉及非常大序列的数据问题时，传统的 RNN 会出现一个称为消失梯度问题的问题。 在这里梯度变得非常小，因此它们不再对网络的学习过程有所贡献，而这种学习过程通常发生在网络的较早层中，从而导致网络无法长期存储。
 
-为了解决这个问题，开发了 LSTM 网络。 这种网络体系结构能够存储两种类型的内存，因此得名。 此外，在此网络中进行的数学计算允许它仅通过存储过去的相关信息来忘记信息。
+为了解决这个问题，开发了 LSTM 网络。 这种网络架构能够存储两种类型的内存，因此得名。 此外，在此网络中进行的数学计算允许它仅通过存储过去的相关信息来忘记信息。
 
 最后，解释了一个非常流行的 NLP 任务：情绪分析。 在此任务中，重要的是要理解文本提取背后的情感。 对于机器而言，这是一个非常困难的问题，因为人们可以使用许多不同的单词和表达形式（例如讽刺）来描述事件背后的情绪。 但是，由于社交媒体使用量的增加，这导致需要更快地处理文本数据，这个问题在投入大量时间和金钱来创建多个近似值以解决该问题的大公司中变得非常普遍，如图所示。 本章的最后活动。
 
-既然您已经遍历了本书的所有章节，您将对不同的深度神经网络体系结构有广泛的了解，这些体系结构可用于使用 PyTorch 解决各种数据问题。 本书中说明的体系结构也可以用于解决其他数据问题。
\ No newline at end of file
+既然您已经遍历了本书的所有章节，您将对不同的深度神经网络架构有广泛的了解，这些架构可用于使用 PyTorch 解决各种数据问题。 本书中说明的架构也可以用于解决其他数据问题。
\ No newline at end of file

new/dl-pt-workshop/7.md

@@ -807,7 +807,7 @@
 
     打印（acc_test）
 
-    通过模型体系结构和此处定义的参数获得的精度应为 80% 左右。
+    通过模型架构和此处定义的参数获得的精度应为 80% 左右。
 
     注意
 
@@ -1117,7 +1117,7 @@
 
     返回 x
 
-    前面的代码段包含一个定义了网络体系结构的类（`__init__`方法），以及在信息正向传递过程中所遵循的步骤（`forward`方法）。
+    前面的代码段包含一个定义了网络架构的类（`__init__`方法），以及在信息正向传递过程中所遵循的步骤（`forward`方法）。
 
 7.  Define all of the parameters that are required to train your model. Set the number of epochs to`50`:
 
@@ -1543,7 +1543,7 @@
 
 1.  Duplicate the notebook from the previous activity.
 
-    要完成此活动，按照以下步骤，除了在网络体系结构中添加一些层之外，不会更改任何代码。
+    要完成此活动，按照以下步骤，除了在网络架构中添加一些层之外，不会更改任何代码。
 
 2.  Add batch normalization to each convolutional layer, as well as to the first fully connected layer.
 
@@ -1613,7 +1613,7 @@
 
     注意
 
-    尽管本章未对此进行探讨，但理想的步骤是为网络体系结构添加辍学以减少高方差。 随意尝试一下，看看您是否能够进一步提高性能。
+    尽管本章未对此进行探讨，但理想的步骤是为网络架构添加辍学以减少高方差。 随意尝试一下，看看您是否能够进一步提高性能。
 
 4.  Calculate the accuracy of the resulting model on the testing set.
 
@@ -2059,7 +2059,7 @@
 
     返回，隐藏
 
-    与之前的活动一样，该类包含`__init__`方法以及网络体系结构，以及`forward`方法，该方法确定信息在各层之间的流动。
+    与之前的活动一样，该类包含`__init__`方法以及网络架构，以及`forward`方法，该方法确定信息在各层之间的流动。
 
 6.  Instantiate the **class** function containing the model. Feed the input size, the number of neurons in each recurrent layer (`10`), and the number of recurrent layers (`1`):
 
@@ -2313,7 +2313,7 @@
 
     返回状态
 
-    此类包含`__init__`方法（其中定义了网络的体系结构），`forward`方法（用于确定通过层的数据流）以及`init_state`用零初始化隐藏状态和单元状态的方法。
+    此类包含`__init__`方法（其中定义了网络的架构），`forward`方法（用于确定通过层的数据流）以及`init_state`用零初始化隐藏状态和单元状态的方法。
 
 7.  Determine the number of batches to be created out of your dataset, bearing in mind that each batch should contain 100 sequences, each with a length of 50\. Next, split the encoded data into 100 sequences:
 
@@ -2687,7 +2687,7 @@
 
     返回
 
-    该类包含用于定义网络体系结构的`__init__`方法和用于确定数据流经不同层的方式的`forward`方法。
+    该类包含用于定义网络架构的`__init__`方法和用于确定数据流经不同层的方式的`forward`方法。
 
 7.  Instantiate the model using 64 embedding dimensions and 128 neurons for three LSTM layers:
 

new/handson-1shot-learn-py/0.md

@@ -2,7 +2,7 @@
 
 一次学习一直是许多科学家的活跃研究领域，他们试图找到一种在学习方面尽可能接近人类的认知机器。 关于人类如何实现一键式学习的理论多种多样，从非参数模型和深度学习架构到概率模型，可以采用多种方法来实现这一功能。
 
-《Python 一次学习实用指南》将专注于设计和学习可以从一个或几个训练示例中学习与对象有关的信息的模型。 本书将首先为您简要介绍深度学习和一次学习，以帮助您入门。 然后，您将学习实现此目标的不同方法，包括非参数模型，深度学习体系结构和概率模型。 精通核心原理后，您将探索一些实用的实际示例和使用 scikit-learn 和 PyTorch 的一键式学习的实现。
+《Python 一次学习实用指南》将专注于设计和学习可以从一个或几个训练示例中学习与对象有关的信息的模型。 本书将首先为您简要介绍深度学习和一次学习，以帮助您入门。 然后，您将学习实现此目标的不同方法，包括非参数模型，深度学习架构和概率模型。 精通核心原理后，您将探索一些实用的实际示例和使用 scikit-learn 和 PyTorch 的一键式学习的实现。
 
 到本书结尾，您将熟悉单发和少发的学习方法，并能够通过单发学习来加速深度学习过程。
 
@@ -16,13 +16,13 @@
 
 第 2 章和“基于度量的方法”通过将核心保持为基本的 k 最近邻，探索了使用不同形式的嵌入和评估度量的方法。
 
-第 3 章和“基于模型的方法”探索了两种体系结构，其内部体系结构有助于训练 k-shot 学习模型。
+第 3 章和“基于模型的方法”探索了两种架构，其内部架构有助于训练 k-shot 学习模型。
 
 “基于优化的方法”探索了各种形式的优化算法，即使数据量很少，它们也有助于提高准确性。
 
 “基于生成模型的方法”探索了一种用概率模型表示对象类别的贝叶斯学习框架的开发。
 
-“结论和其他方法”仔细研究了体系结构，指标和算法的某些方面，以了解我们如何确定方法是否接近人脑的能力。
+“结论和其他方法”仔细研究了架构，指标和算法的某些方面，以了解我们如何确定方法是否接近人脑的能力。
 
 # 充分利用这本书
 
@@ -86,7 +86,7 @@ y = iris.target
 pip install -r requirements.txt
 ```
 
-**粗体**：表示新术语，重要单词或您在屏幕上看到的单词。 例如，菜单或对话框中的单词会出现在这样的文本中。 这是一个示例：“我们可以使用称为**三重损失**的新损失函数，该函数可以帮助体系结构获得更好的结果。”
+**粗体**：表示新术语，重要单词或您在屏幕上看到的单词。 例如，菜单或对话框中的单词会出现在这样的文本中。 这是一个示例：“我们可以使用称为**三重损失**的新损失函数，该函数可以帮助架构获得更好的结果。”
 
 警告或重要提示如下所示。
 

new/handson-1shot-learn-py/1.md

@@ -74,7 +74,7 @@
 
 # 一键式学习–概述
 
-一次学习可以看作是一种类似于人类学习方式的机器训练方法。 一次学习是一种在有限的监督数据的帮助下，借助强大的先验知识来学习新任务的方法。 李菲菲博士最早发表的导致图像分类问题精度高的著作可以追溯到 2000 年代-尽管近年来，研究人员在通过不同的深度学习体系结构和优化算法（例如， 匹配网络，不可知论元学习模型和记忆增强神经网络。 一键式学习在多个行业中都有很多应用，尤其是在医疗和制造业中。 在医学上，当可用数据有限时，例如在治疗罕见疾病时，我们可以使用一次学习。 而在制造中，我们可以减少人为错误，例如表壳制造中的缺陷。
+一次学习可以看作是一种类似于人类学习方式的机器训练方法。 一次学习是一种在有限的监督数据的帮助下，借助强大的先验知识来学习新任务的方法。 李菲菲博士最早发表的导致图像分类问题精度高的著作可以追溯到 2000 年代-尽管近年来，研究人员在通过不同的深度学习架构和优化算法（例如， 匹配网络，不可知论元学习模型和记忆增强神经网络。 一键式学习在多个行业中都有很多应用，尤其是在医疗和制造业中。 在医学上，当可用数据有限时，例如在治疗罕见疾病时，我们可以使用一次学习。 而在制造中，我们可以减少人为错误，例如表壳制造中的缺陷。
 
 # 一口气学习的先决条件
 
@@ -152,7 +152,7 @@ jupyter notebook
 
 # 编码练习
 
-在本节中，我们将探索一种基本的一次学习方法。 作为人类，我们有一种分层的思维方式。 例如，如果我们看到一些未知的东西，我们会寻找它与我们已经知道的对象的相似性。 同样，在本练习中，我们将使用非参数 kNN 方法查找类。 我们还将其性能与基本神经网络体系结构进行比较。
+在本节中，我们将探索一种基本的一次学习方法。 作为人类，我们有一种分层的思维方式。 例如，如果我们看到一些未知的东西，我们会寻找它与我们已经知道的对象的相似性。 同样，在本练习中，我们将使用非参数 kNN 方法查找类。 我们还将其性能与基本神经网络架构进行比较。
 
 # kNN –基本的一次学习
 
@@ -287,7 +287,7 @@ Accuracy of our model is equal 50.0 %.
 
 # 概要
 
-深度学习已经彻底变革了数据科学领域，并且仍在不断进步，但是仍然有一些主要行业尚未体验到深度学习的所有优势，例如医疗和制造业。 人类成就的顶峰将是创造一种可以像人类一样学习并且可以像人类一样成为专家的机器。 但是，成功的深度学习通常需要拥有非常庞大的数据集才能进行工作。 幸运的是，本书重点介绍了可以消除此先决条件的体系结构。
+深度学习已经彻底变革了数据科学领域，并且仍在不断进步，但是仍然有一些主要行业尚未体验到深度学习的所有优势，例如医疗和制造业。 人类成就的顶峰将是创造一种可以像人类一样学习并且可以像人类一样成为专家的机器。 但是，成功的深度学习通常需要拥有非常庞大的数据集才能进行工作。 幸运的是，本书重点介绍了可以消除此先决条件的架构。
 
 在本章中，我们了解了人类的大脑以及人工神经网络的结构如何接近我们的大脑结构。 我们介绍了机器学习和深度学习的基本概念及其挑战。 我们还讨论了一次学习及其各种类型，然后在`iris`数据集上进行了实验，以比较在数据稀缺情况下的参数方法和非参数方法。 总的来说，我们得出结论，正确的特征表示在确定机器学习模型的效率方面起着重要作用。
 

new/handson-1shot-learn-py/3.md

 # 基于模型的方法
 
-在上一章中，我们讨论了两种基于优化的方法。 我们试图用元学习机制来训练模型，这与人类所见相似。 当然，除了学习新事物的能力外，人类在执行任何任务时还可以访问大量内存。 通过回忆过去的经历和经验，这使我们能够更轻松地学习新任务。 遵循相同的思想过程，设计了基于模型的体系结构，并添加了外部存储器以快速概括一次学习任务。 在这些方法中，使用存储在外部存储器中的信息，模型仅需几个训练步骤即可收敛。
+在上一章中，我们讨论了两种基于优化的方法。 我们试图用元学习机制来训练模型，这与人类所见相似。 当然，除了学习新事物的能力外，人类在执行任何任务时还可以访问大量内存。 通过回忆过去的经历和经验，这使我们能够更轻松地学习新任务。 遵循相同的思想过程，设计了基于模型的架构，并添加了外部存储器以快速概括一次学习任务。 在这些方法中，使用存储在外部存储器中的信息，模型仅需几个训练步骤即可收敛。
 
 本章将涵盖以下主题：
 
@@ -22,9 +22,9 @@
 *   神经网络仅接受固定大小的输入，这在输入长度可变的现实生活中不会有太大帮助。
 *   神经网络无法将值绑定到我们已知的两个信息系统（人脑和计算机）大量使用的数据结构中的特定位置。 简单来说，在神经网络中，我们无法将特定的权重设置到特定的位置。
 
-第一个问题可以通过在各种任务上实现最先进性能的 RNN 来解决。 通过查看**神经图灵机**（**NTM**）可以解决第二个问题。 在本节中，我们将讨论 NTM 的总体体系结构，这是理解**记忆增强神经网络**（**MANN**）的基础，这些神经网络修改了 NMT 的体系结构并使之适用于一个 镜头的学习任务。
+第一个问题可以通过在各种任务上实现最先进性能的 RNN 来解决。 通过查看**神经图灵机**（**NTM**）可以解决第二个问题。 在本节中，我们将讨论 NTM 的总体架构，这是理解**记忆增强神经网络**（**MANN**）的基础，这些神经网络修改了 NMT 的架构并使之适用于一个 镜头的学习任务。
 
-# NTM 的体系结构
+# NTM 的架构
 
 在过去的 50 年中，现代计算机发生了很大的变化。 但是，它们仍然由三个系统组成-内存，控制流和算术/逻辑运算。 来自生物学和计算神经科学领域的研究提供了广泛的证据，表明记忆对于快速有效地存储和检索信息至关重要。 从中汲取灵感，NTM 基本上由神经网络组成，该神经网络由控制器和称为存储库（或存储矩阵）的二维矩阵组成。 在每个时间步长，神经网络都会接收一些输入，并生成与该输入相对应的输出。 在这样做的过程中，它还访问内部存储库并对其执行读取和/或写入操作。 从传统的图灵机中汲取灵感，NMT 使用术语**头部**来指定内存位置。 下图显示了总体架构：
 
@@ -82,7 +82,7 @@
 
 所有操作（包括读取，写入和寻址的四个阶段）都是差分的，因此可以使用反向传播和任何基于梯度下降的优化器从头到尾训练整个 NMT 模型。 控制器是一个神经网络，可以是前馈网络，也可以是循环神经网络，例如**长短期记忆**（**LSTM**）。 它已显示在各种算法任务（例如复制任务）上均具有良好的性能，这些任务将在本章的稍后部分实现。
 
-既然我们了解了 NTM 的体系结构和工作原理，我们就可以开始研究 MANN，这是对 NMT 的修改，并且经过修改可以在一次学习中表现出色。
+既然我们了解了 NTM 的架构和工作原理，我们就可以开始研究 MANN，这是对 NMT 的修改，并且经过修改可以在一次学习中表现出色。
 
 # 记忆增强神经网络
 
@@ -108,7 +108,7 @@ MANN 的读取操作与 NTM 的读取操作非常相似，唯一的区别是此
 
 通过对 Omniglot 数据集进行一次一次性分类任务，MANN 已显示出令人鼓舞的结果。 由于其基本的模型 NTM，它们表现良好。 NTM 能够快速编码，存储和检索数据。 它们还能够存储长期和短期权重。 可以使用 MANN 的方法添加 NTM，以跟踪*最久未使用的存储位置*，以执行基于内容的寻址，以读取和写入*最久未使用的*位置。 它使 MANN 成为少量学习的理想人选。
 
-在下一部分中，我们将学习另一种基于模型的体系结构，该体系结构由四个体系结构的网络组成，并为一次学习领域做出了重大贡献。
+在下一部分中，我们将学习另一种基于模型的架构，该架构由四个架构的网络组成，并为一次学习领域做出了重大贡献。
 
 # 了解元网络
 
@@ -138,7 +138,7 @@ MANN 的读取操作与 NTM 的读取操作非常相似，唯一的区别是此
 *   <sub>*![](img/86d121fb-e454-4b03-bb18-1224e2c5db40.png) *</sub> ：一种 LSTM 架构，用于学习嵌入函数的快速权重 <sub>![](img/45de2f89-d9d7-48df-807e-474abf54ba2c.png)</sub> （（ <sub>![](img/e2604082-7c04-461c-a490-d861af786a6d.png)</sub> ）的慢速网络。
 *   <sub>*![](img/73662f56-4d4a-4173-8fda-cbc27fcddb1e.png) *</sub> ：通过`v`学习快速权重 <sub>![](img/1473324d-1977-4883-a009-fd5653b452c9.png)</sub> 参数化的神经网络，用于基础学习器 <sub>![](img/5bbeac7c-31a0-4f2d-aeb2-f2d2eec0fe92.png)</sub> ，来自其损耗梯度。
 
-下图说明了元网络体系结构：
+下图说明了元网络架构：
 
 ![](img/7ee8a46f-a88d-4310-a261-da0df68aa4f7.png)
 
@@ -147,7 +147,7 @@ MANN 的读取操作与 NTM 的读取操作非常相似，唯一的区别是此
 *   LSTM 网络（ <sub>![](img/ec5b8bec-9208-4445-81ab-61ba0dfed94d.png)</sub> ），学习嵌入函数的（元学习器）快速权重-即 <sub>![](img/0c81d110-6d01-4cad-9801-a4af6d5d6bd4.png)</sub> 。
 *   神经网络（ <sub>![](img/e810d56f-4e6e-431c-8004-6d820808ca9a.png)</sub> ），以学习基本学习器的快速权重，即 <sub>![](img/776bf61b-01d6-468a-b4c5-d77740a4d7cc.png)</sub> 。
 
-现在我们已经了解了快速权重和慢速权重的概念和体系结构，让我们尝试观察整个元网络体系结构：
+现在我们已经了解了快速权重和慢速权重的概念和架构，让我们尝试观察整个元网络架构：
 
 ![](img/d98e350d-6d91-4bff-b79d-6f33824b0e59.png)
 
@@ -204,7 +204,7 @@ MANN 的读取操作与 NTM 的读取操作非常相似，唯一的区别是此
 
 5.  使用 <sub>![](img/2c7b6001-b226-47b4-ab23-4296938f9944.png)</sub> 更新所有参数（θ，ϕ，w，v）。
 
-在选择嵌入网络时，元网络使用 LSTM 体系结构。 如我们所见，匹配网络和 LSTM 元学习器也遵循相同的策略，分别用于提取数据和元信息的上下文嵌入。 这是因为 LSTM 体系结构倾向于记住历史，这使得元学习器的目标能够跨任务提取重要信息。
+在选择嵌入网络时，元网络使用 LSTM 架构。 如我们所见，匹配网络和 LSTM 元学习器也遵循相同的策略，分别用于提取数据和元信息的上下文嵌入。 这是因为 LSTM 架构倾向于记住历史，这使得元学习器的目标能够跨任务提取重要信息。
 
 例如，假设我们正在训练我们的网络以完成多种任务，例如猫的品种分类和狗的品种分类。 当我们使用 LSTM 元学习器进行训练时，它会学习例如狗品种分类中体重更新的策略，并使用这些学习到的信息以较少的步骤和较少的数据来优化其用于猫品种分类的操作。 使用元网络在 Omniglot 数据集上达到了 95.92% 的准确性，而人类的准确性仅为 95.5%，因此，元网络被认为是最新模型之一。
 
@@ -716,7 +716,7 @@ class WriteHead(Memory):
 
 # 概要
 
-在本章中，我们探索了用于单次学习的不同形式的基于模型的体系结构。 我们观察到的最常见的事情是使用外部存储器，这对学习神经网络不同阶段的表示形式有什么帮助。 NMT 方法在一次学习任务中表现良好，但是由于手工设计的内存寻址功能，它们的能力仍然有限，因为它们必须具有差异性。 探索更复杂的功能来处理内存可能很有趣。 在元网络中，我们看到了如何定义一个新网络以实现对原始网络的快速学习，以及如何在元学习器级别上存储有关表示的信息如何在基础级别上微调参数。 尽管基于模型的体系结构是实现一次学习的好方法，但它们具有外部存储器的先决条件，因此与其他方法相比，实现基于模型的体系结构的成本昂贵。
+在本章中，我们探索了用于单次学习的不同形式的基于模型的架构。 我们观察到的最常见的事情是使用外部存储器，这对学习神经网络不同阶段的表示形式有什么帮助。 NMT 方法在一次学习任务中表现良好，但是由于手工设计的内存寻址功能，它们的能力仍然有限，因为它们必须具有差异性。 探索更复杂的功能来处理内存可能很有趣。 在元网络中，我们看到了如何定义一个新网络以实现对原始网络的快速学习，以及如何在元学习器级别上存储有关表示的信息如何在基础级别上微调参数。 尽管基于模型的架构是实现一次学习的好方法，但它们具有外部存储器的先决条件，因此与其他方法相比，实现基于模型的架构的成本昂贵。
 
 在下一章中，我们将介绍基于优化的方法，例如与模型无关的元学习和 LSTM 元学习。 内存为我们提供了一种方式来存储我们所学到的信息，因此优化策略使我们能够更快地学习事物。 在后面的章节中，我们将探索一些不同形式的优化策略，这些策略可以用来学习目标。
 

new/handson-1shot-learn-py/5.md

@@ -10,7 +10,7 @@
 *   了解定向图形模型
 *   概率方法概述
 *   贝叶斯程序学习
-*   判别式 k 镜头学习
+*   判别式 k 次学习
 
 # 技术要求
 
@@ -32,11 +32,11 @@
 
 ![](img/f1da3c33-07dc-4b1d-8a75-aa4162729d8c.png)
 
-我们可以从数据的右侧删除 *P（data）*，因为它不依赖于 ***θ*** 来进行优化，因此也可以进行优化 问题如下：
+我们可以从数据的右侧删除 *P（data）*，因为它不依赖于 **`θ`** 来进行优化，因此也可以进行优化 问题如下：
 
 ![](img/d5a1d317-b037-40b4-b612-10d2e168e328.png)
 
-在非概率视图（也称为**期望最大化框架**）中，右侧等式中的术语 <sub>![](img/b2bc2505-5ae0-48b6-8e48-9e6b6f33452f.png)</sub> 和 <sub>![](img/eaf61a80-dcfc-4e84-9c97-4a61a0f3cf8e.png)</sub> ，分别成为损失函数和正则化。 在给定的概率设置中，相同的术语称为**可能性**（数据中，给定 ***θ***）和**在先的**（先验信念） 在参数空间中）。 这种概率优化称为**最大 A ** **后验**（**MAP**）估计，因为我们正在从数据中最大化模型参数的后验分布。 但是，贝叶斯统计不相信 MAP 估计，因为它可能给我们有关最终学习参数的错误结果。 一个不同的数据集很有可能会给我们完全不同的学习参数，这些参数在参数空间中与从原始数据集中学习的参数相距甚远。 这就是贝叶斯学习试图解决的问题。 它显式地模拟参数空间中的不确定性。
+在非概率视图（也称为**期望最大化框架**）中，右侧等式中的术语 <sub>![](img/b2bc2505-5ae0-48b6-8e48-9e6b6f33452f.png)</sub> 和 <sub>![](img/eaf61a80-dcfc-4e84-9c97-4a61a0f3cf8e.png)</sub> ，分别成为损失函数和正则化。 在给定的概率设置中，相同的术语称为**可能性**（数据中，给定 **`θ`**）和**在先的**（先验信念） 在参数空间中）。 这种概率优化称为**最大 A ** **后验**（**MAP**）估计，因为我们正在从数据中最大化模型参数的后验分布。 但是，贝叶斯统计不相信 MAP 估计，因为它可能给我们有关最终学习参数的错误结果。 一个不同的数据集很有可能会给我们完全不同的学习参数，这些参数在参数空间中与从原始数据集中学习的参数相距甚远。 这就是贝叶斯学习试图解决的问题。 它显式地模拟参数空间中的不确定性。
 
 考虑给定左撇子和右撇子人数据集的参数分布示例。 下图显示了分布：
 
@@ -124,7 +124,7 @@
 
 BPL 是一种高度直观的模型，可以在贝叶斯框架下使用简单的程序为概念建模。 从训练数据中学习概率分布的参数。 在分类和生成的单次计算机视觉任务上，该模型的性能与人类水平的性能相当，其数据需求远低于某些最新的深度学习模型。 这里研究的概率程序非常基础，适合于相当容易的字符识别任务。 BPL 框架支持设计更复杂的程序，这些程序可以对各种对象的复杂表示进行建模。 例如，可以使用此框架对在零件和关系方面具有清晰直观描述的对象（例如车辆，食品，动物，甚至人脸）进行建模。 为此，BPL 框架甚至支持建模抽象知识，例如自然语言语义和物理理论。 然而，这些概率程序需要对数据及其部分，子部分和关系进行手动标记，这是一个耗时的过程，而深度学习方法则是自己学习这些人类直观特征和深层抽象特征。
 
-# 判别式 k 镜头学习
+# 判别式 k 次学习
 
 k-shot 学习的一种非常常见的方法是训练具有相关任务的大型模型，而我们为此拥有大型数据集。 然后，通过 k 镜头特定任务对该模型进行微调。 因此，来自大型数据集的知识被*提炼为*到模型中，这仅从几个示例中增加了对新相关任务的学习。 2003 年，Bakker 和 Heskes 提出了一种用于 k-shot 学习的概率模型，其中所有任务共享一个公共特征提取器，但具有各自的线性分类器，其中仅包含几个特定于任务的参数。
 
@@ -134,7 +134,7 @@ k-shot 学习的一种非常常见的方法是训练具有相关任务的大型
 
 *   表征学习
 *   概念学习
-*   K 镜头学习
+*   K 次学习
 *   K-shot 测试
 
 下图显示了具有四个阶段的框架。 以下各节将对它们进行更正式的讨论：
@@ -206,7 +206,7 @@ k 射击学习（等式 2）期间新权重![](img/211df3d3-5161-4ea1-9817-744ff
 
 概率模型直接适合于 MAP 权重 <sub>![](img/01b11f3a-0686-4edc-b119-3eccb26d356b.png)</sub> 。 对于共轭模型，后验分布是通过解析获得的。 否则，将使用 <sub>![](img/520f8b84-704b-4501-b74d-294304b03b84.png)</sub> 的 MAP 估算值。
 
-# 第三阶段– k 镜头学习
+# 第三阶段– k 次学习
 
 在 softmax 权重![](img/95e5adea-fdbb-436c-88f6-f09289f49929.png)，<sub>，![](img/61d62897-a8a3-40e0-921a-874ff6675301.png)，</sub>上的后缀是难以处理的。 通过使用 MAP 估计 <sub>![](img/753955cd-a77f-44a0-9416-1c544281ad1f.png)</sub> 或通过采样 <sub>![](img/8d7be54d-e3d8-433a-b254-f77d0ab6bc06.png)</sub> 可以近似得出。 必须注意， <sub>![](img/56b110e9-b61a-43f4-bb35-e01064a4f8bf.png)</sub> 是针对共轭模型的分析。 但是，如果在阶段 2 中根据 MAP 估计来估计 <sub>![](img/8b45bb65-bd49-4e47-aab4-7b7202c19589.png)</sub> ，则如等式 4 中所述使用 <sub>![](img/9cbd85bb-2d4e-4eea-9724-09693a33bce5.png)</sub> 。
 
@@ -214,7 +214,7 @@ k 射击学习（等式 2）期间新权重![](img/211df3d3-5161-4ea1-9817-744ff
 
 k 镜头测试时间 <sub>![](img/c3734ba9-5a51-47ff-84f2-54c038662868.png)</sub> 的推论是难以理解的，因此此处使用近似值。 如果从阶段 3 开始使用 <sub>![](img/8ad46a3a-039b-4f21-9049-c640cc90b96b.png)</sub> （ <sub>![](img/e631a1e5-efaa-41e0-b3af-d080d5df4b7a.png)</sub> ）的 MAP 估计值，则 <sub>![](img/52f71d1d-16a5-446e-9276-d0e2faedd10c.png)</sub> 。 如果在阶段 3 中重新采样，则使用 <sub>![](img/858ad399-04bb-4869-aa0e-88ba105b2300.png)</sub> 。
 
-在 miniImageNet 数据集（由 100 个类组成，每个类中包含 600 个图像）上，此方法可以一次学习一次和五次学习获得最先进的结果。 离统一概率模型和深度学习的领域又迈进了一步，将两者结合起来，可以开发出真正强大的模型，从而利用概率领域的强大数学保证和深度学习模型的强大健壮功能。 区分性 k 镜头学习方法仍然需要大量带标签的训练数据来训练基于深度学习的特征提取器。 另一方面，贝叶斯程序学习方法利用模型中的归纳偏差和手工设计的特征，因此需要较少的标注训练数据。
+在 miniImageNet 数据集（由 100 个类组成，每个类中包含 600 个图像）上，此方法可以一次学习一次和五次学习获得最先进的结果。 离统一概率模型和深度学习的领域又迈进了一步，将两者结合起来，可以开发出真正强大的模型，从而利用概率领域的强大数学保证和深度学习模型的强大健壮功能。 区分性 k 次学习方法仍然需要大量带标签的训练数据来训练基于深度学习的特征提取器。 另一方面，贝叶斯程序学习方法利用模型中的归纳偏差和手工设计的特征，因此需要较少的标注训练数据。
 
 # 概要
 

new/handson-1shot-learn-py/6.md

 # 结论和其他方法
 
-在这本书中，我们了解了用于深度学习的各种形式的体系结构，以及从手动特征提取到变型贝叶斯框架的各种技术和方法。 一次学习是一个特别活跃的研究领域，因为它专注于根据人类的神经能力更紧密地建立一种机器意识。 过去 5 年中，随着深度学习社区的进步，我们至少可以说，我们正在开发一种可以像人类一样同时学习多个任务的机器。 在这一章中，我们将看到一键式学习还有哪些其他选择，并讨论本书中未深入探讨的其他方法。
+在这本书中，我们了解了用于深度学习的各种形式的架构，以及从手动特征提取到变型贝叶斯框架的各种技术和方法。 一次学习是一个特别活跃的研究领域，因为它专注于根据人类的神经能力更紧密地建立一种机器意识。 过去 5 年中，随着深度学习社区的进步，我们至少可以说，我们正在开发一种可以像人类一样同时学习多个任务的机器。 在这一章中，我们将看到一键式学习还有哪些其他选择，并讨论本书中未深入探讨的其他方法。
 
 将涵盖以下主题：
 
@@ -12,7 +12,7 @@
 
 在深度学习社区中，已经提出了用于一次学习的各种其他方法，例如使用 GAN 的生成建模，图像变形元网络，基于代表的度量学习等。 到目前为止，我们已经看到了使用一次学习进行分类的模型，但是在对象检测和语义分割方面也取得了一些进步。 在本节中，我们将介绍一些主要的基于机器学习的会议的最新论文（例如 CVPR，NeurIPS，ICLR 等）。
 
-基于度量的学习是进行单次学习的较旧方法之一。 尽管该区域较旧，但仍在探索许多方面。 一个很好的例子是关于[《为短时学习重新研究基于局部描述符的图像到类度量》](https://arxiv.org/abs/1903.12290)主题的研究工作。 在本文中，作者提出了一种卷积神经网络体系结构，称为 **D4N** （**深最近邻神经网络**），该体系结构可提取图像级特征。 它与其他神经网络体系结构的主要区别是用基于局部描述符的图像到类度量替代了最后一层。
+基于度量的学习是进行单次学习的较旧方法之一。 尽管该区域较旧，但仍在探索许多方面。 一个很好的例子是关于[《为短时学习重新研究基于局部描述符的图像到类度量》](https://arxiv.org/abs/1903.12290)主题的研究工作。 在本文中，作者提出了一种卷积神经网络架构，称为 **D4N** （**深最近邻神经网络**），该架构可提取图像级特征。 它与其他神经网络架构的主要区别是用基于局部描述符的图像到类度量替代了最后一层。
 
 [《通过类别遍历查找与几次任务学习相关的任务相关特征》](https://arxiv.org/abs/1905.11116)也为改进度量学习方法做出了贡献，方法是引入 一个插件框架。 在本文中，作者讨论了众所周知的度量学习方法（例如连体网络和匹配网络）如何一次只关注一个任务，而不是整个学习所有任务。 **类别遍历模块**（**CTM**）插件组件通过完成所有支持任务来学习重要的尺寸特征。 CTM 在集中器和投影仪单元的帮助下，为相似类别提取通用特征嵌入，并在不同类别中提取唯一特征。 使用 CTM 的输出，我们可以在元学习器之前添加一个强大的功能，这可以使我们更快更好地进行优化。 通过使用此框架，他们显示了基于度量的学习方法的显着改进。
 
@@ -30,7 +30,7 @@
 
 同样， [《PANet：具有原型对齐功能的几次语义分割》](https://arxiv.org/abs/1908.06391)通过以下方式解决了少数镜头分割问题： 度量学习方法。 本文还提出了一种对齐网络，以更好地利用从支持集中提取的信息。 在 PANet 中，最初，网络从特定嵌入空间内的一些支持图像中学习特定于类别的表示，然后通过将每个像素与学习到的特定于类别的表示进行匹配，对查询/目标图像执行分割。 通过使用这种方法，PANet 可以利用支持集中的重要见解，并在几次分割的情况下提供更可靠的概括。
 
-如我们所见，这些解决方案适用于数据有限的情况。 我们如何量化有限的和足够的？ 我们需要查看我们希望训练的模型体系结构的能力以及希望解决的问题的复杂性。 类似于一次学习，多年来研究人员提出了其他一些方法，也旨在解决数据有限的问题。 在下一节中，我们将学习机器学习的这些领域，以及它们与单次学习相比的效率。
+如我们所见，这些解决方案适用于数据有限的情况。 我们如何量化有限的和足够的？ 我们需要查看我们希望训练的模型架构的能力以及希望解决的问题的复杂性。 类似于一次学习，多年来研究人员提出了其他一些方法，也旨在解决数据有限的问题。 在下一节中，我们将学习机器学习的这些领域，以及它们与单次学习相比的效率。
 
 # 相关领域
 
@@ -43,7 +43,7 @@
 
 # 半监督学习
 
-假设我们有 10,000 个数据点，其中只有 20,000 个被标记，而 80,000 个未被标记。 在这种情况下，我们将采用半监督学习。 在半监督学习中，我们使用未标记的数据来总体上进一步了解人口结构。 半监督学习通过伪标签技术来增加训练集。 也就是说，我们使用 20,000 个带标签的数据集训练模型，并在大小相等的测试数据点上使用该模型为它们创建伪标签。 下图说明了半监督学习体系结构：
+假设我们有 10,000 个数据点，其中只有 20,000 个被标记，而 80,000 个未被标记。 在这种情况下，我们将采用半监督学习。 在半监督学习中，我们使用未标记的数据来总体上进一步了解人口结构。 半监督学习通过伪标签技术来增加训练集。 也就是说，我们使用 20,000 个带标签的数据集训练模型，并在大小相等的测试数据点上使用该模型为它们创建伪标签。 下图说明了半监督学习架构：
 
 ![](img/59858a66-819e-4871-955e-a0c5ffb64345.png)
 
@@ -88,5 +88,5 @@
 *   [《通过类别遍历查找与几项学习相关的任务相关功能》](https://arxiv.org/pdf/1905.11116.pdf)
 *   [《RepMet：基于代表的度量学习，用于分类和几次检测》](https://arxiv.org/abs/1806.04728)
 *   [《具有共同注意和共同激励的一次对象检测》](https://arxiv.org/pdf/1911.12529.pdf)
-*   [《CANet：具有迭代细化和专心的几次镜头学习的类不可知分割网络》](https://arxiv.org/pdf/1903.02351.pdf)
+*   [《CANet：具有迭代细化和专心的几次次学习的类不可知分割网络》](https://arxiv.org/pdf/1903.02351.pdf)
 *   [《PANet：具有原型对齐功能的几次图像语义分割》](https://arxiv.org/pdf/1908.06391.pdf)
\ No newline at end of file

new/handson-nlp-pt-1x/2.md

@@ -114,7 +114,7 @@ GPU 最初是为了有效地渲染图形而创建的，但是由于深度学习
 
 图 2.8 –并行执行通行证的方法
 
-**计算统一设备体系结构**（**CUDA**）是 Nvidia GPU 特有的技术，可在 PyTorch 上实现硬件加速。 为了启用 CUDA，我们首先必须确保我们系统上的图形卡兼容 CUDA。 [可在此处找到 CUDA 兼容 GPU 的列表](https://developer.nvidia.com/cuda-gpus)。 如果您具有兼容 CUDA 的 GPU，[则可以从此链接安装 CUDA](https://developer.nvidia.com/cuda-downloads)。 我们将使用以下步骤激活它：
+**计算统一设备架构**（**CUDA**）是 Nvidia GPU 特有的技术，可在 PyTorch 上实现硬件加速。 为了启用 CUDA，我们首先必须确保我们系统上的图形卡兼容 CUDA。 [可在此处找到 CUDA 兼容 GPU 的列表](https://developer.nvidia.com/cuda-gpus)。 如果您具有兼容 CUDA 的 GPU，[则可以从此链接安装 CUDA](https://developer.nvidia.com/cuda-downloads)。 我们将使用以下步骤激活它：
 
 1.  首先，为了在 PyTorch 上实际启用 CUDA 支持，您将必须从源代码构建 PyTorch。 有关如何完成此操作的详细信息，请参见以下网址：https：//github.com/pytorch/pytorch#from-source。
 2.  Then, to actually CUDA within our PyTorch code, we must type the following into our Python code:

new/handson-nlp-pt-1x/5.md

@@ -789,6 +789,6 @@ curl -X GET https://sentiment-analysis-flask-api.herokuapp.com/predict -H“内
 
 # 摘要
 
-在本章中，我们讨论了 RNN 的基础及其主要变体之一 LSTM。 然后，我们演示了如何从头开始构建自己的 RNN 并将其部署在基于云的平台 Heroku 上。 尽管 RNN 通常用于 NLP 任务的深度学习，但它们绝不是唯一适合此任务的神经网络体系结构。
+在本章中，我们讨论了 RNN 的基础及其主要变体之一 LSTM。 然后，我们演示了如何从头开始构建自己的 RNN 并将其部署在基于云的平台 Heroku 上。 尽管 RNN 通常用于 NLP 任务的深度学习，但它们绝不是唯一适合此任务的神经网络架构。
 
 在下一章中，我们将研究卷积神经网络，并展示如何将其用于 NLP 学习任务。
\ No newline at end of file

new/handson-nlp-pt-1x/6.md

 # “第 6 章”：用于文本分类的卷积神经网络
 
-在上一章中，我们展示了如何使用 RNN 为文本提供情感分类。 但是，RNN 并不是唯一可用于 NLP 分类任务的神经网络体系结构。 **卷积神经网络**（**CNN**）是另一种这样的架构。
+在上一章中，我们展示了如何使用 RNN 为文本提供情感分类。 但是，RNN 并不是唯一可用于 NLP 分类任务的神经网络架构。 **卷积神经网络**（**CNN**）是另一种这样的架构。
 
 RNN 依赖顺序建模，保持隐藏状态，然后逐个单词顺序地遍历文本，并在每次迭代时更新状态。 CNN 不依赖于语言的顺序元素，而是尝试通过分别感知句子中的每个单词并了解其与句子中周围单词的关系来从文本中学习。
 

new/handson-nlp-pt-1x/8.md

@@ -1293,7 +1293,7 @@ corpus_name = "movie_corpus"
 
 图 8.21 –错误的输出
 
-很明显，我们已经创建了一个聊天机器人，能够进行简单的来回对话。 但是，我们的聊天机器人要通过图灵测试并说服我们我们实际上正在与人类交谈，我们还有很长的路要走。 但是，考虑到我们训练模型所涉及的数据量相对较小，在序列到序列模型中使用注意已显示出相当不错的结果，证明了这些体系结构的通用性。
+很明显，我们已经创建了一个聊天机器人，能够进行简单的来回对话。 但是，我们的聊天机器人要通过图灵测试并说服我们我们实际上正在与人类交谈，我们还有很长的路要走。 但是，考虑到我们训练模型所涉及的数据量相对较小，在序列到序列模型中使用注意已显示出相当不错的结果，证明了这些架构的通用性。
 
 虽然最好的聊天机器人是在数十亿个数据点的庞大数据集上进行训练的，但事实证明，相对较小的聊天机器人，该模型是相当有效的。 但是，基本注意力网络已不再是最新技术，在下一章中，我们将讨论 NL P 学习的一些最新发展，这些发展已使聊天机器人更加逼真。
 

new/handson-nlp-pt-1x/9.md

@@ -81,18 +81,18 @@ BERT 使用这两种方法（屏蔽语言建模和下一句预测）进行了训
 
 ## BERT –建筑
 
-模型体系结构建立在前几章中看到的许多原理的基础上，以使用双向编码提供复杂的语言表示。 BERT 有两种不同的变体，每种变体由不同数量的层和关注头组成：
+模型架构建立在前几章中看到的许多原理的基础上，以使用双向编码提供复杂的语言表示。 BERT 有两种不同的变体，每种变体由不同数量的层和关注头组成：
 
 *   **BERT Base**：12 个变压器块（层），12 个关注头，约 1.1 亿个参数
 *   **BERT 大型**：24 个变压器块（层），16 个关注头，约 3.4 亿个参数
 
-虽然 BERT Large 只是具有更多参数的 BERT Base 的更深版本，但我们将专注于 BERT Base 的体系结构。
+虽然 BERT Large 只是具有更多参数的 BERT Base 的更深版本，但我们将专注于 BERT Base 的架构。
 
 BERT 是按照**变压器**的原理构建的，现在将对其进行详细说明。
 
 ### 变形金刚
 
-模型体系结构建立在我们迄今为止在本书中看到的许多原理的基础上。 到目前为止，您应该熟悉编码器和解码器的概念，其中我们的模型学习编码器以形成输入句子的表示形式，然后学习解码器将该表示形式解码为最终输出，无论是分类还是分类。 翻译任务：
+模型架构建立在我们迄今为止在本书中看到的许多原理的基础上。 到目前为止，您应该熟悉编码器和解码器的概念，其中我们的模型学习编码器以形成输入句子的表示形式，然后学习解码器将该表示形式解码为最终输出，无论是分类还是分类。 翻译任务：
 
 ![Figure 9.2 – Transformer workflow ](img/B12365_09_2.jpg)
 
@@ -257,7 +257,7 @@ BERT 是按照**变压器**的原理构建的，现在将对其进行详细说
 
 ## GPT-2
 
-GPT-2 与 BERT 类似，但在一些细微的方面有所不同。 虽然这两种模型都基于先前概述的变压器体系结构，但是 BERT 使用一种称为自我注意力的注意力形式，而 GPT-2 使用屏蔽的自我注意力。 两者之间的另一个细微差别是 GPT-2 的构造方式使其可以一次输出一个令牌。
+GPT-2 与 BERT 类似，但在一些细微的方面有所不同。 虽然这两种模型都基于先前概述的变压器架构，但是 BERT 使用一种称为自我注意力的注意力形式，而 GPT-2 使用屏蔽的自我注意力。 两者之间的另一个细微差别是 GPT-2 的构造方式使其可以一次输出一个令牌。
 
 这是因为 GPT-2 实际上在其工作方式上是自回归的。 这意味着当它生成输出（句子中的第一个单词）时，该输出将递归添加到输入中。 然后，此输入用于预测句子中的下一个单词，并重复进行直到生成完整的句子为止。 您可以在以下示例中看到这一点：
 
@@ -542,7 +542,7 @@ Figure 9.20 – Bi-directional LSTM (SLING)
 
 假设我们首先有此模型的简化版本。 假设我们已经知道该问题的答案已出现在文档中。因此，鉴于有关水的 Wikipedia 页面，我们能否训练一个模型来回答问题*“水的沸点是多少？”。* 首先做一个简单的方法，而不是合并完整语言模型的元素，而是简单地返回包含我们问题答案的 Wikipedia 页面的段落。
 
-我们可以训练以完成此任务的体系结构可能看起来像这样：
+我们可以训练以完成此任务的架构可能看起来像这样：
 
 ![Figure 9.24 – Architecture of the model ](img/B12365_09_24.jpg)
 
@@ -580,7 +580,7 @@ Figure 9.20 – Bi-directional LSTM (SLING)
 
 图 9.27 –对偶模型表示
 
-实际上，近来在 NLU 中的进步意味着这种模型现已成为现实。 通过组合许多元素，我们能够创建一个神经网络结构，该结构能够执行对偶模型的功能，如先前的所示。 这就是**双问-答网络**。 实际上，我们的模型包含到目前为止我们在本书中看到的神经网络的大多数组件，即，嵌入层，卷积层，编码器，解码器和注意层。 问答网络的完整体系结构类似于以下内容：
+实际上，近来在 NLU 中的进步意味着这种模型现已成为现实。 通过组合许多元素，我们能够创建一个神经网络结构，该结构能够执行对偶模型的功能，如先前的所示。 这就是**双问-答网络**。 实际上，我们的模型包含到目前为止我们在本书中看到的神经网络的大多数组件，即，嵌入层，卷积层，编码器，解码器和注意层。 问答网络的完整架构类似于以下内容：
 
 ![Figure 9.28 – Architecture of ask-answer network ](img/B12365_09_28.jpg)
 

new/pt-ai-fund/0.md

@@ -24,7 +24,7 @@
 
 第 6 章和*探索生成对抗网络*探索生成对抗网络，以及如何实现 PyTorch 的组件并训练端到端网络。 我们将探索 DCGAN，并通过渐进式 GAN 网络进一步改善 DCGAN 的局限性。
 
-第 7 章，*深度强化学习*可帮助您通过各种食谱来了解深度 RL。 本章是一系列食谱和任务，您将在其中利用所需的能力和体系结构来转变为深度强化学习专家。
+第 7 章，*深度强化学习*可帮助您通过各种食谱来了解深度 RL。 本章是一系列食谱和任务，您将在其中利用所需的能力和架构来转变为深度强化学习专家。
 
 第 8 章和*在 PyTorch* 中生产 AI 模型，着眼于以两种方式生产 PyTorch 应用程序。 首先，生成已经训练过的模型，其次，对大型数据集进行分布式训练。 最后，我们将研究各种框架之间的可移植性。
 

new/pt-ai-fund/1.md

@@ -564,7 +564,7 @@ PyTorch 有一个名为`autograd`的软件包，可以对张量上的所有操
 
 # 在 PyTorch 中查看张量
 
-在使用张量和处理神经网络时，我们经常需要遍历和重新排列张量中的数据，以使张量的尺寸适合体系结构的需求。 在本节中，我们将探讨 PyTorch 中常见的重排和重塑技术。
+在使用张量和处理神经网络时，我们经常需要遍历和重新排列张量中的数据，以使张量的尺寸适合架构的需求。 在本节中，我们将探讨 PyTorch 中常见的重排和重塑技术。
 
 在本食谱中，我们将学习如何使张量看起来像我们想要的样子。
 
@@ -638,7 +638,7 @@ tensor([[1., 2., 3.],
 
 # 这个怎么运作...
 
-在前面的食谱中，我们基于网络体系结构操纵了张量以改变其形状，研究了三种不同的方法，每种方法都适用于不同的用例：
+在前面的食谱中，我们基于网络架构操纵了张量以改变其形状，研究了三种不同的方法，每种方法都适用于不同的用例：
 
 *   `.reshape()` **方法**：`.reshape(a, b)`返回一个新张量，该张量具有与原始张量`(a, b)`相同的数据，因为它会将数据复制到内存的另一部分； `.reshape()`可以在连续和非连续张量上运行，并且可以返回原始张量的副本或视图。
 *   `.resize()` **方法**：`.resize_(a, b)`返回相同的张量，而不创建具有新给定形状的副本。 但是我们应该记住，如果新形状产生的元素少于原始张量，那么它将不会引发任何错误，并且某些元素将从张量中删除，但不会从内存中删除。 如果新形状产生的元素多于原始张量，则新元素将在内存中未初始化而不会引发任何错误。

new/pt-ai-fund/2.md

@@ -6,7 +6,7 @@
 
 ![](img/d6e62091-b4e4-489a-b2e8-926df04945ed.png)
 
-神经网络所看到的只是数字集，它试图识别数据中的模式。 通过训练，神经网络学会识别输入中的模式。 但是，某些特定的体系结构在应用于特定类别的问题时比其他结构具有更好的性能。 一个简单的神经网络体系结构由三种层组成：**输入**层，**输出**层和**隐藏**层。 当隐藏层不止一个时，它称为**深度** **神经网络**。
+神经网络所看到的只是数字集，它试图识别数据中的模式。 通过训练，神经网络学会识别输入中的模式。 但是，某些特定的架构在应用于特定类别的问题时比其他结构具有更好的性能。 一个简单的神经网络架构由三种层组成：**输入**层，**输出**层和**隐藏**层。 当隐藏层不止一个时，它称为**深度** **神经网络**。
 
 以下是深度神经网络的表示：
 
@@ -140,7 +140,7 @@ pip install torchvision
 
 TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机器上没有它，它将为您下载，传递转换并将数据转换为所需的格式以供模型训练。 在我们的案例中，数据集带有训练和测试集，并相应地加载它们。 我们使用`torch.utils.data.DataLoader`将处理后的数据分批加载，并进行其他操作，例如改组和加载到正确的设备（CPU 或 GPU）。
 
-我们可以用任何名称定义模型类，但是重要的是它是`nn.Module`的子类并具有`super().__init__()`，该类为模型提供了许多有用的方法和属性，并保留了体系结构的知识。
+我们可以用任何名称定义模型类，但是重要的是它是`nn.Module`的子类并具有`super().__init__()`，该类为模型提供了许多有用的方法和属性，并保留了架构的知识。
 
 我们使用`nn.Linear()`通过输入和输出尺寸来定义全连接层。 我们将 softmax 层用于最后一层输出，因为有 10 个输出类。 我们在输出层之前的层中使用 ReLU 激活来学习数据中的非线性。 `hidden1`层采用 784 个输入单元，并给出 256 个输出单元。 `hidden2`短语输出 128 个单位，输出层有 10 个输出单位，代表 10 个输出类别。 softmax 层将激活转换为概率，以便沿维度 1 加 1。
 
@@ -156,7 +156,7 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机
 
 在本食谱中，我们将扩展在先前食谱中定义的类*定义神经网络类*。 在*定义神经网络类*配方中，我们仅创建了所需架构的组件； 现在我们将把所有这些部分捆绑在一起，以建立一个明智的网络。 我们各层的进度将从 784 个单位增加到 256 个，然后是 128 个，最后是 10 个单位的输出层。
 
-在本食谱中，我们将使用类的构造函数中定义的组件来研究网络体系结构。 然后，我们将完成网络类定义并创建其对象。
+在本食谱中，我们将使用类的构造函数中定义的组件来研究网络架构。 然后，我们将完成网络类定义并创建其对象。
 
 # 怎么做...
 
@@ -236,7 +236,7 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机
 
 # 还有更多...
 
-我们可以在不使用`nn.Sequential`模块定义网络类的情况下定义网络体系结构，并且尽管`__init__`中的序列无关紧要，但重要的是要确保`forward`方法中的操作顺序正确排序。 。 您可以使用`nn.Tanh`进行 tanh 激活。 您可以使用`model.hidden.weight`和`model.hidden.bias`从模型对象访问权重和偏差张量。
+我们可以在不使用`nn.Sequential`模块定义网络类的情况下定义网络架构，并且尽管`__init__`中的序列无关紧要，但重要的是要确保`forward`方法中的操作顺序正确排序。 。 您可以使用`nn.Tanh`进行 tanh 激活。 您可以使用`model.hidden.weight`和`model.hidden.bias`从模型对象访问权重和偏差张量。
 
 # 也可以看看
 

new/pt-ai-fund/4.md

@@ -53,7 +53,7 @@
 
 图 5：多层 LSTM
 
-双向 LSTM 和多层 LSTM 是对基本 LSTM 网络体系结构的改进。
+双向 LSTM 和多层 LSTM 是对基本 LSTM 网络架构的改进。
 
 # 技术要求
 
@@ -539,7 +539,7 @@ class MultiLSTMClassifier(nn.Module):
 
 # 还有更多...
 
-在本配方中，我们仅考虑了最后一个 LSTM 层的隐藏状态。 但是，可能存在使用所有隐藏层的复杂体系结构。 有一个 dropout 参数，可用于在多层 LSTM 的各层之间施加 dropout。
+在本配方中，我们仅考虑了最后一个 LSTM 层的隐藏状态。 但是，可能存在使用所有隐藏层的复杂架构。 有一个 dropout 参数，可用于在多层 LSTM 的各层之间施加 dropout。
 
 # 也可以看看
 
@@ -609,7 +609,7 @@ class BiLSTMClassifier(nn.Module):
 
 # 还有更多...
 
-我们选择了最后的前向和后向隐藏状态并将它们连接起来，这就是我们选择的体系结构。 但是，根据手头的任务，我们可以选择任何或所有隐藏状态。
+我们选择了最后的前向和后向隐藏状态并将它们连接起来，这就是我们选择的架构。 但是，根据手头的任务，我们可以选择任何或所有隐藏状态。
 
 # 也可以看看
 

new/pt-ai-fund/6.md

@@ -114,7 +114,7 @@ def forward(self, input):
 
 # 这个怎么运作...
 
-在此食谱中，我们进行了变换以将图像转换为张量并对其进行归一化，就像在第 3 章和*用于计算机视觉的卷积神经网络*中所做的一样。 然后，我们确定了机器上的设备：CPU 或 GPU。 然后，我们定义了从`nn.Module`类继承的`Generator_model`类，就像在所有以前的体系结构中所做的一样。
+在此食谱中，我们进行了变换以将图像转换为张量并对其进行归一化，就像在第 3 章和*用于计算机视觉的卷积神经网络*中所做的一样。 然后，我们确定了机器上的设备：CPU 或 GPU。 然后，我们定义了从`nn.Module`类继承的`Generator_model`类，就像在所有以前的架构中所做的一样。
 
 在构造函数中，我们传递了`z_dim`参数，这是我们的噪声矢量大小。 然后，我们定义了一个全连接单元`self.fc`，我们将噪声矢量传递给该单元，并为其提供了`256 * 7 * 7`输出。 然后，我们定义了一个称为`self.gen`的`nn.Sequential`单元，其中包含用于定义生成器的关键组件。 我们使用 PyTorch 中提供的`nn.ConvTranspose2d`，`nn.BatchNorm2d`和`nn.LeakyReLU`使用一组反卷积，批处理规范化和激活层。 `ConvTranspose2d`接受输入通道，输出通道，内核大小，步幅和填充等参数。 `BatchNorm2d`接受上一层的要素/通道数作为其参数，而 LeakyReLU 接受负斜率的角度。
 

new/pt-dl-handson/1.md

@@ -90,7 +90,7 @@ ONNX 内置在 PyTorch 的核心中，因此将模型迁移到 ONNX 表单不需
 
 ### 使用静态图
 
-处理神经网络体系结构的传统方法是使用静态图。 在对给出的数据进行任何处理之前，该程序将构建图形的正向和反向传递。 不同的开发小组尝试了不​​同的方法。 有些人先构建前向传递，然后将相同的图实例用于前向传递和后向传递。 另一种方法是先构建前向静态图，然后创建后向图并将其附加到前向图的末尾，以便可以将整个前向-后向传递作为单个图执行来执行。 按时间顺序排列节点。
+处理神经网络架构的传统方法是使用静态图。 在对给出的数据进行任何处理之前，该程序将构建图形的正向和反向传递。 不同的开发小组尝试了不​​同的方法。 有些人先构建前向传递，然后将相同的图实例用于前向传递和后向传递。 另一种方法是先构建前向静态图，然后创建后向图并将其附加到前向图的末尾，以便可以将整个前向-后向传递作为单个图执行来执行。 按时间顺序排列节点。
 
 ![Using static graphs](img/B09475_01_03.jpg)
 
@@ -165,7 +165,7 @@ with tf.Session() as sess:
 
 ### 使用动态图
 
-势在必行的编程风格始终拥有较大的用户群，因为程序流程对于任何开发人员都是直观的。 动态能力是命令式图形构建的良好副作用。 与静态图不同，动态图体系结构不会在数据传递之前构建图。 程序将等待数据到达并在遍历数据时构建图形。 结果，每次数据迭代都会构建一个新的图实例，并在完成向后传递后销毁它。 由于图形是为每次迭代构建的，因此它不依赖于数据大小，长度或结构。 自然语言处理是需要这种方法的领域之一。
+势在必行的编程风格始终拥有较大的用户群，因为程序流程对于任何开发人员都是直观的。 动态能力是命令式图形构建的良好副作用。 与静态图不同，动态图架构不会在数据传递之前构建图。 程序将等待数据到达并在遍历数据时构建图形。 结果，每次数据迭代都会构建一个新的图实例，并在完成向后传递后销毁它。 由于图形是为每次迭代构建的，因此它不依赖于数据大小，长度或结构。 自然语言处理是需要这种方法的领域之一。
 
 例如，如果您试图对成千上万的句子进行情感分析，则需要使用静态图形来破解并采取变通办法。 在普通的**循环神经网络**（**RNN**）模型中，每个单词都经过一个 RNN 单元，该单元生成输出和隐藏状态。 该隐藏状态将提供给下一个 RNN，后者处理句子中的下一个单词。 由于您在构建静态图形时做了一个固定长度的插槽，因此您需要增加短句并减少长句。
 
@@ -234,17 +234,17 @@ for epoch in range(epochs):
 
 图 1.10：深度神经网络
 
-### 了解不同的体系结构
+### 了解不同的架构
 
-深度学习已经存在了数十年，针对不同的用例演变出了不同的结构和体系结构。 其中一些基于我们对大脑的想法，而另一些则基于大脑的实际工作。 即将到来的所有章节均基于业界正在使用的的最新体系结构。 我们将介绍每种体系结构下的一个或多个应用程序，每一章都涵盖所有概念，规范和技术细节，其中显然都包含 PyTorch 代码。
+深度学习已经存在了数十年，针对不同的用例演变出了不同的结构和架构。 其中一些基于我们对大脑的想法，而另一些则基于大脑的实际工作。 即将到来的所有章节均基于业界正在使用的的最新架构。 我们将介绍每种架构下的一个或多个应用程序，每一章都涵盖所有概念，规范和技术细节，其中显然都包含 PyTorch 代码。
 
 #### 全连接网络
 
-全连接或密集或线性网络是最基本但功能最强大的体系结构。 这是通常所谓的机器学习的直接扩展，在该机器学习中，您使用具有单个隐藏层的神经网络。 全连接层充当所有体系结构的端点，以使用下面的深度网络来找到分数的概率分布。 顾名思义，一个全连接网络将所有神经元在上一层和下一层相互连接。 网络可能最终决定通过设置权重来关闭某些神经元，但是在理想情况下，最初，所有神经元都参与了通信。
+全连接或密集或线性网络是最基本但功能最强大的架构。 这是通常所谓的机器学习的直接扩展，在该机器学习中，您使用具有单个隐藏层的神经网络。 全连接层充当所有架构的端点，以使用下面的深度网络来找到分数的概率分布。 顾名思义，一个全连接网络将所有神经元在上一层和下一层相互连接。 网络可能最终决定通过设置权重来关闭某些神经元，但是在理想情况下，最初，所有神经元都参与了通信。
 
 #### 编码器和解码器
 
-编码器和解码器可能是深度学习框架下的下一个最基本的体系结构。 所有网络都有一个或多个编码器-解码器层。 您可以将全连接层中的隐藏层视为来自编码器的编码形式，而将输出层视为将隐藏层解码为输出的解码器。 通常，编码器将输入编码为中间状态，其中输入表示为向量，然后解码器网络将其解码为我们想要的输出形式。
+编码器和解码器可能是深度学习框架下的下一个最基本的架构。 所有网络都有一个或多个编码器-解码器层。 您可以将全连接层中的隐藏层视为来自编码器的编码形式，而将输出层视为将隐藏层解码为输出的解码器。 通常，编码器将输入编码为中间状态，其中输入表示为向量，然后解码器网络将其解码为我们想要的输出形式。
 
 编码器-解码器网络的一个典型示例是**序列到序列**（**seq2seq**）网络，可以将其用作机器翻译。 用英语说的句子将被编码为中间向量表示，其中整个句子将以一些浮点数的形式进行分块，并且解码器从中间向量以另一种语言解码输出句子。
 
@@ -256,7 +256,7 @@ for epoch in range(epochs):
 
 如果您能够训练一个可以做到这一点的神经网络，那么 voilà，您将找到一个很好的压缩算法，可以将高维输入以一个数量级的幅度传输到低维向量 获得。
 
-如今，自动编码器被用于不同的情况和行业。 当我们讨论语义分割时，您将在第 4 章，*计算机视觉*中看到类似的体系结构。
+如今，自动编码器被用于不同的情况和行业。 当我们讨论语义分割时，您将在第 4 章，*计算机视觉*中看到类似的架构。
 
 ![Encoders and decoders](img/B09475_01_12.jpg)
 
@@ -308,7 +308,7 @@ Figure 1.16: GAN setup
 
 现代强化学习使用深度网络进行学习，这与我们以前明确编码那些规则的旧方法不同。 我们将研究 Q 学习和深度 Q 学习，向您展示有无深度学习的强化学习之间的区别。
 
-强化学习被认为是通向一般智能的途径之一，在这种途径中，计算机或代理通过与现实世界，对象或实验的交互或从反馈中学习。 教一个强化学习代理人相当于通过负面和正面奖励来训练狗。 当您给一块饼干拿起球时，或者当您对狗不捡球而大喊时，您会通过消极和积极的奖励来增强对狗大脑的了解。 我们对 AI 代理执行相同的操作，但是正数奖励将为正数，负数奖励将为负数。 即使我们不能将强化学习视为类似于 CNN / RNN 等的另一种体系结构，但我还是在这里将其作为使用深度神经网络解决实际问题的另一种方法：
+强化学习被认为是通向一般智能的途径之一，在这种途径中，计算机或代理通过与现实世界，对象或实验的交互或从反馈中学习。 教一个强化学习代理人相当于通过负面和正面奖励来训练狗。 当您给一块饼干拿起球时，或者当您对狗不捡球而大喊时，您会通过消极和积极的奖励来增强对狗大脑的了解。 我们对 AI 代理执行相同的操作，但是正数奖励将为正数，负数奖励将为负数。 即使我们不能将强化学习视为类似于 CNN / RNN 等的另一种架构，但我还是在这里将其作为使用深度神经网络解决实际问题的另一种方法：
 
 ![Reinforcement learning](img/B09475_01_17.jpg)
 
@@ -587,7 +587,7 @@ array([[20.,  1.],[ 1.,  1.]], dtype=float32)
 
 ### 摘要
 
-在本章中，我们了解了 PyTorch 的历史以及动态图库相对于静态图库的优缺点。 我们还浏览了人们为解决各个领域的复杂问题而提出的不同体系结构和模型。 我们介绍了 PyTorch 中最重要的内容：Torch 张量的内部。 张量的概念是深度学习的基础，并且对于您使用的所有深度学习框架都是通用的。
+在本章中，我们了解了 PyTorch 的历史以及动态图库相对于静态图库的优缺点。 我们还浏览了人们为解决各个领域的复杂问题而提出的不同架构和模型。 我们介绍了 PyTorch 中最重要的内容：Torch 张量的内部。 张量的概念是深度学习的基础，并且对于您使用的所有深度学习框架都是通用的。
 
 在下一章中，我们将采用更多的动手方法，并将在 PyTorch 中实现一个简单的神经网络。
 

new/pt-dl-handson/2.md

@@ -20,7 +20,7 @@
 
 ## 数据集
 
-建立数据管道与网络的体系结构一样重要，尤其是在实时训练网络时。 从野外获得的数据永远不会干净，在将其扔到网络之前，您必须对其进行处理。 例如，如果我们要收集数据以预测某人是否购买产品，那么最终将出现异常值。 离群值可以是任何种类且不可预测的。 例如，某人可能不小心下了订单，或者他们可以访问后来下订单的朋友，依此类推。
+建立数据管道与网络的架构一样重要，尤其是在实时训练网络时。 从野外获得的数据永远不会干净，在将其扔到网络之前，您必须对其进行处理。 例如，如果我们要收集数据以预测某人是否购买产品，那么最终将出现异常值。 离群值可以是任何种类且不可预测的。 例如，某人可能不小心下了订单，或者他们可以访问后来下订单的朋友，依此类推。
 
 从理论上讲，深度神经网络非常适合从数据集中查找模式和解，因为它们应该模仿人的大脑。 但是，实际上，情况并非总是如此。 如果您的数据干净且格式正确，您的网络将能够通过找到模式来轻松解决问题。 PyTorch 开箱即用地提供了数据预处理包装器，我们将在第 3 章和*深度学习工作流程*中进行讨论。 除此之外，我们将讨论如何格式化或清除数据集。
 

new/pt-dl-handson/3.md

@@ -30,7 +30,7 @@ PyTorch 最初是由 Facebook 实习生作为研究框架开始的，现已发
 
 不同类型的深度学习问题需要不同类型的数据集，并且每种类型的可能需要不同类型的预处理，具体取决于我们使用的神经网络架构。 这是深度学习管道构建中的核心问题之一。
 
-尽管社区已经免费提供了用于不同任务的数据集，但是编写预处理脚本几乎总是很痛苦。 PyTorch 通过提供抽象类来编写自定义数据集和数据加载器来解决此问题。 这里给出的示例是一个简单的`dataset`类，用于加载我们在第 2 章，*一个简单神经网络*中使用的`fizzbuzz`数据集，但是将其扩展为可以处理任何类型的数据集 非常简单。 PyTorch 的官方文档使用类似的方法对图像数据集进行预处理，然后再将其传递给复杂的**卷积神经网络**（**CNN**）体系结构。
+尽管社区已经免费提供了用于不同任务的数据集，但是编写预处理脚本几乎总是很痛苦。 PyTorch 通过提供抽象类来编写自定义数据集和数据加载器来解决此问题。 这里给出的示例是一个简单的`dataset`类，用于加载我们在第 2 章，*一个简单神经网络*中使用的`fizzbuzz`数据集，但是将其扩展为可以处理任何类型的数据集 非常简单。 PyTorch 的官方文档使用类似的方法对图像数据集进行预处理，然后再将其传递给复杂的**卷积神经网络**（**CNN**）架构。
 
 PyTorch 中的`dataset`类是高级抽象，可处理数据加载程序几乎需要的所有内容。 用户定义的自定义`dataset`类需要覆盖父类的`__len__`函数和`__getitem__`函数，其中数据加载程序正在使用`__len__`来确定数据集的长度，而`__getitem__` 数据加载器正在使用该物品来获取物品。 `__getitem__`函数希望用户将索引作为参数传递，并获取驻留在该索引上的项目：
 
@@ -175,7 +175,7 @@ Dataset MNIST
 
 ```
 
-`torchvision`的`models`模块包装有几种常用的型号，可以直接使用。 由于当今大多数高级模型都使用转移学习来获得其他体系结构学习的权重（例如，第三章中的语义分段模型使用经过训练的 resnet18 网络），因此这是最常用的模型之一`torchvision`功能。 以下代码段显示了如何从`torchvision.models`下载 resnet18 模型。 标志`pretrained`告诉`torchvision`仅使用模型或获取从 PyTorch 服务器下载的预训练模型。
+`torchvision`的`models`模块包装有几种常用的型号，可以直接使用。 由于当今大多数高级模型都使用转移学习来获得其他架构学习的权重（例如，第三章中的语义分段模型使用经过训练的 resnet18 网络），因此这是最常用的模型之一`torchvision`功能。 以下代码段显示了如何从`torchvision.models`下载 resnet18 模型。 标志`pretrained`告诉`torchvision`仅使用模型或获取从 PyTorch 服务器下载的预训练模型。
 
 ```py
 >>> resnet18 = torchvision.models.resnet18(pretrained=False)
@@ -401,7 +401,7 @@ transform = transforms.Compose(
 
 ## 模型实现
 
-毕竟，实现模型是我们开发流程中最重要的一步。 在某种程度上，我们为此步骤构建了整个管道。 除了构建网络体系结构之外，我们还需要考虑许多细节来优化实现（在工作量，时间以及代码效率方面）。
+毕竟，实现模型是我们开发流程中最重要的一步。 在某种程度上，我们为此步骤构建了整个管道。 除了构建网络架构之外，我们还需要考虑许多细节来优化实现（在工作量，时间以及代码效率方面）。
 
 在本次会议中，我们将讨论 PyTorch 软件包本身和`ignite`（PyTorch 的推荐训练者实用程序）中提供的性能分析和瓶颈工具。 第一部分介绍了瓶颈和性能分析实用程序，当模型开始表现不佳并且您需要知道哪里出了问题时，这是必不可少的。 本课程的第二部分介绍了训练师模块`ignite`。
 

new/pt-dl-handson/4.md

@@ -2,15 +2,15 @@
 
 计算机视觉是使计算机具有视觉效果的工程流。 它支持各种图像处理，例如 iPhone，Google Lens 等中的人脸识别。 计算机视觉已经存在了几十年，可能最好在人工智能的帮助下进行探索，这将在本章中进行演示。
 
-几年前，我们在 ImageNet 挑战中达到了计算机视觉的人类准确性。 在过去的十年中，计算机视觉发生了巨大的变化，从以学术为导向的对象检测问题到在实际道路上自动驾驶汽车使用的分割问题。 尽管人们提出了许多不同的网络体系结构来解决计算机视觉问题，但是**卷积神经网络**（**CNN**）击败了所有这些。
+几年前，我们在 ImageNet 挑战中达到了计算机视觉的人类准确性。 在过去的十年中，计算机视觉发生了巨大的变化，从以学术为导向的对象检测问题到在实际道路上自动驾驶汽车使用的分割问题。 尽管人们提出了许多不同的网络架构来解决计算机视觉问题，但是**卷积神经网络**（**CNN**）击败了所有这些。
 
 在本章中，我们将讨论基于 PyTorch 构建的基本 CNN，以及它们的变体，它们已经成功地应用于一些为大公司提供支持的最新模型中。
 
 ## CNN 简介
 
-CNN 是具有数十年历史的机器学习算法，直到 Geoffrey Hinton 和他的实验室提出 AlexNet 时，才证明其功能强大。 从那时起，CNN 经历了多次迭代。 现在，我们在 CNN 之上构建了一些不同的体系结构，这些体系结构为世界各地的所有计算机视觉实现提供了动力。
+CNN 是具有数十年历史的机器学习算法，直到 Geoffrey Hinton 和他的实验室提出 AlexNet 时，才证明其功能强大。 从那时起，CNN 经历了多次迭代。 现在，我们在 CNN 之上构建了一些不同的架构，这些架构为世界各地的所有计算机视觉实现提供了动力。
 
-CNN 是一种基本上由小型网络组成的网络体系结构，几乎类似于第 2 章，*简单神经网络*中引入的简单前馈网络，但用于解决图像作为输入的问题。 CNN 由神经元组成，这些神经元具有非线性，权重参数，偏差并吐出一个损耗值，基于该值，可以使用反向传播对整个网络进行重新排列。
+CNN 是一种基本上由小型网络组成的网络架构，几乎类似于第 2 章，*简单神经网络*中引入的简单前馈网络，但用于解决图像作为输入的问题。 CNN 由神经元组成，这些神经元具有非线性，权重参数，偏差并吐出一个损耗值，基于该值，可以使用反向传播对整个网络进行重新排列。
 
 如果这听起来像简单的全连接网络，那么 CNN 为何特别适合处理图像？ CNN 让开发人员做出适用于图像的某些假设，例如像素值的空间关系。
 
@@ -95,7 +95,7 @@ def normalize(image, mean, std):
 
 ##### 型号
 
-`SimpleCNNModel`是从 PyTorch 的`nn.Module`继承的模型类。 这是使用其他自定义类和 PyTorch 类来设置体系结构的父类。
+`SimpleCNNModel`是从 PyTorch 的`nn.Module`继承的模型类。 这是使用其他自定义类和 PyTorch 类来设置架构的父类。
 
 ```py
 class SimpleCNNModel(nn.Module):
@@ -261,7 +261,7 @@ trainloader, testloader = get_data()
 
 ##### 注意
 
-动量是当今与优化算法一起使用的一种非常流行的技术。 我们将电流梯度的因数添加到电流梯度本身以获得更大的值，然后将其从权重中减去。 动量在与现实世界动量类似的极小方向上加速损失的运动。
+动量是当今与优化算法一起使用的一种非常流行的技术。 我们将当前梯度的因数添加到当前梯度本身以获得更大的值，然后将其从权重中减去。 动量在与现实世界动量类似的极小方向上加速损失的运动。
 
 ![Model](img/B09475_04_06.jpg)
 
@@ -308,7 +308,7 @@ running_loss += loss.item()
 
 #### LinkNet
 
-LinkNet 利用自动编码器的思想，该思想曾经是一种数据压缩技术。 自动编码器的体系结构有两个部分：编码器和解码器。 编码器将输入编码到低维空间，而解码器从低维空间解码/重新创建输入。 自动编码器被广泛用于减小压缩的尺寸等。
+LinkNet 利用自动编码器的思想，该思想曾经是一种数据压缩技术。 自动编码器的架构有两个部分：编码器和解码器。 编码器将输入编码到低维空间，而解码器从低维空间解码/重新创建输入。 自动编码器被广泛用于减小压缩的尺寸等。
 
 ![LinkNet](img/B09475_04_10.jpg)
 
@@ -316,9 +316,9 @@ LinkNet 利用自动编码器的思想，该思想曾经是一种数据压缩技
 
 LinkNet 由一个初始块，一个最终块，一个带有四个卷积模块的编码器块以及一个带有四个解卷积模块的解码器组成。 初始块使用跨步卷积和最大池化层对输入图像进行两次下采样。 然后，编码器模块中的每个卷积模块都会以大步卷积对输入进行一次下采样。 然后将编码后的输出传递到解码器块，该解码器块会在每个反卷积块中使用步进反卷积对输入进行上采样； 反卷积将在以下部分中说明。
 
-然后，解码器模块的输出通过最终模块，该模块将上采样两次，就像初始模块下采样两次一样。 还有更多：与其他语义分割模型相比，LinkNet 通过使用跳过连接的思想可以减少体系结构中的参数数量。
+然后，解码器模块的输出通过最终模块，该模块将上采样两次，就像初始模块下采样两次一样。 还有更多：与其他语义分割模型相比，LinkNet 通过使用跳过连接的思想可以减少架构中的参数数量。
 
-在每个卷积块之后，编码器块与解码器块进行通信，这使编码器块在前向通过之后会忘记某些信息。 由于编码器模块的输出不必保留该信息，因此参数的数量可能比其他现有体系结构的数量少得多。 实际上，该论文的作者使用 ResNet18 作为编码器，并且仍然能够以惊人的性能获得最新的结果。 下面是 LinkNet 的体系结构：
+在每个卷积块之后，编码器块与解码器块进行通信，这使编码器块在前向通过之后会忘记某些信息。 由于编码器模块的输出不必保留该信息，因此参数的数量可能比其他现有架构的数量少得多。 实际上，该论文的作者使用 ResNet18 作为编码器，并且仍然能够以惊人的性能获得最新的结果。 下面是 LinkNet 的架构：
 
 ![LinkNet](img/B09475_04_11.jpg)
 
@@ -344,11 +344,11 @@ LinkNet 由一个初始块，一个最终块，一个带有四个卷积模块的
 
 ##### 跳过连接
 
-LinkNet 体系结构中编码器和解码器之间的平行水平线是跳过连接表示。 跳过连接有助于网络在编码过程中忘记某些信息，并在解码时再次查看。 由于网络解码和生成图像所需的信息量相对较低，因此这减少了网络所需的参数数量。 可以通过不同的操作来实现跳过连接。 使用跳过连接的另一个优点是，梯度梯度流可以容易地流过相同的连接。 LinkNet 将隐藏的编码器输出添加到相应的解码器输入，而另一种语义分割算法 Tiramisu [4]将两者连接在一起，将其发送到下一层。
+LinkNet 架构中编码器和解码器之间的平行水平线是跳过连接表示。 跳过连接有助于网络在编码过程中忘记某些信息，并在解码时再次查看。 由于网络解码和生成图像所需的信息量相对较低，因此这减少了网络所需的参数数量。 可以通过不同的操作来实现跳过连接。 使用跳过连接的另一个优点是，梯度梯度流可以容易地流过相同的连接。 LinkNet 将隐藏的编码器输出添加到相应的解码器输入，而另一种语义分割算法 Tiramisu [4]将两者连接在一起，将其发送到下一层。
 
 #### 型号
 
-语义分割模型的编码器是我们在第一个会话中构建的 SimpleCNN 模型的扩展，但具有更多的卷积模块。 我们的主类使用五个次要组件/模块来构建前面描述的体系结构：
+语义分割模型的编码器是我们在第一个会话中构建的 SimpleCNN 模型的扩展，但具有更多的卷积模块。 我们的主类使用五个次要组件/模块来构建前面描述的架构：
 
 *   `ConvBlock`是自定义的`nn.Module`类，可实现卷积和非线性。
 *   `DeconvBlock`是一个自定义`nn.Module`类，可实现解卷积和非线性。
@@ -440,7 +440,7 @@ class DeconvBlock(nn.Module):
 
 ##### 合并
 
-PyTorch 有几个用于池化操作的选项，我们从其中选择使用`MaxPool`。 正如我们在`SimpleCNN`示例中看到的那样，这是一个显而易见的操作，我们可以通过仅从池中提取突出的特征来减少输入的维数。 `MaxPool2d`接受类似于`Conv2d`的参数来确定内核大小，填充和步幅。 但是除了这些参数之外，`MaxPool2d`接受两个额外的参数，即返回索引和`ciel`。 返回索引返回最大值的索引，可在某些网络体系结构中进行池化时使用。 `ciel`是布尔参数，它通过确定尺寸的上限或下限来确定输出形状。
+PyTorch 有几个用于池化操作的选项，我们从其中选择使用`MaxPool`。 正如我们在`SimpleCNN`示例中看到的那样，这是一个显而易见的操作，我们可以通过仅从池中提取突出的特征来减少输入的维数。 `MaxPool2d`接受类似于`Conv2d`的参数来确定内核大小，填充和步幅。 但是除了这些参数之外，`MaxPool2d`接受两个额外的参数，即返回索引和`ciel`。 返回索引返回最大值的索引，可在某些网络架构中进行池化时使用。 `ciel`是布尔参数，它通过确定尺寸的上限或下限来确定输出形状。
 
 ##### 编码器块
 
@@ -450,9 +450,9 @@ PyTorch 有几个用于池化操作的选项，我们从其中选择使用`MaxPo
 
 图 4.10：编码器图
 
-如上图所示，LinkNet 中的每个编码器块均由四个卷积块组成。 前两个卷积块被分组为一个块。 然后将其与残差输出（由 ResNet 推动的体系结构决策）相加。 然后，带有该加法的残差输出将进入第二块，这也与第一块类似。 然后将块 2 的输入添加到块 2 的输出中，而无需通过单独的残差块。
+如上图所示，LinkNet 中的每个编码器块均由四个卷积块组成。 前两个卷积块被分组为一个块。 然后将其与残差输出（由 ResNet 推动的架构决策）相加。 然后，带有该加法的残差输出将进入第二块，这也与第一块类似。 然后将块 2 的输入添加到块 2 的输出中，而无需通过单独的残差块。
 
-第一个块用因子 2 对输入进行下采样，第二个块对输入的尺寸没有任何作用。 这就是为什么我们需要一个残差网以及第一个模块，而对于第二个模块，我们可以直接添加输入和输出。 实现该体系结构的代码如下。 `init`功能实际上是在初始化`conv`块和`residue`块。 PyTorch 帮助我们处理张量的加法，因此我们只需要编写我们想做的数学运算，就像您在普通的 Python 变量上执行此操作一样，而 PyTorch 的`autograd`将在上完成 从那里。
+第一个块用因子 2 对输入进行下采样，第二个块对输入的尺寸没有任何作用。 这就是为什么我们需要一个残差网以及第一个模块，而对于第二个模块，我们可以直接添加输入和输出。 实现该架构的代码如下。 `init`功能实际上是在初始化`conv`块和`residue`块。 PyTorch 帮助我们处理张量的加法，因此我们只需要编写我们想做的数学运算，就像您在普通的 Python 变量上执行此操作一样，而 PyTorch 的`autograd`将在上完成 从那里。
 
 ```py
 class EncoderBlock(nn.Module):
@@ -571,7 +571,7 @@ class SegmentationModel(nn.Module):
 
 在过去的十年中，借助人工智能，计算机视觉领域得到了显着改善。 现在，它不仅用于诸如对象检测/识别之类的传统用例，而且还用于提高图像质量，从图像/视频进行丰富的搜索，从图像/视频生成文本，3D 建模等等。
 
-在本章中，我们已经介绍了 CNN，这是迄今为止计算机视觉取得所有成功的关键。 CNN 的许多体系结构变体已用于不同目的，但是所有这些实现的核心是 CNN 的基本构建块。 关于 CNN 的技术局限性，已经进行了大量研究，尤其是从人类视觉仿真的角度。 已经证明，CNN 不能完全模拟人类视觉系统的工作方式。 这使许多研究小组认为应该有替代方案。 替代 CNN 的一种最流行的方法是使用胶囊网络，这也是杰弗里·欣顿实验室的成果。 但是现在，CNN 正在作为成千上万的实时和关键计算机视觉应用程序的核心。
+在本章中，我们已经介绍了 CNN，这是迄今为止计算机视觉取得所有成功的关键。 CNN 的许多架构变体已用于不同目的，但是所有这些实现的核心是 CNN 的基本构建块。 关于 CNN 的技术局限性，已经进行了大量研究，尤其是从人类视觉仿真的角度。 已经证明，CNN 不能完全模拟人类视觉系统的工作方式。 这使许多研究小组认为应该有替代方案。 替代 CNN 的一种最流行的方法是使用胶囊网络，这也是杰弗里·欣顿实验室的成果。 但是现在，CNN 正在作为成千上万的实时和关键计算机视觉应用程序的核心。
 
 在下一章中，我们将研究另一种基本的网络架构：循环神经网络。
 

new/pt-dl-handson/5.md

@@ -10,7 +10,7 @@
 
 尽管原始 RNN（在输入中为每个单元展开一个简单的 RNN 单元）是一个革命性的想法，但未能提供可用于生产的结果。 主要障碍是长期依赖问题。 当输入序列的长度增加时，网络到达最后一个单元时将无法从初始单位（单词，如果是自然语言）中记住信息。 我们将在接下来的部分中看到 RNN 单元包含的内容以及如何将其展开。
 
-几次迭代和多年的研究得出了 RNN 架构设计的几种不同方法。 最新的模型现在使用**长短期内存**（**LSTM**）实现或**门控循环单元**（**GRU**）。 这两种实现都将 RNN 单元内的门用于不同目的，例如遗忘门，它使网络忘记不必要的信息。 这些体系结构具有香草 RNN 所存在的长期依赖性问题，因此使用门不仅要忘记不必要的信息，而且要记住在长距离移动到最后一个单元时所必需的信息。
+几次迭代和多年的研究得出了 RNN 架构设计的几种不同方法。 最新的模型现在使用**长短期内存**（**LSTM**）实现或**门控循环单元**（**GRU**）。 这两种实现都将 RNN 单元内的门用于不同目的，例如遗忘门，它使网络忘记不必要的信息。 这些架构具有香草 RNN 所存在的长期依赖性问题，因此使用门不仅要忘记不必要的信息，而且要记住在长距离移动到最后一个单元时所必需的信息。
 
 注意是下一个重大发明，它可以帮助网络将注意力集中在输入的重要部分上，而不是搜索整个输入并试图找到答案。 实际上，来自 Google Brain 和多伦多大学的一个团队证明，注意力可以击败 LSTM 和 GRU 网络[1]。 但是，大多数实现都同时使用 LSTM / GRU 和注意力。
 
@@ -358,7 +358,7 @@ opt = optim.Adam(model.parameters(), lr=lr)
 
 ### 高级 RNN
 
-对于基于 LSTM 和 GRU 的网络，高级可能是一个模糊的术语，因为默认情况下，这些是在所有顺序数据处理网络中使用的网络体系结构。 与 1990 年代提出的 LSTM 网络相比，GRU 网络是一个相对较新的设计。 两种网络都是门控循环网络的不同形式，其中 LSTM 网络建立的体系结构比 GRU 网络复杂。 这些体系结构被概括为门控循环网络，因为它们具有用于处理通过网络的输入/梯度流的门。 门从根本上是激活，例如 Sigmoid，以决定要流经的数据量。 在这里，我们将详细研究 LSTM 和 GRU 的体系结构，并了解 PyTorch 如何提供对 LSTM 和 GRU 的 API 的访问。
+对于基于 LSTM 和 GRU 的网络，高级可能是一个模糊的术语，因为默认情况下，这些是在所有顺序数据处理网络中使用的网络架构。 与 1990 年代提出的 LSTM 网络相比，GRU 网络是一个相对较新的设计。 两种网络都是门控循环网络的不同形式，其中 LSTM 网络建立的架构比 GRU 网络复杂。 这些架构被概括为门控循环网络，因为它们具有用于处理通过网络的输入/梯度流的门。 门从根本上是激活，例如 Sigmoid，以决定要流经的数据量。 在这里，我们将详细研究 LSTM 和 GRU 的架构，并了解 PyTorch 如何提供对 LSTM 和 GRU 的 API 的访问。
 
 ##### LSTM
 
@@ -368,7 +368,7 @@ opt = optim.Adam(model.parameters(), lr=lr)
 
 LSTM 网络由 Sepp Hochreiter 于 1991 年引入，并于 1997 年发布。LSTM 网络在循环单元中建立了多个门，其中正常的`RNNCell`具有`Linear`层，该层通过`softmax`层相互作用以生成输出和 另一个`Linear`层会生成隐藏状态。 有关 LSTM 的详细说明，请参见原始论文或克里斯托弗·奥拉（Christopher Olah）的博客，标题为*了解 LSTM 网络* [4]。
 
-LSTM 主要由遗忘门，更新门和单元状态组成，这使得 LSTM 与常规 RNN 单元不同。 该体系结构经过精心设计，可以执行特定任务。 遗忘门使用输入向量和先前状态的隐藏状态来确定例如应忘记的内容，更新门使用当前输入和先前的隐藏状态来确定应添加到信息存储库中的内容。
+LSTM 主要由遗忘门，更新门和单元状态组成，这使得 LSTM 与常规 RNN 单元不同。 该架构经过精心设计，可以执行特定任务。 遗忘门使用输入向量和先前状态的隐藏状态来确定例如应忘记的内容，更新门使用当前输入和先前的隐藏状态来确定应添加到信息存储库中的内容。
 
 这些决定基于 S 形层的输出，该层始终输出一个介于 0 到 1 范围内的值。 因此，“遗忘门”中的值 1 表示记住所有内容，而值 0 则表示忘记所有内容。 更新门同样适用。
 
@@ -477,7 +477,7 @@ RNN 实现通常是单向的，这就是到目前为止我们已经实现的。
 
 一旦概念清晰，在 PyTorch 中获得关注就很简单。 注意可以有效地用于许多应用中，包括语音处理； 翻译，以前自动编码器是首选实现； CNN 到 RNN，用于图像字幕； 和别的。
 
-实际上，*就是您所需要的全部* [5]是该论文的作者仅通过关注并删除所有其他复杂的网络体系结构（如 LSTM）就能够获得 SOTA 结果的方法。
+实际上，*就是您所需要的全部* [5]是该论文的作者仅通过关注并删除所有其他复杂的网络架构（如 LSTM）就能够获得 SOTA 结果的方法。
 
 ### 循环神经网络
 
@@ -491,7 +491,7 @@ RNN 实现通常是单向的，这就是到目前为止我们已经实现的。
 
 SPINN 将输入的句子编码为固定长度的向量，就像基于 RNN 的编码器如何从每个序列创建“含义”向量一样。 来自每个数据点的两个句子都将通过 SPINN 传递并为每个句子创建编码的向量，然后使用合并网络和分类器网络对其进行处理以获得这三个类别中每个类别的得分。
 
-如果您想知道需要在不公开 PyTorch 的任何其他功能 API 的情况下显示 SPINN 实现的方法，那么答案是 SPINN 是展示 PyTorch 如何适应任何类型的神经网络体系结构的最佳示例。 你发展。 无论您考虑的架构要求如何，PyTorch 都不会妨碍您。
+如果您想知道需要在不公开 PyTorch 的任何其他功能 API 的情况下显示 SPINN 实现的方法，那么答案是 SPINN 是展示 PyTorch 如何适应任何类型的神经网络架构的最佳示例。 你发展。 无论您考虑的架构要求如何，PyTorch 都不会妨碍您。
 
 静态计算图之上构建的框架不能实现 SPINN 这样的网络架构，而不会造成混乱。 这可能是所有流行框架围绕其核心实现构建动态计算图包装的原因，例如 TensorFlow 的热切需求，MXNet，CNTK 的 Gluon API 等。 我们将看到 PyTorch 的 API 对实现任何类型的条件或循环到计算图中的 API 有多么直观。 SPINN 是展示这些的完美示例。
 

new/pt-dl-handson/6.md

@@ -6,7 +6,7 @@
 
 生成网络已经在不同的深度学习领域，特别是在计算机视觉领域显示出了可喜的成果。 去模糊或提高图像的分辨率，图像修补以填充缺失的片段，对音频片段进行降噪，从文本生成语音，自动回复消息以及从文本生成图像/视频是一些研究的活跃领域。
 
-在本章中，我们将讨论一些主要的生成网络体系结构。 更准确地说，我们将看到一个自回归模型和一个**生成对抗网络**（**GAN**）。 首先，我们将了解这两种体系结构的基本组成部分是什么，以及它们之间的区别。 除此说明外，我们还将介绍一些示例和 PyTorch 代码。
+在本章中，我们将讨论一些主要的生成网络架构。 更准确地说，我们将看到一个自回归模型和一个**生成对抗网络**（**GAN**）。 首先，我们将了解这两种架构的基本组成部分是什么，以及它们之间的区别。 除此说明外，我们还将介绍一些示例和 PyTorch 代码。
 
 ## 定义方法
 
@@ -203,7 +203,7 @@ PyTorch 提供了用于快速傅里叶变换（`torch.fft`），快速傅里叶
 
 ```
 
-WaveNet 并不是第一个引入序列数据卷积网络或扩张的卷积网络以加快操作速度的体系结构。 但是 WaveNet 成功地将两者结合使用，从而产生了可区分的音频。 第一波 WaveNet 的作者发布了另一篇迭代论文，该论文极大地加速了的产生，称为并行 WaveNet。 但是，在本章中，我们将重点关注普通的 WaveNet，这在很大程度上受到了戈尔宾的资料库的启发[3]。
+WaveNet 并不是第一个引入序列数据卷积网络或扩张的卷积网络以加快操作速度的架构。 但是 WaveNet 成功地将两者结合使用，从而产生了可区分的音频。 第一波 WaveNet 的作者发布了另一篇迭代论文，该论文极大地加速了的产生，称为并行 WaveNet。 但是，在本章中，我们将重点关注普通的 WaveNet，这在很大程度上受到了戈尔宾的资料库的启发[3]。
 
 WaveNet 的基本构件是膨胀卷积，它取代了 RNN 的功能来获取上下文信息。
 
@@ -294,7 +294,7 @@ class WaveNetModule(torch.nn.Module):
 
 前面的代码块中给出的程序是主要的父 WaveNet 模块，该模块使用所有子组件来创建图形。 `init`定义了三个主要成分，其中是第一个普通卷积，然后是`res_stack`（它是由所有膨胀卷积和 S 型正切门组成的残差连接块）。 然后，最后的`convdensnet`在 1x1 卷积的顶部进行。 `forward`引入一个求和节点，依次执行这些模块。 然后，将`convdensnet`创建的输出通过`contiguous()`移动到存储器的单个块。 这是其余网络所必需的。
 
-`ResidualStack`是需要更多说明的模块，它是 WaveNet 体系结构的核心。 `ResidualStack`是`ResidualBlock`的层的堆栈。 WaveNet 图片中的每个小圆圈都是一个残差块。 在正常卷积之后，数据到达`ResidualBlock`，如前所述。 `ResidualBlock`从膨胀的卷积开始，并且期望得到膨胀。 因此，`ResidualBlock`决定了体系结构中每个小圆节点的膨胀因子。 如前所述，膨胀卷积的输出然后通过类似于我们在 PixelCNN 中看到的门的门。
+`ResidualStack`是需要更多说明的模块，它是 WaveNet 架构的核心。 `ResidualStack`是`ResidualBlock`的层的堆栈。 WaveNet 图片中的每个小圆圈都是一个残差块。 在正常卷积之后，数据到达`ResidualBlock`，如前所述。 `ResidualBlock`从膨胀的卷积开始，并且期望得到膨胀。 因此，`ResidualBlock`决定了架构中每个小圆节点的膨胀因子。 如前所述，膨胀卷积的输出然后通过类似于我们在 PixelCNN 中看到的门的门。
 
 在那之后，它必须经历两个单独的卷积以进行跳过连接和残差连接。 尽管作者并未将其解释为两个单独的卷积，但使用两个单独的卷积更容易理解。
 
@@ -541,7 +541,7 @@ loss = nn.BCELoss()
 
 资料来源：*使用周期一致的对抗性网络*的不成对图像翻译，朱俊彦等
 
-CycleGAN 是 GAN 类型的智能变体之一。 在同一体系结构中，两个 GAN 之间巧妙设计的循环流可教导两个不同分布之间的映射。 先前的方法需要来自不同分布的成对图像，以便网络学习映射。 对于示例，如果目标是建立一个可以将黑白图像转换为彩色图像的网络，则数据集在训练集中需要将同一图像的黑白和彩色版本作为一对。 尽管很难，但在一定程度上这是可能的。 但是，如果要使冬天拍摄的图像看起来像夏天拍摄的图像，则训练集中的这对图像必须是在冬天和夏天拍摄的具有相同对象和相同帧的完全相同的图像。 这是完全不可能的，而那正是 CycleGAN 可以提供帮助的地方。
+CycleGAN 是 GAN 类型的智能变体之一。 在同一架构中，两个 GAN 之间巧妙设计的循环流可教导两个不同分布之间的映射。 先前的方法需要来自不同分布的成对图像，以便网络学习映射。 对于示例，如果目标是建立一个可以将黑白图像转换为彩色图像的网络，则数据集在训练集中需要将同一图像的黑白和彩色版本作为一对。 尽管很难，但在一定程度上这是可能的。 但是，如果要使冬天拍摄的图像看起来像夏天拍摄的图像，则训练集中的这对图像必须是在冬天和夏天拍摄的具有相同对象和相同帧的完全相同的图像。 这是完全不可能的，而那正是 CycleGAN 可以提供帮助的地方。
 
 CycleGAN 学习每种分布的模式，并尝试将图像从一种分布映射到另一种分布。 “图 6.19”中给出了 CycleGAN 的简单架构图。 上面的图显示了如何训练一个 GAN，下面的图显示了如何使用正在工作的 CycleGAN 典型示例：马和斑马来训练另一个。
 
@@ -633,7 +633,7 @@ class ResidualBlock(nn.Module):
 
 在本章中，我们学习了一系列全新的神经网络，这些神经网络使人工智能世界发生了翻天覆地的变化。 生成网络对我们始终很重要，但是直到最近我们才能达到人类无法比拟的准确性。 尽管有一些成功的生成网络架构，但在本章中我们仅讨论了两个最受欢迎的网络。
 
-生成网络使用 CNN 或 RNN 之类的基本体系结构作为整个网络的构建块，但是使用一些不错的技术来确保网络正在学习生成一些输出。 到目前为止，生成网络已在艺术中得到广泛使用，并且由于模型必须学习数据分布以生成输出，因此我们可以轻松地预测生成网络将成为许多复杂网络的基础。 生成网络最有前途的用途可能不是生成，而是通过生成学习数据分发并将该信息用于其他目的。
+生成网络使用 CNN 或 RNN 之类的基本架构作为整个网络的构建块，但是使用一些不错的技术来确保网络正在学习生成一些输出。 到目前为止，生成网络已在艺术中得到广泛使用，并且由于模型必须学习数据分布以生成输出，因此我们可以轻松地预测生成网络将成为许多复杂网络的基础。 生成网络最有前途的用途可能不是生成，而是通过生成学习数据分发并将该信息用于其他目的。
 
 在下一章中，我们将研究最受关注的网络：强化学习算法。
 

new/pt-tut-17/21.md

@@ -10,7 +10,7 @@
 
 ## 威胁模型]（docs / modern-java-zh /
 
-就上下文而言，有多种类型的对抗性攻击，每种攻击者的目标和假设都不同。 但是，总的来说，总体目标是向输入数据添加最少的扰动，以引起所需的错误分类。 攻击者的知识有几种假设，其中两种是：**白盒**和**黑盒**。 *白盒*攻击假定攻击者具有完全的知识并可以访问模型，包括体系结构，输入，输出和权重。 *黑匣子*攻击假定攻击者只能访问模型的输入和输出，并且对底层体系结构或权重一无所知。 目标也有几种类型，包括**错误分类**和**源/目标错误分类**。 *错误分类的目标是*，这意味着对手只希望输出分类错误，而不在乎新分类是什么。 *源/目标错误分类*意味着对手想要更改最初属于特定源类别的图像，以便将其分类为特定目标类别。
+就上下文而言，有多种类型的对抗性攻击，每种攻击者的目标和假设都不同。 但是，总的来说，总体目标是向输入数据添加最少的扰动，以引起所需的错误分类。 攻击者的知识有几种假设，其中两种是：**白盒**和**黑盒**。 *白盒*攻击假定攻击者具有完全的知识并可以访问模型，包括架构，输入，输出和权重。 *黑匣子*攻击假定攻击者只能访问模型的输入和输出，并且对底层架构或权重一无所知。 目标也有几种类型，包括**错误分类**和**源/目标错误分类**。 *错误分类的目标是*，这意味着对手只希望输出分类错误，而不在乎新分类是什么。 *源/目标错误分类*意味着对手想要更改最初属于特定源类别的图像，以便将其分类为特定目标类别。
 
 在这种情况下，FGSM 攻击是*白盒*攻击，目标是*错误分类*。 有了这些背景信息，我们现在可以详细讨论攻击了。
 

new/pt-tut-17/22.md

@@ -192,7 +192,7 @@ def weights_init(m):
 
 ![dcgan_generator](img/85974d98be6202902f21ce274418953f.png)
 
-请注意，我们在输入部分中设置的输入（ *nz* ， *ngf* 和 *nc* ）如何影响代码中的生成器体系结构。 *nz* 是 z 输入向量的长度， *ngf* 与通过生成器传播的特征图的大小有关， *nc* 是 输出图像中的通道（对于 RGB 图像设置为 3）。 下面是生成器的代码。
+请注意，我们在输入部分中设置的输入（ *nz* ， *ngf* 和 *nc* ）如何影响代码中的生成器架构。 *nz* 是 z 输入向量的长度， *ngf* 与通过生成器传播的特征图的大小有关， *nc* 是 输出图像中的通道（对于 RGB 图像设置为 3）。 下面是生成器的代码。
 
 ```py
 # Generator Code
@@ -274,7 +274,7 @@ Generator(
 
 ### 判别器]（docs / modern-java-zh /
 
-如前所述，鉴别符\（D \）是一个二进制分类网络，将图像作为输入并输出标量概率，即输入图像是真实的（与假的相对）。 在这里，\（D \）拍摄 3x64x64 的输入图像，通过一系列的 Conv2d，BatchNorm2d 和 LeakyReLU 层对其进行处理，然后通过 Sigmoid 激活函数输出最终概率。 如果需要解决此问题，可以用更多层扩展此体系结构，但是使用跨步卷积，BatchNorm 和 LeakyReLU 仍然很重要。 DCGAN 论文提到，使用跨步卷积而不是通过池化来进行下采样是一个好习惯，因为它可以让网络学习自己的池化功能。 批处理规范和泄漏 relu 函数还可以促进健康的梯度流，这对于\（G \）和\（D \）的学习过程都是至关重要的。
+如前所述，鉴别符\（D \）是一个二进制分类网络，将图像作为输入并输出标量概率，即输入图像是真实的（与假的相对）。 在这里，\（D \）拍摄 3x64x64 的输入图像，通过一系列的 Conv2d，BatchNorm2d 和 LeakyReLU 层对其进行处理，然后通过 Sigmoid 激活函数输出最终概率。 如果需要解决此问题，可以用更多层扩展此架构，但是使用跨步卷积，BatchNorm 和 LeakyReLU 仍然很重要。 DCGAN 论文提到，使用跨步卷积而不是通过池化来进行下采样是一个好习惯，因为它可以让网络学习自己的池化功能。 批处理规范和泄漏 relu 函数还可以促进健康的梯度流，这对于\（G \）和\（D \）的学习过程都是至关重要的。
 
 鉴别码
 
@@ -385,7 +385,7 @@ optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))
 
 **第 1 部分-训练鉴别器**
 
-回想一下，训练鉴别器的目的是最大程度地提高将给定输入正确分类为真实或伪造的可能性。 就古德费罗而言，我们希望“通过提高其随机梯度来更新鉴别器”。 实际上，我们要最大化\（log（D（x））+ log（1-D（G（z）））\）。 由于 ganhacks 提出了单独的小批量建议，因此我们将分两步进行计算。 首先，我们将从训练集中构造一批真实样本，向前通过\（D \），计算损失（\（log（D（x（x））\））），然后在向后通过中计算梯度。 其次，我们将使用电流生成器构造一批假样本，将这批伪造通过\（D \），计算损失（\（log（1-D（G（z（））））\）），然后*向后累积*梯度。 现在，利用全批量和全批量的累积梯度，我们称之为鉴别器优化程序的一个步骤。
+回想一下，训练鉴别器的目的是最大程度地提高将给定输入正确分类为真实或伪造的可能性。 就古德费罗而言，我们希望“通过提高其随机梯度来更新鉴别器”。 实际上，我们要最大化\（log（D（x））+ log（1-D（G（z）））\）。 由于 ganhacks 提出了单独的小批量建议，因此我们将分两步进行计算。 首先，我们将从训练集中构造一批真实样本，向前通过\（D \），计算损失（\（log（D（x（x））\））），然后在向后通过中计算梯度。 其次，我们将使用当前生成器构造一批假样本，将这批伪造通过\（D \），计算损失（\（log（1-D（G（z（））））\）），然后*向后累积*梯度。 现在，利用全批量和全批量的累积梯度，我们称之为鉴别器优化程序的一个步骤。
 
 **第 2 部分-训练发电机**
 

new/pt-tut-17/54.md

@@ -22,7 +22,7 @@ import torch.nn.functional as F
 
 ## 创建模型] [docs / modern-java-zh /
 
-在本教程中，我们使用 LeCun 等人，1998 年的 [LeNet](http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf) 体系结构。
+在本教程中，我们使用 LeCun 等人，1998 年的 [LeNet](http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf) 架构。
 
 ```py
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

new/pt-tut-17/55.md

@@ -26,7 +26,7 @@ import torch.nn.functional as F
 
 ## 1.定义模型]（docs / modern-java-zh /
 
-在这里，我们根据词语言模型示例中的[模型](https://github.com/pytorch/examples/blob/master/word_language_model/model.py)定义 LSTM 模型体系结构。
+在这里，我们根据词语言模型示例中的[模型](https://github.com/pytorch/examples/blob/master/word_language_model/model.py)定义 LSTM 模型架构。
 
 ```py
 class LSTMModel(nn.Module):

new/pt-tut-17/57.md

@@ -46,7 +46,7 @@ torch.manual_seed(191009)
 
 ## 1.模型架构]（docs / modern-java-zh /
 
-我们首先定义 MobileNetV2 模型体系结构，并进行了一些值得注意的修改以实现量化：
+我们首先定义 MobileNetV2 模型架构，并进行了一些值得注意的修改以实现量化：
 
 *   用`nn.quantized.FloatFunctional`代替添加
 *   在网络的开头和结尾处插入`QuantStub`和`DeQuantStub`。

new/rl-tf/00.md

@@ -2,7 +2,7 @@
 
 **强化学习**（**RL**）使您可以在业务环境中开发智能，快速且自学的系统。 这是训练您的学习型代理商并解决人工智能中各种问题的有效方法，从游戏，自动驾驶汽车和机器人到企业应用程序，其范围从数据中心节能（冷却数据中心）到智能仓储解决方案。
 
-本书涵盖了通过将深度神经网络体系结构与强化学习相结合而在深度强化学习中取得的主要进步和成功。 该书还向读者介绍了强化学习的概念，它的优点以及为什么它如此受欢迎。 它讨论了 MDP，蒙特卡洛树搜索，策略和值迭代，时间差异学习（例如 Q 学习）和 SARSA。 您将使用 TensorFlow 和 OpenAI Gym 来构建简单的神经网络模型，以从自己的行为中学习。 您还将看到强化学习算法如何在游戏，图像处理和 NLP 中发挥作用。
+本书涵盖了通过将深度神经网络架构与强化学习相结合而在深度强化学习中取得的主要进步和成功。 该书还向读者介绍了强化学习的概念，它的优点以及为什么它如此受欢迎。 它讨论了 MDP，蒙特卡洛树搜索，策略和值迭代，时间差异学习（例如 Q 学习）和 SARSA。 您将使用 TensorFlow 和 OpenAI Gym 来构建简单的神经网络模型，以从自己的行为中学习。 您还将看到强化学习算法如何在游戏，图像处理和 NLP 中发挥作用。
 
 到本书结尾，您将对 TensorFlow 和 OpenAI Gym 的功能有一个深刻的了解，即什么是强化学习以及如何将您的知识付诸实践。
 

new/rl-tf/01.md

-# 深度学习–体系结构和框架
+# 深度学习–架构和框架
 
 人工神经网络是一种计算系统，为我们提供了解决诸如图像识别到语音翻译等具有挑战性的机器学习任务的重要工具。 最近的突破，例如 Google DeepMind 的 AlphaGo 击败了最好的围棋玩家，或者卡内基梅隆大学的 Libratus 击败了世界上最好的职业扑克玩家，都证明了算法的进步。 这些算法像人类一样学习狭窄的智能，并达到超人水平的性能。 用通俗易懂的话说，人工神经网络是我们可以在计算机上编程的人脑的松散表示。 确切地说，这是受我们对人脑功能知识的启发而产生的一种方法。 神经网络的一个关键概念是创建输入数据的表示空间，然后在该空间中解决问题。 也就是说，从数据的当前状态开始扭曲数据，以便可以以不同的状态表示数据，从而可以解决有关的问题陈述（例如分类或回归）。 深度学习意味着多个隐藏的表示，即具有许多层的神经网络，可以创建更有效的数据表示。 每一层都会细化从上一层收到的信息。
 
@@ -187,7 +187,7 @@ ReLU 的导数图，对于 x <=0 and f'(x) = 1 for x> 0 显示 f'（x）= 0
 
 # 逻辑回归作为神经网络
 
-Logistic 回归是一种分类器算法。 在这里，我们尝试预测输出类别的概率。 具有最高概率的类别将成为预测输出。 使用交叉熵计算实际输出和预测输出之间的误差，并通过反向传播将其最小化。 检查下图，了解二进制逻辑回归和多类逻辑回归。 区别基于问题陈述。 如果输出类的唯一数量为两个，则称为**二进制分类**；如果输出类的唯一数量为两个以上，则称为多类分类。 如果没有隐藏层，我们将 Sigmoid 函数用于二进制分类，并获得用于二进制逻辑回归的体系结构。 类似地，如果没有隐藏层，并且我们使用 softmax 函数进行多类分类，则可以得到多类逻辑回归的体系结构。
+Logistic 回归是一种分类器算法。 在这里，我们尝试预测输出类别的概率。 具有最高概率的类别将成为预测输出。 使用交叉熵计算实际输出和预测输出之间的误差，并通过反向传播将其最小化。 检查下图，了解二进制逻辑回归和多类逻辑回归。 区别基于问题陈述。 如果输出类的唯一数量为两个，则称为**二进制分类**；如果输出类的唯一数量为两个以上，则称为多类分类。 如果没有隐藏层，我们将 Sigmoid 函数用于二进制分类，并获得用于二进制逻辑回归的架构。 类似地，如果没有隐藏层，并且我们使用 softmax 函数进行多类分类，则可以得到多类逻辑回归的架构。
 
 现在出现一个问题，为什么不使用 Sigmoid 函数进行多类 Logistic 回归？
 
@@ -439,11 +439,11 @@ Xavier 初始化是神经网络中权重的初始化，是遵循高斯分布的
 
 设置好此结构后，我们必须重复执行这些优化步骤（更新![](img/1ac8a61d-f0cd-4875-bb19-8e24af95ab5b.png)和![](img/1dae3d1b-e4bc-4a91-b6f7-c05238e0f6f5.png)），以进行多次迭代以训练我们的神经网络。
 
-这将我们带到了神经网络基础的结尾，它构成了任何浅或深的神经网络的基本构建块。 我们的下一个前沿将是了解一些著名的深度神经网络架构，例如**循环神经网络**（**RNNs**）和**卷积神经网络**（**CNN**）。 除此之外，我们还将介绍基准的深度神经网络体系结构，例如 AlexNet，VGG-net 和 Inception。
+这将我们带到了神经网络基础的结尾，它构成了任何浅或深的神经网络的基本构建块。 我们的下一个前沿将是了解一些著名的深度神经网络架构，例如**循环神经网络**（**RNNs**）和**卷积神经网络**（**CNN**）。 除此之外，我们还将介绍基准的深度神经网络架构，例如 AlexNet，VGG-net 和 Inception。
 
 # 循环神经网络
 
-循环神经网络，缩写为 RNN，用于顺序数据的情况下，无论是作为输入，输出还是两者。 RNN 之所以如此有效，是因为它们的体系结构可以汇总来自过去数据集的学习，并将其与新数据一起使用以增强学习。 这样，它可以捕获事件的顺序，这在前馈神经网络或统计时间序列分析的早期方法中是不可能的。
+循环神经网络，缩写为 RNN，用于顺序数据的情况下，无论是作为输入，输出还是两者。 RNN 之所以如此有效，是因为它们的架构可以汇总来自过去数据集的学习，并将其与新数据一起使用以增强学习。 这样，它可以捕获事件的顺序，这在前馈神经网络或统计时间序列分析的早期方法中是不可能的。
 
 考虑时间序列数据，例如股票市场，音频或视频数据集，其中事件的顺序非常重要。 因此，在这种情况下，除了从整个数据中进行集体学习之外，从时间上遇到的数据中学习的顺序也很重要。 这将有助于捕捉潜在趋势。
 
@@ -555,7 +555,7 @@ CNN 在计算机视觉和自然语言处理领域具有广泛的应用。 就行
 
 ![](img/ca81209f-a26b-4c0e-ab94-77dceaa9bcab.png)
 
-CNN 体系结构由一系列这些卷积层组成。 如果这些卷积层中的跨步值大于 1，则会导致空间缩小。 因此，步幅，斑块大小和激活函数成为超参数。 除卷积层外，有时还会添加一个重要的层，称为**池化层**。 这将附近的所有卷积合并起来。 池化的一种形式称为**最大池化**。
+CNN 架构由一系列这些卷积层组成。 如果这些卷积层中的跨步值大于 1，则会导致空间缩小。 因此，步幅，斑块大小和激活函数成为超参数。 除卷积层外，有时还会添加一个重要的层，称为**池化层**。 这将附近的所有卷积合并起来。 池化的一种形式称为**最大池化**。
 
 在最大池中，功能图会查看补丁中的所有值，并返回其中的最大值。 因此，池大小（即池补丁/窗口大小）和池跨度是超参数。 下图描述了最大池化的概念：
 
@@ -569,7 +569,7 @@ CNN 体系结构由一系列这些卷积层组成。 如果这些卷积层中的
 
 ![](img/8bad0a66-b329-41a9-966b-e3f7fac7dee8.png)
 
-LeNet-5 的体系结构，来自 LeCunn 等人的基于梯度的学习应用于文档识别（http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf）
+LeNet-5 的架构，来自 LeCunn 等人的基于梯度的学习应用于文档识别（http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf）
 
 LeNet-5 是一个七级卷积神经网络，由 Yann LeCunn，Yoshua Bengio，Leon Bottou 和 Patrick Haffner 于 1998 年组成的团队发布，对数字进行了分类，银行将其用于识别支票上的手写数字。 这些层按以下顺序排序：
 

new/rl-tf/05.md

@@ -38,7 +38,7 @@ DeepMind 在研究期刊 **Nature** 上发表了他们的论文[《通过深度
 
 因此，对于基于随机环境的问题，似乎最好的学习方法是尝试各种可能性。 因此，与其通过监督分类将其解决为模式识别问题，不如通过试错法更好，在这种方法中，结果标签将替换为量化特定操作对完成给定问题的最终目的的有用性的奖励。 声明。
 
-这产生了环境-代理交互方法，我们在第 1 章，*深度强化–体系结构和框架，*中讨论了该方法，在该系统中，我们设计了一种使代理与环境交互的系统 首先，通过传感器感知状态，通过效应器对环境执行一些操作，然后接收反馈，即对所采取操作的奖励，如下图所示：
+这产生了环境-代理交互方法，我们在第 1 章，*深度强化–架构和框架，*中讨论了该方法，在该系统中，我们设计了一种使代理与环境交互的系统 首先，通过传感器感知状态，通过效应器对环境执行一些操作，然后接收反馈，即对所采取操作的奖励，如下图所示：
 
 ![](img/c7f38da6-965e-4b9f-9149-bc088223f8bd.png)
 
@@ -400,11 +400,11 @@ end
 
 # 深度 Q 网络以及其他方面的进步
 
-随着更多的研究和更多的时间，深度 Q 网络已经进行了许多改进，从而获得了更好的体系结构，从而提供了更高的性能和稳定性。 在本节中，我们将仅讨论两种著名的体系结构，即 **Double DQN** 和 **Dueling DQN** 。
+随着更多的研究和更多的时间，深度 Q 网络已经进行了许多改进，从而获得了更好的架构，从而提供了更高的性能和稳定性。 在本节中，我们将仅讨论两种著名的架构，即 **Double DQN** 和 **Dueling DQN** 。
 
 # 双 DQN
 
-使用 **Double DQN（DDQN）**的原因是常规 DQN 高估了在给定状态下可能采取的措施的 Q 值。 在常规 DQN 中，所有动作之间的高估都不相等。 因此，问题仍然存在：否则，所有行动之间的均等估算就不会成为问题。 结果，某些次优的行为获得了更高的价值，因此学习最佳策略的时间增加了。 这导致我们对常规 DQN 体系结构进行了少量修改，并导致了所谓的 DDQN，即双深度 Q 网络。
+使用 **Double DQN（DDQN）**的原因是常规 DQN 高估了在给定状态下可能采取的措施的 Q 值。 在常规 DQN 中，所有动作之间的高估都不相等。 因此，问题仍然存在：否则，所有行动之间的均等估算就不会成为问题。 结果，某些次优的行为获得了更高的价值，因此学习最佳策略的时间增加了。 这导致我们对常规 DQN 架构进行了少量修改，并导致了所谓的 DDQN，即双深度 Q 网络。
 
 在 DDQN 中，我们不是在训练过程中计算目标 Q 值时取最大 Q 值，而是使用主要网络选择操作，并使用目标网络为该操作生成目标 Q 值。 这使动作脱钩。 从目标 Q 网络中进行选择，生成目标 Q 值，从而减少高估，并有助于更快地进行训练。 DDQN 中的目标 Q 值通过以下公式更新：
 
@@ -436,7 +436,7 @@ import tensorflow as tf
 import gym
 ```
 
-让我们讨论一下 DQN 类，其中包含深度 Q 网络的体系结构：
+让我们讨论一下 DQN 类，其中包含深度 Q 网络的架构：
 
 *   `__init__`（`self`，`learning_rate`，`gamma`，`n_features`，`n_actions`，`epsilon`，`parameter_changing_pointer`，`memory_size`）：默认构造函数，用于分配超参数，例如：
     *   `learning_rate`
@@ -449,7 +449,7 @@ import gym
 *   `fit(self)`：训练我们的深度 Q 网络
 *   `epsilon_greedy(self,obs)`：对于给定的观察状态，要采取的操作，即根据现有策略利用操作或随机探索新操作
 
-可以使用以下代码定义具有主要功能的 DQN 类的体系结构：
+可以使用以下代码定义具有主要功能的 DQN 类的架构：
 
 ```py
 class DQN:
@@ -906,7 +906,7 @@ import gym
 from scipy.misc import imresize
 ```
 
-具有以下主要功能的`class DQN`的体系结构可以使用以下代码定义：
+具有以下主要功能的`class DQN`的架构可以使用以下代码定义：
 
 ```py
 class DQN:
@@ -936,7 +936,7 @@ if __name__ == "__main__":
     ....
 ```
 
-让我们讨论 DQN 类及其参数，它包含一个深度 Q 网络的体系结构：
+让我们讨论 DQN 类及其参数，它包含一个深度 Q 网络的架构：
 
 *   `__init__(self,learning_rate,gamma,n_features,n_actions,epsilon,parameter_changing_pointer,memory_size)`：分配超参数的默认构造函数，例如：
     *   `learning_rate`
@@ -1027,7 +1027,7 @@ def bias_variable(self,b_shape,layer,c):
 *   **大步前进**：以[`1,x_movement,y_movement,1`]形式出现的列表，其中：
     *   `x_movement`：定义水平移动补丁的步数
     *   `y_movement`：定义在垂直方向上移动的色块的步数
-*   **填充**：`SAME`或`VALID`（我们在第 1 章，*深度学习–体系结构和框架*中讨论了此和有效的填充）
+*   **填充**：`SAME`或`VALID`（我们在第 1 章，*深度学习–架构和框架*中讨论了此和有效的填充）
 
 我们将使用以下代码定义函数：
 

new/rl-tf/06.md

@@ -36,7 +36,7 @@ Google DeepMind 和 MILA 的联合团队于 2016 年 6 月发布了用于深度
 
 在异步方法中，为每个线程分配了一个进程，该进程包含一个学习器，该学习器表示与自己的环境副本进行交互的代理网络。 因此，这些多个学习器并行运行以探索他们自己的环境版本。 这种并行方法允许代理在任何给定的时间步长同时经历各种不同的状态，并涵盖了非策略学习和策略学习学习算法的基础。
 
-如上所述，异步方法能够在多核 CPU（而不是 GPU）中显示出良好的效果。 因此，异步方法非常快，因此成为最新的强化学习算法，因为到目前为止，深度强化学习算法的实现依赖于 GPU 驱动的机器和分布式体系结构，以见证所实现算法的更快收敛。
+如上所述，异步方法能够在多核 CPU（而不是 GPU）中显示出良好的效果。 因此，异步方法非常快，因此成为最新的强化学习算法，因为到目前为止，深度强化学习算法的实现依赖于 GPU 驱动的机器和分布式架构，以见证所实现算法的更快收敛。
 
 这些并行运行的多个学习器使用不同的探索策略，从而最大限度地提高了多样性。 不同学习器的不同探索策略会更改参数，并且这些更新与时间相关的机会最少。 因此，不需要经验回放记忆，并且我们依靠使用不同探索策略的并行学习来执行先前在 DQN 中使用的经验回放的角色。
 
@@ -52,11 +52,11 @@ Google DeepMind 和 MILA 的联合团队于 2016 年 6 月发布了用于深度
 *   异步 n 步 Q 学习
 *   **异步优势演员评论家**（**A3C**）
 
-将变体 A3C 应用于各种 Atari 2600 游戏时，在多核 CPU 上获得了更好的基准测试结果，相对于早期的深度强化学习算法而言，其结果所需的时间要短得多，后者需要在 GPU 驱动的机器上运行。 因此，由于依赖于昂贵的硬件资源（如 GPU）以及不同的复杂分布式体系结构，因此解决了该问题。 由于所有这些优点，A3C 学习代理是当前最先进的强化学习代理。
+将变体 A3C 应用于各种 Atari 2600 游戏时，在多核 CPU 上获得了更好的基准测试结果，相对于早期的深度强化学习算法而言，其结果所需的时间要短得多，后者需要在 GPU 驱动的机器上运行。 因此，由于依赖于昂贵的硬件资源（如 GPU）以及不同的复杂分布式架构，因此解决了该问题。 由于所有这些优点，A3C 学习代理是当前最先进的强化学习代理。
 
 # 异步一站式 Q 学习
 
-异步单步 Q 学习的体系结构与 DQN 非常相似。 DQN 中的代理由一组主要网络和目标网络表示，其中一步损失的计算方法是主要网络预测的当前状态 s 的状态作用值与目标状态- 目标网络计算的当前状态的动作值。 相对于策略网络的参数来计算损失的梯度，然后使用梯度下降优化器将损失最小化，从而导致主网络的参数更新。
+异步单步 Q 学习的架构与 DQN 非常相似。 DQN 中的代理由一组主要网络和目标网络表示，其中一步损失的计算方法是主要网络预测的当前状态 s 的状态作用值与目标状态- 目标网络计算的当前状态的动作值。 相对于策略网络的参数来计算损失的梯度，然后使用梯度下降优化器将损失最小化，从而导致主网络的参数更新。
 
 异步单步 Q 学习中的区别在于，有多个此类学习代理，例如，学习器并行运行并计算此损失。 因此，梯度计算也并行发生在不同的线程中，其中每个学习代理都与自己的环境副本进行交互。 这些梯度在多个时间步长上在不同线程中的累积用于在固定时间步长后或情节结束后更新策略网络参数。 梯度的累积优于策略网络参数更新，因为这样可以避免覆盖每个学习器代理执行的更改。
 
@@ -105,7 +105,7 @@ repeat until  :
 
 # 异步一步式 SARSA
 
-异步单步 SARSA 的体系结构几乎与异步单步 Q 学习的体系结构相似，不同之处在于目标网络计算当前状态的目标状态作用值的方式。 SARSA 并未使用目标网络使用下一个状态 *s'*的最大 Q 值，而是使用![](img/c892cdd9-ead0-40f4-968b-9e3210f4e73d.png) -greedy 为下一个状态 *s'*选择动作 a'。 下一个状态动作对的 Q 值 Q（s'，a'; ![](img/88250d05-5523-43d2-b0fc-20f621b58966.png)）用于计算当前状态的目标状态动作值。
+异步单步 SARSA 的架构几乎与异步单步 Q 学习的架构相似，不同之处在于目标网络计算当前状态的目标状态作用值的方式。 SARSA 并未使用目标网络使用下一个状态 *s'*的最大 Q 值，而是使用![](img/c892cdd9-ead0-40f4-968b-9e3210f4e73d.png) -greedy 为下一个状态 *s'*选择动作 a'。 下一个状态动作对的 Q 值 Q（s'，a'; ![](img/88250d05-5523-43d2-b0fc-20f621b58966.png)）用于计算当前状态的目标状态动作值。
 
 异步单步 SARSA 的伪代码如下所示。 这里，以下是全局参数：
 
@@ -152,7 +152,7 @@ repeat until  :
 
 # 异步 n 步 Q 学习
 
-异步 n 步 Q 学习的体系结构在某种程度上类似于异步单步 Q 学习的体系结构。 区别在于，使用探索策略最多选择![](img/934eccea-ab73-4d16-8dd9-6ae2bef78aa9.png)步骤或直到达到终端状态，才能选择学习代理动作，以便计算策略网络参数的单个更新。 此过程列出了自上次更新以来![](img/55e36559-5c3e-4598-b8a3-954b2a844161.png)来自环境的奖励。 然后，对于每个时间步长，将损失计算为该时间步长的折现未来奖励与估算 Q 值之间的差。 对于每个时间步长，此损耗相对于特定于线程的网络参数的梯度将被计算和累积。 有多个这样的学习代理并行运行和累积梯度。 这些累积的梯度用于执行策略网络参数的异步更新。
+异步 n 步 Q 学习的架构在某种程度上类似于异步单步 Q 学习的架构。 区别在于，使用探索策略最多选择![](img/934eccea-ab73-4d16-8dd9-6ae2bef78aa9.png)步骤或直到达到终端状态，才能选择学习代理动作，以便计算策略网络参数的单个更新。 此过程列出了自上次更新以来![](img/55e36559-5c3e-4598-b8a3-954b2a844161.png)来自环境的奖励。 然后，对于每个时间步长，将损失计算为该时间步长的折现未来奖励与估算 Q 值之间的差。 对于每个时间步长，此损耗相对于特定于线程的网络参数的梯度将被计算和累积。 有多个这样的学习代理并行运行和累积梯度。 这些累积的梯度用于执行策略网络参数的异步更新。
 
 异步 n 步 Q 学习的伪代码如下所示。 这里，以下是全局参数：
 
@@ -208,7 +208,7 @@ repeat until  :
 
 # 异步优势演员评论家
 
-在异步优势参与者批评者的体系结构中，每个学习代理都包含一个参与者批评者，该学习器结合了基于价值和基于策略的方法的优点。 参与者网络将状态作为输入，并预测该状态的最佳动作，而评论家网络将状态和动作作为输入，并输出动作分数以量化该状态的动作效果。 参与者网络使用策略梯度更新其权重参数，而评论者网络使用 *TD（0）*来更新其权重参数，换言之，两个时间步长之间的值估计之差，如[中所述 ]第 4 章](../Text/04.html)和*政策梯度*。
+在异步优势参与者批评者的架构中，每个学习代理都包含一个参与者批评者，该学习器结合了基于价值和基于策略的方法的优点。 参与者网络将状态作为输入，并预测该状态的最佳动作，而评论家网络将状态和动作作为输入，并输出动作分数以量化该状态的动作效果。 参与者网络使用策略梯度更新其权重参数，而评论者网络使用 *TD（0）*来更新其权重参数，换言之，两个时间步长之间的值估计之差，如[中所述 ]第 4 章](../Text/04.html)和*政策梯度*。
 
 在第 4 章和*策略梯度*中，我们研究了如何通过从策略梯度的预期未来收益中减去基线函数来更新策略梯度，从而在不影响预期收益的情况下减少方差的情况。 梯度。 预期的未来奖励和基线函数之间的差称为**优势函数**； 它不仅告诉我们状态的好坏，而且还告诉我们该动作的预期好坏。
 
@@ -314,7 +314,7 @@ def preprocessing_image(obs): #where I is the single frame of the game as the in
     return obs.astype('float').ravel() #flattening to 1D
 ```
 
-以下代码显示了`actor-critic`类，其中包含`actor`和`critic`网络的体系结构：
+以下代码显示了`actor-critic`类，其中包含`actor`和`critic`网络的架构：
 
 ```py
 class ActorCriticNetwork(object):

new/rl-tf/07.md

@@ -54,7 +54,7 @@ Brett Sperry 首先使用术语**实时策略**（**RTS**）作为宣传其游
 
 在检索步骤中，从案例库中选择与问题相关的案例子集。 在重用步骤中，将根据所选情况调整解决方案。 然后，在修订步骤中，通过在实际环境中进行测试来验证适应的解决方案，并观察到量化预测解决方案准确性的反馈。 保留步骤决定是否将此新解决的案例存储在案例库中。 因此，基于案例的推理和计划涉及重用以前的计划，并使它们适应新情况。
 
-基于案例的推理主要应用于静态域，也就是说，代理有时间决定要采取的操作，与此同时，环境的状态也不会改变。 但是现实世界中的问题是动态的，并且有时间限制。 因此，基于案例的推理不适合实际的策略游戏，这导致**在线基于案例的计划**，其中与基于案例的推理不同，实时进行计划和执行。 下图给出了基于案例的在线计划的体系结构：
+基于案例的推理主要应用于静态域，也就是说，代理有时间决定要采取的操作，与此同时，环境的状态也不会改变。 但是现实世界中的问题是动态的，并且有时间限制。 因此，基于案例的推理不适合实际的策略游戏，这导致**在线基于案例的计划**，其中与基于案例的推理不同，实时进行计划和执行。 下图给出了基于案例的在线计划的架构：
 
 ![](img/2296ca03-8f44-4eff-b1f6-5e92a222af79.png)
 
@@ -107,11 +107,11 @@ Brett Sperry 首先使用术语**实时策略**（**RTS**）作为宣传其游
 
 ![](img/29ee99cf-f820-4ee5-961e-9f762dec4114.png)
 
-自动编码器的体系结构
+自动编码器的架构
 
 此处，`X`表示输入和输出层中的节点数，它等于输入数据的特征（维度）数，而`N`表示节点数 在中间层中，它等于紧凑压缩表示形式所需的特征（尺寸）数。
 
-例如，假设您输入的是游戏环境的 28x28 像素图像，即 784 像素。 因此，示例编码器网络体系结构可以按以下顺序拥有节点（不必遵循该顺序）：
+例如，假设您输入的是游戏环境的 28x28 像素图像，即 784 像素。 因此，示例编码器网络架构可以按以下顺序拥有节点（不必遵循该顺序）：
 
 ![](img/ceb7b4a7-7850-4895-9c83-b0776f17ab0f.png)
 

new/rl-tf/08.md

@@ -52,7 +52,7 @@ Go 游戏起源于中国大约 3000 年前。 游戏规则很简单，如下所
 
 # 围棋
 
-1997 年，IBM 的 DeepBlue 在国际象棋比赛中击败了当时的世界冠军加里·卡斯帕罗夫。 大约二十年后，Google DeepMind 的 AI 程序 AlphaGo 击败了 9 杆围棋选手和前世界冠军 Lee Sedol。 为了了解通过 AlphaGo 进行的 Google DeepMind 的巨大飞跃和成就，让我们首先了解这两个游戏之间的区别，然后再了解 DeepBlue 和 AlphaGo 的 AI 背后使用的体系结构。
+1997 年，IBM 的 DeepBlue 在国际象棋比赛中击败了当时的世界冠军加里·卡斯帕罗夫。 大约二十年后，Google DeepMind 的 AI 程序 AlphaGo 击败了 9 杆围棋选手和前世界冠军 Lee Sedol。 为了了解通过 AlphaGo 进行的 Google DeepMind 的巨大飞跃和成就，让我们首先了解这两个游戏之间的区别，然后再了解 DeepBlue 和 AlphaGo 的 AI 背后使用的架构。
 
 国际象棋和围棋都需要两名球员。 在国际象棋中，每个玩家都有十六种不同类型的十六种棋子，根据游戏规则它们具有不同的优势。 目的是夺取对手的国王。 另一方面，围棋从一个空白的棋盘开始，每个棋手依次一个人放置一块石头，并且所有石头都具有相同的强度，遵循相同的规则。 此处的目标是在板上捕获尽可能多的区域。
 
@@ -62,7 +62,7 @@ Go 游戏起源于中国大约 3000 年前。 游戏规则很简单，如下所
 
 # DeepBlue 如何击败 Gary Kasparov？
 
-在第 5 章， *Q 学习和深度 Q 网络*中，我们研究了游戏树和 minimax 算法。 让我们回想一下那些了解 IBM DeepBlue AI 程序背后的体系结构的方法。
+在第 5 章， *Q 学习和深度 Q 网络*中，我们研究了游戏树和 minimax 算法。 让我们回想一下那些了解 IBM DeepBlue AI 程序背后的架构的方法。
 
 游戏树表示游戏的完整端到端表示，其中树中的每个节点表示特定的游戏状态（位置），链接节点的边表示在先前游戏状态下所采取的动作（动作），导致 新游戏状态。 根节点代表游戏的开始，下一级别的节点代表在游戏的开始状态下采取了所有不同的可能动作之后生成的可能状态，并且类似地生成了其他层中的节点。
 
@@ -88,7 +88,7 @@ DeepBlue 搜索国际象棋的游戏树到最低深度（因为不可能创建
 
 因此，高级树搜索（例如具有深度神经网络的蒙特卡罗树搜索）被认为是捕捉人类用来玩围棋游戏的直觉的新颖方法。 这些神经网络是**卷积神经网络**（**CNN**），并为电路板拍摄图像，即电路板的描述，并通过一系列层激活它以找到最佳的 根据游戏的给定状态移动。
 
-AlphaGo 的体系结构中使用了两个神经网络，分别是：
+AlphaGo 的架构中使用了两个神经网络，分别是：
 
 *   **策略网络**：此神经网络决定要采取的下一步行动/行动
 *   **价值网络**：此神经网络从当前位置预测游戏的获胜者
@@ -113,7 +113,7 @@ AlphaGo 使用策略和价值网络的方式是将搜索树的巨大复杂性降
 
 AlphaGo 之前的 Go 的 AI 程序完全依赖于 Monte Carlo Tree Search。 这些是 Fuego，Pachi，Zen 和 Crazy Stone。 其中，Pachi 是最强的，直到 AlphaGo 仅使用策略网络而不使用任何搜索方法将其击败。 前面提到的 Go 的 AI 程序还依赖于一些领域知识，以便在蒙特卡洛模拟期间选择更好的结果并达到强大的业余水平。 纯粹的蒙特卡洛树搜索（Monte Carlo Carlo Tree Search）不会通过经验模拟来学习，它只是优化位置（游戏状态/节点）。
 
-# AlphaGo 的体系结构和属性
+# AlphaGo 的架构和属性
 
 所有方法都依赖于结合某些领域知识和人工干预的树搜索。 AlphaGo 使用树搜索和两种 CNN（策略和价值网络）来指导树搜索。 这些 CNN 类似于 DeepBlue 中使用的评估功能，但有一个区别，即 CNN 在手工制作 DeepBlue 中使用的评估功能时学习评估功能。
 
@@ -128,17 +128,17 @@ AlphaGo 之前的 Go 的 AI 程序完全依赖于 Monte Carlo Tree Search。 这
 
 因此，价值网络输出直觉（赢和输的机会），而政策网络输出反思（训练游戏知识）。 因此，AlphaGo 中直觉和反射的混合使其比任何基于搜索的方法都强大。 但是在 AlphaGo 中，这些网络可根据所开发的直觉和学习的反射来帮助更快，优化树搜索。
 
-下图是神经网络训练管道和体系结构：
+下图是神经网络训练管道和架构：
 
 ![](img/f77be421-b1a7-498d-9548-eaf8ce014bb0.png)
 
-Silver et。的 Google DeepMind 在 AlphaGo in Nature（https://storage.googleapis.com/deepmind-media/alphago/AlphaGoNaturePaper.pdf）中的出版物中摘录了 AlphaGo 的神经网络训练流水线和体系结构。 等
+Silver et。的 Google DeepMind 在 AlphaGo in Nature（https://storage.googleapis.com/deepmind-media/alphago/AlphaGoNaturePaper.pdf）中的出版物中摘录了 AlphaGo 的神经网络训练流水线和架构。 等
 
 让我们讨论前面详细显示的 AlphaGo 的神经网络架构图：
 
 *  `a`：快速部署策略*ρ<sub class="calibre209">π</sub>* 和监督学习策略网络*ρ<sub class="calibre209">σ</sub>* 受过专家训练 播放包含 3000 万个董事会职位的数据集，以像人类专家一样学习预测动作。 通过学习的监督学习策略网络的权重初始化强化学习策略网络，并通过使用策略梯度来最大化策略质量，从而改进其策略*ρ<sub class="calibre209">ρ</sub>* 政策网络的早期版本。 通过使用此更新的策略网络进行自我播放，将生成一个新的数据集。 数据集包含棋盘位置的图像及其相应的最终结果，即获胜或失败。 最后，使用该自玩数据集通过回归训练值网络*ν<sub class="calibre209">θ</sub>* ，以输出获胜的概率。
 
-*   **b：**该流程的体系结构流程，其中策略网络将棋盘位置（游戏状态）的图像表示作为输入，并通过参数*σ*的卷积层传播（如果它 是一个有监督的学习策略网络）或*ρ*（如果它是强化学习策略网络），并针对所有可能的动作*和*返回概率分布![](img/a20e03f6-d7b8-4a24-9ed4-c0e49948b873.png)或![](img/b319e230-6055-4a7d-97eb-3b94f0b8886e.png) 输出。 价值网络还使用参数*θ*的许多卷积层，返回标量值![](img/e967cc42-4300-4276-8f1b-e362c4705662.png)，该标量值表示在给定位置 *s'中获胜或失败的结果（最终结果）的概率：*
+*   **b：**该流程的架构流程，其中策略网络将棋盘位置（游戏状态）的图像表示作为输入，并通过参数*σ*的卷积层传播（如果它 是一个有监督的学习策略网络）或*ρ*（如果它是强化学习策略网络），并针对所有可能的动作*和*返回概率分布![](img/a20e03f6-d7b8-4a24-9ed4-c0e49948b873.png)或![](img/b319e230-6055-4a7d-97eb-3b94f0b8886e.png) 输出。 价值网络还使用参数`θ`的许多卷积层，返回标量值![](img/e967cc42-4300-4276-8f1b-e362c4705662.png)，该标量值表示在给定位置 *s'中获胜或失败的结果（最终结果）的概率：*
 
 ![](img/8d06defa-4382-48e4-a4c2-2a831bdf246f.png)
 
@@ -179,7 +179,7 @@ AlphaGo 项目背后的目标不是击败最佳的人类围棋选手，而是发
 
 Google DeepMind 已经开始使用 AlphaGo Zero 来了解蛋白质折叠，因为错误折叠的蛋白质会导致许多疾病，例如阿尔茨海默氏病，帕金森氏病，II 型糖尿病和囊性纤维化。 因此，使用基于 Tabras Rasa 的深度强化学习方法，可以了解蛋白质折叠，减少能量消耗，发现新元素或新材料以及更多其他内容。
 
-# AlphaGo Zero 的体系结构和属性
+# AlphaGo Zero 的架构和属性
 
 与先前版本的 AlphaGo 相比有五处变化。 它们如下：
 
@@ -200,7 +200,7 @@ Google DeepMind 已经开始使用 AlphaGo Zero 来了解蛋白质折叠，因
 
 因此，网络输入由 19 x 19 x（1 + 1 + 7 + 7 + 1）= 19 x 19 x 17 张量表示。 使用过去七个动作的特征图的原因在于，这段历史就像一个注意力机制。
 
-为什么我们使用残差架构而不是普通卷积架构？ 其背后的原因是残留的体系结构允许梯度信号直接穿过层。 此外，即使在卷积层没有做任何有用的学习的早期阶段，重要的学习信号也会进入卷积层并直接进入其他层。 详细解释残留体系结构超出了本书的范围。
+为什么我们使用残差架构而不是普通卷积架构？ 其背后的原因是残留的架构允许梯度信号直接穿过层。 此外，即使在卷积层没有做任何有用的学习的早期阶段，重要的学习信号也会进入卷积层并直接进入其他层。 详细解释残留架构超出了本书的范围。
 
 因此，我们采用板的 19 x 19 x 17 张量表示形式的输入，并将其通过残差卷积网络，从而生成特征向量。 该特征向量通过全连接层传递，以进行最终的特征提取，其中包含两件事：
 
@@ -229,6 +229,6 @@ Silver 等人从 Google DeepMind 在自然界中的 AlphaGo Zero（https://www.n
 
 # 概要
 
-在本章中，我们研究了目前最好的强化学习架构，即 AlphaGo。 我们了解了选择围棋的原因及其相对于象棋的复杂性。 我们还了解了 DeepBlue AI 架构的工作原理，以及 Go 需要一种不同的更好的架构和训练过程。 我们研究了 AlphaGo 和 AlphaGo Zero 使用的体系结构和训练过程，还了解了版本之间的差异以及 AlphaGo Zero 如何超越其早期版本。
+在本章中，我们研究了目前最好的强化学习架构，即 AlphaGo。 我们了解了选择围棋的原因及其相对于象棋的复杂性。 我们还了解了 DeepBlue AI 架构的工作原理，以及 Go 需要一种不同的更好的架构和训练过程。 我们研究了 AlphaGo 和 AlphaGo Zero 使用的架构和训练过程，还了解了版本之间的差异以及 AlphaGo Zero 如何超越其早期版本。
 
 在下一章中，我们将研究如何在自动驾驶和自动驾驶汽车中使用和实施强化学习。
\ No newline at end of file

new/rl-tf/09.md

@@ -81,7 +81,7 @@
 ![](img/a439e6b9-b14f-40fb-84e3-2d8ef4bf84ca.png)
 
 *   识别周围环境的组成部分，其中包括人行道，人，交通信号灯，任何建筑，道路边界，其他车辆等。 对于 AI，由于使用**卷积神经网络**（**CNN**）和**生成对抗网络**（**GAN**）。 CNN 和 GAN 的成功可用于自动驾驶环境要素的识别过程。
-*   **预测**环境的未来状态。 识别当前环境状态的环境的当前组成部分很重要，但是将其用作输入并预测未来环境状态对于计划下一步行动也很有必要。 解决此问题的基本方法之一是创建环境图。 此外，我们可以合并深度神经网络，例如循环神经网络的变体，例如**长短时记忆网络**（**LSTM**）或**门控循环单元**（[ **GRU**），以整合和整合过去时间步长以及当前时间步长和预测未来中的数据。 正如我们在第 1 章，*深度学习–体系结构和框架*中讨论的那样，由于长期依赖以及 LSTM 单元如何解决该问题，围绕梯度消失的问题仍然存在 RNN 的情况。 RNN 是集成时间序列数据的最新技术，它在 [DeepTracking](https://arxiv.org/pdf/1602.00991.pdf)中显示了对象跟踪方面的改进。
+*   **预测**环境的未来状态。 识别当前环境状态的环境的当前组成部分很重要，但是将其用作输入并预测未来环境状态对于计划下一步行动也很有必要。 解决此问题的基本方法之一是创建环境图。 此外，我们可以合并深度神经网络，例如循环神经网络的变体，例如**长短时记忆网络**（**LSTM**）或**门控循环单元**（[ **GRU**），以整合和整合过去时间步长以及当前时间步长和预测未来中的数据。 正如我们在第 1 章，*深度学习–架构和框架*中讨论的那样，由于长期依赖以及 LSTM 单元如何解决该问题，围绕梯度消失的问题仍然存在 RNN 的情况。 RNN 是集成时间序列数据的最新技术，它在 [DeepTracking](https://arxiv.org/pdf/1602.00991.pdf)中显示了对象跟踪方面的改进。
 
 *   **规划**是整个过程中最难的部分。 该任务包括将识别和预测的结果集成在一起，以计划将来的动作序列以及下一个驾驶动作集（向左或向右转向，加速等等），以使导航安全且成功。 这是一项艰巨的任务，因为整合和规划需要处理不可避免的情况才能安全到达目的地。 强化学习最适合此类控制计划任务。 我们已经了解了如何成功地部署强化学习来控制 50 场 Atari 游戏中的计划任务，以及 Google DeepMind 提供的最先进的 AlphaGo Zero。 在这些情况下，我们目睹了深度学习在进行表示学习的同时进行强化学习的规划。
 
@@ -107,17 +107,17 @@
 
 在本节中，我们将讨论 El Sallab 等人（2017）给出的[提出的用于自动驾驶的深度强化学习框架](https://arxiv.org/pdf/1704.02532.pdf)。
 
-以下是端到端深度神经网络的体系结构：
+以下是端到端深度神经网络的架构：
 
 ![](img/c0d1b6ca-7308-4b36-b494-851bef3b4473.png)
 
 [El Sallab 等人（2017）对自动驾驶深度神经网络进行端到端训练](https://arxiv.org/pdf/1704.02532.pdf)。
 
-让我们详细讨论前面的体系结构。 在这种情况下，输入是多个时间步长上环境状态的汇总。
+让我们详细讨论前面的架构。 在这种情况下，输入是多个时间步长上环境状态的汇总。
 
 # 空间聚集
 
-该体系结构的第一个单元是空间聚合网络。 它由两个网络组成，每个网络都用于以下子过程：
+该架构的第一个单元是空间聚合网络。 它由两个网络组成，每个网络都用于以下子过程：
 
 *   传感器融合
 *   空间特征

new/rl-tf/11.md

@@ -10,7 +10,7 @@
 
 在**离散动作空间**（**DAS**）算法下，将处理离散动作空间域的算法归为一组。 诸如策略梯度之类的其他方法通过将状态空间作为输入来直接将状态空间与动作空间连接，并返回最佳策略作为输出，即采取的可行动作。 与基于值的方法（例如 Q 学习）相比，基于策略的方法的优势在于，它们解决了连续操作空间的处理问题，因为对于给定的状态输入，输出策略是跨不同可能操作的随机分布。
 
-诸如处理连续动作空间域的策略梯度之类的算法归为**连续动作空间**（**CAS**）算法。 因此，在行动空间上提供随机表示的基于策略的方法解决了该问题，而不是 DAS 算法中的离散化。 CAS 算法最初是开发并用于低维状态空间，后来使用基于 CNN 的体系结构扩展到高维状态空间。 CAS 算法分为两个子类别：**随机连续动作空间**（**SCAS**）和**确定性连续动作空间**（**DCAS**）算法。 它们之间的主要区别在于复杂性，因为 SCAS 算法提供了更好的覆盖范围，因此需要大量的训练样本来学习更好的策略。 在现实世界的机器人应用中获取大量训练样本是非常不可行的，因此，仿真必须以尽可能最佳的方式表示现实世界，否则生成现实世界的数据将非常昂贵。
+诸如处理连续动作空间域的策略梯度之类的算法归为**连续动作空间**（**CAS**）算法。 因此，在行动空间上提供随机表示的基于策略的方法解决了该问题，而不是 DAS 算法中的离散化。 CAS 算法最初是开发并用于低维状态空间，后来使用基于 CNN 的架构扩展到高维状态空间。 CAS 算法分为两个子类别：**随机连续动作空间**（**SCAS**）和**确定性连续动作空间**（**DCAS**）算法。 它们之间的主要区别在于复杂性，因为 SCAS 算法提供了更好的覆盖范围，因此需要大量的训练样本来学习更好的策略。 在现实世界的机器人应用中获取大量训练样本是非常不可行的，因此，仿真必须以尽可能最佳的方式表示现实世界，否则生成现实世界的数据将非常昂贵。
 
 确定性策略梯度的发现超过了随机策略算法，如 [Silver 等人](http://proceedings.mlr.press/v32/silver14.pdf)所述，该技术已包含在[附录 A](../Text/15.html) 中， *强化学习*中的其他主题。 在本章中，我们将介绍机器人强化学习背后的挑战以及当前如何实施机器人强化学习。