2021-01-24 00:15:19

new/pt-tut-17/06.md

@@ -390,7 +390,7 @@ inputs, labels = data[0].to(device), data[1].to(device)
 
 与 CPU 相比，为什么我没有注意到 MASSIVE 加速？ 因为您的网络真的很小。
 
-**练习**：尝试增加网络的宽度（第一个`nn.Conv2d`的参数 2 和第二个`nn.Conv2d`的参数 1 –它们必须是相同的数字），看看您可以提高哪种速度 得到。
+**练习**：尝试增加网络的宽度（第一个`nn.Conv2d`的参数 2 和第二个`nn.Conv2d`的参数 1 –它们必须是相同的数字），看看您可以得到哪种加速。
 
 **已实现的目标**：
 

new/pt-tut-17/07.md

@@ -512,7 +512,7 @@ print(f'Result: {model.string()}')
 
 ### PyTorch：控制流 + 权重共享
 
-作为动态图和权重共享的示例，我们实现了一个非常奇怪的模型：一个三阶多项式，在每个正向传播中选择 3 到 5 之间的一个随机数，并使用该阶数，多次重复使用相同的权重进行计算 第四和第五阶。
+作为动态图和权重共享的示例，我们实现了一个非常奇怪的模型：一个三阶多项式，在每个正向传播中选择 3 到 5 之间的一个随机数，并使用该阶数，多次使用相同的权重重复计算四和五阶。
 
 对于此模型，我们可以使用常规的 Python 流控制来实现循环，并且可以通过在定义正向传播时简单地多次重复使用相同的参数来实现权重共享。
 

new/pt-tut-17/15.md

@@ -2,7 +2,7 @@
 
 > 原文：<https://pytorch.org/tutorials/beginner/examples_nn/dynamic_net.html#sphx-glr-beginner-examples-nn-dynamic-net-py>
 
-为了展示 PyTorch 动态图的强大功能，我们将实现一个非常奇怪的模型：一个三阶多项式，在每个正向传播中选择 3 到 5 之间的一个随机数，并使用该数量的阶次，多次重复使用相同的权重进行计算 第四和第五阶。
+为了展示 PyTorch 动态图的强大功能，我们将实现一个非常奇怪的模型：一个三阶多项式，在每个正向传播中选择 3 到 5 之间的一个随机数，并使用该数量的阶次，多次使用相同的权重重复计算四和五阶。
 
 ```py
 import random

new/pt-tut-17/16.md

@@ -340,7 +340,7 @@ with torch.no_grad():
 
 ```
 
-现在我们可以利用`model.parameters()`和`model.zero_grad()`（它们都由 PyTorch 为`nn.Module`定义）来使这些步骤更简洁，并且更不会出现忘记某些参数的错误，尤其是当 我们有一个更复杂的模型：
+现在我们可以利用`model.parameters()`和`model.zero_grad()`（它们都由 PyTorch 为`nn.Module`定义）来使这些步骤更简洁，并且更不会出现忘记某些参数的错误，尤其是当我们有一个更复杂的模型的时候：
 
 ```py
 with torch.no_grad():

new/pt-tut-17/22.md

@@ -389,7 +389,7 @@ optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))
 
 **第 2 部分-训练生成器**
 
-如原始论文所述，我们希望通过最小化`log(1 - D(G(z)))`来训练生成器，以产生更好的假货。 如前所述，Goodfellow 证明这不能提供足够的梯度，尤其是在学习过程的早期。 作为解决方法，我们希望最大化`log D(G(z))`。 在代码中，我们通过以下步骤来实现此目的：将第 1 部分的生成器输出与判别器进行分类，使用实数标签`GT`计算`G`的损失，反向计算`G`的梯度，最后使用优化器更新`G`的参数 步。 将真实标签用作损失函数的`GT`标签似乎是违反直觉的，但这使我们可以使用 BCELoss 的`log(x)`部分（而不是`log(1 - x)`部分），这正是我们想要的。
+如原始论文所述，我们希望通过最小化`log(1 - D(G(z)))`来训练生成器，以产生更好的假货。 如前所述，Goodfellow 证明这不能提供足够的梯度，尤其是在学习过程的早期。 作为解决方法，我们希望最大化`log D(G(z))`。 在代码中，我们通过以下步骤来实现此目的：将第 1 部分的生成器输出与判别器进行分类，使用实数标签`GT`计算`G`的损失，反向计算`G`的梯度，最后使用优化器步骤更新`G`的参数。 将真实标签用作损失函数的`GT`标签似乎是违反直觉的，但这使我们可以使用 BCELoss 的`log(x)`部分（而不是`log(1 - x)`部分），这正是我们想要的。
 
 最后，我们将进行一些统计报告，并在每个时期结束时，将我们的`fixed_noise`批量推送到生成器中，以直观地跟踪`G`的训练进度。 报告的训练统计数据是：
 

new/pt-tut-17/28.md

@@ -4,7 +4,7 @@
 
 **作者**： [Sean Robertson](https://github.com/spro/practical-pytorch)
 
-我们将建立和训练基本的字符级 RNN 对单词进行分类。 本教程与以下两个教程一起，展示了如何“从头开始”进行 NLP 建模的预处理数据，特别是不使用`torchtext`的许多便利功能，因此您可以了解如何进行 NLP 建模的预处理 在低水平上工作。
+我们将建立和训练基本的字符级 RNN 对单词进行分类。 本教程与以下两个教程一起，展示了如何“从头开始”进行 NLP 建模的预处理数据，特别是不使用`torchtext`的许多便利功能，因此您可以了解 NLP 建模的预处理如何在低水平上工作。
 
 字符级 RNN 将单词作为一系列字符读取-在每个步骤输出预测和“隐藏状态”，将其先前的隐藏状态输入到每个下一步。 我们将最终的预测作为输出，即单词属于哪个类别。
 
@@ -466,7 +466,7 @@ plt.show()
 
 ![../_img/sphx_glr_char_rnn_classification_tutorial_002.png](img/029a9d26725997aae97e9e3f6f10067f.png)
 
-您可以从主轴上挑出一些亮点，以显示它猜错了哪些语言，例如 中文（朝鲜语）和西班牙语（意大利语）。 它似乎与希腊语搭配得很好，而与英语搭配得很差（可能是因为与其他语言重叠）。
+您可以从主轴上挑出一些亮点，以显示它猜错了哪些语言，例如中文（朝鲜语）和西班牙语（意大利语）。 它似乎与希腊语搭配得很好，而与英语搭配得很差（可能是因为与其他语言重叠）。
 
 ### 在用户输入上运行
 

new/pt-tut-17/29.md

@@ -173,7 +173,7 @@ def randomTrainingPair():
 
 对于每个时间步（即，对于训练词中的每个字母），网络的输入将为`(category, current letter, hidden state)`，而输出将为`(next letter, next hidden state)`。 因此，对于每个训练集，我们都需要类别，一组输入字母和一组输出/目标字母。
 
-由于我们正在预测每个时间步中当前字母的下一个字母，因此字母对是该行中连续字母的组-例如 对于`"ABCD<EOS>"`，我们将创建`('A', 'B'), ('B', 'C'), ('C', 'D'), ('D', 'EOS')`。
+由于我们正在预测每个时间步中当前字母的下一个字母，因此字母对是该行中连续字母的组-例如对于`"ABCD<EOS>"`，我们将创建`('A', 'B'), ('B', 'C'), ('C', 'D'), ('D', 'EOS')`。
 
 ![](img/3fae03d85aed3a2237fd4b2f7fb7b480.png)
 

new/pt-tut-17/30.md

@@ -102,7 +102,7 @@ I am cold.    J'ai froid.
 
 ![](img/7fa129004e942671707f8f2d4fb80a20.png)
 
-我们将需要每个单词一个唯一的索引，以便以后用作网络的输入和目标。 为了跟踪所有这些，我们将使用一个名为`Lang`的帮助程序类，该类具有单词→索引（`word2index`）和索引→单词（`index2word`）字典，以及每个要使用的单词`word2count`的计数 以便以后替换稀有词。
+我们将需要每个单词一个唯一的索引，以便以后用作网络的输入和目标。 为了跟踪所有这些，我们将使用一个名为`Lang`的帮助程序类，该类具有单词→索引（`word2index`）和索引→单词（`index2word`）字典，以及每个要使用的单词`word2count`的计数，以便以后替换稀有词。
 
 ```py
 SOS_token = 0
@@ -402,7 +402,7 @@ def tensorsFromPair(pair):
 
 “教师强制”的概念是使用实际目标输出作为每个下一个输入，而不是使用解码器的猜测作为下一个输入。 使用教师强制会导致其收敛更快，但是当使用受过训练的网络时，[可能会显示不稳定](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.378.4095&rep=rep1&type=pdf)。
 
-您可以观察到以教师为主导的网络的输出，这些输出阅读的是连贯的语法，但是却偏离了正确的翻译-直观地，它已经学会了代表输出语法，并且一旦老师说了最初的几个单词就可以“理解”含义，但是 首先，它还没有正确地学习如何从翻译中创建句子。
+您可以观察到以教师为主导的网络的输出，这些输出阅读的是连贯的语法，但是却偏离了正确的翻译-直观地，它已经学会了代表输出语法，并且一旦老师说了最初的几个单词就可以“理解”含义，但是首先，它还没有正确地学习如何从翻译中创建句子。
 
 由于 PyTorch 的 Autograd 具有给我们的自由，我们可以通过简单的`if`语句随意选择是否使用教师强迫。 调高`teacher_forcing_ratio`以使用更多功能。
 

new/pt-tut-17/34.md

@@ -103,7 +103,7 @@ class ReplayMemory(object):
 
 我们的目标是制定一种策略，尝试最大化折扣的累积奖励`R[t[0]] = Σ γ^(t - t[0]) r[t], t = t[0] -> ∞`，其中`R[t[0]]`也称为*回报*。 折扣`γ`应该是`0`和`1`之间的常数，以确保总和收敛。 这使得来自不确定的遥远未来的回报对我们的代理商而言不如可以对其充满信心的近期回报重要。
 
-Q 学习的主要思想是，如果我们有一个函数`Q*：State x Action => R`，这可以告诉我们，如果我们取一个 在给定状态下采取行动，那么我们就可以轻松地制定出使我们的回报最大化的策略：
+Q 学习的主要思想是，如果我们有一个函数`Q*：State x Action => R`，这可以告诉我们，如果我们在给定状态下采取行动，那么我们就可以轻松地制定出使我们的回报最大化的策略：
 
 ![](img/tex34-1.gif)
 

new/pt-tut-17/37.md

@@ -105,7 +105,7 @@ def transform_image(image_bytes):
 
 ```
 
-上面的方法以字节为单位获取图像数据，应用一系列变换并返回张量。 要测试上述方法，请以字节模式读取图像文件（首先将`../_static/img/sample_file.jpeg`替换为计算机上文件的实际路径），然后查看是否获得张量 背部：
+上面的方法以字节为单位获取图像数据，应用一系列变换并返回张量。 要测试上述方法，请以字节模式读取图像文件（首先将`../_static/img/sample_file.jpeg`替换为计算机上文件的实际路径），然后查看是否取回张量：
 
 ```py
 with open("../_static/img/sample_file.jpeg", 'rb') as f:

new/pt-tut-17/40.md

@@ -23,7 +23,7 @@ import torch.onnx
 
 超分辨率是一种提高图像，视频分辨率的方法，广泛用于图像处理或视频编辑中。 在本教程中，我们将使用一个小的超分辨率模型。
 
-首先，让我们在 PyTorch 中创建一个`SuperResolution`模型。 该模型使用了[《使用高效的子像素卷积神经网络的实时单幅图像和视频超分辨率》](https://arxiv.org/abs/1609.05158)（Shi 等人）中所述的高效子像素卷积层来提高图像的分辨率 受高档因素的影响。 该模型期望图像的 YCbCr 的 Y 分量作为输入，并以超分辨率输出放大的 Y 分量。
+首先，让我们在 PyTorch 中创建一个`SuperResolution`模型。 该模型使用了[《使用高效的子像素卷积神经网络的实时单幅图像和视频超分辨率》](https://arxiv.org/abs/1609.05158)（Shi 等人）中所述的高效子像素卷积层来提高图像的分辨率受向上缩放因子的影响。 该模型期望图像的 YCbCr 的 Y 分量作为输入，并以超分辨率输出放大的 Y 分量。
 
 [模型](https://github.com/pytorch/examples/blob/master/super_resolution/model.py)直接来自 PyTorch 的示例，未经修改：
 

new/pt-tut-17/42.md

@@ -509,7 +509,7 @@ def prepare_head(tensor):
 
 ```
 
-首先要注意的是代码如何清楚地说明输入和输出尺寸：输入张量必须以`T`和`D`变暗结束，输出张量应以`H`，`T`和`D_head`结束 昏暗。
+首先要注意的是代码如何清楚地说明输入和输出尺寸：输入张量必须以`T`和`D`变暗结束，输出张量应以`H`，`T`和`D_head`维度结束。
 
 要注意的第二件事是代码清楚地描述了正在发生的事情。 `prepare_head`获取键，查询和值，并将嵌入的维度拆分为多个头部，最后将维度顺序重新排列为`[..., 'H', 'T', 'D_head']`。 ParlAI 使用`view`和`transpose`操作实现以下`prepare_head`：
 

new/pt-tut-17/43.md

@@ -304,7 +304,7 @@ output = model(input)
 
 ```
 
-但是，并非所有运算符都完全转换为支持通道在最后（通常返回连续输出）。 这意味着您需要根据[支持的运算符列表](https://github.com/pytorch/pytorch/wiki/Operators-with-Channels-Last-support)来验证已使用运算符的列表，或进行内存格式检查 进入急切的执行模式并运行模型。
+但是，并非所有运算符都完全转换为支持通道在最后（通常返回连续输出）。 这意味着您需要根据[支持的运算符列表](https://github.com/pytorch/pytorch/wiki/Operators-with-Channels-Last-support)来验证已使用运算符的列表，或将内存格式检查引入急切的执行模式并运行模型。
 
 运行以下代码后，如果运算符的输出与输入的存储格式不匹配，运算符将引发异常。
 

new/pt-tut-17/44.md

@@ -30,7 +30,7 @@ C++ 前端无意与 Python 前端竞争。 它是对它的补充。 我们知道
 
 小费
 
-C++ 前端试图提供一个与 Python 前端尽可能接近的 API。 如果您对 Python 前端有丰富的经验，并且问过自己“我如何使用 C++ 前端 X？”，请像在 Python 中那样编写代码，而且大多数情况下，相同的函数和方法也可以在 C++ 中使用 就像在 Python 中一样（只记得用双冒号替换点）。
+C++ 前端试图提供一个与 Python 前端尽可能接近的 API。 如果您对 Python 前端有丰富的经验，并且问过自己“我如何使用 C++ 前端 X？”，请像在 Python 中那样编写代码，而且大多数情况下，相同的函数和方法也可以在 C++ 中使用，就像在 Python 中一样（只记得用双冒号替换点）。
 
 ## 编写基本应用
 

new/pt-tut-17/46.md

@@ -6,7 +6,7 @@ PyTorch 1.0 版本向 PyTorch 引入了一种新的编程模型，称为 [TorchS
 
 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++ 中。
+以下段落提供了一个编写 TorchScript 自定义操作以调用 [OpenCV](https://www.opencv.org) （使用 C++ 编写的计算机视觉库）的示例。 我们将讨论如何在 C++ 中使用张量，如何有效地将它们转换为第三方张量格式（在这种情况下为 OpenCV `Mat`），如何在 TorchScript 运行时中注册您的运算符，以及最后如何编译该运算符并在 Python 和 C++ 中使用它。
 
 ## 在 C++ 中实现自定义运算符
 
@@ -635,7 +635,7 @@ $ ./example_app example.pt
 
 ### 使用 JIT 编译的构建
 
-PyTorch C++ 扩展工具包提供的 JIT 编译功能可将自定义运算符的编译直接嵌入到您的 Python 代码中，例如 在训练脚本的顶部。
+PyTorch C++ 扩展工具包提供的 JIT 编译功能可将自定义运算符的编译直接嵌入到您的 Python 代码中，例如在训练脚本的顶部。
 
 注意
 

new/pt-tut-17/47.md

@@ -383,7 +383,7 @@ $ ./infer
 
 也可能需要将自定义类从自定义 C++ 类实例移入或移出`IValue`, such as when you take or return IValues from TorchScript methods or you want to instantiate a custom class attribute in C++. For creating an IValue：
 
-*   `torch::make_custom_class<T>()`提供类似于`c10::intrusive_ptr<T>`的 API，因为它将采用您提供给它的任何参数集，调用与该参数集匹配的`T`的构造器，并包装该实例 然后退回 但是，它不仅返回指向自定义类对象的指针，还返回包装对象的`IValue`。 然后，您可以将此`IValue`直接传递给 TorchScript。
+*   `torch::make_custom_class<T>()`提供类似于`c10::intrusive_ptr<T>`的 API，因为它将采用您提供给它的任何参数集，调用与该参数集匹配的`T`的构造器，并包装该实例，然后返回。 但是，它不仅返回指向自定义类对象的指针，还返回包装对象的`IValue`。 然后，您可以将此`IValue`直接传递给 TorchScript。
 *   如果您已经有一个指向类的`intrusive_ptr`，则可以使用构造器`IValue(intrusive_ptr<T>)`直接从其构造`IValue`。
 
 要将`IValue`转换回自定义类：

new/pt-tut-17/50.md

@@ -127,7 +127,7 @@ Tensor myadd_autograd(const Tensor& self, const Tensor& other) {
 1.  使用`at::AutoNonVariableTypeMode` RAII 保护器关闭 Autograd 处理，然后
 2.  调用调度函数`myadd`以回调调度程序。
 
-如果没有（1），您的调用将无限循环（并且堆栈溢出），因为`myadd`将使您返回此函数（因为最高优先级分配键仍将是自动微分的。）对于（1），自动微分不包括在 一组正在考虑的调度键，我们将转到下一个处理程序，即 CPU 和 CUDA。
+如果没有（1），您的调用将无限循环（并且堆栈溢出），因为`myadd`将使您返回此函数（因为最高优先级分配键仍将是自动微分的。）对于（1），自动微分从一组正在考虑的调度键中排除，我们将转到下一个处理程序，即 CPU 和 CUDA。
 
 现在，我们可以按照注册 CPU/CUDA 函数的相同方式注册此函数：
 

new/pt-tut-17/53.md

@@ -296,7 +296,7 @@ config = {
 
 ```
 
-`tune.sample_from()`函数使您可以定义自己的采样方法以获得超参数。 在此示例中，`l1`和`l2`参数应为 4 到 256 之间的 2 的幂，因此应为 4、8、16、32、64、128 或 256。`lr`（学习率）应为 在 0.0001 和 0.1 之间均匀采样。 最后，批量大小可以在 2、4、8 和 16 之间选择。
+`tune.sample_from()`函数使您可以定义自己的采样方法以获得超参数。 在此示例中，`l1`和`l2`参数应为 4 到 256 之间的 2 的幂，因此应为 4、8、16、32、64、128 或 256。`lr`（学习率）应在 0.0001 和 0.1 之间均匀采样。 最后，批量大小可以在 2、4、8 和 16 之间选择。
 
 现在，在每次试用中，Ray Tune 都会从这些搜索空间中随机抽取参数组合。 然后它将并行训练许多模型，并在其中找到性能最佳的模型。 我们还使用`ASHAScheduler`，它将尽早终止效果不佳的测试。
 
@@ -316,7 +316,7 @@ result = tune.run(
 
 ```
 
-您可以指定 CPU 的数量，例如 增加 PyTorch `DataLoader`实例的`num_workers`。 在每次试用中，选定数量的 GPU 对 PyTorch 都是可见的。 试用版无法访问未要求使用 GPU 的 GPU，因此您不必担心使用同一组资源进行两次试用。
+您可以指定 CPU 的数量，例如增加 PyTorch `DataLoader`实例的`num_workers`。 在每次试用中，选定数量的 GPU 对 PyTorch 都是可见的。 试用版无法访问未要求使用 GPU 的 GPU，因此您不必担心使用同一组资源进行两次试用。
 
 在这里，我们还可以指定分数 GPU，因此`gpus_per_trial=0.5`之类的东西完全有效。 然后，试用版将彼此共享 GPU。 您只需要确保模型仍然适合 GPU 内存即可。
 

new/pt-tut-17/54.md

@@ -4,7 +4,7 @@
 
 **作者**： [Michela Paganini](https://github.com/mickypaganini)
 
-最新的深度学习技术依赖于难以部署的过度参数化模型。 相反，已知生物神经网络使用有效的稀疏连通性。 为了减少内存，电池和硬件消耗，同时又不牺牲精度，在设备上部署轻量级模型并通过私有设备上计算来确保私密性，确定通过减少模型中的参数数量来压缩模型的最佳技术很重要。 在研究方面，剪裁用于研究参数过度配置和参数不足网络在学习动态方面的差异，以研究幸运的稀疏子网络和初始化（[“彩票”](https://arxiv.org/abs/1803.03635)）具有破坏性的作用 神经结构搜索技术等等。
+最新的深度学习技术依赖于难以部署的过度参数化模型。 相反，已知生物神经网络使用有效的稀疏连通性。 为了减少内存，电池和硬件消耗，同时又不牺牲精度，在设备上部署轻量级模型并通过私有设备上计算来确保私密性，确定通过减少模型中的参数数量来压缩模型的最佳技术很重要。 在研究方面，剪裁用于研究参数过度配置和参数不足网络在学习动态方面的差异，以研究幸运的稀疏子网络的作用（[“彩票”](https://arxiv.org/abs/1803.03635)），以及初始化，作为破坏性的神经结构搜索技术等等。
 
 在本教程中，您将学习如何使用`torch.nn.utils.prune`稀疏神经网络，以及如何扩展它以实现自己的自定义剪裁技术。
 

new/pt-tut-17/56.md

@@ -99,7 +99,7 @@ print(torch.__config__.parallel_info())
 *   在第一句和第二句之间并在最后插入`[SEP]`；
 *   生成标记类型 ID，以指示标记是属于第一序列还是第二序列。
 
-[`gum_compute_metrics`](https://github.com/huggingface/transformers/blob/master/transformers/data/processors/glue.py)函数的计算指标为 [F1 得分](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html)，可以将其解释为精度和召回率的加权平均值，其中 F1 得分在 1 和最差处达到最佳值 得分为 0。精度和召回率对 F1 得分的相对贡献相等。
+[`gum_compute_metrics`](https://github.com/huggingface/transformers/blob/master/transformers/data/processors/glue.py)函数的计算指标为 [F1 得分](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html)，可以将其解释为精度和召回率的加权平均值，其中 F1 得分最佳值为 1，最差值为 0。精度和召回率对 F1 得分的相对贡献相等。
 
 *   F1 分数的公式为：
 

new/pt-tut-17/57.md

@@ -472,7 +472,7 @@ Size (MB): 13.999657
 
 ## 4.训练后的静态量化
 
-训练后的静态量化不仅涉及像动态量化中那样将权重从`float`转换为`int`，而且还执行额外的步骤，即首先通过网络馈送一批数据并计算不同激活的结果分布（具体来说，这是 通过在记录此数据的不同点插入观察者模块来完成）。 然后使用这些分布来确定在推理时如何具体量化不同的激活（一种简单的技术是将整个激活范围简单地划分为 256 个级别，但我们也支持更复杂的方法）。 重要的是，此附加步骤使我们能够在操作之间传递量化值，而不是在每次操作之间将这些值转换为浮点数，然后再转换为整数，从而显着提高了速度。
+训练后的静态量化不仅涉及像动态量化中那样将权重从`float`转换为`int`，而且还执行额外的步骤，即首先通过网络馈送一批数据并计算不同激活的结果分布（具体来说，这通过在记录此数据的不同点插入观察者模块来完成）。 然后使用这些分布来确定在推理时如何具体量化不同的激活（一种简单的技术是将整个激活范围简单地划分为 256 个级别，但我们也支持更复杂的方法）。 重要的是，此附加步骤使我们能够在操作之间传递量化值，而不是在每次操作之间将这些值转换为浮点数，然后再转换为整数，从而显着提高了速度。
 
 ```py
 num_calibration_batches = 10

new/pt-tut-17/58.md

@@ -16,7 +16,7 @@
 
 迁移学习是指利用预训练的模型应用于不同数据集的技术。 使用迁移学习的主要方法有两种：
 
-1.  **作为固定特征提取器的 ConvNet**：在这里，您[“冻结”](https://arxiv.org/abs/1706.04983)网络中所有参数的权重，但最后几层（又称“头部”）的权重通常 连接的层）。 将这些最后一层替换为使用随机权重初始化的新层，并且仅训练这些层。
+1.  **作为固定特征提取器的 ConvNet**：在这里，您[“冻结”](https://arxiv.org/abs/1706.04983)网络中所有参数的权重，除了最后几层（又称“头部”，通常是全连接层）。 将这些最后一层替换为使用随机权重初始化的新层，并且仅训练这些层。
 2.  **ConvNet 的微调**：使用随机训练的网络初始化模型，而不是随机初始化，然后像往常一样使用不同的数据集进行训练。 通常，如果输出数量不同，则在网络中也会更换头部（或头部的一部分）。 这种方法通常将学习率设置为较小的值。 这样做是因为已经对网络进行了训练，并且只需进行较小的更改即可将其“微调”到新的数据集。
 
 您还可以结合以上两种方法：首先，可以冻结特征提取器，并训练头部。 之后，您可以解冻特征提取器（或其一部分），将学习率设置为较小的值，然后继续进行训练。

new/pt-tut-17/64.md

@@ -11,12 +11,12 @@
 
 本教程使用两个简单的示例来演示如何使用[`torch.distributed.rpc`](https://pytorch.org/docs/master/rpc.html)包构建分布式训练，该包首先在 PyTorch v1.4 中作为原型功能引入。 这两个示例的源代码可以在 [PyTorch 示例](https://github.com/pytorch/examples)中找到。
 
-先前的教程[分布式数据并行入门](ddp_tutorial.html)和[使用 PyTorch](dist_tuto.html) 编写分布式应用，描述了[`DistributedDataParallel`](https://pytorch.org/docs/stable/_modules/torch/nn/parallel/distributed.html)，该模型支持特定的训练范例，该模型可在多个过程之间复制模型 每个进程都处理输入数据的拆分。 有时，您可能会遇到需要不同训练范例的场景。 例如：
+先前的教程[分布式数据并行入门](ddp_tutorial.html)和[使用 PyTorch](dist_tuto.html) 编写分布式应用，描述了[`DistributedDataParallel`](https://pytorch.org/docs/stable/_modules/torch/nn/parallel/distributed.html)，该模型支持特定的训练范例，该模型可在多个进程之间复制，每个进程都处理输入数据的拆分。 有时，您可能会遇到需要不同训练范例的场景。 例如：
 
 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 的分布式强化学习
 
@@ -390,7 +390,7 @@ class RNNModel(nn.Module):
 
 现在，我们准备实现训练循环。 初始化模型参数后，我们创建`RNNModel`和`DistributedOptimizer`。 分布式优化器将采用参数`RRefs`的列表，查找所有不同的所有者工作器，并在每个所有者工作器上创建给定的本地优化器（即，在这种情况下，您也可以使用其他本地优化器`SGD`） 使用给定的参数（即`lr=0.05`）。
 
-在训练循环中，它首先创建一个分布式 Autograd 上下文，这将帮助分布式 Autograd 引擎查找梯度和涉及的 RPC 发送/接收功能。 分布式 Autograd 引擎的设计详细信息可以在其[设计说明](https://pytorch.org/docs/master/notes/distributed_autograd.html)中找到。 然后，它像本地模型一样开始正向传播，并运行分布式后向传递。 对于后向分布，您只需要指定一个根列表，在这种情况下，就是损失`Tensor`。 分布式 Autograd 引擎将自动遍历分布式图形并正确编写梯度。 接下来，它在分布式优化器上运行`step`函数，该功能将与所有涉及的本地优化器联系以更新模型参数。 与本地训练相比，一个较小的差异是您不需要运行`zero_grad()`，因为每个 Autograd 上下文都有专用的空间来存储梯度，并且在每次迭代创建上下文时，来自不同迭代的那些梯度不会累积到 同一组`Tensors`。
+在训练循环中，它首先创建一个分布式 Autograd 上下文，这将帮助分布式 Autograd 引擎查找梯度和涉及的 RPC 发送/接收功能。 分布式 Autograd 引擎的设计详细信息可以在其[设计说明](https://pytorch.org/docs/master/notes/distributed_autograd.html)中找到。 然后，它像本地模型一样开始正向传播，并运行分布式后向传递。 对于后向分布，您只需要指定一个根列表，在这种情况下，就是损失`Tensor`。 分布式 Autograd 引擎将自动遍历分布式图形并正确编写梯度。 接下来，它在分布式优化器上运行`step`函数，该功能将与所有涉及的本地优化器联系以更新模型参数。 与本地训练相比，一个较小的差异是您不需要运行`zero_grad()`，因为每个 Autograd 上下文都有专用的空间来存储梯度，并且在每次迭代创建上下文时，来自不同迭代的那些梯度不会累积到同一组`Tensors`。
 
 ```py
 def run_trainer():

new/pt-tut-17/65.md

@@ -250,7 +250,7 @@ def run_training_loop(rank, num_gpus, train_loader, test_loader):
 
 接下来，我们定义我们的主要训练循环。 我们遍历了 PyTorch 的[`DataLoader`](https://pytorch.org/docs/stable/data.html)提供的可迭代项。 在编写典型的前向/后向/优化器循环之前，我们首先将逻辑包装在[分布式 Autograd 上下文](https://pytorch.org/docs/stable/rpc.html#torch.distributed.autograd.context)中。 请注意，这需要记录在模型的正向传播中调用的 RPC，以便可以构造一个适当的图，其中包括在后向传递中所有参与的分布式工作者。 分布式 Autograd 上下文返回`context_id`，它用作用于累积和优化与特定迭代对应的梯度的标识符。
 
-与调用典型的`loss.backward()`会启动此本地工作程序的反向传播相反，我们调用`dist_autograd.backward()`并传递我们的`context_id`和`loss`，这是我们希望反向传播的根 开始。 另外，我们将此`context_id`传递到优化程序调用中，该调用程序必须能够在所有节点上查找由该特定反向传播计算出的相应梯度。
+与调用典型的`loss.backward()`会启动此本地工作程序的反向传播相反，我们调用`dist_autograd.backward()`并传递我们的`context_id`和`loss`，这是我们希望反向传播从它开始的根。 另外，我们将此`context_id`传递到优化程序调用中，该调用程序必须能够在所有节点上查找由该特定反向传播计算出的相应梯度。
 
 ```py
 def run_training_loop(rank, num_gpus, train_loader, test_loader):

new/pt-tut-17/67.md

@@ -130,7 +130,7 @@ class Trainer(object):
 
 ## 批量 CartPole 求解器
 
-本节以 [OpenAI Gym](https://gym.openai.com/) 中的 CartPole-v1 为例，说明批量 RPC 的性能影响。 请注意，我们的目标是演示[`@rpc.functions.async_execution`](https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution)的用法，而不是构建最佳的 CartPole 求解器或解决大多数不同的 RL 问题，我们使用非常简单的策略和奖励计算策略，并将重点放在 多观察者单代理批量 RPC 实现。 我们使用与前面的教程类似的`Policy`模型，如下所示。 与上一教程相比，不同之处在于其构造器使用了一个附加的`batch`参数来控制`F.softmax`的`dim`参数，因为进行批量时，`forward`函数中的`x`参数包含来自多个观察者的状态 因此尺寸需要适当更改。 其他所有内容保持不变。
+本节以 [OpenAI Gym](https://gym.openai.com/) 中的 CartPole-v1 为例，说明批量 RPC 的性能影响。 请注意，我们的目标是演示[`@rpc.functions.async_execution`](https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution)的用法，而不是构建最佳的 CartPole 求解器或解决大多数不同的 RL 问题，我们使用非常简单的策略和奖励计算策略，并将重点放在多观察者单智能体的批量 RPC 实现。 我们使用与前面的教程类似的`Policy`模型，如下所示。 与上一教程相比，不同之处在于其构造器使用了一个附加的`batch`参数来控制`F.softmax`的`dim`参数，因为进行批量时，`forward`函数中的`x`参数包含来自多个观察者的状态，因此尺寸需要适当更改。 其他所有内容保持不变。
 
 ```py
 import argparse