2021-01-21 23:35:32

new/dl-pt-workshop/0.md

@@ -6,7 +6,7 @@
 
 毫不奇怪，由于自动驾驶汽车，聊天机器人和声控助手等智能应用使深度学习在过去几年中迅速普及，这使我们的生活更加轻松。 本书将带您进入深度学习领域，在这里您将使用 PyTorch 来了解神经网络架构的复杂性。
 
-《PyTorch 深度学习研讨会》首先介绍了深度学习及其应用。 您将探索 PyTorch 的语法，并学习如何定义网络架构和训练模型。 接下来，您将学习三种主要的神经网络架构-卷积，人工和循环-甚至使用这些网络解决实际数据问题。 后面的章节将向您展示如何创建样式转换模型以从两个图像中开发一个新图像，最后再带您了解 RNN 如何存储内存以解决关键数据问题。
+《PyTorch 深度学习研讨会》首先介绍了深度学习及其应用。 您将探索 PyTorch 的语法，并学习如何定义网络架构和训练模型。 接下来，您将学习三种主要的神经网络架构-卷积，人工和循环-甚至使用这些网络解决实际数据问题。 后面的章节将向您展示如何创建样式迁移模型以从两个图像中开发一个新图像，最后再带您了解 RNN 如何存储内存以解决关键数据问题。
 
 到本书结尾，您将掌握 PyTorch 的基本概念，工具和库，以开发自己的深度神经网络和智能应用。
 

new/dl-pt-workshop/1.md

@@ -497,7 +497,7 @@ for i in range(100):
     15 0.20741790533065796
     ```
 
-    前面的输出显示纪元号以及损失函数的值，可以看出，该函数正在减小。 这意味着训练过程使损失函数最小化，这意味着模型能够理解输入特征和目标之间的关系。
+    前面的输出显示周期号以及损失函数的值，可以看出，该函数正在减小。 这意味着训练过程使损失函数最小化，这意味着模型能够理解输入特征和目标之间的关系。
 
 5.  绘制线图以显示每个时期的损失函数的值：
 
@@ -532,12 +532,12 @@ for i in range(100):
 
 用于此活动的数据集来自 UC Irvine 机器学习存储库，[该存储库可使用以下 URL 从**数据文件夹**超链接中下载](https://archive.ics.uci.edu/ml/datasets/Somerville+Happiness+Survey)。 [也可以在本书的 GitHub 存储库中找到它](https://packt.live/38gzpr5)。
 
-1.  导入所需的库，包括用于读取 CSV 文件的熊猫。
+1.  导入所需的库，包括用于读取 CSV 文件的Pandas。
 2.  读取包含数据集的 CSV 文件。
 
     注意
 
-    建议使用熊猫的`read_csv`函数加载 CSV 文件。 要了解有关此功能的更多信息，请访问[这里](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html)。
+    建议使用Pandas的`read_csv`函数加载 CSV 文件。 要了解有关此功能的更多信息，请访问[这里](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html)。
 
 3.  将输入特征与目标分开。 请注意，目标位于 CSV 文件的第一列中。 接下来，将值转换为张量，确保将值转换为浮点数。
 

new/dl-pt-workshop/2.md

@@ -58,8 +58,8 @@ Rosenblatt 还介绍了权重的概念（`w1`，`w2`，...，`wn`），这些数
 
 下个星期五在您的镇上有一个音乐节，但是您生病了，想决定是否要去（0 表示您不参加，1 表示您要参加）。 您的决定取决于三个因素：
 
-*   会好天气吗？ （`X1`）
-*   你要和谁一起去吗？ （`X2`）
+*   天气会好吗？ （`X1`）
+*   你要和谁一起去？ （`X2`）
 *   音乐是您喜欢的吗？ （`X3`）
 
 对于前面的因素，如果问题的答案为是，则将使用 1，如果答案为否，则将使用 0。 此外，由于您病得很重，因此与天气相关的因素非常重要，因此您决定赋予该因素比其他两个因素大两倍的权重。 因此，您决定因素的权重将为 4（`w1`），2（`w2`）和 2（`w3`）。 现在，考虑阈值 5：
@@ -386,7 +386,7 @@ RNN 允许以输入序列，输出序列或什至同时以两种形式处理数
 数据准备过程可以分为三个主要任务：
 
 1.  了解数据并处理任何潜在问题
-2.  重新缩放功能，以确保不会因错误引入偏见
+2.  重新缩放特征，以确保不会因错误引入偏差
 3.  拆分数据以能够准确地衡量性能
 
 所有这三个任务将在下一节中进一步说明。
@@ -437,7 +437,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
     import pandas as pd
     ```
 
-3.  使用熊猫读取 CSV 文件，其中包含我们从 UC Irvine 机器学习存储库站点下载的数据集。
+3.  使用Pandas读取 CSV 文件，其中包含我们从 UC Irvine 机器学习存储库站点下载的数据集。
 
     接下来，删除名为`date`的列，因为我们不想在以下练习中考虑它：
 
@@ -631,7 +631,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
     Y_shuffle = Y.sample(frac=1, random_state=0)
     ```
 
-    使用熊猫`sample`函数，可以对特征和目标矩阵中的元素进行混洗。 通过将`frac`设置为 1，我们确保所有实例都经过改组并在函数的输出中返回。 使用`random_state`参数，我们确保两个数据集均被混洗。
+    使用Pandas`sample`函数，可以对特征和目标矩阵中的元素进行混洗。 通过将`frac`设置为 1，我们确保所有实例都经过改组并在函数的输出中返回。 使用`random_state`参数，我们确保两个数据集均被混洗。
 
 4.  使用索引将经过改组的数据集分为要素和目标数据这三组：
 
@@ -747,9 +747,9 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
 [也可以在本书的 GitHub 存储库中找到它](https://packt.live/38kZzZR)
 
 1.  导入所需的库。
-2.  使用熊猫，加载`.csv`文件。
+2.  使用Pandas，加载`.csv`文件。
 3.  验证数据集中是否存在任何定性数据。
-4.  检查缺少的值。
+4.  检查缺失值。
 
     您还可以添加一个附加的`sum()`函数，以获取整个数据集中的缺失值之和，而无需按列进行区分。
 

new/dl-pt-workshop/3.md

@@ -110,7 +110,7 @@
 
 但是，在开始训练模型之前，必须处理一些关键方面。 您已经从上一章中了解了其中的大多数内容，这些内容将应用于当前数据集，并在目标特征中添加了类不平衡的修订：
 
-*   **看看数据**：使用熊猫读取数据集后，打印数据集的标题。 这有助于确保已加载正确的数据集。 此外，它还提供了准备后转换数据集的证据。
+*   **看看数据**：使用Pandas读取数据集后，打印数据集的标题。 这有助于确保已加载正确的数据集。 此外，它还提供了准备后转换数据集的证据。
 
     注意
 
@@ -456,13 +456,13 @@ batch_size = 100
 
 请记住，**时期**是指整个数据集通过网络架构前后传递的次数。`batch_size`是指单个批量（数据集的一部分）中训练示例的数量。 最后，**迭代**是指完成一个时期所需的批量数量。
 
-第二个`for`循环遍历总数据集的每个批量，直到完成一个纪元为止。 在此循环中，发生以下计算：
+第二个`for`循环遍历总数据集的每个批量，直到完成一个周期为止。 在此循环中，发生以下计算：
 
 1.  在一批训练集上训练模型。 在此获得预测。
 2.  通过比较上一步的预测值和训练集的标签（真实情况）来计算损失。
 3.  将梯度设置为零并针对当前步骤再次计算。
 4.  网络的参数基于梯度进行更新。
-5.  该模型对训练数据的准确性计算如下：
+5.  该模型对训练数据的准确率计算如下：
 
     获取模型预测的指数，以便获得属于每个类标签的给定数据片段的概率。
 
@@ -474,7 +474,7 @@ batch_size = 100
 
 1.  该模型对验证集中的数据执行预测。
 2.  通过将先前的预测与验证集中的标签进行比较来计算损失函数。
-3.  准确性是根据验证集计算得出的。 要在验证集上计算模型的准确性，请使用对训练数据进行相同计算所用的同一组步骤：
+3.  准确率是根据验证集计算得出的。 要在验证集上计算模型的准确率，请使用对训练数据进行相同计算所用的同一组步骤：
 
     注意
 
@@ -552,12 +552,12 @@ batch_size = 100
     即使使用种子，考虑到训练集在每个时期之前都经过了改组，该活动的确切结果也无法重现。
 
 2.  读取先前准备的数据集，该数据集应已命名为`dccc_prepared.csv`。
-3.  将功能与目标分开。
+3.  将特征与目标分开。
 4.  使用 scikit-learn 的`train_test_split`函数，将数据集分为训练，验证和测试集。 使用 60:20:20 的分配比例。 将`random_state`设置为`0`。
 5.  考虑到要素矩阵应为浮点型，而目标矩阵则应为非浮点型，将验证和测试集转换为张量。 目前暂时不要转换训练集，因为它们将进行进一步的转换。
 6.  构建用于定义网络层的自定义模块类。 包括一个前向功能，该功能指定将应用于每层输出的激活函数。 对于除输出之外的所有层，请使用 **ReLU**，在此处应使用`log_softmax`。
 7.  实例化模型并定义训练模型所需的所有变量。 将时期数设置为`50`，并将批大小设置为`128`。 使用`0.001`的学习率。
-8.  使用训练集的数据训练网络。 使用验证集来衡量性能。 为此，请保存每个时期中训练集和验证集的损失和准确性。
+8.  使用训练集的数据训练网络。 使用验证集来衡量性能。 为此，请保存每个时期中训练集和验证集的损失和准确率。
 
     注意
 
@@ -656,7 +656,7 @@ batch_size = 100
 
     据此，该模型存在高偏差，这意味着该模型不适合。
 
-2.  确定提高模型准确性所需的操作。
+2.  确定提高模型准确率所需的操作。
 
     为了提高模型的性能，可以遵循的两个操作过程是增加时期数并增加隐藏层数和/或单元数（每层中的神经元）。
 

new/dl-pt-workshop/4.md

@@ -56,7 +56,7 @@ CNN 能够捕获图像的空间相关性，因为它根据滤镜的大小将它
 
 与文本数据相比，馈入 CNN 的图像不需要太多预处理。 图像通常按原样提供，最常见的更改如下：
 
-*   标准化像素值以加快学习过程并提高性能
+*   标准化像素值来加快学习过程并提高性能
 *   缩小图像（即减小其宽度和长度）以加快学习过程
 
 归一化输入的最简单方法是取每个像素的值并将其除以 255，这样我们最终得到的值介于 0 到 1 之间。但是，使用了不同的方法来归一化图像，例如均值中心技术 。 在大多数情况下，选择一个或另一个的决定是一个优先事项。 但是，在使用预训练模型时，强烈建议您使用与第一次训练模型相同的技术。 该信息通常在预训练模型的文档中可用。
@@ -567,7 +567,7 @@ test_loader = torch.utils.data.DataLoader(test_data, \
 
     Linear2：一个全连接层，可生成 10 个输出，每个类标签一个。 将`log_softmax`激活函数用于输出层。
 
-7.  定义训练模型所需的所有参数。 将纪元数设置为 50。
+7.  定义训练模型所需的所有参数。 将周期数设置为 50。
 8.  训练您的网络，并确保保存训练和验证集的损失和准确率值。
 9.  绘制两组的损失和准确率。
 0.  在测试集上检查模型的准确度--它应该在 72% 左右。
@@ -674,7 +674,7 @@ test_data = datasets.CIFAR10('data', train=False, download=True, \
 
     对于测试集，请勿添加任何其他转换。
 
-3.  训练模型 100 个纪元。由此得到的训练集和验证集的损失和准确度图应与这里所示的相似。
+3.  训练模型 100 个周期。由此得到的训练集和验证集的损失和准确度图应与这里所示的相似。
 
     ![Figure 4.18: Resulting plot showing the loss of the sets ](img/B15778_04_18.jpg)
 
@@ -760,7 +760,7 @@ class CNN(nn.Module):
 
 1.  复制上一个活动中的笔记本。
 2.  将批量归一化添加到每个卷积层以及第一个 FC 层。
-3.  训练模型 100 个纪元。由此得到的训练集和验证集的损失和准确度图应该与这里的图相似。
+3.  训练模型 100 个周期。由此得到的训练集和验证集的损失和准确度图应该与这里的图相似。
 
     ![Figure 4.21: Resulting plot showing the loss of the sets ](img/B15778_04_21.jpg)
 

new/dl-pt-workshop/5.md

@@ -2,7 +2,7 @@
 
 总览
 
-本章介绍了使用预训练的模型来创建或利用性能良好的算法而不必收集大量数据的过程。 在本章中，您将学习如何从 PyTorch 加载预训练的模型以创建样式转换模型。 到本章末，您将能够通过使用预训练的模型来执行样式转换。
+本章介绍了使用预训练的模型来创建或利用性能良好的算法而不必收集大量数据的过程。 在本章中，您将学习如何从 PyTorch 加载预训练的模型以创建样式迁移模型。 到本章末，您将能够通过使用预训练的模型来执行样式迁移。
 
 # 简介
 
@@ -10,7 +10,7 @@
 
 这些架构的配置和学习任务各不相同。 如今，由牛津机器人学院的 Karen Simonyan 和 Andrew Zisserman 创建的**视觉几何组**（**VGG**）架构是一种非常流行的方法。 它是为对象识别而开发的，并由于网络所依赖的大量参数而达到了最先进的性能。 它在数据科学家中受欢迎的主要原因之一是训练后的模型的参数（权重和偏差）的可用性，这使研究人员无需训练即可使用它，并且模型具有出色的性能。
 
-在本章中，我们将使用这种经过预训练的模型来解决计算机视觉问题，该问题由于专门用于共享图像的社交媒体渠道的普及而特别著名。 它包括执行样式转换，以便使用一个图像的样式（颜色和纹理）以及另一个图像的内容（形状和对象）创建新图像。
+在本章中，我们将使用这种经过预训练的模型来解决计算机视觉问题，该问题由于专门用于共享图像的社交媒体渠道的普及而特别著名。 它包括执行样式迁移，以便使用一个图像的样式（颜色和纹理）以及另一个图像的内容（形状和对象）创建新图像。
 
 每天对常规图像应用滤镜以提高其质量和吸引力，同时在社交媒体个人资料上发布时，每天执行数百万次此任务。 尽管这看起来很简单，但本章将解释这些图像编辑应用幕后发生的魔术。
 
@@ -20,11 +20,11 @@
 
 # 样式迁移
 
-简而言之，样式迁移包括修改图像的样式，同时又保留其内容。 一个示例是拍摄动物的图像，然后将样式转换为类似莫奈的绘画，如下图所示：
+简而言之，样式迁移包括修改图像的样式，同时又保留其内容。 一个示例是拍摄动物的图像，然后将样式迁移为类似莫奈的绘画，如下图所示：
 
 ![Figure 5.1: Style transfer inputs and output – the result of the final exercise of this chapter ](img/B15778_05_01.jpg)
 
-图 5.1：样式转换输入和输出–本章最后练习的结果
+图 5.1：样式迁移输入和输出–本章最后练习的结果
 
 注意
 
@@ -34,18 +34,18 @@
 
 ## 它如何工作？
 
-与解决上一章中说明的传统计算机视觉问题相反，样式转换需要一组不同的步骤才能有效地将两个图像作为输入并创建一个新图像作为输出。
+与解决上一章中说明的传统计算机视觉问题相反，样式迁移需要一组不同的步骤才能有效地将两个图像作为输入并创建一个新图像作为输出。
 
-以下是解决样式转换问题时要遵循的步骤的简要说明：
+以下是解决样式迁移问题时要遵循的步骤的简要说明：
 
 1.  **馈入输入**：内容和样式图像都将馈入模型，并且它们必须具有相同的形状。 这里的常见做法是调整样式图像的大小，以使其与内容图像具有相同的形状。
-2.  **加载模型**：牛津大学的 VGG 创建了一个模型架构，该模型在样式转换问题上表现出色，被称为 VGG 网络。 他们还将模型的参数提供给任何人，以便可以缩短或跳过模型的训练过程（这就是预训练模型的目的）。
+2.  **加载模型**：牛津大学的 VGG 创建了一个模型架构，该模型在样式迁移问题上表现出色，被称为 VGG 网络。 他们还将模型的参数提供给任何人，以便可以缩短或跳过模型的训练过程（这就是预训练模型的目的）。
 
     注意
 
     VGG 网络有不同的版本，并且都使用不同数量的层。 为了区分不同的版本，术语是这样的，即首字母缩写处的破折号和数字代表该特定架构的层数。 在本章中，我们将使用网络的 19 层版本，即 VGG-19。
 
-    因此，可以使用 PyTorch 的**模型**子包加载预训练的模型，以执行样式转换任务，而无需训练大量图像的网络。
+    因此，可以使用 PyTorch 的**模型**子包加载预训练的模型，以执行样式迁移任务，而无需训练大量图像的网络。
 
 3.  **确定层的功能**：鉴于手头有两项主要任务（识别图像的内容并区分另一幅图像的样式），不同的层将具有不同的功能来提取不同的特征。 对于样式图像，重点应该放在颜色和纹理上，对于内容图像，重点应该放在边缘和形状上。 在此步骤中，将不同的层分为不同的任务。
 4.  **定义优化问题**：与其他任何监督问题一样，有必要定义一个损失函数，该函数将负责测量输出和输入之间的差异。 与其他受监督的问题不同，样式迁移的任务要求您定义三个不同的损失函数，在训练过程中应将所有这些损失最小化。 这里介绍了三种损失函数：
@@ -68,7 +68,7 @@ VGG-19 是由 19 层组成的 CNN。 它使用 ImageNet 数据库中的数百万
 
 考虑到其深度，该网络能够从各种图像中识别出复杂的特征，这使其特别适用于样式迁移问题，在这些问题中，特征提取对于不同阶段和不同目的至关重要。
 
-本节将重点介绍如何使用预训练的 VGG-19 模型执行样式转换。 本章的最终目标将是拍摄动物或风景的图像（作为内容图像）以及来自知名艺术家的一幅画（作为样式图像）以创建常规对象的新图像。 具有艺术风格。
+本节将重点介绍如何使用预训练的 VGG-19 模型执行样式迁移。 本章的最终目标将是拍摄动物或风景的图像（作为内容图像）以及来自知名艺术家的一幅画（作为样式图像）以创建常规对象的新图像。 具有艺术风格。
 
 但是，在进行此过程之前，以下是导入的列表以及其使用的简要说明：
 
@@ -94,7 +94,7 @@ VGG-19 是由 19 层组成的 CNN。 它使用 ImageNet 数据库中的数百万
 
 ## 输入–加载和显示
 
-执行样式转换的第一步包括加载内容和样式图像。 在此步骤中，将处理基本的预处理，其中图像必须具有相同的大小（最好是用于训练预训练模型的图像的大小），该大小也将等于输出图像的大小。 此外，图像会转换为 PyTorch 张量，并且可以根据需要进行归一化。
+执行样式迁移的第一步包括加载内容和样式图像。 在此步骤中，将处理基本的预处理，其中图像必须具有相同的大小（最好是用于训练预训练模型的图像的大小），该大小也将等于输出图像的大小。 此外，图像会转换为 PyTorch 张量，并且可以根据需要进行归一化。
 
 最好始终显示已加载的图像，以确保它们符合要求。 考虑到此时图像已被转换为张量并进行了规范化，应该克隆张量，并且需要执行一组新的转换，以便我们可以使用 Matplotlib 显示它们。 这意味着张量应转换回 **Python 图像库**（**PIL**）图像，并且必须还原规范化过程，如以下示例所示：
 
@@ -115,11 +115,11 @@ transforms.Compose([transforms.Normalize((-0.5/0.25, \
 
 注意
 
-本章的所有练习都应在同一笔记本中进行编码，合并后的代码将一起执行样式转换任务。
+本章的所有练习都应在同一笔记本中进行编码，合并后的代码将一起执行样式迁移任务。
 
 ## 练习 5.01：加载和显示图像
 
-这是执行样式转换的四个步骤中的第一步。 本练习的目的是加载并显示将在以后的练习中使用的图像（内容和样式图像）。 请按照以下步骤完成此练习：
+这是执行样式迁移的四个步骤中的第一步。 本练习的目的是加载并显示将在以后的练习中使用的图像（内容和样式图像）。 请按照以下步骤完成此练习：
 
 注意
 
@@ -127,7 +127,7 @@ transforms.Compose([transforms.Normalize((-0.5/0.25, \
 
 在本书的 [GitHub 存储库](https://packt.live/2yiR97z)中，您将能够找到在本章中用于不同练习和活动的不同图像。
 
-1.  导入执行样式转换所需的所有软件包：
+1.  导入执行样式迁移所需的所有软件包：
 
     ```py
     import numpy as np
@@ -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`：这是指位于网络末端的线性层（也称为完全连接层），包括其参数。 这些层是将图像分类为标签类别之一的层，例如，识别图像中的动物类型。
@@ -283,7 +283,7 @@ for param in model.parameters():
 
 ## 练习 5.02：在 PyTorch 中加载预先训练的模型
 
-使用与上一练习相同的笔记本，本练习旨在加载预先训练的模型，该模型将在后续练习中使用我们先前加载的图像执行样式转换任务。
+使用与上一练习相同的笔记本，本练习旨在加载预先训练的模型，该模型将在后续练习中使用我们先前加载的图像执行样式迁移任务。
 
 1.  打开上一个练习中的笔记本。
 2.  从 PyTorch 加载 VGG-19 预训练模型：
@@ -367,7 +367,7 @@ for index, layer in model._modules.items():
 使用上一练习的网络架构和本章第一练习的图像，我们将创建几个函数，这些函数能够从输入图像中提取特征并为样式特征创建语法矩阵。
 
 1.  打开上一个练习中的笔记本。
-2.  打印我们在上一个练习中加载的模型的体系结构。 这将帮助我们识别相关层，以便我们可以执行样式转换任务：
+2.  打印我们在上一个练习中加载的模型的体系结构。 这将帮助我们识别相关层，以便我们可以执行样式迁移任务：
 
     ```py
     print(model)
@@ -457,11 +457,11 @@ style_features = features_extractor(style_img, model, \
 
 要访问此源代码的 GPU 版本，请参考[这里](https://packt.live/3ePLxlA)。 此版本的源代码无法作为在线交互示例使用，需要通过 GPU 设置在本地运行。
 
-这样，您就成功完成了特征提取并计算了语法矩阵来执行样式转换。
+这样，您就成功完成了特征提取并计算了语法矩阵来执行样式迁移。
 
 ## 优化算法，损失和参数更新
 
-尽管使用参数不变的预训练网络执行样式转换，但是创建目标图像包含一个迭代过程，在此过程中，通过仅更新与目标图像有关的参数来计算并最小化三个不同的损失函数。
+尽管使用参数不变的预训练网络执行样式迁移，但是创建目标图像包含一个迭代过程，在此过程中，通过仅更新与目标图像有关的参数来计算并最小化三个不同的损失函数。
 
 为了实现目标图像的创建，需要计算两个不同的损失函数（内容损失和样式损失），然后将它们放在一起以计算总损失函数，该函数将被优化以得到合适的目标图像。 但是，考虑到在内容和样式方面实现的测量精度差异很大，下面是对内容和样式损失函数的计算的说明，以及如何计算总损失的说明。
 
@@ -522,7 +522,7 @@ style_features = features_extractor(style_img, model, \
 
 ## 练习 5.04：创建目标图像
 
-在本章的最后练习中，您将执行样式转换的任务。 该练习包括对负责执行不同迭代的部分进行编码，同时优化损失函数，以便获得理想的目标图像。 为此，至关重要的是利用我们在本章前面的练习中编程的代码位：
+在本章的最后练习中，您将执行样式迁移的任务。 该练习包括对负责执行不同迭代的部分进行编码，同时优化损失函数，以便获得理想的目标图像。 为此，至关重要的是利用我们在本章前面的练习中编程的代码位：
 
 注意
 
@@ -619,7 +619,7 @@ style_features = features_extractor(style_img, model, \
 
 [要查看高质量的彩色图像，请访问本书的 GitHub 存储库](https://packt.live/2VBZA5E)。
 
-这样，您就成功地执行了样式转换。
+这样，您就成功地执行了样式迁移。
 
 注意
 
@@ -631,9 +631,9 @@ style_features = features_extractor(style_img, model, \
 
 ## 练习 5.01：执行样式迁移
 
-在此活动中，我们将进行样式转换。 为此，我们将编写本章所学的所有概念。 让我们看一下以下情况。
+在此活动中，我们将进行样式迁移。 为此，我们将编写本章所学的所有概念。 让我们看一下以下情况。
 
-您需要更改一些图像，以使其具有艺术气息，为实现此目的，您决定创建一些代码，该代码使用预先训练的神经网络执行样式转换。 请按照以下步骤完成此活动：
+您需要更改一些图像，以使其具有艺术气息，为实现此目的，您决定创建一些代码，该代码使用预先训练的神经网络执行样式迁移。 请按照以下步骤完成此活动：
 
 1.  导入所需的库。
 2.  指定要对输入图像执行的转换。 确保将它们调整为相同的大小，将它们转换为张量，然后对其进行规范化。
@@ -668,15 +668,15 @@ style_features = features_extractor(style_img, model, \
 
 # 总结
 
-本章介绍了样式转换，这是当今很流行的任务，可以使用 CNN 来执行。 它包括同时获取内容图像和样式图像作为输入，并返回新创建的图像作为输出，以保留其中一个图像的内容和另一个图像的样式。 它通常用于通过将随机的常规图像与伟大艺术家的绘画相结合来赋予图像艺术外观。
+本章介绍了样式迁移，这是当今很流行的任务，可以使用 CNN 来执行。 它包括同时获取内容图像和样式图像作为输入，并返回新创建的图像作为输出，以保留其中一个图像的内容和另一个图像的样式。 它通常用于通过将随机的常规图像与伟大艺术家的绘画相结合来赋予图像艺术外观。
 
-尽管使用 CNN 进行样式转换，但是按常规训练网络并不能实现创建目标图像的过程。 本章介绍了如何使用经过预训练的网络来考虑一些相关层的输出，这些层尤其擅长识别某些功能。
+尽管使用 CNN 进行样式迁移，但是按常规训练网络并不能实现创建目标图像的过程。 本章介绍了如何使用经过预训练的网络来考虑一些相关层的输出，这些层尤其擅长识别某些功能。
 
-本章介绍了开发能够执行样式转换任务的代码所需的每个步骤，其中第一步包括加载和显示输入。 正如我们前面提到的，模型有两个输入（内容和样式图像）。 每个图像都将经历一系列转换，目的是将图像调整为相等大小，将它们转换为张量，并对它们进行规范化，以使它们可以被网络正确处理。
+本章介绍了开发能够执行样式迁移任务的代码所需的每个步骤，其中第一步包括加载和显示输入。 正如我们前面提到的，模型有两个输入（内容和样式图像）。 每个图像都将经历一系列转换，目的是将图像调整为相等大小，将它们转换为张量，并对它们进行规范化，以使它们可以被网络正确处理。
 
 接下来，加载预训练的模型。 如本章所述，VGG-19 是解决此类任务的最常用架构之一。 它由 19 个层组成，包括卷积层，池化层和全连接层，其中对于所讨论的任务，仅使用某些卷积层。 考虑到 PyTorch 提供了一个包含多个预训练网络架构的子包，加载预训练模型的过程非常简单。
 
-一旦加载了网络，在检测某些对于样式转换至关重要的功能时，网络的某些层将被识别为性能卓越的提供商。 尽管五个不同的层都具有提取与图像样式相关的特征（例如颜色和纹理）的能力，但是只有一层可以非常出色地提取内容特征（例如边缘和形状）。 因此，至关重要的是定义将用于从输入图像中提取信息以创建所需目标图像的那些层。
+一旦加载了网络，在检测某些对于样式迁移至关重要的功能时，网络的某些层将被识别为性能卓越的提供商。 尽管五个不同的层都具有提取与图像样式相关的特征（例如颜色和纹理）的能力，但是只有一层可以非常出色地提取内容特征（例如边缘和形状）。 因此，至关重要的是定义将用于从输入图像中提取信息以创建所需目标图像的那些层。
 
 最后，是时候对该迭代过程进行编码了，以用于创建具有所需功能的目标图像。 为此，计算了三种不同的损失。 有一个用于比较内容图像和目标图像之间的内容差异（内容损失），另一个用于比较样式图像和目标图像之间的风格差异（样式损失）， 通过计算克矩阵实现。 最后，有一个结合了内容损失和样式损失（总损失）。
 

new/dl-pt-workshop/6.md

@@ -269,10 +269,10 @@ for i in range(1, epochs+1):
 
 5.  创建一个包含网络架构的类； 请注意，全连接层的输出大小应为 1。
 6.  实例化包含模型的类函数。 输入输入大小，每个循环层中的神经元数（10）和循环层数（1）。
-7.  定义损失函数，优化算法和训练网络的时期数。 为此，请使用均方误差损失函数，Adam 优化器和 10,000 个纪元。
+7.  定义损失函数，优化算法和训练网络的时期数。 为此，请使用均方误差损失函数，Adam 优化器和 10,000 个周期。
 8.  使用`for`循环通过遍历所有时期来执行训练过程。 在每个时期，都必须进行预测，以及随后的损失函数计算和网络参数优化。 然后，保存每个时期的损失。
 9.  绘制所有时期的损失。
-0.  使用散点图，显示在训练过程的最后一个纪元中获得的预测值与地面真实值（即上周的销售交易）的对比。
+0.  使用散点图，显示在训练过程的最后一个周期中获得的预测值与地面真实值（即上周的销售交易）的对比。
 
     注意
 
@@ -688,11 +688,11 @@ while starter[-1] != "." and counter < 50:
 6.  创建一个定义网络架构的类。 该类应包含一个用于初始化 LSTM 层状态的附加函数。
 7.  请确定要从数据集中创建的批量数量，请记住每个批量应包含 100 个序列，每个批量的长度应为 50。接下来，将编码数据拆分为 100 个序列。
 8.  使用 256 作为隐藏单位数（总共两个循环层）实例化模型。
-9.  定义损失函数和优化算法。使用 Adam 优化器和交叉熵损失。训练网络 20 个纪元。
+9.  定义损失函数和优化算法。使用 Adam 优化器和交叉熵损失。训练网络 20 个周期。
 
     注意
 
-    根据您的资源，训练过程将花费很长时间，这就是为什么建议仅运行 20 个纪元的原因。 但是，本书的 GitHub 存储库中提供了可以在 GPU 上运行的代码的等效版本。 这将使您运行更多的时代并获得出色的性能。
+    根据您的资源，训练过程将花费很长时间，这就是为什么建议仅运行 20 个周期的原因。 但是，本书的 GitHub 存储库中提供了可以在 GPU 上运行的代码的等效版本。 这将使您运行更多的时代并获得出色的性能。
 
 0.  在每一个时代，数据必须被划分为 50 个序列长度的批次。这意味着每个时代将有 100 个序列，每个序列的长度为 50。
 
@@ -709,7 +709,7 @@ while starter[-1] != "." and counter < 50:
 
 最后一句话会有所不同，因为在选择每个字符时会有一个随机因素。 但是，它应该看起来像这样：
 
-`So she was considering in her own mind us on," said she whad se the sire.`前面的句子没有意义，因为网络没有经过足够的时间训练（损失函数可能仍然是 最小化），并且可以一次选择每个字符，而无需长期存储以前创建的单词（尽管如此），我们可以看到，仅 20 个纪元后，网络就已经能够形成一些有意义的单词。
+`So she was considering in her own mind us on," said she whad se the sire.`前面的句子没有意义，因为网络没有经过足够的时间训练（损失函数可能仍然是 最小化），并且可以一次选择每个字符，而无需长期存储以前创建的单词（尽管如此），我们可以看到，仅 20 个周期后，网络就已经能够形成一些有意义的单词。
 
 # 自然语言处理
 
@@ -837,7 +837,7 @@ class LSTM(nn.Module):
 7.  使用 3 个 LSTM 层的 64 个嵌入尺寸和 128 个神经元实例化模型。
 8.  定义损失函数，优化算法以及要训练的时期数。 例如，您可以将二进制交叉熵损失用作损失函数，Adam 优化器，并训练 10 个历元。
 9.  创建一个`for`循环，该循环将经历不同的时期并分别经历每个审核。 对于每次审核，都要进行预测，计算损失函数并更新网络参数。 此外，根据该训练数据计算网络的准确率。
-0.  随时间绘制损失的进度和准确率。
+0.  随时间绘制损失和准确率。
 
 最终的精度图将如下所示：
 

new/dl-pt-workshop/7.md

@@ -161,7 +161,7 @@
     Y = data.iloc[:, 0]
     ```
 
-7.  使用标准化方法对特征数据进行重新标定。
+7.  使用标准化方法对特征数据进行重新缩放。
 
     ```py
     X = (X - X.mean())/X.std()
@@ -386,7 +386,7 @@
             return out
     ```
 
-7.  实例化模型并定义训练模型所需的所有变量。设置纪元数为`50`，批次大小为`128`。使用`0.001`的学习率。
+7.  实例化模型并定义训练模型所需的所有变量。设置周期数为`50`，批次大小为`128`。使用`0.001`的学习率。
 
     ```py
     model = Classifier(X_train.shape[1])
@@ -396,7 +396,7 @@
     batch_size = 128
     ```
 
-8.  使用训练集的数据来训练网络。使用验证集来衡量性能。要做到这一点，请保存每个时代的训练集和验证集的损失和准确性。
+8.  使用训练集的数据来训练网络。使用验证集来衡量性能。要做到这一点，请保存每个时代的训练集和验证集的损失和准确率。
 
     ```py
     train_losses, dev_losses, \
@@ -518,7 +518,7 @@
     y_test_torch = torch.tensor(y_test.values)
     ```
 
-3.  考虑到该模型存在较高的偏差，重点应放在增加纪元的数量上，或通过在每层中增加额外的层或单位来增加网络的规模。目标应该是将验证集的准确度近似到 80%。
+3.  考虑到该模型存在较高的偏差，重点应放在增加周期的数量上，或通过在每层中增加额外的层或单位来增加网络的规模。目标应该是将验证集的准确度近似到 80%。
 
     之后，将显示性能最佳的模型，该模型是在几次微调尝试之后实现的。 首先，定义模型架构和正向传递，如以下代码片段所示：
 
@@ -604,7 +604,7 @@
 
     可以在以前共享的 GitHub 存储库中找到此活动随附的 Jupyter 笔记本。 在那里，您会发现对模型进行微调的各种尝试及其结果。 性能最佳的型号可以在笔记本电脑的末尾找到。
 
-4.  绘制两组数据的损失和准确性。
+4.  绘制两组数据的损失和准确率。
 
     注意
 
@@ -929,7 +929,7 @@
     model = CNN().to("cuda")
     ```
 
-8.  训练你的网络，并确保保存训练集和验证集的损失和准确性的值。
+8.  训练你的网络，并确保保存训练集和验证集的损失和准确率的值。
 
     ```py
     train_losses, dev_losses, train_acc, dev_acc= [], [], [], []
@@ -1093,7 +1093,7 @@
 
     可以看出，在第 15 个时期之后，过拟合开始影响模型。
 
-0.  在测试集上检查模型的准确性。
+0.  在测试集上检查模型的准确率。
 
     ```py
     model.eval()
@@ -1164,7 +1164,7 @@
                                  (0.5, 0.5, 0.5))])}
     ```
 
-3.  训练模型 100 个纪元。
+3.  训练模型 100 个周期。
 
     如果您的计算机具有可用的 GPU，请确保使用代码的 GPU 版本来训练模型。
 
@@ -1231,7 +1231,7 @@
             return x
     ```
 
-3.  训练模型 100 个纪元。
+3.  训练模型 100 个周期。
 
     如果您的计算机具有可用的 GPU，请确保使用代码的 GPU 版本来训练模型。 训练和验证集的损失和准确率的结果图应类似于此处所示：
 
@@ -1263,7 +1263,7 @@
 
 # 5.样式迁移
 
-## 活动 5.01：执行样式转换
+## 活动 5.01：执行样式迁移
 
 ### 解决方案
 
@@ -1606,7 +1606,7 @@
     )
     ```
 
-7.  定义一个损失函数，一个优化算法，以及训练网络的周期数。使用 MSE 损失函数、Adam 优化器和 10,000 个纪元来完成这一任务。
+7.  定义一个损失函数，一个优化算法，以及训练网络的周期数。使用 MSE 损失函数、Adam 优化器和 10,000 个周期来完成这一任务。
 
     ```py
     loss_function = nn.MSELoss()
@@ -1614,7 +1614,7 @@
     epochs = 10000
     ```
 
-8.  使用`for`循环来执行训练过程，经历所有的周期。在每个纪元中，必须进行预测，以及随后的损失函数计算和网络参数的优化。保存每个纪元的损失。
+8.  使用`for`循环来执行训练过程，经历所有的周期。在每个周期中，必须进行预测，以及随后的损失函数计算和网络参数的优化。保存每个周期的损失。
 
     注意
 
@@ -1650,7 +1650,7 @@
     epoch: 10000 ... Loss function: 7.311776161193848
     ```
 
-9.  将所有时代的损失绘制如下：
+9.  将所有周期的损失绘制如下：
 
     ```py
     x_range = range(len(losses))
@@ -1666,7 +1666,7 @@
 
     图 6.28：显示所有时期的损失的图
 
-0.  使用散点图，显示在训练过程的最后一个纪元中获得的预测值与地面真实值（即上周的销售交易）的对比。
+0.  使用散点图，显示在训练过程的最后一个周期中获得的预测值与地面真实值（即上周的销售交易）的对比。
 
     ```py
     x_range = range(len(data))
@@ -1917,7 +1917,7 @@
                   losses[-1])
     ```
 
-    将训练过程运行 500 个纪元的结果如下：
+    将训练过程运行 500 个周期的结果如下：
 
     ```py
     epoch: 50 ... Loss function: 1.5207843986050835
@@ -2093,7 +2093,7 @@
     ```
 
 
-8.  定义损失函数，优化算法，以及训练的纪元数。例如，您可以使用二进制交叉熵损失作为损失函数，Adam 优化器，并训练 10 个周期。
+8.  定义损失函数，优化算法，以及训练的周期数。例如，您可以使用二进制交叉熵损失作为损失函数，Adam 优化器，并训练 10 个周期。
 
     ```py
     loss_function = nn.BCELoss()
@@ -2101,7 +2101,7 @@
     epochs = 10
     ```
 
-9.  创建一个`for`循环，通过不同的纪元，并分别通过每一个单次评论。对于每一个评论，进行预测，计算损失函数，并更新网络的参数。此外，计算该训练数据上网络的准确性。
+9.  创建一个`for`循环，通过不同的周期，并分别通过每一个单次评论。对于每一个评论，进行预测，计算损失函数，并更新网络的参数。此外，计算该训练数据上网络的准确率。
 
     ```py
     losses = []

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

@@ -916,7 +916,7 @@ class MatchingNetwork(nn.Module):
         return accuracy, crossentropy_loss
 ```
 
-7.  创建一个数据集加载器。 对于我们的案例，当我们使用 Omniglot 数据集时，它将创建一个 Omniglot 构建器，该构建器将调用匹配的网络并运行其纪元以进行训练，测试和验证：
+7.  创建一个数据集加载器。 对于我们的案例，当我们使用 Omniglot 数据集时，它将创建一个 Omniglot 构建器，该构建器将调用匹配的网络并运行其周期以进行训练，测试和验证：
 
 ```py
 def run_epoch(total_train_batches, name='train'):

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

@@ -549,7 +549,7 @@ plt.savefig('daml-sine.png')
 
 1.  梯度下降优化算法的优缺点是什么？
 2.  梯度下降优化算法有其他选择吗？
-3.  为什么训练神经网络需要那么多的纪元？
+3.  为什么训练神经网络需要那么多的周期？
 
 # 进一步阅读
 

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

@@ -248,7 +248,7 @@ class MNISTClassifier(nn.Module):
 self.dropout = nn.Dropout(p=0.2)
 ```
 
-丢弃是一种规范化我们的神经网络以防止过拟合的方法。 在每个训练纪元上，对于已应用丢包的层中的每个节点，都有可能（此处定义为`p`= 20%）该层内的每个节点将不用于训练/反向传播 。 这意味着，在训练时，我们的网络会针对过拟合变得健壮，因为在训练过程的每次迭代中都不会使用每个节点。 这可以防止我们的网络过于依赖网络中特定节点的预测。
+丢弃是一种规范化我们的神经网络以防止过拟合的方法。 在每个训练周期上，对于已应用丢包的层中的每个节点，都有可能（此处定义为`p`= 20%）该层内的每个节点将不用于训练/反向传播 。 这意味着，在训练时，我们的网络会针对过拟合变得健壮，因为在训练过程的每次迭代中都不会使用每个节点。 这可以防止我们的网络过于依赖网络中特定节点的预测。
 
 ## 定义正向传递
 
@@ -297,7 +297,7 @@ Loss(y) = -log(y)
 
 最后，我们实际上可以开始训练我们的网络了：
 
-1.  首先，创建一个循环，为我们训练的每一个纪元运行一次。在这里，我们将在 50 个周期中运行我们的训练循环。我们首先将输入的图像张量和输出的标签张量转化为 PyTorch 变量。一个**变量**是一个 PyTorch 对象，它包含一个`backward()`方法，我们可以使用该方法通过我们的网络进行反向传播。
+1.  首先，创建一个循环，为我们训练的每一个周期运行一次。在这里，我们将在 50 个周期中运行我们的训练循环。我们首先将输入的图像张量和输出的标签张量转化为 PyTorch 变量。一个**变量**是一个 PyTorch 对象，它包含一个`backward()`方法，我们可以使用该方法通过我们的网络进行反向传播。
 
     ```py
     for epoch in range(50):
@@ -305,7 +305,7 @@ Loss(y) = -log(y)
         labels = Variable(y)
     ```
 
-2.  接下来，我们在优化器上调用`zero_grad()`，将计算出的梯度设为零。在 PyTorch 中，梯度是在每次反向传播时累计计算的。虽然这在某些模型中很有用，例如在训练 RNNs 时，但对于我们的示例，我们希望在每个纪元后从头开始计算梯度，因此我们确保在每次通过后将梯度重置为零。
+2.  接下来，我们在优化器上调用`zero_grad()`，将计算出的梯度设为零。在 PyTorch 中，梯度是在每次反向传播时累计计算的。虽然这在某些模型中很有用，例如在训练 RNNs 时，但对于我们的示例，我们希望在每个周期后从头开始计算梯度，因此我们确保在每次通过后将梯度重置为零。
 
     ```py
     opt.zero_grad()
@@ -325,7 +325,7 @@ Loss(y) = -log(y)
     opt.step()
     ```
 
-5.  最后，在每个纪元完成后，我们打印总损失。我们可以观察到这一点，以确保我们的模型正在学习。
+5.  最后，在每个周期完成后，我们打印总损失。我们可以观察到这一点，以确保我们的模型正在学习。
 
     ```py
     print ('Epoch [%d/%d] Loss: %.4f' %(epoch+1, 50, loss.data.item()))
@@ -335,7 +335,7 @@ Loss(y) = -log(y)
 
 ![Figure 2.14 – Training epochs ](img/B12365_02_14.jpg)
 
-图 2.14 –训练纪元
+图 2.14 –训练周期
 
 ## 进行预测
 
@@ -493,7 +493,7 @@ print((correct/preds)*100)
 
 ## 训练分类器
 
-首先，我们建立一个循环，该循环由希望模型运行的时期数组成。 在这种情况下，我们将选择 100 个纪元。
+首先，我们建立一个循环，该循环由希望模型运行的时期数组成。 在这种情况下，我们将选择 100 个周期。
 
 在此循环中，我们首先将梯度归零（否则，PyTorch 会累积计算梯度），然后对于每个句子/标签对，分别将其转换为词袋向量和目标。 然后，通过使数据向前通过模型的当前状态，我们计算出该特定句子对的预测输出。
 

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

@@ -81,7 +81,7 @@ The panda eats shoots and leaves
 The panda eats, shoots, and leaves
 ```
 
-在这里，加上逗号会将描述熊猫的饮食习惯的句子转换为描述熊猫武装抢劫餐馆的句子！ 尽管如此，为了保持一致性，能够从句子中删除标点符号仍然很重要。 我们可以使用`re`库在 Python 中执行此操作，以使用正则表达式匹配任何标点符号，并使用`sub()`方法将任何匹配的标点符号替换为空字符：
+在这里，加上逗号会将描述Pandas的饮食习惯的句子转换为描述Pandas武装抢劫餐馆的句子！ 尽管如此，为了保持一致性，能够从句子中删除标点符号仍然很重要。 我们可以使用`re`库在 Python 中执行此操作，以使用正则表达式匹配任何标点符号，并使用`sub()`方法将任何匹配的标点符号替换为空字符：
 
 ```py
 input_text = "This ,sentence.'' contains-£ no:: punctuation?"

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

@@ -451,7 +451,7 @@ if (step % print_every) == 0:
             net.train()
 ```
 
-这意味着在每个时期结束时，我们的模型都会调用`net.eval()`冻结模型的权重，并像以前一样使用我们的数据进行正向传播。 请注意，当我们处于评估模式时，也不会应用丢弃。 但是，这次，我们使用验证加载程序，而不是使用训练数据加载程序。 通过这样做，我们可以在我们的验证数据集中计算模型当前状态的总损失。 最后，我们打印结果并调用`net.train()`解冻模型的权重，以便我们可以在下一个纪元再次进行训练。 我们的输出看起来像，如下所示：
+这意味着在每个时期结束时，我们的模型都会调用`net.eval()`冻结模型的权重，并像以前一样使用我们的数据进行正向传播。 请注意，当我们处于评估模式时，也不会应用丢弃。 但是，这次，我们使用验证加载程序，而不是使用训练数据加载程序。 通过这样做，我们可以在我们的验证数据集中计算模型当前状态的总损失。 最后，我们打印结果并调用`net.train()`解冻模型的权重，以便我们可以在下一个周期再次进行训练。 我们的输出看起来像，如下所示：
 
 ![Figure 5.18 – Training the model ](img/B12365_05_18.jpg)
 

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

@@ -173,7 +173,7 @@ CNN 背后的基本概念是卷积。 **卷积**本质上是一个滑动窗口
     train_data
     ```
 
-但是，在这里，我们正在处理`TorchText`数据集对象，而不是像我们以前所看到的那样，将数据集加载到熊猫中。 这意味着前面代码的输出如下：
+但是，在这里，我们正在处理`TorchText`数据集对象，而不是像我们以前所看到的那样，将数据集加载到Pandas中。 这意味着前面代码的输出如下：
 
 ![Figure 6.10 – Output of the TorchText object ](img/B12365_06_10.png)
 

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

@@ -743,7 +743,7 @@ for line in lines[:3]:
         print_loss += loss
     ```
 
-2.  在每一次迭代中，我们还确保打印出迄今为止的进度，跟踪我们已经完成了多少次迭代，以及每个纪元的损失是多少。
+2.  在每一次迭代中，我们还确保打印出迄今为止的进度，跟踪我们已经完成了多少次迭代，以及每个周期的损失是多少。
 
     ```py
     if iteration % print_every == 0:
@@ -755,7 +755,7 @@ for line in lines[:3]:
         print_loss = 0
     ```
 
-3.  为了完成，我们还需要在每隔几个纪元后保存我们的模型状态。这让我们可以重新审视我们已经训练过的任何历史模型；例如，如果我们的模型开始过拟合，我们可以恢复到早期的迭代。
+3.  为了完成，我们还需要在每隔几个周期后保存我们的模型状态。这让我们可以重新审视我们已经训练过的任何历史模型；例如，如果我们的模型开始过拟合，我们可以恢复到早期的迭代。
 
     ```py
     if (iteration % save_every == 0):
@@ -967,7 +967,7 @@ print('Response:', ' '.join(output_words))
 
     我们首先初始化一些训练超参数。 以与模型超参数相同的方式，可以调整这些参数以影响训练时间以及模型的学习方式。 裁剪控制梯度裁剪，教师强迫控制我们在模型中使用教师强迫的频率。 请注意，我们如何使用教师强制比 1，以便始终使用教师强制。 降低教学强迫率将意味着我们的模型需要更长的时间才能收敛。 但是，从长远来看，这可能有助于我们的模型更好地自行生成正确的句子。
 
-6.  我们还需要定义模型的学习率和解码器的学习率。你会发现，当解码器在梯度下降过程中进行较大的参数更新时，你的模型表现会更好。因此，我们引入一个解码器学习率，对学习率施加一个倍数，使解码器的学习率大于编码器的学习率。我们还定义了我们的模型打印和保存结果的频率，以及我们希望我们的模型运行多少个纪元。
+6.  我们还需要定义模型的学习率和解码器的学习率。你会发现，当解码器在梯度下降过程中进行较大的参数更新时，你的模型表现会更好。因此，我们引入一个解码器学习率，对学习率施加一个倍数，使解码器的学习率大于编码器的学习率。我们还定义了我们的模型打印和保存结果的频率，以及我们希望我们的模型运行多少个周期。
 
     ```py
     save_dir = './'

new/pt-ai-fund/3.md

@@ -863,7 +863,7 @@ valid_loss = valid_loss/len(valid_loader.sampler)
 
 在此秘籍中，我们找到并训练了我们的模型。 为此，我们进行了导入，首先要确定模型并将模型分配给我们在计算机上拥有的适当设备。 我们使用`model.to(device)`方法移动模型，这比使用`model.cuda()`或`model.cpu()`更为优雅。
 
-然后，我们定义了损失函数，也称为`criterion`。 由于这是一个分类问题，因此我们使用了交叉熵损失。 然后，我们选择 SGD 优化器在反向传播时更新模型权重，学习速率为 0.01，并使用`model.parameters()`传入模型参数。 然后，我们将模型运行了 30 个纪元，尽管我们可以选择任何合理的数目来执行此操作。 在循环中，我们将训练和验证损失重置为 0，并将模型设置为训练模式，然后遍历训练数据集中的每个批量。 我们首先将批量移至设备，这样，如果我们的 GPU 内存有限，则并非所有数据都不会完全加载到 GPU 内存中。 然后，我们将输入张量传递到模型中，并获取输出，并将其传递到损失函数中，以评估预测标签和真实标签之间的差异。
+然后，我们定义了损失函数，也称为`criterion`。 由于这是一个分类问题，因此我们使用了交叉熵损失。 然后，我们选择 SGD 优化器在反向传播时更新模型权重，学习速率为 0.01，并使用`model.parameters()`传入模型参数。 然后，我们将模型运行了 30 个周期，尽管我们可以选择任何合理的数目来执行此操作。 在循环中，我们将训练和验证损失重置为 0，并将模型设置为训练模式，然后遍历训练数据集中的每个批量。 我们首先将批量移至设备，这样，如果我们的 GPU 内存有限，则并非所有数据都不会完全加载到 GPU 内存中。 然后，我们将输入张量传递到模型中，并获取输出，并将其传递到损失函数中，以评估预测标签和真实标签之间的差异。
 
 此后，我们使用`loss.backward()`进行了反向传播，并使用`optimizer.step()`步骤更新了模型权重。 然后，我们使用总历时损失来汇总批量中的损失。 然后，我们使用`model.eval()`将模型转换为评估模型，因为该模型的性能需要在验证集上进行评估，并且该模型在此阶段中不会学习，因此我们也需要关闭退出项。 遍历验证批量，我们获得了模型输出，并在整个时期累积了验证批量之间的损失。 此后，我们格式化了模型性能，以查看每个时期模型的变化。 我们注意到，模型训练和验证损失随时间的推移而减少，这表明模型正在学习。
 

new/pt-ai-fund/4.md

@@ -273,7 +273,7 @@ pip install torchtext
 
 # 操作步骤
 
-在此秘籍中，我们将数据集转换为迭代器，以便在每个纪元准备好要迭代的适当批量：
+在此秘籍中，我们将数据集转换为迭代器，以便在每个周期准备好要迭代的适当批量：
 
 1.  我们将从导入开始：
 

new/pt-dl-handson/3.md

@@ -529,7 +529,7 @@ def run_evaluator_on_validation_data(engine):
     evaluator.run(val_loader)
 ```
 
-到目前为止，我必须已经使您相信 Ignite 是工具箱中的必备工具。 在前面的示例中，已为三个事件设置了`@trainer.on`装饰器； 实际上，在两个事件上，我们在`EPOCH_COMPLETED`事件上设置了两个功能。 使用第一个功能，我们可以将训练状态打印到终端上。 但是有些事情我们还没有看到。 状态是`Engine`用来保存有关执行信息的`state`变量。 在示例中，我们看到状态保存了有关时期，迭代乃至输出的信息，这实际上是训练循环的损失。 `state`属性包含纪元，迭代，当前数据，指标（如果有）（我们将很快了解指标）； 调用`run`函数时设置的最大纪元，以及`training_loop`函数的输出。
+到目前为止，我必须已经使您相信 Ignite 是工具箱中的必备工具。 在前面的示例中，已为三个事件设置了`@trainer.on`装饰器； 实际上，在两个事件上，我们在`EPOCH_COMPLETED`事件上设置了两个功能。 使用第一个功能，我们可以将训练状态打印到终端上。 但是有些事情我们还没有看到。 状态是`Engine`用来保存有关执行信息的`state`变量。 在示例中，我们看到状态保存了有关时期，迭代乃至输出的信息，这实际上是训练循环的损失。 `state`属性包含周期，迭代，当前数据，指标（如果有）（我们将很快了解指标）； 调用`run`函数时设置的最大周期，以及`training_loop`函数的输出。
 
 ##### 注意
 
@@ -580,7 +580,7 @@ def attach(self, engine, name):
     engine.add_event_handler(Events.EPOCH_COMPLETED, self.completed, name)
 ```
 
-通过`Engine`设置事件处理程序后，事件发生时将自动调用它们。 `EPOCH_STARTED`事件通过调用`reset()`方法来清理指标，并使存储对于当前纪元指标集合保持干净。
+通过`Engine`设置事件处理程序后，事件发生时将自动调用它们。 `EPOCH_STARTED`事件通过调用`reset()`方法来清理指标，并使存储对于当前周期指标集合保持干净。
 
 `ITERATION_COMPLETED`触发器将调用相应指标的`update()`方法并进行指标更新。 例如，如果度量等于损失，则它会在创建`Engine`时调用我们作为参数传递给`Loss`类的损失函数来计算当前损失。 然后将计算出的损耗保存到对象变量中，以备将来使用。
 

new/pt-dl-handson/6.md

@@ -531,7 +531,7 @@ loss = nn.BCELoss()
 
 ![Simple GAN](img/B09475_06_18.jpg)
 
-图 6.17：300 个纪元后的输出
+图 6.17：300 个周期后的输出
 
 ### CycleGAN
 

new/pt-tut-17/21.md

@@ -18,11 +18,11 @@
 
 迄今为止，最早的也是最流行的对抗性攻击之一被称为*快速梯度符号攻击（FGSM）*，由[《解释和利用对抗性示例》](https://arxiv.org/abs/1412.6572)（Goodfellow 等）描述。 攻击非常强大，而且直观。 它旨在利用神经网络学习*梯度*的方式来攻击神经网络。 这个想法很简单，不是通过基于反向传播的梯度来调整权重来使损失最小化，攻击会基于相同的反向传播的梯度来调整输入数据，以使损失最大化。 换句话说，攻击使用损失相对于输入数据的梯度，然后调整输入数据以使损失最大化。
 
-在进入代码之前，让我们看一下著名的 [FGSM](https://arxiv.org/abs/1412.6572) 熊猫示例，并提取一些符号。
+在进入代码之前，让我们看一下著名的 [FGSM](https://arxiv.org/abs/1412.6572) Pandas示例，并提取一些符号。
 
 ![fgsm_panda_image](img/d74012096c3134b776b5e9f70e8178f3.png)
 
-从图中，`x`是正确分类为“熊猫”的原始输入图像，`y`是`x`的输出，`θ`表示模型参数，而`J(θ, x, y)`是用于训练网络的损耗。 攻击会将梯度反向传播回输入数据，以计算`ᐁ[x] J(θ, x, y)`。 然后，它会沿方向（即`ᐁ[x] J(θ)`）沿一小步（图片中的`ε`或`0.007`）调整输入数据，`(x, y)`，这将使损失最大化。 然后，当目标图像仍明显是“熊猫”时，目标网络将它们误分类为“长臂猿”。
+从图中，`x`是正确分类为“Pandas”的原始输入图像，`y`是`x`的输出，`θ`表示模型参数，而`J(θ, x, y)`是用于训练网络的损耗。 攻击会将梯度反向传播回输入数据，以计算`ᐁ[x] J(θ, x, y)`。 然后，它会沿方向（即`ᐁ[x] J(θ)`）沿一小步（图片中的`ε`或`0.007`）调整输入数据，`(x, y)`，这将使损失最大化。 然后，当目标图像仍明显是“Pandas”时，目标网络将它们误分类为“长臂猿”。
 
 希望本教程的动机已经明确，所以让我们跳入实现过程。
 

new/pt-tut-17/22.md

@@ -398,7 +398,7 @@ optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))
 *   `D(x)`-所有真实批量的判别器的平均输出（整个批量）。 这应该从接近 1 开始，然后在`G`变得更好时理论上收敛到 0.5。 想想这是为什么。
 *   `D(G(z))`-所有假批量的平均判别器输出。 第一个数字在`D`更新之前，第二个数字在`D`更新之后。 这些数字应从 0 开始，并随着`G`的提高收敛到 0.5。 想想这是为什么。
 
-**注意**：此步骤可能需要一段时间，具体取决于您运行了多少个纪元以及是否从数据集中删除了一些数据。
+**注意**：此步骤可能需要一段时间，具体取决于您运行了多少个周期以及是否从数据集中删除了一些数据。
 
 ```py
 # Training Loop

new/pt-tut-17/25.md

@@ -358,7 +358,7 @@ with tqdm(total=n_epoch) as pbar:
 
 ```
 
-2 个纪元后，测试集的网络准确度应超过 65%，而 21 个纪元后，网络应达到 85%。 让我们看一下训练集中的最后几句话，看看模型是如何做到的。
+2 个周期后，测试集的网络准确度应超过 65%，而 21 个周期后，网络应达到 85%。 让我们看一下训练集中的最后几句话，看看模型是如何做到的。
 
 ```py
 def predict(tensor):

new/pt-tut-17/31.md

@@ -223,7 +223,7 @@ Epoch: 5  | time in 0 minutes, 11 seconds
 
 使用以下信息在 GPU 上运行模型：
 
-纪元：1 | 时间在 0 分 11 秒内
+周期：1 | 时间在 0 分 11 秒内
 
 ```py
 Loss: 0.0263(train)     |       Acc: 84.5%(train)
@@ -231,7 +231,7 @@ Loss: 0.0001(valid)     |       Acc: 89.0%(valid)
 
 ```
 
-纪元：2 | 时间在 0 分钟 10 秒内
+周期：2 | 时间在 0 分钟 10 秒内
 
 ```py
 Loss: 0.0119(train)     |       Acc: 93.6%(train)
@@ -239,7 +239,7 @@ Loss: 0.0000(valid)     |       Acc: 89.6%(valid)
 
 ```
 
-纪元：3 | 时间在 0 分钟 9 秒内
+周期：3 | 时间在 0 分钟 9 秒内
 
 ```py
 Loss: 0.0069(train)     |       Acc: 96.4%(train)
@@ -247,7 +247,7 @@ Loss: 0.0000(valid)     |       Acc: 90.5%(valid)
 
 ```
 
-纪元：4 | 时间在 0 分 11 秒内
+周期：4 | 时间在 0 分 11 秒内
 
 ```py
 Loss: 0.0038(train)     |       Acc: 98.2%(train)
@@ -255,7 +255,7 @@ Loss: 0.0000(valid)     |       Acc: 90.4%(valid)
 
 ```
 
-纪元：5 | 时间在 0 分 11 秒内
+周期：5 | 时间在 0 分 11 秒内
 
 ```py
 Loss: 0.0022(train)     |       Acc: 99.0%(train)

new/pt-tut-17/44.md

@@ -914,7 +914,7 @@ print("Saved ", options.out_file)
 
 ```
 
-现在，让我们训练模型约 30 个纪元：
+现在，让我们训练模型约 30 个周期：
 
 ```py
 root@3c0711f20896:/home/build# make && ./dcgan                                                                                                                                10:17:57

new/pt-tut-17/55.md

@@ -121,7 +121,7 @@ corpus = Corpus(model_data_filepath + 'wikitext-2')
 
 ## 3.加载预先训练的模型
 
-这是一本有关动态量化的教程，这是在训练模型后应用的一种量化技术。 因此，我们将简单地将一些预训练的权重加载到此模型架构中； 这些权重是通过使用单词语言模型示例中的默认设置训练五个纪元而获得的。
+这是一本有关动态量化的教程，这是在训练模型后应用的一种量化技术。 因此，我们将简单地将一些预训练的权重加载到此模型架构中； 这些权重是通过使用单词语言模型示例中的默认设置训练五个周期而获得的。
 
 ```py
 ntokens = len(corpus.dictionary)

new/rl-tf/10.md

@@ -197,7 +197,7 @@ EIIE 通过**在线随机批量学习**（**OSBL**）进行训练，其中强化
 
 创建了三个具有深度神经网络的三个不同变体的策略网络，分别是 CNN，RNN 和 LSTM。 前一个时间段的输出是当前时间段内网络的输入。 因此，使用策略梯度和深层 Q 网络中的经验回放的想法，创建了一个 PVM，用于存储网络输出，也就是说，它将包含每个时间步骤的投资组合权重向量。
 
-PVM 是按时间步长顺序（即时间顺序）收集投资组合向量的集合。 在训练纪元的每个时间步`t`，策略网络从`t-1`的存储位置取最后时间段的投资组合权重向量![](img/ca7f8384-0365-47e5-8367-e72df668cd15.png)，并进行覆盖`t`处的内存与输出投资组合权重向量![](img/ae0ed081-d2b6-4980-bda0-ab8224c0ed3f.png)的关系。 由于策略网络参数的收敛，PVM 中的值随着训练时期的增加而收敛。
+PVM 是按时间步长顺序（即时间顺序）收集投资组合向量的集合。 在训练周期的每个时间步`t`，策略网络从`t-1`的存储位置取最后时间段的投资组合权重向量![](img/ca7f8384-0365-47e5-8367-e72df668cd15.png)，并进行覆盖`t`处的内存与输出投资组合权重向量![](img/ae0ed081-d2b6-4980-bda0-ab8224c0ed3f.png)的关系。 由于策略网络参数的收敛，PVM 中的值随着训练时期的增加而收敛。
 
 单个内存堆栈（例如 PVM）还有助于使用小批量提高训练过程的并行性，从而提高训练过程的效率。