2021-01-24 20:28:20

new/dl-pt-workshop/0.md

@@ -12,7 +12,7 @@
 
 ## 受众群体
 
-对于想要使用 PyTorch 创建和训练深度学习模型的人来说，这本深度学习书非常理想。 对 Python 编程语言及其软件包的深入了解将帮助您更快地掌握本书中涉及的主题。
+对于想要使用 PyTorch 创建和训练深度学习模型的人来说，这本深度学习书非常理想。 对 Python 编程语言及其包的深入了解将帮助您更快地掌握本书中涉及的主题。
 
 ## 关于各章
 
@@ -32,7 +32,7 @@
 
 文本中的代码字，数据库表名称，文件夹名称，文件名，文件扩展名，路径名，虚拟 URL，用户输入和 Twitter 句柄如下所示：
 
-“从 PyTorch 导入`torch`，`optimize`软件包，以及`matplotlib`：
+“从 PyTorch 导入`torch`，`optimize`包，以及`matplotlib`：
 
 您在屏幕上看到的单词，例如在菜单或对话框中，也以相同的格式出现。
 
@@ -148,7 +148,7 @@ pip --version
 要安装带有或不带有 CUDA 的 PyTorch，请按照以下步骤操作：
 
 1.  [请访问以下链接](https://pytorch.org/get-started/locally/)。
-2.  在**本地启动**标题下，选择适用于您的选项。 这将为您提供在本地计算机上下载 PyTorch 所需执行的命令。 使用`pip`作为软件包下载 PyTorch。
+2.  在**本地启动**标题下，选择适用于您的选项。 这将为您提供在本地计算机上下载 PyTorch 所需执行的命令。 使用`pip`作为包下载 PyTorch。
 3.  复制命令并在终端或命令提示符中运行它。
 
 ## 安装库

new/dl-pt-workshop/1.md

@@ -92,7 +92,7 @@ x.to("cpu")
 
 在 CUDA 中，当解决深度学习数据问题时，优良作法是分配保存网络架构的模型以及输入数据。 这将确保在训练过程中执行的所有计算均由 GPU 处理。
 
-但是，只有在您的计算机具有可用的 GPU 且您已将 CUDA 软件包安装了 PyTorch 的情况下，才能进行此分配。 要验证您是否能够在 CUDA 中分配变量，请使用以下代码段：
+但是，只有在您的计算机具有可用的 GPU 且您已将 CUDA 包安装了 PyTorch 的情况下，才能进行此分配。 要验证您是否能够在 CUDA 中分配变量，请使用以下代码段：
 
 ```py
 torch.cuda.is_available()
@@ -102,7 +102,7 @@ torch.cuda.is_available()
 
 注意
 
-要与 CUDA 软件包一起安装 PyTorch，请访问 PyTorch 的网站，[并确保选择包含 CUDA（两个版本）的选项](https://pytorch.org/get-started/locally/)。
+要与 CUDA 包一起安装 PyTorch，请访问 PyTorch 的网站，[并确保选择包含 CUDA（两个版本）的选项](https://pytorch.org/get-started/locally/)。
 
 ## 什么是张量？
 
@@ -230,7 +230,7 @@ PyTorch 已被许多研究人员和人工智能开发人员采用，这使其成
 
 要强调的关键方面如下：
 
-*   **易于使用**：就 API 而言，PyTorch 具有简单的界面，可轻松开发和运行模型。 许多早期采用者认为它比 TensorFlow 等其他库更直观。
+*   **易于使用**：就 API 而言，PyTorch 具有简单的接口，可轻松开发和运行模型。 许多早期采用者认为它比 TensorFlow 等其他库更直观。
 *   **速度**：使用 GPU 使该库的训练速度比其他深度学习库更快。 当必须测试不同的近似值以获得最佳的模型时，这特别有用。 此外，即使其他库也可以选择使用 GPU 加速计算，您也可以在 PyTorch 中通过键入几行简单的代码来实现。
 *   **便利性**：PyTorch 灵活。 它使用动态计算图，使您可以随时随地更改网络。 由于易于对常规架构进行调整，因此在构建架构时还具有极大的灵活性。
 *   **急切执行**：PyTorch 也是急切执行。 每行代码都是单独执行的，使您可以实时跟踪模型，并以方便的方式调试模型。
@@ -240,7 +240,7 @@ PyTorch 已被许多研究人员和人工智能开发人员采用，这使其成
 
 尽管优点很多，但仍然存在一些要考虑的缺点，在这里进行了说明：
 
-*   **小型社区**：与其他库（例如 TensorFlow）相比，该库的适配器社区很小。 但是，它仅对公众开放了三年，今天，它已成为实现深度学习解决方案的最受欢迎的前五名图书馆之一，并且它的社区每天都在增长。
+*   **小型社区**：与其他库（例如 TensorFlow）相比，该库的适配器社区很小。 但是，它仅对公众开放了三年，今天，它已成为实现深度学习解决方案的最受欢迎的前五个库之一，并且它的社区每天都在增长。
 *   **参差不齐的文档**：与其他深度学习库相比，该库是一个相当新的文档，因此该文档并不完整。 但是，由于库的特性和功能正在增加，因此文档正在扩展。 此外，随着社区的不断发展，互联网上将提供更多信息。
 *   **有关生产准备就绪的问题**：尽管有关该库的许多投诉都集中在无法将其部署到生产中，但在发布 1.0 版之后，该库包含了生产能力，可以导出最终模型并在生产环境中使用它们。
 
@@ -396,15 +396,15 @@ loss_funct = nn.MSELoss()
 
 您已经成功定义了单层网络架构。
 
-### PyTorch `optim`软件包
+### PyTorch `optim`包
 
-`optim`程序包用于定义优化器，该优化器将使用`autograd`计算出的梯度来更新每次迭代中的参数（将在以下各章中进一步说明）。 模块。 在这里，可以从可用的不同优化算法中进行选择，例如 **Adam**，**随机梯度下降**（**SGD**）和**均方根传播**（**RMSprop**）等。
+`optim`包用于定义优化器，该优化器将使用`autograd`计算出的梯度来更新每次迭代中的参数（将在以下各章中进一步说明）。 模块。 在这里，可以从可用的不同优化算法中进行选择，例如 **Adam**，**随机梯度下降**（**SGD**）和**均方根传播**（**RMSprop**）等。
 
 注意
 
 后续章节将介绍最流行的优化算法。
 
-要设置要使用的优化程序，在导入软件包后，以下代码行就足够了：
+要设置要使用的优化程序，在导入包后，以下代码行就足够了：
 
 ```py
 optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

new/dl-pt-workshop/2.md

@@ -424,7 +424,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
 
 **电器能耗预测数据集**包含 4.5 个月的数据，涉及低能耗建筑物中不同房间的温度和湿度测量，目的是预测某些电器使用的能耗。
 
-在本练习中，我们将使用`pandas`（这是一个受欢迎的 Python 软件包）来探索手头的数据并学习如何检测缺失值，离群值和定性值。 执行以下步骤以完成本练习：
+在本练习中，我们将使用`pandas`（这是一个受欢迎的 Python 包）来探索手头的数据并学习如何检测缺失值，离群值和定性值。 执行以下步骤以完成本练习：
 
 注意
 
@@ -668,7 +668,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
 
     注意
 
-    尽管根据实际学习的需要导入了不同的程序包和库，但是在代码开始时导入它们始终是一种好习惯。
+    尽管根据实际学习的需要导入了不同的包和库，但是在代码开始时导入它们始终是一种好习惯。
 
 7.  拆分打乱后的数据集：
 

new/dl-pt-workshop/4.md

@@ -610,7 +610,7 @@ test_loader = torch.utils.data.DataLoader(test_data, \
 
 ## PyTorch 数据扩充
 
-使用`Torchvision`包在 PyTorch 中执行数据扩充非常容易。 该软件包除了包含流行的数据集和模型架构之外，还包含可以在数据集上执行的常见图像转换函数。
+使用`Torchvision`包在 PyTorch 中执行数据扩充非常容易。 该包除了包含流行的数据集和模型架构之外，还包含可以在数据集上执行的常见图像转换函数。
 
 注意
 

new/dl-pt-workshop/5.md

@@ -127,7 +127,7 @@ transforms.Compose([transforms.Normalize((-0.5/0.25, \
 
 在本书的 [GitHub 存储库](https://packt.live/2yiR97z)中，您将能够找到在本章中用于不同练习和活动的不同图像。
 
-1.  导入执行样式迁移所需的所有软件包：
+1.  导入执行样式迁移所需的所有包：
 
     ```py
     import numpy as np
@@ -255,9 +255,9 @@ transforms.Compose([transforms.Normalize((-0.5/0.25, \
 
 ## 载入模型
 
-像在许多其他框架中一样，PyTorch 有一个子程序包，其中包含不同的模型，这些模型先前已经过训练并可供公众使用。 考虑到从头开始训练神经网络非常耗时，这一点很重要。 从预先训练的模型开始可以帮助减少训练时间。 这意味着可以加载经过预训练的模型，以便我们可以使用它们的最终参数（应该是使损失函数最小的参数），而无需经过迭代过程。
+像在许多其他框架中一样，PyTorch 有一个子包，其中包含不同的模型，这些模型先前已经过训练并可供公众使用。 考虑到从头开始训练神经网络非常耗时，这一点很重要。 从预先训练的模型开始可以帮助减少训练时间。 这意味着可以加载经过预训练的模型，以便我们可以使用它们的最终参数（应该是使损失函数最小的参数），而无需经过迭代过程。
 
-如前所述，用于执行样式迁移任务的架构是 19 层 VGG 网络的架构，也称为 VGG-19。 在`torchvision`的`model`子程序包下提​​供了预训练的模型。 在 PyTorch 中保存的模型分为两部分：
+如前所述，用于执行样式迁移任务的架构是 19 层 VGG 网络的架构，也称为 VGG-19。 在`torchvision`的`model`子包下提​​供了预训练的模型。 在 PyTorch 中保存的模型分为两部分：
 
 1.  `vgg19.features`：这包括网络的所有卷积和池化层以及参数。 这些层负责从图像中提取特征。 有些层专门用于样式特征（例如颜色），而另一些层则专门用于内容特征（例如边缘）。
 2.  `vgg19.classifier`：这是指位于网络末端的线性层（也称为完全连接层），包括其参数。 这些层是将图像分类为标签类别之一的层，例如，识别图像中的动物类型。
@@ -266,7 +266,7 @@ transforms.Compose([transforms.Normalize((-0.5/0.25, \
 
     要探索 PyTorch 中可用的其他预训练模型，请访问[这里](https://pytorch.org/docs/stable/torchvision/models.html)。
 
-根据前面的信息，仅应加载模型的特征部分，以便提取内容和样式图像的必要特征。 加载模型包括调用`model`子程序包，然后调用模型名称，并确保将`pretrained`参数设置为`True`（为了加载先前训练过程中的参数），并按照以下代码片段仅加载要素层：
+根据前面的信息，仅应加载模型的特征部分，以便提取内容和样式图像的必要特征。 加载模型包括调用`model`子包，然后调用模型名称，并确保将`pretrained`参数设置为`True`（为了加载先前训练过程中的参数），并按照以下代码片段仅加载要素层：
 
 ```py
 model = models.vgg19(pretrained=True).features

new/dl-pt-workshop/7.md

@@ -835,7 +835,7 @@
                                  transform=transform)
     ```
 
-    前面的代码将下载可通过 PyTorch 的`Torchvision`软件包获得的训练和测试数据集。 根据上一步中定义的转换对数据集进行转换。
+    前面的代码将下载可通过 PyTorch 的`Torchvision`包获得的训练和测试数据集。 根据上一步中定义的转换对数据集进行转换。
 
 4.  使用 20% 的验证大小，定义训练和验证采样器，用于将数据集划分为这两组。
 

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

@@ -14,7 +14,7 @@
 
 “第 1 章”，“机器学习和深度学习的基础知识”，概述了机器学习和神经网络的基本方面。
 
-“第 2 章”，“用于 NLP 的 PyTorch 1.x 入门”，向您展示如何下载，安装和启动 PyTorch。 我们还将介绍该软件包的一些基本功能。
+“第 2 章”，“用于 NLP 的 PyTorch 1.x 入门”，向您展示如何下载，安装和启动 PyTorch。 我们还将介绍该包的一些基本功能。
 
 “第 3 章”，“NLP 和文本嵌入”展示了如何为 NLP 创建文本嵌入并在基本语言模型中使用它们。
 

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

@@ -10,11 +10,11 @@
 
 # 技术要求
 
-在本章中，需要安装 Python。 建议使用最新版本的 Python（3.6 或更高版本）。 还建议使用 Anaconda 软件包管理器来安装 PyTorch。 需要 CUDA 兼容 GPU 才能在 GPU 上运行张量操作。 本章的所有代码都可以在[这个页面](https://github.com/PacktPublishing/Hands-On-Natural-Language-Processing-with-PyTorch-1.x)中找到。
+在本章中，需要安装 Python。 建议使用最新版本的 Python（3.6 或更高版本）。 还建议使用 Anaconda 包管理器来安装 PyTorch。 需要 CUDA 兼容 GPU 才能在 GPU 上运行张量操作。 本章的所有代码都可以在[这个页面](https://github.com/PacktPublishing/Hands-On-Natural-Language-Processing-with-PyTorch-1.x)中找到。
 
 # 安装和使用 PyTorch 1.x
 
-像大多数 Python 软件包一样，PyTorch 的安装非常简单。 这样做有两种主要方法。 首先，要使用命令行中的`pip`简单地安装。 只需键入以下命令：
+像大多数 Python 包一样，PyTorch 的安装非常简单。 这样做有两种主要方法。 首先，要使用命令行中的`pip`简单地安装。 只需键入以下命令：
 
 ```py
 pip install torch torchvision

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

@@ -25,7 +25,7 @@ He jumps
 
 # 技术要求
 
-对于本章中的文本预处理，我们将主要使用内置的 Python 函数，但也将使用外部 **BeautifulSoup** 程序包。 对于词干提取和词形还原，我们将使用 NLTK Python 软件包。 本章中的所有代码都可以在[这个页面](https://github.com/PacktPublishing/Hands-On-Natural-Language-Processing-with-PyTorch-1.x/tree/master/Chapter4)中找到。
+对于本章中的文本预处理，我们将主要使用内置的 Python 函数，但也将使用外部 **BeautifulSoup** 包。 对于词干提取和词形还原，我们将使用 NLTK Python 包。 本章中的所有代码都可以在[这个页面](https://github.com/PacktPublishing/Hands-On-Natural-Language-Processing-with-PyTorch-1.x/tree/master/Chapter4)中找到。
 
 # 文本预处理
 
@@ -33,7 +33,7 @@ He jumps
 
 ## 删除 HTML
 
-从在线来源抓取文本时，您可能会发现您的文本包含 HTML 标记和其他非文本工件。 我们通常不希望在模型的 NLP 输入中包括这些，因此默认情况下应将其删除。 例如，在 HTML 中，`<b>`标签指示其后的文本应为粗体。 但是，它不包含有关句子内容的任何文本信息，因此我们应该删除它。 幸运的是，在 Python 中，有一个名为 **BeautifulSoup** 的软件包，它使我们可以在几行中删除所有 HTML：
+从在线来源抓取文本时，您可能会发现您的文本包含 HTML 标记和其他非文本工件。 我们通常不希望在模型的 NLP 输入中包括这些，因此默认情况下应将其删除。 例如，在 HTML 中，`<b>`标签指示其后的文本应为粗体。 但是，它不包含有关句子内容的任何文本信息，因此我们应该删除它。 幸运的是，在 Python 中，有一个名为 **BeautifulSoup** 的包，它使我们可以在几行中删除所有 HTML：
 
 ```py
 input_text = "<b> This text is in bold</br>, <i> This text is in italics </i>"

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

@@ -607,13 +607,13 @@ cd flaskAPI
 python3 -m venv vir_env
 ```
 
-在您的环境中，使用`pip`安装所需的所有软件包。 这包括您在模型程序中使用的所有软件包，例如 NLTK， **Pandas**，NumPy 和 PyTorch，以及运行 API 所需的软件包，例如 Flask 和 Gunicorn：
+在您的环境中，使用`pip`安装所需的所有包。 这包括您在模型程序中使用的所有包，例如 NLTK， **Pandas**，NumPy 和 PyTorch，以及运行 API 所需的包，例如 Flask 和 Gunicorn：
 
 ```py
 pip install nltk pandas numpy torch flask gunicorn
 ```
 
-然后，我们创建 API 将使用的需求列表。 请注意，当我们将其上传到 Heroku 时，Heroku 将自动下载并安装此列表中的所有软件包。 我们可以通过键入以下命令来做到这一点：
+然后，我们创建 API 将使用的需求列表。 请注意，当我们将其上传到 Heroku 时，Heroku 将自动下载并安装此列表中的所有包。 我们可以通过键入以下命令来做到这一点：
 
 ```py
 pip freeze > requirements.txt
@@ -742,7 +742,7 @@ git commit -m 'commit message here'
 git push heroku master
 ```
 
-编译可能会花费一些时间，因为系统不仅必须将所有文件从本地目录复制到 Heroku，而且 Heroku 将自动构建您定义的环境，安装所有必需的程序包并运行您的 API。
+编译可能会花费一些时间，因为系统不仅必须将所有文件从本地目录复制到 Heroku，而且 Heroku 将自动构建您定义的环境，安装所有必需的包并运行您的 API。
 
 现在，如果一切正常，您的 API 将自动在 Heroku 云上运行。 为了做出预测，您只需使用项目名称而不是`sentiment-analysis-flask-api`向 API 发出请求：
 

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

@@ -227,7 +227,7 @@ questions.build_vocab(train_data,
 labels.build_vocab(train_data)
 ```
 
-在这里，我们可以看到，通过使用`build_vocab`函数并将我们的问题和标签作为训练数据进行传递，我们可以构建由 200 维 GLoVe 向量组成的词汇表。 请注意，`torchtext`软件包将自动下载并获取 GLoVe 向量，因此在这种情况下无需手动安装 GLoVe。 我们还定义了我们希望如何处理词汇表中未知的值（即，如果模型传递了不在预训练词汇表中的标记，则模型将如何处理）。 在这种情况下，我们选择将它们视为具有未指定值的普通张量，尽管稍后会进行更新。
+在这里，我们可以看到，通过使用`build_vocab`函数并将我们的问题和标签作为训练数据进行传递，我们可以构建由 200 维 GLoVe 向量组成的词汇表。 请注意，`torchtext`包将自动下载并获取 GLoVe 向量，因此在这种情况下无需手动安装 GLoVe。 我们还定义了我们希望如何处理词汇表中未知的值（即，如果模型传递了不在预训练词汇表中的标记，则模型将如何处理）。 在这种情况下，我们选择将它们视为具有未指定值的普通张量，尽管稍后会进行更新。
 
 现在，通过调用以下命令，我们可以看到我们的词汇表由一系列预先训练的 200 维 GLoVe 向量组成：
 

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

@@ -466,7 +466,7 @@ The apple was sold by the shop to the man
 
 因此，能够训练模型以执行准确且有效的语义角色标记将对 NLP 的其余部分有用。 最早的语义角色标记系统完全基于规则，由从语法派生的基本规则集组成。 在深度学习的最新发展之前，这些方法已经演变为包含统计建模方法，这意味着可以训练分类器来识别句子中的相关语义角色。
 
-与任何分类任务一样，这是一个有监督的学习问题，需要完整注释的句子才能训练模型，该模型将识别以前未见过的句子的语义角色。 但是，这样带注释的句子的可用性非常稀缺。 我们在本章前面看到的巨大的语言模型（例如 BERT）是在原始句子上训练的，不需要带标签的示例。 但是，在语义角色标记的情况下，我们的模型需要使用正确标记的句子才能执行此任务。 尽管确实存在用于此目的的数据集，但它们的大小和通用性不足以训练完全综合，准确的模型，该模型在各种句子上均能很好地表现。
+与任何分类任务一样，这是一个有监督的学习问题，需要完整标注的句子才能训练模型，该模型将识别以前未见过的句子的语义角色。 但是，这样带标注的句子的可用性非常稀缺。 我们在本章前面看到的巨大的语言模型（例如 BERT）是在原始句子上训练的，不需要带标签的示例。 但是，在语义角色标记的情况下，我们的模型需要使用正确标记的句子才能执行此任务。 尽管确实存在用于此目的的数据集，但它们的大小和通用性不足以训练完全综合，准确的模型，该模型在各种句子上均能很好地表现。
 
 您可能会想到，解决语义角色标记任务的最新技术都是基于神经网络的。 初始模型使用 LSTM 和双向 LSTM 结合 GLoVe 嵌入，以便对句子进行分类。 这些模型还包含了卷积层，也表现出良好的表现。
 
@@ -474,7 +474,7 @@ The apple was sold by the shop to the man
 
 其他研究也表明，图卷积网络在语义标记方面是有效的。 图由节点和边构成，其中图内的节点代表语义成分，边代表父子部分之间的关​​系。
 
-也可以使用许多用于语义角色标记的开源模型。 Google 的 SLING 解析器经过训练，可以执行数据的语义注释。 该模型使用双向 LSTM 对句子进行编码，并使用基于过渡的循环单元进行解码。 该模型仅将文本标记用作输入和输出角色，而无需任何进一步的符号表示：
+也可以使用许多用于语义角色标记的开源模型。 Google 的 SLING 解析器经过训练，可以执行数据的语义标注。 该模型使用双向 LSTM 对句子进行编码，并使用基于过渡的循环单元进行解码。 该模型仅将文本标记用作输入和输出角色，而无需任何进一步的符号表示：
 
 ![Figure 9.20 – Bi-directional LSTM (SLING) ](img/B12365_09_20.jpg)
 

new/pt-ai-fund/1.md

@@ -4,7 +4,7 @@
 
 PyTorch 是 Python 中的一个开源深度学习框架，它使我们能够从研究问题开始，提出原型解决方案，并在开发此解决方案的过程中一直进行到创建分布式计算集群为止。 它使您从研究到生产都可以覆盖。 PyTorch 改编自 Torch，后者是一个科学计算框架，广泛支持机器学习算法，使用 Lua 编写，可为您提供强大的功能（使用 GPU）。 那为什么要用 PyTorch？
 
-PyTorch 与 Python 深度集成，具有命令式风格，使用类似 Python 的语法，并且在 Eager 模式下易于使用且灵活。 它的学习曲线很浅，可以让您专注于功能而不是框架的样板和语法。 Python 命令的纯命令执行将失去很多优化机会，因此，随着**即时**（**JIT**）编译器的引入，PyTorch 允许过渡到图形 C++ 运行时环境中用于速度，功能和优化的模式。 它得到了来自不同领域的专业人员的大力社区支持，并且与图书馆打交道。 它具有与框架互操作性的本地**开放神经网络交换**（**ONNX**）支持。 它是分布式的，可扩展到生产环境，与 TensorBoard 集成，并具有出色的文档和 API，您可以轻松编写针对 CPU 和 GPU 的自定义扩展。 我们将在接下来的章节中探索这些以及更多内容。
+PyTorch 与 Python 深度集成，具有命令式风格，使用类似 Python 的语法，并且在 Eager 模式下易于使用且灵活。 它的学习曲线很浅，可以让您专注于功能而不是框架的样板和语法。 Python 命令的纯命令执行将失去很多优化机会，因此，随着**即时**（**JIT**）编译器的引入，PyTorch 允许过渡到图形 C++ 运行时环境中用于速度，功能和优化的模式。 它得到了来自不同领域的专业人员的大力社区支持，并且与库打交道。 它具有与框架互操作性的本地**开放神经网络交换**（**ONNX**）支持。 它是分布式的，可扩展到生产环境，与 TensorBoard 集成，并具有出色的文档和 API，您可以轻松编写针对 CPU 和 GPU 的自定义扩展。 我们将在接下来的章节中探索这些以及更多内容。
 
 在本章中，我们将介绍以下秘籍：
 
@@ -24,7 +24,7 @@ PyTorch 与 Python 深度集成，具有命令式风格，使用类似 Python
 
 NumPy 是本章必不可少的库，在您安装 PyTorch 时，NumPy 会自动为您安装它的依赖项。 这意味着我们无需显式安装 NumPy。
 
-您可以将 PyTorch 与其他软件包管理器一起安装，例如 Conda，如[这个页面](https://pytorch.org/)中所述。
+您可以将 PyTorch 与其他包管理器一起安装，例如 Conda，如[这个页面](https://pytorch.org/)中所述。
 
 要为 Python3 CPU 安装 PyTorch，我们可以使用以下命令：
 
@@ -60,7 +60,7 @@ pip3 install torch
 pip3 install https://download.pytorch.org/whl/cu90/torch-1.1.0-cp36-cp36m-win_amd64.whl
 ```
 
-MacOS 二进制不支持 CUDA，因此如果需要 CUDA，则应从源代码安装它。 您也可以使用其他软件包管理器进行安装，甚至可以从源代码进行构建。 有关其他软件包管理器和 Python 版本，请访问[这个页面](https://pytorch.org/)。
+MacOS 二进制不支持 CUDA，因此如果需要 CUDA，则应从源代码安装它。 您也可以使用其他包管理器进行安装，甚至可以从源代码进行构建。 有关其他包管理器和 Python 版本，请访问[这个页面](https://pytorch.org/)。
 
 您可以通过转到 Python 终端并键入以下命令来快速验证安装是否正常：
 
@@ -332,7 +332,7 @@ tensor([[3, 3],
 
 # 探索 NumPy 桥接
 
-NumPy 是 Python 中科学计算的基本软件包。 它是一个 Python 库，提供多维数组对象和各种派生对象。 除此之外，NumPy 用作通用多维数据的有效容器。 NumPy 允许与各种数据库进行无缝，快速的集成。
+NumPy 是 Python 中科学计算的基本包。 它是一个 Python 库，提供多维数组对象和各种派生对象。 除此之外，NumPy 用作通用多维数据的有效容器。 NumPy 允许与各种数据库进行无缝，快速的集成。
 
 NumPy 是标准的 Python 库，用于处理数字数据。 Python 中许多著名的 ML/DS 库，例如 pandas（用于从许多来源读取数据的库）和 scikit-learn（用于读取和写入图像的最重要的 ML 库之一）都使用 NumPy 引擎盖。 例如，在处理表格数据，使用`pandas`库加载表格数据并将`numpy`数组移出数据框时，您将处理很多`numpy`。 读取图像，许多现有库都具有内置的 API，可以将它们读取为`numpy`数组； 并将`numpy`数组转换为图像以及文本和其他形式的数据。 同样，它们都使用`scikit-learn`（机器学习库）支持`numpy`数组。 如您所见，在`numpy`数组和 PyTorch 张量之间建立桥梁非常重要。
 
@@ -430,7 +430,7 @@ tensor([[2., 2., 2.],
 
 **梯度下降**是一种优化算法，用于通过在梯度的负值所定义的最陡下降方向上反复移动来使函数最小化。 我们在训练模型时会使用它，以使损失最小化。 它用于查找使成本或损失函数最小化的函数参数值（机器学习中的系数或权重）。
 
-那么什么是梯度呢？ 梯度度量的是当输入改变很小的时候给定函数的输出有多少变化，这与微积分中的导数概念相同。 梯度会计算所有权重相对于误差变化的变化。 梯度是函数的斜率。 较高的坡度意味着坡度更陡，并且模型可以更快地学习。 梯度指向最陡的倾斜方向。 PyTorch 中的`Autograd`模块在 PyTorch 中执行所有梯度计算。 它是自动差异化的核心 Torch 软件包。 它使用基于磁带的系统进行自动区分。 在前进阶段，`Autograd`磁带将记住它执行的所有操作，而在倒退阶段，它将重放它们。
+那么什么是梯度呢？ 梯度度量的是当输入改变很小的时候给定函数的输出有多少变化，这与微积分中的导数概念相同。 梯度会计算所有权重相对于误差变化的变化。 梯度是函数的斜率。 较高的坡度意味着坡度更陡，并且模型可以更快地学习。 梯度指向最陡的倾斜方向。 PyTorch 中的`Autograd`模块在 PyTorch 中执行所有梯度计算。 它是自动差异化的核心 Torch 包。 它使用基于磁带的系统进行自动区分。 在前进阶段，`Autograd`磁带将记住它执行的所有操作，而在倒退阶段，它将重放它们。
 
 # 操作步骤
 
@@ -550,7 +550,7 @@ False
 
 我们首先创建一种新的张量，将`require_grad`设置为`True`，然后创建一个张量`y`，使得`y = 2x^2 + 3`并发现`y`具有一个附加到它的不同的梯度函数。 我们还研究了使用`requires_grad_()`，最后使用了`no_grad()`。
 
-PyTorch 有一个名为`autograd`的软件包，可以对张量上的所有操作执行所有跟踪和自动微分。 这是一个按运行定义的框架，这意味着您的反向传播是由代码的运行方式定义的，并且每次迭代都可以不同。 我们利用`torch.Tensor`类的`require_grad`属性来确定梯度计算的状态，并在调用`.backward()`方法后自动计算其`.grad`属性中的所有梯度和张量的梯度。
+PyTorch 有一个名为`autograd`的包，可以对张量上的所有操作执行所有跟踪和自动微分。 这是一个按运行定义的框架，这意味着您的反向传播是由代码的运行方式定义的，并且每次迭代都可以不同。 我们利用`torch.Tensor`类的`require_grad`属性来确定梯度计算的状态，并在调用`.backward()`方法后自动计算其`.grad`属性中的所有梯度和张量的梯度。
 
 我们可以禁用代码之间的梯度计算，也可以暂时禁用对张量的跟踪以进行梯度计算，从而提高计算速度。 禁用计算主要在评估期间使用。
 

new/pt-ai-fund/2.md

@@ -461,7 +461,7 @@ Training loss: 0.2596
 
 在本秘籍中，我们首先使用`Adam`优化器定义优化器，然后为优化器设置学习率，并查看默认参数。 我们设置一个时期`10`，并为每个时期开始迭代，在每次迭代中将`running_loss`设置为 0，并在该时期内对每个图像进行迭代（模型看到数据集的次数）。 我们首先使用`.zero_grad()`方法清除梯度。 PyTorch 在每次反向传播时都会累积梯度，这在某些情况下很有用，因此将其导入以将梯度归零，以正确更新模型参数。
 
-接下来，我们通过将每批 64 幅图像（每幅图像由`28 x 28`像素组成）展平到 784 来重塑图像，从而将张量形状从`64 x 28 x 28`更改为`64 x 784`，因为我们的模型期望这种输入形状。 接下来，我们将此输入发送到模型，并从模型中获得该批量的输出预测，然后将其传递给损失函数，也称为`criterion`； 在那里，它评估了预测班级与实际班级之间的差异。
+接下来，我们通过将每批 64 幅图像（每幅图像由`28 x 28`像素组成）展平到 784 来重塑图像，从而将张量形状从`64 x 28 x 28`更改为`64 x 784`，因为我们的模型期望这种输入形状。 接下来，我们将此输入发送到模型，并从模型中获得该批量的输出预测，然后将其传递给损失函数，也称为`criterion`； 在那里，它评估了预测类与实际类之间的差异。
 
 `loss.backward()`函数计算了梯度（即，误差相对于权重的偏导数），我们调用了`optimizer.step()`函数来更新模型的权重，以适应评估的误差。 `.item()`方法从单个元素张量中拉出标量，因此使用`loss.item()`从批量中获得`error`的标量值，将其累加到所有批量的损失中，最后在周期末尾打印损失。
 

new/pt-ai-fund/7.md

@@ -195,7 +195,7 @@ def cartpole_model(observation_space, action_space):
 
 # 准备
 
-在完成本秘籍之前，您应该完成本章的“OpenAI Gym 介绍 – Cartpole”秘籍，以便设置`gym`程序包。
+在完成本秘籍之前，您应该完成本章的“OpenAI Gym 介绍 – Cartpole”秘籍，以便设置`gym`包。
 
 # 操作步骤
 

new/pt-dl-handson/0.md

@@ -29,7 +29,7 @@
 *   该代码用 Python 编写并托管在 GitHub 上。 尽管可以下载压缩代码存储库，但在线 GitHub 存储库将收到错误修复和更新。 因此，需要具备对 GitHub 的基本了解，以及具有良好的 Python 知识。
 *   尽管不是强制性的，但如果您未使用任何预训练的模型，则使用 CUDA 驱动程序将有助于加快训练过程。
 *   这些代码示例是在 Ubuntu 18.10 机器上开发的，但是可以在所有流行的平台上运行。 但是，如果您遇到任何困难，请随时在 GitHub 存储库中提出问题。
-*   本书中的某些示例要求您使用其他服务或程序包，例如 redis-server 和 Flask 框架。 所有这些外部依赖项和“操作方法”指南均在其出现的章节中进行了记录。
+*   本书中的某些示例要求您使用其他服务或包，例如 redis-server 和 Flask 框架。 所有这些外部依赖项和“操作方法”指南均在其出现的章节中进行了记录。
 
 ### 下载示例代码文件
 

new/pt-dl-handson/1.md

@@ -40,9 +40,9 @@ PyTorch 核心社区不仅为 Torch 的 C 二进制文件构建了 Python 包装
 
 ### 安装 PyTorch
 
-如果您已安装 CUDA 和 CuDNN，则 PyTorch 的安装非常简单（出于对 GPU 的支持，但是如果您尝试在 PyTorch 中尝试并且没有 GPU，那也可以）。 PyTorch 的主页[2]显示一个交互式屏幕，用于选择您所选择的操作系统和程序包管理器。 选择选项并执行命令进行安装。
+如果您已安装 CUDA 和 CuDNN，则 PyTorch 的安装非常简单（出于对 GPU 的支持，但是如果您尝试在 PyTorch 中尝试并且没有 GPU，那也可以）。 PyTorch 的主页[2]显示一个交互式屏幕，用于选择您所选择的操作系统和包管理器。 选择选项并执行命令进行安装。
 
-尽管最初仅支持 Linux 和 Mac 操作系统，但从 PyTorch 0.4 Windows 开始，Windows 也在受支持的操作系统列表中。 PyTorch 已包装并运送到 PyPI 和 Conda。 PyPI 是软件包的官方 Python 存储库，并且软件包管理器`pip`可以在 Torch 的名称下找到 PyTorch。
+尽管最初仅支持 Linux 和 Mac 操作系统，但从 PyTorch 0.4 Windows 开始，Windows 也在受支持的操作系统列表中。 PyTorch 已包装并运送到 PyPI 和 Conda。 PyPI 是包的官方 Python 存储库，并且包管理器`pip`可以在 Torch 的名称下找到 PyTorch。
 
 但是，如果您想冒险并获取最新代码，则可以按照 GitHub `README`页面上的说明从源代码安装 PyTorch。 PyTorch 的每晚版本都将推送到 PyPI 和 Conda。 如果您希望获得最新的代码而无需经历从源代码安装的麻烦，那么每晚构建将非常有用。
 
@@ -54,7 +54,7 @@ PyTorch 核心社区不仅为 Torch 的 C 二进制文件构建了 Python 包装
 
 在可靠的深度学习框架的众多中，由于速度和效率的原因，几乎每个人都在使用静态图或基于符号图的方法。 动态网络的内在问题（例如表现问题）使开发人员无法花费大量时间来实现它。 但是，静态图的限制使研究人员无法思考解决问题的多种不同方法，因为思维过程必须限制在静态计算图的框内。
 
-如前所述，哈佛大学的 Autograd 软件包最初是作为解决此问题的方法，然后 Torch 社区从 Python 采纳了这个想法并实现了 torch-autograd。 Chainer 和 CMU 的 DyNet 可能是接下来的两个基于动态图的框架，得到了社区的大力支持。 尽管所有这些框架都可以解决借助强制方法创建的静态图所产生的问题，但它们没有其他流行的静态图框架所具有的动力。 PyTorch 绝对是答案。 PyTorch 团队采用了经过良好测试的著名 Torch 框架的后端，并将其与 Chainer 的前端合并以得到最佳组合。 团队优化了内核，添加了更多的 Pythonic API，并正确设置了抽象，因此 PyTorch 不需要像 Keras 这样的抽象库即可让初学者入门。
+如前所述，哈佛大学的 Autograd 包最初是作为解决此问题的方法，然后 Torch 社区从 Python 采纳了这个想法并实现了 torch-autograd。 Chainer 和 CMU 的 DyNet 可能是接下来的两个基于动态图的框架，得到了社区的大力支持。 尽管所有这些框架都可以解决借助强制方法创建的静态图所产生的问题，但它们没有其他流行的静态图框架所具有的动力。 PyTorch 绝对是答案。 PyTorch 团队采用了经过良好测试的著名 Torch 框架的后端，并将其与 Chainer 的前端合并以得到最佳组合。 团队优化了内核，添加了更多的 Pythonic API，并正确设置了抽象，因此 PyTorch 不需要像 Keras 这样的抽象库即可让初学者入门。
 
 PyTorch 在研究界获得了广泛的接受，因为大多数人已经在使用 Torch，并且可能对 TensorFlow 之类的框架在没有提供太多灵活性的情况下的发展感到沮丧。 PyTorch 的动态性质对许多人来说是一个好处，并帮助他们在早期阶段接受 PyTorch。
 
@@ -64,7 +64,7 @@ PyTorch 允许用户定义 Python 在向前传递中允许他们执行的任何
 
 ONNX 和 DLPack 是 AI 社区看到的下两个“大事情”。 微软和 Facebook 共同宣布了 **开放神经网络交换**（**ONNX**）协议，该协议旨在帮助开发人员将任何模型从任何框架迁移到任何其他框架。 ONNX 与 PyTorch，Caffe2，TensorFlow，MXNet 和 CNTK 兼容，并且社区正在构建/改善对几乎所有流行框架的支持。
 
-ONNX 内置在 PyTorch 的核心中，因此将模型迁移到 ONNX 表单不需要用户安装任何其他软件包或工具。 同时，DLPack 通过定义不同框架应遵循的标准数据结构，将互操作性提高到一个新水平，从而使张量在同一程序中从一个框架到另一个框架的迁移不需要用户序列化数据，或遵循任何其他解决方法。 例如，如果您有一个程序可以将训练过的 TensorFlow 模型用于计算机视觉，而一个高效的 PyTorch 模型用于循环数据，则可以使用一个程序来处理视频中的每个三维帧， TensorFlow 模型并将 TensorFlow 模型的输出直接传递给 PyTorch 模型以预测视频中的动作。 如果您退后一步，看看深度学习社区，您会发现整个世界都趋向于一个单一的点，在这个点上，所有事物都可以与其他事物互操作，并尝试以类似方法解决问题。 那是我们大家都想生活的世界。
+ONNX 内置在 PyTorch 的核心中，因此将模型迁移到 ONNX 表单不需要用户安装任何其他包或工具。 同时，DLPack 通过定义不同框架应遵循的标准数据结构，将互操作性提高到一个新水平，从而使张量在同一程序中从一个框架到另一个框架的迁移不需要用户序列化数据，或遵循任何其他解决方法。 例如，如果您有一个程序可以将训练过的 TensorFlow 模型用于计算机视觉，而一个高效的 PyTorch 模型用于循环数据，则可以使用一个程序来处理视频中的每个三维帧， TensorFlow 模型并将 TensorFlow 模型的输出直接传递给 PyTorch 模型以预测视频中的动作。 如果您退后一步，看看深度学习社区，您会发现整个世界都趋向于一个单一的点，在这个点上，所有事物都可以与其他事物互操作，并尝试以类似方法解决问题。 那是我们大家都想生活的世界。
 
 ## 使用计算图
 
@@ -296,7 +296,7 @@ Figure 1.16: GAN setup
 
 让我们用一些代码弄脏一下。 如果您以前使用过 NumPy，那么您将在这里。 如果没有，请不要担心。 PyTorch 旨在简化初学者的生活。
 
-作为深度学习框架，PyTorch 也可以用于数值计算。 在这里，我们讨论 PyTorch 中的基本操作。 本章中的基本 PyTorch 操作将在下一章中简化您的工作，在下一章中，我们将尝试为一个简单的用例构建一个实际的神经网络。 本书中的所有程序都将使用 Python 3.7 和 PyTorch 1.0。 GitHub 存储库也使用相同的配置构建：尽管 PyTorch 团队推荐使用该软件包管理器，但它是从 PyPI 而不是 Conda 获得的 PyTorch。
+作为深度学习框架，PyTorch 也可以用于数值计算。 在这里，我们讨论 PyTorch 中的基本操作。 本章中的基本 PyTorch 操作将在下一章中简化您的工作，在下一章中，我们将尝试为一个简单的用例构建一个实际的神经网络。 本书中的所有程序都将使用 Python 3.7 和 PyTorch 1.0。 GitHub 存储库也使用相同的配置构建：尽管 PyTorch 团队推荐使用该包管理器，但它是从 PyPI 而不是 Conda 获得的 PyTorch。
 
 ### 学习基本操作
 

new/pt-dl-handson/2.md

@@ -125,7 +125,7 @@ b2 = torch.zeros(1, output_size, requires_grad=True, device=device, dtype=dtype)
 
 **注意**：自动区分，有时也称为算法区分，是通过计算机程序利用函数执行顺序的技术。 自动区分的两种主要方法是正向模式和反向模式。 在前向模式自动微分中，我们首先找到外部函数的导数，然后递归进入内部，直到我们探索所有子节点。 反向模式自动区分正好相反，并且被深度学习社区和框架使用。 它由 Seppo Linnainmaa 于 1970 年在其硕士论文中首次出版。反向模式微分的主要构建模块是存储中间变量的存储器，以及使这些变量计算导数的功能，同时从子节点移回到父节点。
 
-正如 PyTorch 主页所说，PyTorch 中所有神经网络的中心都是 Autograd 软件包。 PyTorch 借助 Autograd 软件包获得了动态功能。 程序执行时，Autograd 将每个操作写入磁带状数据结构并将其存储在内存中。
+正如 PyTorch 主页所说，PyTorch 中所有神经网络的中心都是 Autograd 包。 PyTorch 借助 Autograd 包获得了动态功能。 程序执行时，Autograd 将每个操作写入磁带状数据结构并将其存储在内存中。
 
 这是反向模式自动微分的关键特征之一。 这有助于 PyTorch 动态化，因为无论用户在向前传递中作为操作编写的内容都可以写入磁带，并且在反向传播开始时，Autograd 可以在磁带上向后移动并随梯度一起移动，直到到达最外层父级。
 
@@ -374,7 +374,7 @@ class FizBuzNet(nn.Module):
 
 `nn.Module`使您更容易拥有如此漂亮的抽象。 初始化`class`对象时，将调用`__init__()`，这又将初始化层并返回对象。 `nn.Module`实现了两个主要函数，即`__call__`和`backward()`，并且用户需要覆盖`forward`和`__init__()`。
 
-一旦返回了层初始化的对象，就可以通过调用`model`对象本身将输入数据传递给模型。 通常，Python 对象不可调用。 要调用对象方法，用户必须显式调用它们。 但是，`nn.Module`实现了魔术函数`__call__()`，该函数又调用了用户定义的`forward`函数。 用户具有在前向呼叫中定义所需内容的特权。
+一旦返回了层初始化的对象，就可以通过调用`model`对象本身将输入数据传递给模型。 通常，Python 对象不可调用。 要调用对象方法，用户必须显式调用它们。 但是，`nn.Module`实现了魔术函数`__call__()`，该函数又调用了用户定义的`forward`函数。 用户具有在正向调用中定义所需内容的特权。
 
 只要 PyTorch 知道如何反向传播`forward`中的内容，您就很安全。 但是，如果您在`forward`中具有自定义函数或层，则 PyTorch 允许您覆盖`backward`函数，并且该函数将在返回磁带时执行。
 
@@ -566,13 +566,13 @@ b1.grad.zero_()
 b2.grad.zero_()
 ```
 
-`optim`软件包内置了所有流行的优化器。 在这里，我们使用完全相同的简单优化程序– `SGD`：
+`optim`包内置了所有流行的优化器。 在这里，我们使用完全相同的简单优化程序– `SGD`：
 
 ```py
 optimizer = optim.SGD(net.parameters(), lr=lr)
 ```
 
-`optimizer`对象现在具有模型参数。 `optim`软件包提供了一个方便的函数，称为`step()`，该函数根据优化程序定义的策略进行参数更新：
+`optimizer`对象现在具有模型参数。 `optim`包提供了一个方便的函数，称为`step()`，该函数根据优化程序定义的策略进行参数更新：
 
 ```py
 for epoch in range(epochs):

new/pt-dl-handson/3.md

@@ -24,7 +24,7 @@ PyTorch 最初是由 Facebook 实习生作为研究框架开始的，现已发
 
 构建问题陈述的理论基础之后，我们进入设计和/或实验阶段，在其中通过尝试几种模型实现来构建 POC。 设计和实验的关键部分在于数据集和数据集的预处理。 对于任何数据科学项目，主要的时间份额都花在了数据清理和预处理上。 深度学习与此不同。
 
-数据预处理是构建深度学习管道的重要部分之一。 通常，不清理或格式化现实世界的数据集以供神经网络处理。 在进行进一步处理之前，需要转换为浮点数或整数，进行规范化等操作。 建立数据处理管道也是一项艰巨的任务，其中包括编写大量样板代码。 为了使其更容易，将数据集构建器和`DataLoader`管道程序包内置到 PyTorch 的核心中。
+数据预处理是构建深度学习管道的重要部分之一。 通常，不清理或格式化现实世界的数据集以供神经网络处理。 在进行进一步处理之前，需要转换为浮点数或整数，进行规范化等操作。 建立数据处理管道也是一项艰巨的任务，其中包括编写大量样板代码。 为了使其更容易，将数据集构建器和`DataLoader`管道包内置到 PyTorch 的核心中。
 
 ### 数据集和`DataLoader`类
 
@@ -87,7 +87,7 @@ for batch in dataloader:
 
 `num_worker`参数决定应该操作多少个并行线程来获取数据。 这有助于避免 CPU 瓶颈，以便 CPU 可以赶上 GPU 的并行操作。 数据加载器允许用户指定是否使用固定的 CUDA 内存，这会将数据张量复制到 CUDA 的固定的内存中，然后再返回给用户。 使用固定内存是设备之间快速数据传输的关键，因为数据是由数据加载程序本身加载到固定内存中的，而无论如何，这都是由 CPU 的多个内核完成的。
 
-大多数情况下，尤其是在进行原型制作时，开发人员可能无法使用自定义数据集，在这种情况下，自定义数据集必须依赖现有的开放数据集。 处理开放数据集的好处是，大多数数据集免于许可负担，成千上万的人已经尝试过对其进行预处理，因此社区将提供帮助。 PyTorch 提出了针对所有三种类型的数据集的工具包，这些程序包具有经过预训练的模型，经过预处理的数据集以及与这些数据集一起使用的工具函数。
+大多数情况下，尤其是在进行原型制作时，开发人员可能无法使用自定义数据集，在这种情况下，自定义数据集必须依赖现有的开放数据集。 处理开放数据集的好处是，大多数数据集免于许可负担，成千上万的人已经尝试过对其进行预处理，因此社区将提供帮助。 PyTorch 提出了针对所有三种类型的数据集的工具包，这些包具有经过预训练的模型，经过预处理的数据集以及与这些数据集一起使用的工具函数。
 
 ### 工具包
 
@@ -102,7 +102,7 @@ pip install torchvision
 
 `torchvision`是 PyTorch 中最成熟，使用最多的工具包，它由数据集，预先训练的模型和预先构建的转换脚本组成。 `torchvision`具有功能强大的 API，使用户能够轻松进行数据的预处理，并且在原型阶段（甚至可能无法使用数据集）特别有用。
 
-`torchvision`的功能分为三类：预加载的，可下载的数据集，用于几乎所有类型的计算机视觉问题； 流行的计算机视觉架构的预训练模型； 以及用于计算机视觉问题的常见转换函数。 另外一个好处是，`torchvision`软件包的函数式 API 的简单性使用户可以编写自定义数据集或转换函数。 以下是`torchvision`程序包中可用的所有当前数据集的表格及其说明：
+`torchvision`的功能分为三类：预加载的，可下载的数据集，用于几乎所有类型的计算机视觉问题； 流行的计算机视觉架构的预训练模型； 以及用于计算机视觉问题的常见转换函数。 另外一个好处是，`torchvision`包的函数式 API 的简单性使用户可以编写自定义数据集或转换函数。 以下是`torchvision`包中可用的所有当前数据集的表格及其说明：
 
 | 数据集 | 描述 |
 | --- | --- |
@@ -333,7 +333,7 @@ print(next(iter(test_iter)))
 
 #### `torchaudio`
 
-音频工具可能是 PyTorch 所有工具包中最不成熟的程序包。 无法安装在`pip`之上的事实证明了这一主张。 但是，`torchaudio`涵盖了音频域中任何问题陈述的基本用例。 此外，PyTorch 还向内核添加了一些方便的功能，例如**逆快速傅里叶变换**（**IFFT**）和**稀疏快速傅里叶变换**（**SFFT**） ，显示 PyTorch 在音频领域的进步。
+音频工具可能是 PyTorch 所有工具包中最不成熟的包。 无法安装在`pip`之上的事实证明了这一主张。 但是，`torchaudio`涵盖了音频域中任何问题陈述的基本用例。 此外，PyTorch 还向内核添加了一些方便的功能，例如**逆快速傅里叶变换**（**IFFT**）和**稀疏快速傅里叶变换**（**SFFT**） ，显示 PyTorch 在音频领域的进步。
 
 `torchaudio`依赖于跨平台音频格式更改器**声音交换**（**SoX**）。 一旦安装了依赖项，就可以使用 Python 设置文件从源文件中安装。
 
@@ -342,7 +342,7 @@ python setup.py install
 
 ```
 
-`torchaudio`带有两个预先构建的数据集，一些转换以及一个用于音频文件的加载和保存工具。 让我们深入探讨其中的每一个。 加载和保存音频文件总是很麻烦，并且依赖于其他几个软件包。 `torchaudio`通过提供简单的加载和保存函数式 API 使其变得更加容易。 `torchtext`可以加载任何常见的音频文件并将其转换为 PyTorch 张量。 它还可以对数据进行规范化和非规范化，以及以任何通用格式写回磁盘。 保存的 API 接受文件路径，并从文件路径推断输出格式，然后将其转换为该格式，然后再将其写回磁盘。
+`torchaudio`带有两个预先构建的数据集，一些转换以及一个用于音频文件的加载和保存工具。 让我们深入探讨其中的每一个。 加载和保存音频文件总是很麻烦，并且依赖于其他几个包。 `torchaudio`通过提供简单的加载和保存函数式 API 使其变得更加容易。 `torchtext`可以加载任何常见的音频文件并将其转换为 PyTorch 张量。 它还可以对数据进行规范化和非规范化，以及以任何通用格式写回磁盘。 保存的 API 接受文件路径，并从文件路径推断输出格式，然后将其转换为该格式，然后再将其写回磁盘。
 
 ```py
 >>> data, sample_rate = torchaudio.load('foo.mp3')
@@ -376,7 +376,7 @@ transform = transforms.Compose(
 
 毕竟，实现模型是我们开发流程中最重要的一步。 在某种程度上，我们为此步骤构建了整个管道。 除了构建网络架构之外，我们还需要考虑许多细节来优化实现（在工作量，时间以及代码效率方面）。
 
-在本次会议中，我们将讨论 PyTorch 软件包本身和`ignite`（PyTorch 的推荐训练者工具）中提供的性能分析和瓶颈工具。 第一部分介绍了瓶颈和性能分析工具，当模型开始表现不佳并且您需要知道哪里出了问题时，这是必不可少的。 本课程的第二部分介绍了训练器模块`ignite`。
+在本次会议中，我们将讨论 PyTorch 包本身和`ignite`（PyTorch 的推荐训练者工具）中提供的性能分析和瓶颈工具。 第一部分介绍了瓶颈和性能分析工具，当模型开始表现不佳并且您需要知道哪里出了问题时，这是必不可少的。 本课程的第二部分介绍了训练器模块`ignite`。
 
 训练器网络并不是真正必需的组件，但它是一个很好的帮助程序工具，可以节省大量时间来编写样板文件和修复错误。 有时，它可以将程序的行数减少一半，这也有助于提高可读性。
 
@@ -596,7 +596,7 @@ def run_evaluator_on_validation_data(engine):
     print(f"Avg accuracy: {avg_accuracy} Avg loss: {avg_nll}")
 ```
 
-`metrics`状态以与最初传递的用户同名的名称保存在`Engine`状态变量中，作为字典，并以输出作为值。 Ignite 只是为用户提供了整个流程流畅和无缝的界面，因此用户不必担心编写所有普通代码。
+`metrics`状态以与最初传递的用户同名的名称保存在`Engine`状态变量中，作为字典，并以输出作为值。 Ignite 只是为用户提供了整个流程流畅和无缝的接口，因此用户不必担心编写所有普通代码。
 
 #### 保存检查点
 

new/pt-dl-handson/4.md

@@ -244,7 +244,7 @@ SimpleCNNModel((conv1): Conv()(pool): MaxPool()(conv2): Conv()
 
 ```
 
-我们已经按照需要的方式连接了神经网络，以便在看到图像时可以给出班级评分。 现在我们定义损失函数和优化器。
+我们已经按照需要的方式连接了神经网络，以便在看到图像时可以给出类评分。 现在我们定义损失函数和优化器。
 
 ```py
 net = SimpleCNNModel()
@@ -257,7 +257,7 @@ trainloader, testloader = get_data()
 
 在下一行中定义的损失函数也是`torch.nn.Module`的子类，它也具有`forward()`函数，该函数由`__call__()`和向后函数调用。 这使我们可以灵活地创建自定义损失函数。
 
-在以后的章节中，我们将提供示例。 现在，我们将使用一个称为`CrossEntropyLoss()`的内置损失函数。 就像前面几章中的一样，我们将使用 PyTorch 优化程序包来获取预定义的优化程序。 对于此示例，我们将**随机梯度下降**（**SGD**）用于示例，但与上一章不同，我们将使用带有动量的 SGD，这有助于我们向正确方向加速梯度。
+在以后的章节中，我们将提供示例。 现在，我们将使用一个称为`CrossEntropyLoss()`的内置损失函数。 就像前面几章中的一样，我们将使用 PyTorch 优化包来获取预定义的优化程序。 对于此示例，我们将**随机梯度下降**（**SGD**）用于示例，但与上一章不同，我们将使用带有动量的 SGD，这有助于我们向正确方向加速梯度。
 
 ##### 注意
 

new/pt-dl-handson/5.md

@@ -339,7 +339,7 @@ class RNNClassifier(nn.Module):
 
 图 5.5：丢弃
 
-PyTorch 作为`torch.nn`程序包的一部分提供了更高级别的丢弃层，该层在初始化时接受退出因子。 它的`forward`函数只是关闭一些输入。
+PyTorch 作为`torch.nn`包的一部分提供了更高级别的丢弃层，该层在初始化时接受退出因子。 它的`forward`函数只是关闭一些输入。
 
 #### 训练
 

new/pt-dl-handson/8.md

@@ -12,7 +12,7 @@ ONNX 很棒，并且每个人都喜欢它，但是 ONNX 的主要缺点之一是
 
 接下来是 TorchScript 的引入，它可以将本机 Python 模型转换为可以在高性能 Universe 中加载的序列化形式，例如 C++ 线程。 PyTorch 的后端 LibTorch 可以读取 TorchScript，这使 PyTorch 高效。 有了它，开发人员可以对模型进行原型设计，甚至可以使用 Python 本身对其进行训练。 训练后，可以将模型转换为到**中间表示**（**IR**）。 目前，仅开发了 C++ 后端，因此可以将 IR 作为 C++ 对象加载，然后可以从 PyTorch 的 C++ API 中读取。 TorchScript 甚至可以在 Python 程序中转换控制流，这在生产支持的情况下使其优于 ONNX 方法。 TorchScript 本身是 Python 语言中可能的操作的子集，因此不允许任何 Python 操作用 TorchScript 编写。 官方文档本身提供了非常详细的说明，并讨论了可能的情况和不可能的情况，以及许多示例[1]。
 
-在本章中，我们将从使用 Flask（流行的 Python Web 框架）提供普通的 Python PyTorch 模型开始。 这样的设置通常就足够了，特别是如果您要设置示例 Web 应用或满足您个人需求或类似用例的东西。 然后，我们将探索 ONNX 并将 PyTorch 模型转换为 MXNet，然后可以使用 MXNet 模型服务器提供服务。 从那里，我们将转到 TorchScript，这是 PyTorch 街区的新孩子。 使用 TorchScript，我们将制作 C++ 可执行文件，然后可以在 LibTorch 的帮助下从 C++ 执行该可执行文件。 然后，可以从稳定，高性能的 C++ 服务器甚至使用 cgo 的 Go 服务器提供高效的 C++ 可执行文件。 对于所有份量，我们将使用在第 2 章，“简单神经网络”中构建的 fizzbuzz 网络。
+在本章中，我们将从使用 Flask（流行的 Python Web 框架）提供普通的 Python PyTorch 模型开始。 这样的设置通常就足够了，特别是如果您要设置示例 Web 应用或满足您个人需求或类似用例的东西。 然后，我们将探索 ONNX 并将 PyTorch 模型转换为 MXNet，然后可以使用 MXNet 模型服务器提供服务。 从那里，我们将转到 TorchScript，这是 PyTorch 社区的新东西。 使用 TorchScript，我们将制作 C++ 可执行文件，然后可以在 LibTorch 的帮助下从 C++ 执行该可执行文件。 然后，可以从稳定，高性能的 C++ 服务器甚至使用 cgo 的 Go 服务器提供高效的 C++ 可执行文件。 对于所有份量，我们将使用在第 2 章，“简单神经网络”中构建的 fizzbuzz 网络。
 
 ## 与 Flask 一起使用
 
@@ -22,7 +22,7 @@ ONNX 很棒，并且每个人都喜欢它，但是 ONNX 的主要缺点之一是
 
 Flask 是的微框架，已被 Python 领域的多家大公司用于生产。 即使 Flask 提供了可用于将 UI 推送到客户端的模板引擎，我们也没有使用它。 相反，我们将制作一个提供 API 的 RESTful 后端。
 
-可以使用`pip`来安装 Flask ，就像其他任何 Python 软件包一样：
+可以使用`pip`来安装 Flask ，就像其他任何 Python 包一样：
 
 ```py
 pip install Flask
@@ -160,9 +160,9 @@ Flask 为我们提供了`request`工具，它是一个全局变量，但对于
 
 #### 为生产准备的服务器
 
-这是关于如何使用 Flask 将 PyTorch 模型部署到服务器的非常基本的演练。 但是 Flask 的内置服务器尚未投入生产，只能用于开发目的。 开发完成后，我们应该使用其他服务器软件包在生产中为 Flask 应用提供服务。
+这是关于如何使用 Flask 将 PyTorch 模型部署到服务器的非常基本的演练。 但是 Flask 的内置服务器尚未投入生产，只能用于开发目的。 开发完成后，我们应该使用其他服务器包在生产中为 Flask 应用提供服务。
 
-Gunicorn 是 Python 开发人员使用的最受欢迎的服务器软件包之一，将其与 Flask 应用绑定非常容易。 您可以使用`pip`安装 Gunicorn，就像我们安装 Flask 一样：
+Gunicorn 是 Python 开发人员使用的最受欢迎的服务器包之一，将其与 Flask 应用绑定非常容易。 您可以使用`pip`安装 Gunicorn，就像我们安装 Flask 一样：
 
 ```py
 pip install gunicorn
@@ -305,7 +305,7 @@ MXNet 比其他服务模块更好。 在撰写本文时，TensorFlow 与 Python
 
 #### MXNet 模型存档器
 
-我们将通过安装 MXNet 模型存档器开始我们的旅程。 MXNet 模型服务器随附的默认模型存档器不支持 ONNX，因此我们需要单独安装。 ONNX 的模型存档器依赖于协议缓冲区和 MXNet 软件包本身。 官方文档中提供了为每个操作系统安装 protobuf 编译器的指南。 可以通过`pip`来安装 MXNet 软件包，就像我们已经安装了其他软件包一样（对于 GPU，MXNet 还有另一个软件包，但是这里我们正在安装 MXNet 的基本版本）：
+我们将通过安装 MXNet 模型存档器开始我们的旅程。 MXNet 模型服务器随附的默认模型存档器不支持 ONNX，因此我们需要单独安装。 ONNX 的模型存档器依赖于协议缓冲区和 MXNet 包本身。 官方文档中提供了为每个操作系统安装 protobuf 编译器的指南。 可以通过`pip`来安装 MXNet 包，就像我们已经安装了其他包一样（对于 GPU，MXNet 还有另一个包，但是这里我们正在安装 MXNet 的基本版本）：
 
 ```py
 pip install mxnet
@@ -683,7 +683,7 @@ redis-server redis.conf --loadmodule ../RedisAI/build/redisai.so
 
 现在，我们的 Redis 服务器已全部就绪。 设置 RedisAI 服务器就这么简单。 现在，使用 Sentinel 或 Cluster 对其进行扩展也并不可怕。 官方文档具有足够的信息供您入门。
 
-在这里，我们从最小的 Python 脚本开始，以使用 RedisAI 运行 fizzbuzz 示例。 我们正在使用 Python 软件包`Redis`与 Redis 服务器通信。 RedisAI 已经建立了一个正式的客户端，但是在撰写本文时还不能使用它。
+在这里，我们从最小的 Python 脚本开始，以使用 RedisAI 运行 fizzbuzz 示例。 我们正在使用 Python 包`Redis`与 Redis 服务器通信。 RedisAI 已经建立了一个正式的客户端，但是在撰写本文时还不能使用它。
 
 ```py
 r = redis.Redis()

new/pt-tut-17/02.md

@@ -8,7 +8,7 @@
 
 ## 什么是 PyTorch？
 
-PyTorch 是基于 Python 的科学计算软件包，可实现两个广泛的目的：
+PyTorch 是基于 Python 的科学计算包，可实现两个广泛的目的：
 
 *   替代 NumPy，以使用 GPU 和其他加速器的功能。
 *   一个自动微分库，对实现神经网络很有用。
@@ -20,7 +20,7 @@ PyTorch 是基于 Python 的科学计算软件包，可实现两个广泛的目
 
 注意
 
-确保已安装[`torch`](https://github.com/pytorch/pytorch)和[`torchvision`](https://github.com/pytorch/vision)软件包。
+确保已安装[`torch`](https://github.com/pytorch/pytorch)和[`torchvision`](https://github.com/pytorch/vision)包。
 
 ![../_img/tensor_illustration_flat.png](img/0c7a402331744a44f5e17575b1607904.png)
 

new/pt-tut-17/05.md

@@ -127,13 +127,13 @@ out.backward(torch.randn(1, 10))
 
 注意
 
-`torch.nn`仅支持小批量。 整个`torch.nn`程序包仅支持作为微型样本而不是单个样本的输入。
+`torch.nn`仅支持小批量。 整个`torch.nn`包仅支持作为微型样本而不是单个样本的输入。
 
 例如，`nn.Conv2d`将采用`nSamples x nChannels x Height x Width`的 4D 张量。
 
 如果您只有一个样品，只需使用`input.unsqueeze(0)`添加一个假批量尺寸。
 
-在继续之前，让我们回顾一下到目前为止所看到的所有课程。
+在继续之前，让我们回顾一下到目前为止所看到的所有类。
 
 **回顾**：
 
@@ -156,7 +156,7 @@ out.backward(torch.randn(1, 10))
 
 损失函数采用一对（输出，目标）输入，并计算一个值，该值估计输出与目标之间的距离。
 
-`nn`软件包下有几种不同的[损失函数](https://pytorch.org/docs/nn.html#loss-functions)。 一个简单的损失是：`nn.MSELoss`，它计算输入和目标之间的均方误差。
+`nn`包下有几种不同的[损失函数](https://pytorch.org/docs/nn.html#loss-functions)。 一个简单的损失是：`nn.MSELoss`，它计算输入和目标之间的均方误差。
 
 例如：
 
@@ -241,7 +241,7 @@ tensor([ 0.0111, -0.0064,  0.0053, -0.0047,  0.0026, -0.0153])
 
 **稍后阅读**：
 
-> 神经网络软件包包含各种模块和损失函数，这些模块和损失函数构成了深度神经网络的构建块。 带有文档的完整列表位于此处。
+> 神经网络包包含各种模块和损失函数，这些模块和损失函数构成了深度神经网络的构建块。 带有文档的完整列表位于此处。
 
 **唯一需要学习的是**：
 

new/pt-tut-17/06.md

@@ -10,11 +10,11 @@
 
 通常，当您必须处理图像，文本，音频或视频数据时，可以使用将数据加载到 NumPy 数组中的标准 Python 包。 然后，您可以将该数组转换为`torch.*Tensor`。
 
-*   对于图像，Pillow，OpenCV 等软件包很有用
-*   对于音频，请使用 SciPy 和 librosa 等软件包
+*   对于图像，Pillow，OpenCV 等包很有用
+*   对于音频，请使用 SciPy 和 librosa 等包
 *   对于文本，基于 Python 或 Cython 的原始加载，或者 NLTK 和 SpaCy 很有用
 
-专门针对视觉，我们创建了一个名为`torchvision`的程序包，其中包含用于常见数据集（例如 Imagenet，CIFAR10，MNIST 等）的数据加载器，以及用于图像（即`torchvision.datasets`和`torch.utils.data.DataLoader`）的数据转换器。
+专门针对视觉，我们创建了一个名为`torchvision`的包，其中包含用于常见数据集（例如 Imagenet，CIFAR10，MNIST 等）的数据加载器，以及用于图像（即`torchvision.datasets`和`torch.utils.data.DataLoader`）的数据转换器。
 
 这提供了极大的便利，并且避免了编写样板代码。
 
@@ -306,7 +306,7 @@ Accuracy of the network on the 10000 test images: 53 %
 
 ```
 
-看起来比偶然更好，准确率是 10%（从 10 个班级中随机选择一个班级）。 好像网络学到了一些东西。
+看起来比偶然更好，准确率是 10%（从 10 个类中随机选择一个类）。 好像网络学到了一些东西。
 
 嗯，哪些类的表现良好，哪些类的表现不佳：
 

new/pt-tut-17/07.md

@@ -131,7 +131,7 @@ print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3'
 
 在上述示例中，我们必须手动实现神经网络的前向和后向传递。 对于小型的两层网络，手动实现反向传递并不是什么大问题，但是对于大型的复杂网络来说，可以很快变得非常麻烦。
 
-幸运的是，我们可以使用[自动微分](https://en.wikipedia.org/wiki/Automatic_differentiation)来自动计算神经网络中的反向传递。 PyTorch 中的 **Autograd** 软件包正是提供了此功能。 使用 Autograd 时，网络的正向传播将定义**计算图**； 图中的节点为张量，边为从输入张量产生输出张量的函数。 然后通过该图进行反向传播，可以轻松计算梯度。
+幸运的是，我们可以使用[自动微分](https://en.wikipedia.org/wiki/Automatic_differentiation)来自动计算神经网络中的反向传递。 PyTorch 中的 **Autograd** 包正是提供了此功能。 使用 Autograd 时，网络的正向传播将定义**计算图**； 图中的节点为张量，边为从输入张量产生输出张量的函数。 然后通过该图进行反向传播，可以轻松计算梯度。
 
 这听起来很复杂，在实践中非常简单。 每个张量代表计算图中的一个节点。 如果`x`是具有`x.requires_grad=True`的张量，则`x.grad`是另一个张量，其保持`x`相对于某个标量值的梯度。
 
@@ -301,9 +301,9 @@ print(f'Result: y = {a.item()} + {b.item()} * P3({c.item()} + {d.item()} x)')
 
 在构建神经网络时，我们经常想到将计算安排在**层**中，其中某些层具有**可学习的参数**，这些参数会在学习期间进行优化。
 
-在 TensorFlow 中，像 [Keras](https://github.com/fchollet/keras) ， [TensorFlow-Slim](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/slim) 和 [TFLearn](http://tflearn.org/) 之类的软件包在原始计算图上提供了更高层次的抽象，可用于构建神经网络。
+在 TensorFlow 中，像 [Keras](https://github.com/fchollet/keras) ， [TensorFlow-Slim](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/slim) 和 [TFLearn](http://tflearn.org/) 之类的包在原始计算图上提供了更高层次的抽象，可用于构建神经网络。
 
-在 PyTorch 中，`nn`包也达到了相同的目的。 `nn`包定义了一组**模块**，它们大致等效于神经网络层。 模块接收输入张量并计算输出张量，但也可以保持内部状态，例如包含可学习参数的张量。 `nn`程序包还定义了一组有用的损失函数，这些函数通常在训练神经网络时使用。
+在 PyTorch 中，`nn`包也达到了相同的目的。 `nn`包定义了一组**模块**，它们大致等效于神经网络层。 模块接收输入张量并计算输出张量，但也可以保持内部状态，例如包含可学习参数的张量。 `nn`包还定义了一组有用的损失函数，这些函数通常在训练神经网络时使用。
 
 在此示例中，我们使用`nn`包来实现我们的多项式模型网络：
 
@@ -384,7 +384,7 @@ print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item
 
 到目前为止，我们已经通过使用`torch.no_grad()`手动更改持有可学习参数的张量来更新模型的权重。 对于像随机梯度下降这样的简单优化算法来说，这并不是一个巨大的负担，但是在实践中，我们经常使用更复杂的优化器（例如 AdaGrad，RMSProp，Adam 等）来训练神经网络。
 
-PyTorch 中的`optim`软件包抽象了优化算法的思想，并提供了常用优化算法的实现。
+PyTorch 中的`optim`包抽象了优化算法的思想，并提供了常用优化算法的实现。
 
 在此示例中，我们将使用`nn`包像以前一样定义我们的模型，但是我们将使用`optim`包提供的 RMSprop 算法来优化模型：
 

new/pt-tut-17/12.md

@@ -4,7 +4,7 @@
 
 经过训练的三阶多项式，可以通过最小化平方的欧几里得距离来预测`y = sin(x)`从`-pi`到`pi`。
 
-此实现使用来自 PyTorch 的`nn`软件包来构建网络。 PyTorch Autograd 使定义计算图和获取梯度变得容易，但是原始的 Autograd 对于定义复杂的神经网络来说可能太低了。 这是`nn`软件包可以提供帮助的地方。 `nn`包定义了一组模块，您可以将其视为神经网络层，该神经网络层从输入产生输出并且可能具有一些可训练的权重。
+此实现使用来自 PyTorch 的`nn`包来构建网络。 PyTorch Autograd 使定义计算图和获取梯度变得容易，但是原始的 Autograd 对于定义复杂的神经网络来说可能太低了。 这是`nn`包可以提供帮助的地方。 `nn`包定义了一组模块，您可以将其视为神经网络层，该神经网络层从输入产生输出并且可能具有一些可训练的权重。
 
 ```py
 import torch

new/pt-tut-17/13.md

@@ -4,9 +4,9 @@
 
 经过训练的三阶多项式，可以通过最小化平方的欧几里得距离来预测`y = sin(x)`从`-pi`到`pi`。
 
-此实现使用来自 PyTorch 的`nn`软件包来构建网络。
+此实现使用来自 PyTorch 的`nn`包来构建网络。
 
-与其像以前那样手动更新模型的权重，不如使用`optim`包定义一个优化器，该优化器将为我们更新权重。 `optim`软件包定义了许多深度学习常用的优化算法，包括 SGD + 动量，RMSProp，Adam 等。
+与其像以前那样手动更新模型的权重，不如使用`optim`包定义一个优化器，该优化器将为我们更新权重。 `optim`包定义了许多深度学习常用的优化算法，包括 SGD + 动量，RMSProp，Adam 等。
 
 ```py
 import torch

new/pt-tut-17/16.md

@@ -434,7 +434,7 @@ tensor(0.0824, grad_fn=<NllLossBackward>)
 
 ## 使用`optim`重构
 
-Pytorch 还提供了一个包含各种优化算法的软件包`torch.optim`。 我们可以使用优化器中的`step`方法采取向前的步骤，而不是手动更新每个参数。
+Pytorch 还提供了一个包含各种优化算法的包`torch.optim`。 我们可以使用优化器中的`step`方法采取向前的步骤，而不是手动更新每个参数。
 
 这将使我们替换之前的手动编码优化步骤：
 

new/pt-tut-17/19.md

@@ -32,7 +32,7 @@
 
 `pip install git+https://github.com/gautamchitnis/cocoapi.git@cocodataset-master#subdirectory=PythonAPI`
 
-关于`labels`的注释。 该模型将`0`类作为背景。 如果您的数据集不包含背景类，则`labels`中不应包含`0`。 例如，假设您只有*猫*和*狗*两类，则可以定义`1`来表示*猫*和`0`代表*狗*。 因此，例如，如果其中一个图像同时具有两个类，则您的`labels`张量应类似于`[1,2]`。
+关于`labels`的注解。 该模型将`0`类作为背景。 如果您的数据集不包含背景类，则`labels`中不应包含`0`。 例如，假设您只有*猫*和*狗*两类，则可以定义`1`来表示*猫*和`0`代表*狗*。 因此，例如，如果其中一个图像同时具有两个类，则您的`labels`张量应类似于`[1,2]`。
 
 此外，如果要在训练过程中使用宽高比分组（以便每个批量仅包含具有相似长宽比的图像），则建议您还实现`get_height_and_width`方法，该方法返回图像的高度和宽度。 如果未提供此方法，我们将通过`__getitem__`查询数据集的所有元素，这会将图像加载到内存中，并且比提供自定义方法慢。
 
@@ -155,7 +155,7 @@ Mask R-CNN 在 Faster R-CNN 中增加了一个分支，该分支还可以预测
 
 ### 1-将预训练模型用于微调
 
-假设您要从在 COCO 上经过预训练的模型开始，并希望针对您的特定班级对其进行微调。 这是一种可行的方法：
+假设您要从在 COCO 上经过预训练的模型开始，并希望针对您的特定类对其进行微调。 这是一种可行的方法：
 
 ```py
 import torchvision

new/pt-tut-17/20.md

@@ -6,7 +6,7 @@
 
 在本教程中，您将学习如何使用迁移学习训练卷积神经网络进行图像分类。 您可以在 [cs231n 笔记](https://cs231n.github.io/transfer-learning/)中阅读有关转学的更多信息。
 
-引用这些注释，
+引用这些注解，
 
 > 实际上，很少有人从头开始训练整个卷积网络（使用随机初始化），因为拥有足够大小的数据集相对很少。 相反，通常在非常大的数据集上对 ConvNet 进行预训练（例如 ImageNet，其中包含 120 万个具有 1000 个类别的图像），然后将 ConvNet 用作初始化或固定特征提取器以完成感兴趣的任务。
 

new/pt-tut-17/24.md

@@ -6,7 +6,7 @@ PyTorch 是一个开源深度学习平台，提供了从研究原型到具有 GP
 
 解决机器学习问题的重要工作是准备数据。 `torchaudio`充分利用了 PyTorch 的 GPU 支持，并提供了许多工具来简化数据加载并使其更具可读性。 在本教程中，我们将看到如何从简单的数据集中加载和预处理数据。 请访问[音频 I/O 和`torchaudio`](https://pytorch.org/tutorials/beginner/audio_preprocessing_tutorial.html)的预处理，以了解更多信息。
 
-对于本教程，请确保已安装`matplotlib`软件包，以便于查看。
+对于本教程，请确保已安装`matplotlib`包，以便于查看。
 
 ```py
 # Uncomment the following line to run in Google Colab
@@ -447,7 +447,7 @@ Shape of mfcc: torch.Size([1383, 13])
 
 ## 可用数据集
 
-如果您不想创建自己的数据集来训练模型，则`torchaudio`提供了统一的数据集界面。 该接口支持将文件延迟加载到内存，下载和提取函数以及数据集以构建模型。
+如果您不想创建自己的数据集来训练模型，则`torchaudio`提供了统一的数据集接口。 该接口支持将文件延迟加载到内存，下载和提取函数以及数据集以构建模型。
 
 当前支持的数据集`torchaudio`为：
 

new/pt-tut-17/25.md

@@ -6,7 +6,7 @@
 
 Colab 提供了 GPU 选项。 在菜单选项卡中，选择“运行系统”，然后选择“更改运行系统类型”。 在随后的弹出窗口中，您可以选择 GPU。 更改之后，运行时应自动重新启动（这意味着来自已执行单元的信息会消失）。
 
-首先，让我们导入常见的 Torch 程序包，例如[`torchaudio`](https://github.com/pytorch/audio)，可以按照网站上的说明进行安装。
+首先，让我们导入常见的 Torch 包，例如[`torchaudio`](https://github.com/pytorch/audio)，可以按照网站上的说明进行安装。
 
 ```py
 # Uncomment the following line to run in Google Colab

new/pt-tut-17/34.md

@@ -20,14 +20,14 @@
 
 严格来说，我们将状态显示为当前屏幕补丁与前一个屏幕补丁之间的差异。 这将允许智能体从一张图像中考虑极点的速度。
 
-**软件包**
+**包**
 
-首先，让我们导入所需的软件包。 首先，我们需要针对环境的 [Gym](https://gym.openai.com/docs)（使用`pip install Gym`进行安装）。 我们还将使用 PyTorch 中的以下内容：
+首先，让我们导入所需的包。 首先，我们需要针对环境的 [Gym](https://gym.openai.com/docs)（使用`pip install Gym`进行安装）。 我们还将使用 PyTorch 中的以下内容：
 
 *   神经网络（`torch.nn`）
 *   优化（`torch.optim`）
 *   自动微分（`torch.autograd`）
-*   视觉任务的工具（`torchvision`-[单独的软件包](https://github.com/pytorch/vision)）。
+*   视觉任务的工具（`torchvision`-[单独的包](https://github.com/pytorch/vision)）。
 
 ```py
 import gym
@@ -158,7 +158,7 @@ class DQN(nn.Module):
 
 ### 输入提取
 
-以下代码是用于从环境中提取和处理渲染图像的工具。 它使用`torchvision`程序包，可轻松组成图像变换。 一旦运行单元，它将显示它提取的示例补丁。
+以下代码是用于从环境中提取和处理渲染图像的工具。 它使用`torchvision`包，可轻松组成图像变换。 一旦运行单元，它将显示它提取的示例补丁。
 
 ```py
 resize = T.Compose([T.ToPILImage(),

new/pt-tut-17/39.md

@@ -8,7 +8,7 @@
 
 PyTorch 模型从 Python 到 C++ 的旅程由 [Torch 脚本](https://pytorch.org/docs/master/jit.html)启用，它是 PyTorch 模型的一种表示形式，可以由 Torch 脚本编译器理解，编译和序列化。 如果您从使用原始“渴望” API 编写的现有 PyTorch 模型开始，则必须首先将模型转换为 Torch 脚本。 在最常见的情况下（如下所述），只需很少的努力。 如果您已经有了 Torch 脚本模块，则可以跳到本教程的下一部分。
 
-有两种将 PyTorch 模型转换为 Torch 脚本的方法。 第一种称为*跟踪*，该机制通过使用示例输入对模型的结构进行一次评估，并记录这些输入在模型中的流量来捕获模型的结构。 这适用于有限使用控制流的模型。 第二种方法是在模型中添加显式批注，以告知 TorchScript 编译器可以根据 Torch Script 语言施加的约束直接解析和编译模型代码。
+有两种将 PyTorch 模型转换为 Torch 脚本的方法。 第一种称为*跟踪*，该机制通过使用示例输入对模型的结构进行一次评估，并记录这些输入在模型中的流量来捕获模型的结构。 这适用于有限使用控制流的模型。 第二种方法是在模型中添加显式注解，以告知 TorchScript 编译器可以根据 Torch Script 语言施加的约束直接解析和编译模型代码。
 
 小费
 

new/pt-tut-17/40.md

@@ -85,7 +85,7 @@ torch_model.eval()
 
 在 PyTorch 中导出模型是通过跟踪或脚本编写的。 本教程将以通过跟踪导出的模型为例。 要导出模型，我们调用`torch.onnx.export()`函数。 这将执行模型，并记录使用什么运算符计算输出的轨迹。 因为`export`运行模型，所以我们需要提供输入张量`x`。 只要是正确的类型和大小，其中的值就可以是随机的。 请注意，除非指定为动态轴，否则输入尺寸将在导出的 ONNX 图形中固定为所有输入尺寸。 在此示例中，我们使用输入`batch_size 1`导出模型，但随后在`torch.onnx.export()`的`dynamic_axes`参数中将第一维指定为动态。 因此，导出的模型将接受大小为`[batch_size, 1, 224, 224]`的输入，其中`batch_size`可以是可变的。
 
-要了解有关 PyTorch 导出界面的更多详细信息，请查看[`torch.onnx`文档](https://pytorch.org/docs/master/onnx.html)。
+要了解有关 PyTorch 导出接口的更多详细信息，请查看[`torch.onnx`文档](https://pytorch.org/docs/master/onnx.html)。
 
 ```py
 # Input to the model

new/pt-tut-17/44.md

@@ -153,7 +153,7 @@ root@fa350df05ecf:/home/build# ./dcgan
 
 ### 模块 API 基础
 
-与 Python 界面一致，基于 C++ 前端的神经网络由称为*模块*的可重用构建块组成。 有一个基础模块类，所有其他模块都从该基础类派生。 在 Python 中，此类为`torch.nn.Module`，在 C++ 中为`torch::nn::Module`。 除了实现模块封装的算法的`forward()`方法之外，模块通常还包含以下三种子对象中的任何一种：参数，缓冲区和子模块。
+与 Python 接口一致，基于 C++ 前端的神经网络由称为*模块*的可重用构建块组成。 有一个基础模块类，所有其他模块都从该基础类派生。 在 Python 中，此类为`torch.nn.Module`，在 C++ 中为`torch::nn::Module`。 除了实现模块封装的算法的`forward()`方法之外，模块通常还包含以下三种子对象中的任何一种：参数，缓冲区和子模块。
 
 参数和缓冲区以张量的形式存储状态。 参数记录梯度，而缓冲区不记录。 参数通常是神经网络的可训练权重。 缓冲区的示例包括批量标准化的均值和方差。 为了重用特定的逻辑和状态块，PyTorch API 允许嵌套模块。 嵌套模块称为*子模块*。
 
@@ -161,7 +161,7 @@ root@fa350df05ecf:/home/build# ./dcgan
 
 #### 定义模块和注册参数
 
-为了将这些词写成代码，让我们考虑一下用 Python 界面编写的简单模块：
+为了将这些词写成代码，让我们考虑一下用 Python 接口编写的简单模块：
 
 ```py
 import torch
@@ -835,7 +835,7 @@ torch::Device device(torch::cuda::is_available() ? torch::kCUDA : torch::kCPU);
 
 ## 检查点和恢复训练状态
 
-我们应该对训练脚本进行的最后扩充是定期保存模型参数的状态，优化器的状态以及一些生成的图像样本。 如果我们的计算机在训练过程中崩溃，则前两个将使我们能够恢复训练状态。 对于长期的训练课程，这是绝对必要的。 幸运的是，C++ 前端提供了一个 API，用于对模型和优化器状态以及单个张量进行序列化和反序列化。
+我们应该对训练脚本进行的最后扩充是定期保存模型参数的状态，优化器的状态以及一些生成的图像样本。 如果我们的计算机在训练过程中崩溃，则前两个将使我们能够恢复训练状态。 对于长期的训练过程，这是绝对必要的。 幸运的是，C++ 前端提供了一个 API，用于对模型和优化器状态以及单个张量进行序列化和反序列化。
 
 为此的核心 API 是`torch::save(thing,filename)`和`torch::load(thing,filename)`，其中`thing`可以是`torch::nn::Module`子类，也可以是优化脚本实例，例如我们在训练脚本中拥有的`Adam`对象。 让我们更新训练循环，以一定间隔检查模型和优化器状态：
 

new/pt-tut-17/46.md

@@ -4,7 +4,7 @@
 
 PyTorch 1.0 版本向 PyTorch 引入了一种新的编程模型，称为 [TorchScript](https://pytorch.org/docs/master/jit.html) 。 TorchScript 是 Python 编程语言的子集，可以通过 TorchScript 编译器进行解析，编译和优化。 此外，已编译的 TorchScript 模型可以选择序列化为磁盘文件格式，然后可以从纯 C++（以及 Python）加载并运行该文件格式以进行推理。
 
-TorchScript 支持`torch`包提供的大量操作子集，使您可以纯粹表示为 PyTorch 的“标准库”中的一系列张量操作来表示多种复杂模型。 但是，有时您可能需要使用自定义 C++ 或 CUDA 函数扩展 TorchScript。 虽然我们建议您仅在无法（简单有效地）将您的想法表达为简单的 Python 函数时才诉诸该选项，但我们确实提供了一个非常友好且简单的界面，用于使用 [ATen](https://pytorch.org/cppdocs/#aten) 定义自定义 C++ 和 CUDA 内核。 ，PyTorch 的高性能 C++ 张量库。 绑定到 TorchScript 后，您可以将这些自定义内核（或“操作”）嵌入到 TorchScript 模型中，并以 Python 或直接以 C++ 的序列化形式执行它们。
+TorchScript 支持`torch`包提供的大量操作子集，使您可以纯粹表示为 PyTorch 的“标准库”中的一系列张量操作来表示多种复杂模型。 但是，有时您可能需要使用自定义 C++ 或 CUDA 函数扩展 TorchScript。 虽然我们建议您仅在无法（简单有效地）将您的想法表达为简单的 Python 函数时才诉诸该选项，但我们确实提供了一个非常友好且简单的接口，用于使用 [ATen](https://pytorch.org/cppdocs/#aten) 定义自定义 C++ 和 CUDA 内核。 ，PyTorch 的高性能 C++ 张量库。 绑定到 TorchScript 后，您可以将这些自定义内核（或“操作”）嵌入到 TorchScript 模型中，并以 Python 或直接以 C++ 的序列化形式执行它们。
 
 以下段落提供了一个编写 TorchScript 自定义操作以调用 [OpenCV](https://www.opencv.org) （使用 C++ 编写的计算机视觉库）的示例。 我们将讨论如何在 C++ 中使用张量，如何有效地将它们转换为第三方张量格式（在这种情况下为 OpenCV `Mat`），如何在 TorchScript 运行时中注册您的运算符，以及最后如何编译该运算符并在 Python 和 C++ 中使用它。
 
@@ -322,7 +322,7 @@ graph(%x.1 : Float(4:8, 8:1),
 
 ### 将自定义运算符与脚本一起使用
 
-除了跟踪之外，获得 PyTorch 程序的 TorchScript 表示形式的另一种方法是直接在 TorchScript 中编写代码。 TorchScript 在很大程度上是 Python 语言的子集，它具有一些限制，使 TorchScript 编译器更容易推理程序。 您可以使用`@torch.jit.script`标记自由函数，使用`@torch.jit.script_method`标记类中的方法（也必须从`torch.jit.ScriptModule`派生），将常规 PyTorch 代码转换为 TorchScript。 有关 TorchScript 批注的更多详细信息，请参见[此处](https://pytorch.org/docs/master/jit.html)。
+除了跟踪之外，获得 PyTorch 程序的 TorchScript 表示形式的另一种方法是直接在 TorchScript 中编写代码。 TorchScript 在很大程度上是 Python 语言的子集，它具有一些限制，使 TorchScript 编译器更容易推理程序。 您可以使用`@torch.jit.script`标记自由函数，使用`@torch.jit.script_method`标记类中的方法（也必须从`torch.jit.ScriptModule`派生），将常规 PyTorch 代码转换为 TorchScript。 有关 TorchScript 注解的更多详细信息，请参见[此处](https://pytorch.org/docs/master/jit.html)。
 
 使用 TorchScript 而不是跟踪的一个特殊原因是，跟踪无法捕获 PyTorch 代码中的控制流。 因此，让我们考虑使用控制流的此函数：
 
@@ -336,7 +336,7 @@ def compute(x, y):
 
 ```
 
-要将此函数从原始 PyTorch 转换为 TorchScript，我们用`@torch.jit.script`对其进行注释：
+要将此函数从原始 PyTorch 转换为 TorchScript，我们用`@torch.jit.script`对其进行注解：
 
 ```py
 @torch.jit.script
@@ -547,7 +547,7 @@ target_compile_features(example_app PRIVATE cxx_range_for)
 
 上面的示例中嵌入了一个关键细节：`warp_perspective`链接行的`-Wl,--no-as-needed`前缀。 这是必需的，因为我们实际上不会在应用代码中从`warp_perspective`共享库中调用任何函数。 我们只需要运行`TORCH_LIBRARY`函数。 麻烦的是，这使链接器感到困惑，并使其认为可以完全跳过与库的链接。 在 Linux 上，`-Wl,--no-as-needed`标志会强制链接发生（注意：此标志特定于 Linux！）。 还有其他解决方法。 最简单的方法是在运算符库中定义*一些函数*，您需要从主应用中调用该函数。 这可能就像在某个标头中声明的函数`void init();`一样简单，然后在运算符库中将其定义为`void init() { }`。 在主应用中调用此`init()`函数会给链接器以印象，这是一个值得链接的库。 不幸的是，这超出了我们的控制范围，我们宁愿让您知道其原因和简单的解决方法，而不是让您将一些不透明的宏放入代码中。
 
-现在，由于我们现在在顶层找到了`Torch`软件包，因此`warp_perspective`子目录中的`CMakeLists.txt`文件可以缩短一些。 它看起来应该像这样：
+现在，由于我们现在在顶层找到了`Torch`包，因此`warp_perspective`子目录中的`CMakeLists.txt`文件可以缩短一些。 它看起来应该像这样：
 
 ```py
 find_package(OpenCV REQUIRED)
@@ -631,7 +631,7 @@ $ ./example_app example.pt
 
 “构建自定义运算符”一节介绍了如何使用 CMake 将自定义运算符构建到共享库中。 本附录概述了两种进一步的编译方法。 他们俩都使用 Python 作为编译过程的“驱动程序”或“接口”。 此外，两者都重用了[现有基础结构](https://pytorch.org/docs/stable/cpp_extension.html)。 PyTorch 提供了 [C++ 扩展](https://pytorch.org/tutorials/advanced/cpp_extension.html)，它们依赖于[`pybind11`](https://github.com/pybind/pybind11)用于将函数从 C++ “显式”绑定到 Python。
 
-第一种方法是使用 C++ 扩展程序的[方便的即时（JIT）编译界面](https://pytorch.org/docs/stable/cpp_extension.html#torch.utils.cpp_extension.load)在您首次运行 PyTorch 脚本时在后台编译代码。 第二种方法依赖于古老的`setuptools`包，并涉及编写单独的`setup.py`文件。 这样可以进行更高级的配置，并与其他基于`setuptools`的项目集成。 我们将在下面详细探讨这两种方法。
+第一种方法是使用 C++ 扩展程序的[方便的即时（JIT）编译接口](https://pytorch.org/docs/stable/cpp_extension.html#torch.utils.cpp_extension.load)在您首次运行 PyTorch 脚本时在后台编译代码。 第二种方法依赖于古老的`setuptools`包，并涉及编写单独的`setup.py`文件。 这样可以进行更高级的配置，并与其他基于`setuptools`的项目集成。 我们将在下面详细探讨这两种方法。
 
 ### 使用 JIT 编译的构建
 

new/pt-tut-17/48.md

@@ -73,7 +73,7 @@ print(example(torch.ones([])))
 
 注意
 
-当我们初始化一个空的期货列表时，我们需要在`futures`上添加一个显式类型注释。 在 TorchScript 中，空容器默认假定它们包含张量值，因此我们将列表构造器＃注释为`List[torch.jit.Future[torch.Tensor]]`类型
+当我们初始化一个空的期货列表时，我们需要在`futures`上添加一个显式类型注解。 在 TorchScript 中，空容器默认假定它们包含张量值，因此我们将列表构造器`#`注解为`List[torch.jit.Future[torch.Tensor]]`类型
 
 本示例使用`fork()`启动函数`foo`的 100 个实例，等待 100 个任务完成，然后对结果求和，返回`-100.0`。
 

new/pt-tut-17/49.md

@@ -2,7 +2,7 @@
 
 > 原文：<https://pytorch.org/tutorials/advanced/cpp_autograd.html>
 
-`autograd`软件包对于在 PyTorch 中构建高度灵活和动态的神经网络至关重要。 PyTorch Python 前端中的大多数 autograd API 也可以在 C++ 前端中使用，从而可以轻松地将 Autograd 代码从 Python 转换为 C++。
+`autograd`包对于在 PyTorch 中构建高度灵活和动态的神经网络至关重要。 PyTorch Python 前端中的大多数 autograd API 也可以在 C++ 前端中使用，从而可以轻松地将 Autograd 代码从 Python 转换为 C++。
 
 在本教程中，我们将看几个在 PyTorch C++ 前端中进行 Autograd 的示例。 请注意，本教程假定您已经对 Python 前端中的 Autograd 有基本的了解。 如果不是这种情况，请先阅读 [Autograd：自动微分](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html)。
 

new/pt-tut-17/53.md

@@ -15,7 +15,7 @@
 3.  添加检查点（可选），
 4.  并定义用于模型调整的搜索空间
 
-要运行本教程，请确保已安装以下软件包：
+要运行本教程，请确保已安装以下包：
 
 *   `ray[tune]`：分布式超参数调整库
 *   `torchvision`：用于数据转换器

new/pt-tut-17/56.md

@@ -18,7 +18,7 @@
 
 *   BERT，或者说转换器的双向嵌入表示，是一种预训练语言表示的新方法，它可以在许多常见的自然语言处理（NLP）任务（例如问题解答，文本分类， 和别的。 [可以在此处找到](https://arxiv.org/pdf/1810.04805.pdf)。
 *   PyTorch 中的动态量化支持将浮点模型转换为具有静态`int8`或`float16`数据类型的权重和动态量化激活的量化模型。 当权重量化为`int8`时，激活（每批）动态量化为`int8`。 在 PyTorch 中，我们有[`torch.quantization.quantize_dynamic` API](https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic)，该 API 用仅动态权重的量化版本替换了指定的模块，并输出了量化模型。
-*   我们在[通用语言理解评估基准（GLUE）](https://gluebenchmark.com/)中演示了 [Microsoft Research Paraphrase 语料库（MRPC）任务](https://www.microsoft.com/en-us/download/details.aspx?id=52398)的准确率和推理表现结果。 MRPC（Dolan 和 Brockett，2005 年）是从在线新闻源中自动提取的句子对的语料库，带有人工注释，说明句子中的句子在语义上是否等效。 由于班级不平衡（正向为 68%，负向为 32%），我们遵循常规做法并报告 [F1 得分](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html)。 MRPC 是用于语言对分类的常见 NLP 任务，如下所示。
+*   我们在[通用语言理解评估基准（GLUE）](https://gluebenchmark.com/)中演示了 [Microsoft Research Paraphrase 语料库（MRPC）任务](https://www.microsoft.com/en-us/download/details.aspx?id=52398)的准确率和推理表现结果。 MRPC（Dolan 和 Brockett，2005 年）是从在线新闻源中自动提取的句子对的语料库，带有人工标注，说明句子中的句子在语义上是否等效。 由于类别不平衡（正向为 68%，负向为 32%），我们遵循常规做法并报告 [F1 得分](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html)。 MRPC 是用于语言对分类的常见 NLP 任务，如下所示。
 
 ![../_img/bert.png](img/b43b70d8a6eef9ea4f75867b5e83b483.png)
 
@@ -26,7 +26,7 @@
 
 ### 1.1 安装 PyTorch 和 HuggingFace 转换器
 
-要开始本教程，首先请遵循 [PyTorch](https://github.com/pytorch/pytorch/#installation) 和 [HuggingFace Github 仓库](https://github.com/huggingface/transformers#installation)中的安装说明。 此外，我们还将安装 [scikit-learn](https://github.com/scikit-learn/scikit-learn) 软件包，因为我们将重复使用其内置的 F1 分数计算助手函数。
+要开始本教程，首先请遵循 [PyTorch](https://github.com/pytorch/pytorch/#installation) 和 [HuggingFace Github 仓库](https://github.com/huggingface/transformers#installation)中的安装说明。 此外，我们还将安装 [scikit-learn](https://github.com/scikit-learn/scikit-learn) 包，因为我们将重复使用其内置的 F1 分数计算助手函数。
 
 ```py
 pip install sklearn

new/pt-tut-17/60.md

@@ -4,7 +4,7 @@
 
 **作者**：[Shen Li](https://mrshenli.github.io/)
 
-这是`torch.distributed`软件包的概述页面。 由于在不同位置添加了越来越多的文档，示例和教程，因此不清楚要针对特定​​问题咨询哪个文档或教程，或者阅读这些内容的最佳顺序是什么。 该页面的目的是通过将文档分类为不同的主题并简要描述每个主题来解决此问题。 如果这是您第一次使用 PyTorch 构建分布式训练应用，建议使用本文档导航至最适合您的用例的技术。
+这是`torch.distributed`包的概述页面。 由于在不同位置添加了越来越多的文档，示例和教程，因此不清楚要针对特定​​问题咨询哪个文档或教程，或者阅读这些内容的最佳顺序是什么。 该页面的目的是通过将文档分类为不同的主题并简要描述每个主题来解决此问题。 如果这是您第一次使用 PyTorch 构建分布式训练应用，建议使用本文档导航至最适合您的用例的技术。
 
 ## 简介
 
@@ -32,7 +32,7 @@ PyTorch 为数据并行训练提供了几种选择。 对于从简单到复杂
 
 ### `torch.nn.DataParallel`
 
-[`DataParallel`](https://pytorch.org/docs/master/generated/torch.nn.DataParallel.html)软件包以最低的编码障碍实现了单机多 GPU 并行处理。 它只需要一行更改应用代码。 教程[可选：数据并行](https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html)显示了一个示例。 需要注意的是，尽管`DataParallel`非常易于使用，但通常无法提供最佳性能。 这是因为`DataParallel`的实现会在每个正向传播中复制该模型，并且其单进程多线程并行性自然会遭受 GIL 争用。 为了获得更好的性能，请考虑使用[`DistributedDataParallel`](https://pytorch.org/docs/master/generated/torch.nn.parallel.DistributedDataParallel.html)。
+[`DataParallel`](https://pytorch.org/docs/master/generated/torch.nn.DataParallel.html)包以最低的编码障碍实现了单机多 GPU 并行处理。 它只需要一行更改应用代码。 教程[可选：数据并行](https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html)显示了一个示例。 需要注意的是，尽管`DataParallel`非常易于使用，但通常无法提供最佳性能。 这是因为`DataParallel`的实现会在每个正向传播中复制该模型，并且其单进程多线程并行性自然会遭受 GIL 争用。 为了获得更好的性能，请考虑使用[`DistributedDataParallel`](https://pytorch.org/docs/master/generated/torch.nn.parallel.DistributedDataParallel.html)。
 
 ### `torch.nn.parallel.DistributedDataParallel`
 
@@ -40,7 +40,7 @@ PyTorch 为数据并行训练提供了几种选择。 对于从简单到复杂
 
 DDP 材料如下：
 
-1.  [DDP 注释](https://pytorch.org/docs/stable/notes/ddp.html)提供了一个入门示例，并简要介绍了其设计和实现。 如果这是您第一次使用 DDP，请从本文档开始。
+1.  [DDP 注解](https://pytorch.org/docs/stable/notes/ddp.html)提供了一个入门示例，并简要介绍了其设计和实现。 如果这是您第一次使用 DDP，请从本文档开始。
 2.  [分布式数据并行入门](../intermediate/ddp_tutorial.html)解释了 DDP 训练的一些常见问题，包括不平衡的工作量，检查点和多设备模型。 请注意，DDP 可以轻松与[单机模型并行最佳实践](../intermediate/model_parallel_tutorial.html)教程中描述的单机多设备模型并行性结合。
 3.  [启动和配置分布式数据并行应用](https://github.com/pytorch/examples/blob/master/distributed/ddp/README.md)文档显示了如何使用 DDP 启动脚本。
 4.  [使用 Amazon AWS 的 PyTorch 分布式训练器](aws_distributed_training_tutorial.html)演示了如何在 AWS 上使用 DDP。
@@ -53,10 +53,10 @@ DDP 材料如下：
 
 许多训练范式不适合数据并行性，例如参数服务器范式，分布式管道并行性，具有多个观察者或智能体的强化学习应用等。 [`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)旨在支持一般的分布式训练方案 。
 
-[`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)程序包具有四个主要支柱：
+[`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)包具有四个主要支柱：
 
 *   [RPC](https://pytorch.org/docs/master/rpc.html#rpc) 支持在远程工作器上运行给定函数
-*   [RRef](https://pytorch.org/docs/master/rpc.html#rref) 帮助管理远程对象的生存期。 引用计数协议在 [RRef 注释](https://pytorch.org/docs/master/rpc/rref.html#remote-reference-protocol)中提供。
+*   [RRef](https://pytorch.org/docs/master/rpc.html#rref) 帮助管理远程对象的生存期。 引用计数协议在 [RRef 注解](https://pytorch.org/docs/master/rpc/rref.html#remote-reference-protocol)中提供。
 *   [分布式自动微分](https://pytorch.org/docs/master/rpc.html#distributed-autograd-framework)将自动微分引擎扩展到机器范围之外。 有关更多详细信息，请参考[分布式 Autograd 设计](https://pytorch.org/docs/master/rpc/distributed_autograd.html#distributed-autograd-design)。
 *   [分布式优化器](https://pytorch.org/docs/master/rpc.html#module-torch.distributed.optim)，它使用分布式 Autograd 引擎计算的梯度自动与所有参与的工作人员联系以更新参数。
 

new/pt-tut-17/62.md

@@ -12,7 +12,7 @@
 *   [`DistributedDataParallel` API 文档](https://pytorch.org/docs/master/generated/torch.nn.parallel.DistributedDataParallel.html)
 *   [`DistributedDataParallel`注意事项](https://pytorch.org/docs/master/notes/ddp.html)
 
-[`DistributedDataParallel`](https://pytorch.org/docs/stable/nn.html#torch.nn.parallel.DistributedDataParallel)（DDP）在模块级别实现可在多台计算机上运行的数据并行性。 使用 DDP 的应用应产生多个进程，并为每个进程创建一个 DDP 实例。 DDP 在[`torch.distributed`](https://pytorch.org/tutorials/intermediate/dist_tuto.html)程序包中使用集体通信来同步梯度和缓冲区。 更具体地说，DDP 为`model.parameters()`给定的每个参数注册一个 Autograd 挂钩，当在后向传递中计算相应的梯度时，挂钩将触发。 然后，DDP 使用该信号触发跨进程的梯度同步。 有关更多详细信息，请参考 [DDP 设计说明](https://pytorch.org/docs/master/notes/ddp.html)。
+[`DistributedDataParallel`](https://pytorch.org/docs/stable/nn.html#torch.nn.parallel.DistributedDataParallel)（DDP）在模块级别实现可在多台计算机上运行的数据并行性。 使用 DDP 的应用应产生多个进程，并为每个进程创建一个 DDP 实例。 DDP 在[`torch.distributed`](https://pytorch.org/tutorials/intermediate/dist_tuto.html)包中使用集体通信来同步梯度和缓冲区。 更具体地说，DDP 为`model.parameters()`给定的每个参数注册一个 Autograd 挂钩，当在后向传递中计算相应的梯度时，挂钩将触发。 然后，DDP 使用该信号触发跨进程的梯度同步。 有关更多详细信息，请参考 [DDP 设计说明](https://pytorch.org/docs/master/notes/ddp.html)。
 
 推荐的使用 DDP 的方法是为每个模型副本生成一个进程，其中一个模型副本可以跨越多个设备。 DDP 进程可以放在同一台计算机上，也可以在多台计算机上，但是 GPU 设备不能在多个进程之间共享。 本教程从一个基本的 DDP 用例开始，然后演示了更高级的用例，包括检查点模型以及将 DDP 与模型并行结合。
 

new/pt-tut-17/63.md

@@ -8,11 +8,11 @@
 
 *   [PyTorch 分布式概述](../beginner/dist_overview.html)
 
-在这个简短的教程中，我们将介绍 PyTorch 的分布式软件包。 我们将了解如何设置分布式设置，如何使用不同的交流策略以及如何查看软件包的一些内部内容。
+在这个简短的教程中，我们将介绍 PyTorch 的分布式包。 我们将了解如何设置分布式设置，如何使用不同的交流策略以及如何查看包的一些内部内容。
 
 ## 设置
 
-PyTorch 中包含的分布式软件包（即`torch.distributed`）使研究人员和从业人员可以轻松地并行化他们在跨进程和机器集群的计算。 为此，它利用了传递消息的语义，从而允许每个进程将数据传递给任何其他进程。 与多处理包相反，进程可以使用不同的通信后端，而不仅限于在同一台计算机上执行。
+PyTorch 中包含的分布式包（即`torch.distributed`）使研究人员和从业人员可以轻松地并行化他们在跨进程和机器集群的计算。 为此，它利用了传递消息的语义，从而允许每个进程将数据传递给任何其他进程。 与多处理包相反，进程可以使用不同的通信后端，而不仅限于在同一台计算机上执行。
 
 为了开始，我们需要同时运行多个进程的能力。 如果您有权访问计算群集，则应咨询本地系统管理员或使用您喜欢的协调工具。 （例如 [pdsh](https://linux.die.net/man/1/pdsh)，[clustershell](https://cea-hpc.github.io/clustershell/) 或[其他](https://slurm.schedmd.com/)）。出于本教程的目的，我们将使用以下模板使用一台计算机并分叉多个进程。
 

new/pt-tut-17/64.md

@@ -16,7 +16,7 @@
 1.  在强化学习中，从环境中获取训练数据可能相对昂贵，而模型本身可能很小。 在这种情况下，产生多个并行运行的观察者并共享一个智能体可能会很有用。 在这种情况下，智能体将在本地负责训练，但是应用仍将需要库在观察者和训练者之间发送和接收数据。
 2.  您的模型可能太大，无法容纳在一台计算机上的 GPU 中，因此需要一个库来帮助将模型拆分到多台计算机上。 或者，您可能正在实现[参数服务器](https://www.cs.cmu.edu/~muli/file/parameter_server_osdi14.pdf)训练框架，其中模型参数和训练器位于不同的机器上。
 
-[`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)程序包可以帮助解决上述情况。 在情况 1 中， [RPC](https://pytorch.org/docs/master/rpc.html#rpc) 和 [RRef](https://pytorch.org/docs/master/rpc.html#rref) 允许将数据从一个工作程序发送到另一个工作程序，同时轻松引用远程数据对象。 在情况 2 中，[分布式 Autograd](https://pytorch.org/docs/master/rpc.html#distributed-autograd-framework) 和[分布式优化器](https://pytorch.org/docs/master/rpc.html#module-torch.distributed.optim)使执行反向传递和优化器步骤就像本地训练一样。 在接下来的两节中，我们将使用强化学习示例和语言模型示例来演示[`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)的 API。 请注意，本教程并非旨在构建最准确或最有效的模型来解决给定的问题，相反，此处的主要目标是演示如何使用[`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)包来构建分布式训练应用。
+[`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)包可以帮助解决上述情况。 在情况 1 中， [RPC](https://pytorch.org/docs/master/rpc.html#rpc) 和 [RRef](https://pytorch.org/docs/master/rpc.html#rref) 允许将数据从一个工作程序发送到另一个工作程序，同时轻松引用远程数据对象。 在情况 2 中，[分布式 Autograd](https://pytorch.org/docs/master/rpc.html#distributed-autograd-framework) 和[分布式优化器](https://pytorch.org/docs/master/rpc.html#module-torch.distributed.optim)使执行反向传递和优化器步骤就像本地训练一样。 在接下来的两节中，我们将使用强化学习示例和语言模型示例来演示[`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)的 API。 请注意，本教程并非旨在构建最准确或最有效的模型来解决给定的问题，相反，此处的主要目标是演示如何使用[`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)包来构建分布式训练应用。
 
 ## 使用 RPC 和 RRef 的分布式强化学习
 
@@ -46,7 +46,7 @@ class Policy(nn.Module):
 
 ```
 
-首先，让我们准备一个助手，以在`RRef`的所有者工作程序上远程运行函数。 您将在本教程的示例中的多个地方发现该函数。 理想情况下，`torch.distributed.rpc`软件包应立即提供这些助手函数。 例如，如果应用可以直接调用`RRef.some_func(*arg)`，然后将其转换为`RRef`所有者的 RPC，将会更容易。 在[`pytorch/pytorch#31743`](https://github.com/pytorch/pytorch/issues/31743)中跟踪了此 API 的进度。
+首先，让我们准备一个助手，以在`RRef`的所有者工作程序上远程运行函数。 您将在本教程的示例中的多个地方发现该函数。 理想情况下，`torch.distributed.rpc`包应立即提供这些助手函数。 例如，如果应用可以直接调用`RRef.some_func(*arg)`，然后将其转换为`RRef`所有者的 RPC，将会更容易。 在[`pytorch/pytorch#31743`](https://github.com/pytorch/pytorch/issues/31743)中跟踪了此 API 的进度。
 
 ```py
 from torch.distributed.rpc import rpc_sync

new/rl-tf/01.md

@@ -665,7 +665,7 @@ Inception 由 Google 团队于 2014 年创建。其主要思想是创建更广
 
 在无监督学习中，为训练目的给出了训练集的输入特征`X`。 没有关联的`Y`值。 目标是创建一个模型，该模型可通过了解底层模式来学习将数据隔离到不同的群集中，从而对数据进行分类以找到某种用途。 然后将该模型进一步用于输入特征`X'`，以预测它们与聚类之一的相似性。
 
-强化学习与有监督的和无监督的都不同。 强化学习可以指导智能体如何在现实世界中行动。 界面比训练向量更广泛，例如在有监督或无监督学习中。 这是整个环境，可以是真实的世界也可以是模拟的世界。 智能体以不同的方式进行训练，即目标是达到目标状态，这与监督学习的情况不同，后者的目的是使可能性最大化或成本最小化。
+强化学习与有监督的和无监督的都不同。 强化学习可以指导智能体如何在现实世界中行动。 接口比训练向量更广泛，例如在有监督或无监督学习中。 这是整个环境，可以是真实的世界也可以是模拟的世界。 智能体以不同的方式进行训练，即目标是达到目标状态，这与监督学习的情况不同，后者的目的是使可能性最大化或成本最小化。
 
 强化学习智能体会自动从环境中获得反馈，即从环境中获得奖励，这与监督学习中的标注需要耗时的人力不同。 强化学习的更大优势之一是，以目标的形式表述任何任务的目标有助于解决各种各样的问题。 例如，视频游戏智能体的目标是通过获得最高分数来赢得比赛。 这也有助于发现实现目标的新方法。 例如，当 AlphaGo 成为围棋世界冠军时，它发现了新颖独特的取胜方法。
 
@@ -770,7 +770,7 @@ A3C 算法由 Google DeepMind 和 MILA 的联合团队于 2016 年 6 月发布
 
 TensorFlow 是 Google 的 Google Brain 团队创建的数学库。 由于其数据流编程，它已被用作研究和开发部门的深度学习库。 自 2015 年成立以来，TensorFlow 已发展成为一个非常庞大的社区。
 
-OpenAI Gym 是一个由 OpenAI 团队创建的强化学习操场，旨在提供一个简单的界面，因为创建环境本身是强化学习中的繁琐任务。 它提供了一个很好的环境列表来测试您的强化学习算法，以便您可以对它们进行基准测试。
+OpenAI Gym 是一个由 OpenAI 团队创建的强化学习操场，旨在提供一个简单的接口，因为创建环境本身是强化学习中的繁琐任务。 它提供了一个很好的环境列表来测试您的强化学习算法，以便您可以对它们进行基准测试。
 
 # TensorFlow 中的基本计算
 

new/rl-tf/02.md

@@ -46,7 +46,7 @@ $ sudo pip install -e . # minimal install
 $ sudo pip install -e .[all]
 ```
 
-您还可以按以下说明将 Gym 作为不同 Python 版本的软件包来获取：
+您还可以按以下说明将 Gym 作为不同 Python 版本的包来获取：
 
 对于 Python 2.7，可以使用以下选项：
 
@@ -66,7 +66,7 @@ $ sudo pip install gym[atari]        # for Atari specific environment installati
 
 # 了解 OpenAI Gym 环境
 
-为了了解导入 Gym 软件包，加载环境以及与 OpenAI Gym 相关的其他重要功能的基础，这里是**冰冻湖**环境的示例。
+为了了解导入 Gym 包，加载环境以及与 OpenAI Gym 相关的其他重要功能的基础，这里是**冰冻湖**环境的示例。
 
 通过以下方式加载冰冻湖环境：
 

new/rl-tf/13.md

@@ -84,7 +84,7 @@ Faster R-CNN 实现了锚框的概念，以处理宽高比和对象比例的变
 
 YOLO 通过执行回归学习类概率和边界框的大小，从而对输入图像执行对象检测。 YOLO 将图像划分为`SxS`网格，每个网格预测`N`边界框和置信度。 该置信度值量化边界框的准确率和对象在边界框中的出现。
 
-YOLO 还可以预测训练中所有班级每个盒子的班级得分。 因此，图像中所有框上的类别得分的总和也有助于计算整个图像的类别概率，从而有助于预测对象。 由于将图像划分为`SxS`网格，并且针对每个输出`N`个边界框，因此，正在预测`SxSxN`框。 但是，由于我们具有盒子的置信度得分并使用显着的阈值，因此可以删除所有低置信度（不包含对象）的盒子。
+YOLO 还可以为每个盒子预测训练中所有类的类得分。 因此，图像中所有框上的类别得分的总和也有助于计算整个图像的类别概率，从而有助于预测对象。 由于将图像划分为`SxS`网格，并且针对每个输出`N`个边界框，因此，正在预测`SxSxN`框。 但是，由于我们具有盒子的置信度得分并使用显着的阈值，因此可以删除所有低置信度（不包含对象）的盒子。
 
 而且，YOLO 一次扫描整个图像，而无需执行先生成兴趣区域，然后以较早的方法将这些区域馈入 CNN 的步骤。 因此，在 YOLO 中运行，图像需要一次经过 CNN，并且实时生成结果。