2021-01-19 21:56:41

new/pt-tut-17/47.md

@@ -427,7 +427,7 @@ RuntimeError: Cannot serialize custom bound C++ class __torch__.torch.classes.my
 
 注意
 
-TorchScript 中`__getstate__`和`__setstate__`的语义与 Python pickle 模块的语义相同。 您可以[阅读更多](https://github.com/pytorch/pytorch/blob/master/torch/csrc/jit/docs/serialization.md#getstate-and-setstate)有关如何使用这些方法的信息。
+TorchScript 中`__getstate__`和`__setstate__`的语义与 Python `pickle`模块的语义相同。 您可以[阅读更多](https://github.com/pytorch/pytorch/blob/master/torch/csrc/jit/docs/serialization.md#getstate-and-setstate)有关如何使用这些方法的信息。
 
 这是`def_pickle`调用的示例，我们可以将其添加到`MyStackClass`的注册中以包括序列化方法：
 
@@ -505,7 +505,7 @@ c10::intrusive_ptr<MyStackClass<std::string>> manipulate_instance(const c10::int
 
 有关注册 API 的更多详细信息，请参见[定制操作教程](https://pytorch.org/tutorials/advanced/torch_script_custom_ops.html)。
 
-完成此操作后，您可以像以下示例一样使用 op：
+完成此操作后，您可以像以下示例一样使用操作：
 
 ```py
 class TryCustomOp(torch.nn.Module):

new/pt-tut-17/49.md

@@ -115,7 +115,7 @@ out.backward();
 
 ```
 
-打印梯度 d（out）/ dx
+打印梯度`d(out) / dx`
 
 ```py
 std::cout << x.grad() << std::endl;

new/pt-tut-17/50.md

@@ -10,7 +10,7 @@
 *   当操作员在`vmap`调用下运行时，应用批量规则。
 *   如果要跟踪导出的模型，则跟踪操作的执行。
 
-如果在[自定义运算符代码](torch_script_custom_ops)中发现自己手动编写了 if 语句来处理这些情况，则调度程序 API 可以帮助组织代码。 （相反，如果您的自定义运算符非常简单并且仅用于 CPU 推断，则可能不需要使用调度程序，只需使用基本 API。）
+如果在[自定义运算符代码](torch_script_custom_ops)中发现自己手动编写了`if`语句来处理这些情况，则调度程序 API 可以帮助组织代码。 （相反，如果您的自定义运算符非常简单并且仅用于 CPU 推断，则可能不需要使用调度程序，只需使用基本 API。）
 
 在本教程中，我们将描述如何构造自定义操作员注册以使用调度程序来组织各种组件。 我们假设您熟悉如何[注册操作员](torch_script_custom_ops)以及如何编写[自定义自动微分功能](cpp_autograd)。
 
@@ -129,7 +129,7 @@ Tensor myadd_autograd(const Tensor& self, const Tensor& other) {
 
 如果没有（1），您的调用将无限循环（并且堆栈溢出），因为`myadd`将使您返回此函数（因为最高优先级分配键仍将是自动微分的。）对于（1），自动微分不包括在 一组正在考虑的调度键，我们将转到下一个处理程序，即 CPU 和 CUDA。
 
-现在，我们可以按照注册 CPU / CUDA 函数的相同方式注册此函数：
+现在，我们可以按照注册 CPU/CUDA 函数的相同方式注册此函数：
 
 ```py
 TORCH_LIBRARY_IMPL(myops, Autograd, m) {
@@ -140,7 +140,7 @@ TORCH_LIBRARY_IMPL(myops, Autograd, m) {
 
 ## 超越 autograd
 
-从某种意义上说，调度员并没有做太多事情：它所做的只是实现一种美化的 if 语句，其方法如下：
+从某种意义上说，调度员并没有做太多事情：它所做的只是实现一种美化的`if`语句，其方法如下：
 
 ```py
 class MyAddFunction : ... {
@@ -163,7 +163,7 @@ public:
 
 那么为什么要使用调度程序呢？ 有几个原因：
 
-1.  它是分散的。 您可以组装运算符的所有部分（CPU，CUDA，Autograd），而不必编写引用所有元素的集中式 if 语句。 重要的是，第三方可以注册其他方面的额外实现，而不必修补操作员的原始定义。
+1.  它是分散的。 您可以组装运算符的所有部分（CPU，CUDA，Autograd），而不必编写引用所有元素的集中式`if`语句。 重要的是，第三方可以注册其他方面的额外实现，而不必修补操作员的原始定义。
 2.  它比 CPU，CUDA 和 Autograd 支持更多的调度键。 您可以在`c10/core/DispatchKey.h`中查看 PyTorch 中当前实现的调度密钥的完整列表。 这些分派密钥为操作员实现了多种可选功能，如果您决定希望自定义操作员支持该功能，则只需为相应的密钥注册内核即可。
 3.  调度程序实现对盒装后备功能的支持，后者是可以一次实现并应用于系统中所有操作员的功能。 盒装后备可用于提供调度键的默认行为。 如果您使用调度程序来实现您的运营商，那么您还可以选择所有这些操作的备用。
 
@@ -171,9 +171,9 @@ public:
 
 ### 自动播送
 
-Autocast 调度键实现对[自动混合精度（AMP）](https://pytorch.org/docs/stable/amp.html)的支持。 自动广播包装器内核通常会在运行 op 之前将传入的`float16`或`float32` CUDA 张量转换为某些首选精度。 例如，浮点 CUDA 张量上的积和卷积通常运行得更快，并且在`float16`中使用较少的内存，而不会影响收敛。 自动广播包装器仅在[启用自动广播的上下文](https://pytorch.org/docs/stable/amp.html#torch.cuda.amp.autocast)中有效。
+Autocast 调度键实现对[自动混合精度（AMP）](https://pytorch.org/docs/stable/amp.html)的支持。 自动广播包装器内核通常会在运行操作之前将传入的`float16`或`float32` CUDA 张量转换为某些首选精度。 例如，浮点 CUDA 张量上的积和卷积通常运行得更快，并且在`float16`中使用较少的内存，而不会影响收敛。 自动广播包装器仅在[启用自动广播的上下文](https://pytorch.org/docs/stable/amp.html#torch.cuda.amp.autocast)中有效。
 
-这是假设的自定义 Matmul 的自动广播包装器及其注册信息：
+这是假设的自定义`Matmul`的自动广播包装器及其注册信息：
 
 ```py
 // Autocast-specific helper functions
@@ -233,7 +233,7 @@ TORCH_LIBRARY_IMPL(myops, Autocast, m) {
 
 ```
 
-没有单独的体操可使后向方法自动广播兼容。 但是，在自定义 Autograd 函数中定义的向后方法将以与正向方法的自动广播集相同的 dtype 运行，因此您应该选择既适合于正向方法又适合于向后方法的`<desired dtype>`。
+没有单独的体操可使后向方法自动广播兼容。 但是，在自定义 Autograd 函数中定义的向后方法将以与正向方法的自动广播集相同的`dtype`运行，因此您应该选择既适合于正向方法又适合于向后方法的`<desired dtype>`。
 
 ### 批量
 

new/pt-tut-17/52.md

@@ -133,7 +133,7 @@ Self CPU time total: 5.931s
 
 ## 提高内存性能
 
-请注意，就内存和时间而言，最昂贵的操作位于`forward (10)`，代表 MASK INDICES 中的操作。 让我们尝试先解决内存消耗问题。 我们可以看到第 12 行的`.to()`操作消耗 953.67 Mb。 该操作将`mask`复制到 CPU。 `mask`使用`torch.double`数据类型初始化。 我们可以通过将其转换为`torch.float`来减少内存占用吗？
+请注意，就内存和时间而言，最昂贵的操作位于`forward (10)`，代表掩码索引中的操作。 让我们尝试先解决内存消耗问题。 我们可以看到第 12 行的`.to()`操作消耗 953.67 Mb。 该操作将`mask`复制到 CPU。 `mask`使用`torch.double`数据类型初始化。 我们可以通过将其转换为`torch.float`来减少内存占用吗？
 
 ```py
 model = MyModule(500, 10).cuda()

new/pt-tut-17/53.md

@@ -116,7 +116,7 @@ optimizer = optim.SGD(net.parameters(), lr=config["lr"], momentum=0.9)
 
 我们还将训练数据分为训练和验证子集。 因此，我们训练了 80% 的数据，并计算了其余 20% 的验证损失。 我们遍历训练和测试集的批量大小也是可配置的。
 
-### 通过 DataParallel 添加（多）GPU 支持
+### 通过`DataParallel`添加（多）GPU 支持
 
 图像分类主要受益于 GPU。 幸运的是，我们可以继续在 Ray Tune 中使用 PyTorch 的抽象。 因此，我们可以将模型包装在`nn.DataParallel`中，以支持在多个 GPU 上进行数据并行训练：
 

new/pt-tut-17/55.md

-# LSTM 单词语言模型上的（beta）动态量化
+# LSTM 单词语言模型上的动态量化（beta）
 
 > 原文：<https://pytorch.org/tutorials/advanced/dynamic_quantization_tutorial.html>
 
@@ -8,7 +8,7 @@
 
 ## 简介
 
-量化涉及将模型的权重和激活从 float 转换为 int，这可以导致模型尺寸更小，推断速度更快，而对准确率的影响很小。
+量化涉及将模型的权重和激活从`float`转换为`int`，这可以导致模型尺寸更小，推断速度更快，而对准确率的影响很小。
 
 在本教程中，我们将最简单的量化形式-[动态量化](https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic)应用于基于 LSTM 的下一个单词预测模型，紧紧遵循 PyTorch 示例中的[单词语言模型](https://github.com/pytorch/examples/tree/master/word_language_model) 。
 

new/pt-tut-17/56.md

-# Beta 上的 BERT 动态量化
+# BERT 上的动态量化（Beta）
 
 > 原文：<https://pytorch.org/tutorials/intermediate/dynamic_quantization_bert_tutorial.html>
 
@@ -16,8 +16,8 @@
 
 在本教程中，我们将动态量化应用在 BERT 模型上，紧跟 [HuggingFace Transformers 示例](https://github.com/huggingface/transformers)中的 BERT 模型。 通过这一循序渐进的旅程，我们将演示如何将著名的 BERT 等最新模型转换为动态量化模型。
 
-*   BERT，或者说 Transformers 的双向嵌入表示，是一种预训练语言表示的新方法，它可以在许多常见的自然语言处理（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 用仅动态权重的量化版本替换了指定的模块，并输出了量化模型。
+*   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 任务，如下所示。
 
 ![../_img/bert.png](img/b43b70d8a6eef9ea4f75867b5e83b483.png)
@@ -34,7 +34,7 @@ pip install transformers
 
 ```
 
-由于我们将使用 PyTorch 的 Beta 版部分，因此建议安装最新版本的 Torch 和 Torchvision。 您可以在此处找到有关本地安装[的最新说明。 例如，要在 Mac 上安装：](https://pytorch.org/get-started/locally/)
+由于我们将使用 PyTorch 的 Beta 版部分，因此建议安装最新版本的 Torch 和`tochvision`。 您可以在此处找到有关本地安装[的最新说明。 例如，要在 Mac 上安装：](https://pytorch.org/get-started/locally/)
 
 ```py
 yes y | pip uninstall torch tochvision
@@ -344,8 +344,8 @@ def load_and_cache_examples(args, task, tokenizer, evaluate=False):
 
 我们在模型上调用`torch.quantization.quantize_dynamic`，将动态量化应用于 HuggingFace BERT 模型。 特别，
 
-*   我们指定要对模型中的 torch.nn.Linear 模块进行量化；
-*   我们指定希望将权重转换为量化的 int8 值。
+*   我们指定要对模型中的`torch.nn.Linear`模块进行量化；
+*   我们指定希望将权重转换为量化的`int8`值。
 
 ```py
 quantized_model = torch.quantization.quantize_dynamic(
@@ -370,7 +370,7 @@ print_size_of_model(quantized_model)
 
 ```
 
-本教程中使用的 BERT 模型（`bert-base-uncased`）的词汇量 V 为 30522。在嵌入量为 768 的情况下，单词嵌入表的总大小为〜4（Bytes / FP32）* 30522 * 768 = 90 MB 。 因此，借助量化，非嵌入表部分的模型大小从 350 MB（FP32 模型）减少到 90 MB（INT8 模型）。
+本教程中使用的 BERT 模型（`bert-base-uncased`）的词汇量`V`为 30522。在嵌入量为 768 的情况下，单词嵌入表的总大小为`~4 (Bytes/FP32) * 30522 * 768 = 90 MB` 。 因此，借助量化，非嵌入表部分的模型大小从 350 MB（FP32 模型）减少到 90 MB（INT8 模型）。
 
 ### 3.2 评估推理准确率和时间
 
@@ -408,7 +408,7 @@ time_model_evaluation(quantized_model, configs, tokenizer)
 
 ### 3.3 序列化量化模型
 
-跟踪模型后，我们可以使用 torch.jit.save 序列化并保存量化模型，以备将来使用。
+跟踪模型后，我们可以使用`torch.jit.save`序列化并保存量化模型，以备将来使用。
 
 ```py
 input_ids = ids_tensor([8, 128], 2)
@@ -420,7 +420,7 @@ torch.jit.save(traced_model, "bert_traced_eager_quant.pt")
 
 ```
 
-要加载量化模型，我们可以使用 torch.jit.load
+要加载量化模型，我们可以使用`torch.jit.load`
 
 ```py
 loaded_quantized_model = torch.jit.load("bert_traced_eager_quant.pt")

new/pt-tut-17/57.md

-# （beta）在 PyTorch 中使用 Eager 模式进行静态量化
+# 在 PyTorch 中使用 Eager 模式进行静态量化（beta）
 
 > 原文：<https://pytorch.org/tutorials/advanced/static_quantization_tutorial.html#>
 
@@ -6,7 +6,7 @@
 
 **编辑**：[赛斯·魏德曼](https://github.com/SethHWeidman/)
 
-本教程说明了如何进行训练后的静态量化，并说明了两种更先进的技术-每通道量化和量化感知训练-可以进一步提高模型的准确率。 请注意，目前仅支持 CPU 量化，因此在本教程中我们将不使用 GPU / CUDA。
+本教程说明了如何进行训练后的静态量化，并说明了两种更先进的技术-每通道量化和量化感知训练-可以进一步提高模型的准确率。 请注意，目前仅支持 CPU 量化，因此在本教程中我们将不使用 GPU/CUDA。
 
 在本教程结束时，您将看到 PyTorch 中的量化如何导致模型大小显着减小同时提高速度。 此外，您将在此处看到如何轻松应用[中显示的一些高级量化技术，以使您的量化模型受到的准确率影响要小得多。](https://arxiv.org/abs/1806.08342)
 
@@ -472,7 +472,7 @@ Size (MB): 13.999657
 
 ## 4.训练后静态量化
 
-训练后的静态量化不仅涉及像动态量化中那样将权重从 float 转换为 int，而且还执行额外的步骤，即首先通过网络馈送一批数据并计算不同激活的结果分布（具体来说，这是 通过在记录此数据的不同点插入观察者模块来完成）。 然后使用这些分布来确定在推理时如何具体量化不同的激活（一种简单的技术是将整个激活范围简单地划分为 256 个级别，但我们也支持更复杂的方法）。 重要的是，此附加步骤使我们能够在操作之间传递量化值，而不是在每次操作之间将这些值转换为浮点数，然后再转换为整数，从而显着提高了速度。
+训练后的静态量化不仅涉及像动态量化中那样将权重从`float`转换为`int`，而且还执行额外的步骤，即首先通过网络馈送一批数据并计算不同激活的结果分布（具体来说，这是 通过在记录此数据的不同点插入观察者模块来完成）。 然后使用这些分布来确定在推理时如何具体量化不同的激活（一种简单的技术是将整个激活范围简单地划分为 256 个级别，但我们也支持更复杂的方法）。 重要的是，此附加步骤使我们能够在操作之间传递量化值，而不是在每次操作之间将这些值转换为浮点数，然后再转换为整数，从而显着提高了速度。
 
 ```py
 num_calibration_batches = 10
@@ -558,7 +558,7 @@ Size (MB): 3.631847
 
 ```
 
-对于这个量化模型，我们发现在这 300 张相同的图像上，准确率仅低至〜62%。 不过，我们确实将模型的大小减小到了 3.6 MB 以下，几乎减少了 4 倍。
+对于这个量化模型，我们发现在这 300 张相同的图像上，准确率仅低至约 62%。 不过，我们确实将模型的大小减小到了 3.6 MB 以下，几乎减少了 4 倍。
 
 此外，我们可以通过使用不同的量化配置来显着提高准确率。 我们使用推荐的配置对 x86 架构进行量化，重复相同的练习。 此配置执行以下操作：
 
@@ -593,7 +593,7 @@ QConfig(activation=functools.partial(<class 'torch.quantization.observer.Histogr
 
 ## 5.量化意识训练
 
-量化意识训练（QAT）是通常导致最高准确率的量化方法。 使用 QAT，在训练的正向和反向过程中，所有权重和激活都被“伪量化”：即，浮点值四舍五入以模拟 int8 值，但所有计算仍使用浮点数完成。 因此，在训练过程中进行所有权重调整，同时“意识到”该模型将最终被量化的事实。 因此，在量化之后，此方法通常会比动态量化或训练后静态量化产生更高的精度。
+量化意识训练（QAT）是通常导致最高准确率的量化方法。 使用 QAT，在训练的正向和反向过程中，所有权重和激活都被“伪量化”：即，浮点值四舍五入以模拟`int8`值，但所有计算仍使用浮点数完成。 因此，在训练过程中进行所有权重调整，同时“意识到”该模型将最终被量化的事实。 因此，在量化之后，此方法通常会比动态量化或训练后静态量化产生更高的精度。
 
 实际执行 QAT 的总体工作流程与之前非常相似：
 

new/pt-tut-17/58.md

-# （beta）计算机视觉教程的量化迁移学习
+# 计算机视觉教程的量化迁移学习（beta）
 
 > 原文：<https://pytorch.org/tutorials/intermediate/quantized_transfer_learning_tutorial.html>
 
@@ -10,7 +10,7 @@
 
 **由**审核： [Raghuraman Krishnamoorthi](https://github.com/raghuramank100)
 
-**编辑**：[林 ess 琳](https://github.com/jlin27)
+**编辑**：[Jessica Lin](https://github.com/jlin27)
 
 本教程以 [Sasank Chilamkurthy](https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html) 编写的原始 [PyTorch 迁移学习](https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html)教程为基础。
 
@@ -261,7 +261,7 @@ def visualize_model(model, rows=3, cols=3):
 
 ## 第 1 部分。训练基于量化特征提取器的自定义分类器
 
-在本节中，您将使用“冻结”量化特征提取器，并在其顶部训练自定义分类器头。 与浮点模型不同，您无需为量化模型设置 require_grad = False，因为它没有可训练的参数。 请参阅[文档](https://pytorch.org/docs/stable/quantization.html)了解更多详细信息。
+在本节中，您将使用“冻结”量化特征提取器，并在其顶部训练自定义分类器头。 与浮点模型不同，您无需为量化模型设置`require_grad = False`，因为它没有可训练的参数。 请参阅[文档](https://pytorch.org/docs/stable/quantization.html)了解更多详细信息。
 
 加载预训练的模型：在本练习中，您将使用 [ResNet-18](https://pytorch.org/hub/pytorch_vision_resnet/) 。
 
@@ -377,9 +377,11 @@ plt.tight_layout()
 
 由于随机初始化，您的结果可能与本教程中显示的结果不同。
 
-＃注意 quantize = False model = models.resnet18（pretrained = True，progress = True，quantize = False）num_ftrs = model.fc.in_features
+```py
+# notice quantize=False model = models.resnet18(pretrained=True, progress=True, quantize=False) num_ftrs = model.fc.in_features
 
-＃步骤 1 model.train（）model.fuse_model（）＃步骤 2 model_ft = create_combined_model（model）model_ft [0] .qconfig = torch.quantization.default_qat_qconfig＃使用默认 QAT 配置＃步骤 3 model_ft = torch.quantization.prepare_qat（ model_ft，inplace = True）
+# Step 1 model.train() model.fuse_model() # Step 2 model_ft = create_combined_model(model) model_ft[0].qconfig = torch.quantization.default_qat_qconfig # Use default QAT configuration # Step 3 model_ft = torch.quantization.prepare_qat(model_ft, inplace=True)
+```
 
 ### 微调模型
 

new/pt-tut-17/60.md

@@ -36,7 +36,7 @@ PyTorch 为数据并行训练提供了几种选择。 对于从简单到复杂
 
 ### `torch.nn.parallel.DistributedDataParallel`
 
-与 [DataParallel](https://pytorch.org/docs/master/generated/torch.nn.DataParallel.html) 相比， [DistributedDataParallel](https://pytorch.org/docs/master/generated/torch.nn.parallel.DistributedDataParallel.html) 还需要设置一个步骤，即调用 [init_process_group](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) 。 DDP 使用多进程并行性，因此在模型副本之间没有 GIL 争用。 此外，该模型是在 DDP 构建时而不是在每个正向传递时广播的，这也有助于加快训练速度。 DDP 附带了几种性能优化技术。 有关更深入的说明，请参阅此 [DDP 论文](https://arxiv.org/abs/2006.15704)（VLDB’20）。
+与 [DataParallel](https://pytorch.org/docs/master/generated/torch.nn.DataParallel.html) 相比， [DistributedDataParallel](https://pytorch.org/docs/master/generated/torch.nn.parallel.DistributedDataParallel.html) 还需要设置一个步骤，即调用 [init_process_group](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) 。 DDP 使用多进程并行性，因此在模型副本之间没有 GIL 争用。 此外，该模型是在 DDP 构建时而不是在每个正向传递时广播的，这也有助于加快训练速度。 DDP 附带了几种性能优化技术。 有关更深入的说明，请参阅此 [DDP 论文](https://arxiv.org/abs/2006.15704)（VLDB'20）。
 
 DDP 材料如下：
 
@@ -70,4 +70,4 @@ RPC 教程如下：
 
 ## PyTorch 分布式开发人员
 
-如果您想为 PyTorch Distributed 做出贡献，请参阅我们的[开发人员指南](https://github.com/pytorch/pytorch/blob/master/torch/distributed/CONTRIBUTING.md)。
\ No newline at end of file
+如果您想为 PyTorch 分布式做出贡献，请参阅我们的[开发人员指南](https://github.com/pytorch/pytorch/blob/master/torch/distributed/CONTRIBUTING.md)。
\ No newline at end of file