2021-01-19 17:40:02

new/pt-tut-17/19.md

@@ -20,9 +20,9 @@
     *   `labels (Int64Tensor[N])`：每个边界框的标签。 `0`始终代表背景类。
     *   `image_id (Int64Tensor[1])`：图像标识符。 它在数据集中的所有图像之间应该是唯一的，并在评估过程中使用
     *   `area (Tensor[N])`：边界框的区域。 在使用 COCO 度量进行评估时，可使用此值来区分小盒子，中盒子和大盒子之间的度量得分。
-    *   `iscrowd (UInt8Tensor[N])`：iscrowd = True 的实例在评估期间将被忽略。
+    *   `iscrowd (UInt8Tensor[N])`：`iscrowd = True`的实例在评估期间将被忽略。
     *   （可选）`masks (UInt8Tensor[N, H, W])`：每个对象的分割蒙版
-    *   （可选）`keypoints (FloatTensor[N, K, 3])`：对于 N 个对象中的每一个，它包含`[x, y, visibility]`格式的 K 个关键点，以定义对象。 可见性= 0 表示关键点不可见。 请注意，对于数据扩充，翻转关键点的概念取决于数据表示形式，您可能应该将`references/detection/transforms.py`修改为新的关键点表示形式
+    *   （可选）`keypoints (FloatTensor[N, K, 3])`：对于 N 个对象中的每一个，它包含`[x, y, visibility]`格式的 K 个关键点，以定义对象。 可见性为 0 表示关键点不可见。 请注意，对于数据扩充，翻转关键点的概念取决于数据表示形式，您可能应该将`references/detection/transforms.py`修改为新的关键点表示形式
 
 如果您的模型返回上述方法，则它们将使其适用于训练和评估，并将使用`pycocotools`中的评估脚本。
 
@@ -400,7 +400,7 @@ IoU metric: segm
 
 ```
 
-因此，经过一个时期的训练，我们获得了 60.6 的 COCO 风格 mAP 和 70.4 的口罩 mAP。
+因此，经过一个时期的训练，我们获得了 60.6 的 COCO 风格 mAP 和 70.4 的遮罩 mAP。
 
 经过 10 个时期的训练，我得到了以下指标
 

new/pt-tut-17/20.md

@@ -39,7 +39,7 @@ plt.ion()   # interactive mode
 
 ## 加载数据
 
-我们将使用 torchvision 和 torch.utils.data 包来加载数据。
+我们将使用`torchvision`和`torch.utils.data`包来加载数据。
 
 我们今天要解决的问题是训练一个模型来对**蚂蚁**和**蜜蜂**进行分类。 我们为蚂蚁和蜜蜂提供了大约 120 张训练图像。 每个类别有 75 个验证图像。 通常，如果从头开始训练的话，这是一个非常小的数据集。 由于我们正在使用迁移学习，因此我们应该能够很好地概括。
 

new/pt-tut-17/21.md

@@ -213,7 +213,7 @@ def test( model, device, test_loader, epsilon ):
 
 ### 运行攻击
 
-实现的最后一部分是实际运行攻击。 在这里，我们为`epsilon`输入中的每个 epsilon 值运行完整的测试步骤。 对于每个 epsilon，我们还保存最终精度，并在接下来的部分中绘制一些成功的对抗示例。 请注意，随着ε值的增加，打印的精度如何降低。 另外，请注意`ε = 0`表示原始测试准确率，没有受到攻击。
+实现的最后一部分是实际运行攻击。 在这里，我们为`epsilon`输入中的每个`ε`值运行完整的测试步骤。 对于每个`ε`，我们还保存最终精度，并在接下来的部分中绘制一些成功的对抗示例。 请注意，随着ε值的增加，打印的精度如何降低。 另外，请注意`ε = 0`表示原始测试准确率，没有受到攻击。
 
 ```py
 accuracies = []
@@ -242,9 +242,9 @@ Epsilon: 0.3    Test Accuracy = 869 / 10000 = 0.0869
 
 ## 结果
 
-### 准确率与 Epsilon
+### 准确率与`ε`
 
-第一个结果是精度与ε曲线的关系。 如前所述，随着ε的增加，我们预计测试精度会降低。 这是因为更大的ε意味着我们朝着将损失最大化的方向迈出了更大的一步。 请注意，即使 epsilon 值是线性间隔的，曲线中的趋势也不是线性的。 例如，`ε = 0.05`处的精度仅比`ε = 0`低约 4%，但`ε = 0.2`处的精度比`ε = 0.15`。 另外，请注意，模型的准确率在`ε = 0.25`和`ε = 0.3`之间达到 10 类分类器的随机准确率。
+第一个结果是精度与`ε`曲线的关系。 如前所述，随着`ε`的增加，我们预计测试精度会降低。 这是因为更大的ε意味着我们朝着将损失最大化的方向迈出了更大的一步。 请注意，即使`ε`值是线性间隔的，曲线中的趋势也不是线性的。 例如，`ε = 0.05`处的精度仅比`ε = 0`低约 4%，但`ε = 0.2`处的精度比`ε = 0.15`。 另外，请注意，模型的准确率在`ε = 0.25`和`ε = 0.3`之间达到 10 类分类器的随机准确率。
 
 ```py
 plt.figure(figsize=(5,5))

new/pt-tut-17/22.md

@@ -14,7 +14,7 @@
 
 GAN 是用于教授 DL 模型以捕获训练数据分布的框架，因此我们可以从同一分布中生成新数据。 GAN 由 Ian Goodfellow 于 2014 年发明，并在论文[生成对抗网络](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)中首次进行了描述。 它们由两个不同的模型组成：*生成器*和*判别器*。 生成器的工作是生成看起来像训练图像的“假”图像。 判别器的工作是查看图像并从生成器输出它是真实的训练图像还是伪图像。 在训练过程中，生成器不断尝试通过生成越来越好的伪造品而使判别器的性能超过智者，而判别器正在努力成为更好的侦探并正确地对真实和伪造图像进行分类。 博弈的平衡点是当生成器生成的伪造品看起来像直接来自训练数据时，而判别器则总是猜测生成器输出是真实还是伪造品的 50% 置信度。
 
-现在，让我们从鉴别符开始定义一些在整个教程中使用的符号。 令`x`为代表图像的数据。 `D(x)`是判别器网络，其输出`x`来自训练数据而不是生成器的（标量）概率。 在这里，由于我们要处理图像，因此`D(x)`的输入是 CHW 大小为 3x64x64 的图像。 直观地，当`x`来自训练数据时，`D(x)`应该为高，而当`x`来自发生器时，它应该为低。 `D(x)`也可以被认为是传统的二分类器。
+现在，让我们从鉴别符开始定义一些在整个教程中使用的符号。 令`x`为代表图像的数据。 `D(x)`是判别器网络，其输出`x`来自训练数据而不是生成器的（标量）概率。 在这里，由于我们要处理图像，因此`D(x)`的输入是 CHW 大小为`3x64x64`的图像。 直观地，当`x`来自训练数据时，`D(x)`应该为高，而当`x`来自发生器时，它应该为低。 `D(x)`也可以被认为是传统的二分类器。
 
 对于生成器的表示法，令`z`是从标准正态分布中采样的潜在空间向量。 `G(z)`表示将隐向量`z`映射到数据空间的生成器函数。 `G`的目标是估计训练数据来自`p_data`的分布，以便它可以从该估计分布（`p_g`）生成假样本。
 
@@ -26,7 +26,7 @@ GAN 是用于教授 DL 模型以捕获训练数据分布的框架，因此我们
 
 ### 什么是 DCGAN？
 
-DCGAN 是上述 GAN 的直接扩展，不同之处在于，DCGAN 分别在判别器和生成器中分别使用卷积和卷积转置层。 它最早由 Radford 等人描述。 等 在论文[中使用深度卷积生成对抗网络](https://arxiv.org/pdf/1511.06434.pdf)进行无监督表示学习。 判别器由分层的[卷积](https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d)层，[批量规范](https://pytorch.org/docs/stable/nn.html#torch.nn.BatchNorm2d)层和 [LeakyReLU](https://pytorch.org/docs/stable/nn.html#torch.nn.LeakyReLU) 激活组成。 输入是 3x64x64 的输入图像，输出是输入来自真实数据分布的标量概率。 生成器由[卷积转置](https://pytorch.org/docs/stable/nn.html#torch.nn.ConvTranspose2d)层，批量规范层和 [ReLU](https://pytorch.org/docs/stable/nn.html#relu) 激活组成。 输入是从标准正态分布中提取的潜向量`z`，输出是 3x64x64 RGB 图像。 跨步的转置层使潜向量可以转换为具有与图像相同形状的体积。 在本文中，作者还提供了一些有关如何设置优化器，如何计算损失函数以及如何初始化模型权重的提示，所有这些都将在接下来的部分中进行解释。
+DCGAN 是上述 GAN 的直接扩展，不同之处在于，DCGAN 分别在判别器和生成器中分别使用卷积和卷积转置层。 它最早由 Radford 等人描述。 等 在论文[中使用深度卷积生成对抗网络](https://arxiv.org/pdf/1511.06434.pdf)进行无监督表示学习。 判别器由分层的[卷积](https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d)层，[批量规范](https://pytorch.org/docs/stable/nn.html#torch.nn.BatchNorm2d)层和 [LeakyReLU](https://pytorch.org/docs/stable/nn.html#torch.nn.LeakyReLU) 激活组成。 输入是`3x64x64`的输入图像，输出是输入来自真实数据分布的标量概率。 生成器由[卷积转置](https://pytorch.org/docs/stable/nn.html#torch.nn.ConvTranspose2d)层，批量规范层和 [ReLU](https://pytorch.org/docs/stable/nn.html#relu) 激活组成。 输入是从标准正态分布中提取的潜向量`z`，输出是`3x64x64` RGB 图像。 跨步的转置层使潜向量可以转换为具有与图像相同形状的体积。 在本文中，作者还提供了一些有关如何设置优化器，如何计算损失函数以及如何初始化模型权重的提示，所有这些都将在接下来的部分中进行解释。
 
 ```py
 from __future__ import print_function
@@ -69,16 +69,16 @@ Random Seed:  999
 让我们为跑步定义一些输入：
 
 *   `dataroot`-数据集文件夹根目录的路径。 我们将在下一节中进一步讨论数据集
-*   `worker`-使用 DataLoader 加载数据的工作线程数
+*   `worker`-使用`DataLoader`加载数据的工作线程数
 *   `batch_size`-训练中使用的批量大小。 DCGAN 纸使用的批量大小为 128
-*   `image_size`-用于训练的图像的空间大小。 此实现默认为 64x64。 如果需要其他尺寸，则必须更改 D 和 G 的结构。 有关更多详细信息，请参见此处的[。](https://github.com/pytorch/examples/issues/70)
+*   `image_size`-用于训练的图像的空间大小。 此实现默认为`64x64`。 如果需要其他尺寸，则必须更改`D`和`G`的结构。 有关更多详细信息，请参见[此处](https://github.com/pytorch/examples/issues/70)。
 *   `nc`-输入图像中的彩色通道数。 对于彩色图像，这是 3
 *   `nz`-潜向量的长度
 *   `ngf`-与通过生成器传送的特征图的深度有关
 *   `ndf`-设置通过判别器传播的特征图的深度
 *   `num_epochs`-要运行的训练时期数。 训练更长的时间可能会导致更好的结果，但也会花费更长的时间
 *   `lr`-训练的学习率。 如 DCGAN 文件中所述，此数字应为 0.0002
-*   `beta1`-Adam 优化器的 beta1 超参数。 如论文所述，该数字应为 0.5
+*   `beta1`-Adam 优化器的`beta1`超参数。 如论文所述，该数字应为 0.5
 *   `ngpu`-可用的 GPU 数量。 如果为 0，则代码将在 CPU 模式下运行。 如果此数字大于 0，它将在该数量的 GPU 上运行
 
 ```py
@@ -136,7 +136,7 @@ ngpu = 1
 
 ```
 
-这是重要的一步，因为我们将使用 ImageFolder 数据集类，该类要求数据集的根文件夹中有子目录。 现在，我们可以创建数据集，创建数据加载器，将设备设置为可以运行，并最终可视化一些训练数据。
+这是重要的一步，因为我们将使用`ImageFolder`数据集类，该类要求数据集的根文件夹中有子目录。 现在，我们可以创建数据集，创建数据加载器，将设备设置为可以运行，并最终可视化一些训练数据。
 
 ```py
 # We can use an image folder dataset the way we have it setup.
@@ -168,11 +168,11 @@ plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=
 
 ## 实现
 
-设置好输入参数并准备好数据集后，我们现在可以进入实现了。 我们将从 weigth 初始化策略开始，然后详细讨论生成器，判别器，损失函数和训练循环。
+设置好输入参数并准备好数据集后，我们现在可以进入实现了。 我们将从权重初始化策略开始，然后详细讨论生成器，判别器，损失函数和训练循环。
 
 ### 权重初始化
 
-在 DCGAN 论文中，作者指定所有模型权重均应从均值= 0，stdev = 0.02 的正态分布中随机初始化。 `weights_init`函数采用已初始化的模型作为输入，并重新初始化所有卷积，卷积转置和批量归一化层以满足此标准。 初始化后立即将此功能应用于模型。
+在 DCGAN 论文中，作者指定所有模型权重均应从均值为 0，`stdev = 0.02`的正态分布中随机初始化。 `weights_init`函数采用已初始化的模型作为输入，并重新初始化所有卷积，卷积转置和批量归一化层以满足此标准。 初始化后立即将此功能应用于模型。
 
 ```py
 # custom weights initialization called on netG and netD
@@ -188,11 +188,11 @@ def weights_init(m):
 
 ### 生成器
 
-生成器`G`用于将潜在空间向量（`z`）映射到数据空间。 由于我们的数据是图像，因此将`z`转换为数据空间意味着最终创建与训练图像大小相同的 RGB 图像（即 3x64x64）。 在实践中，这是通过一系列跨步的二维卷积转置层来完成的，每个层都与 2d 批量规范层和 relu 激活配对。 生成器的输出通过 tanh 函数馈送，以使其返回到输入数据范围`[-1,1]`。 值得注意的是，在卷积转置层之后存在批量规范函数，因为这是 DCGAN 论文的关键贡献。 这些层有助于训练过程中的梯度流动。 DCGAN 纸生成的图像如下所示。
+生成器`G`用于将潜在空间向量（`z`）映射到数据空间。 由于我们的数据是图像，因此将`z`转换为数据空间意味着最终创建与训练图像大小相同的 RGB 图像（即`3x64x64`）。 在实践中，这是通过一系列跨步的二维卷积转置层来完成的，每个层都与 2d 批量规范层和 relu 激活配对。 生成器的输出通过 tanh 函数馈送，以使其返回到输入数据范围`[-1,1]`。 值得注意的是，在卷积转置层之后存在批量规范函数，因为这是 DCGAN 论文的关键贡献。 这些层有助于训练过程中的梯度流动。 DCGAN 纸生成的图像如下所示。
 
 ![dcgan_generator](img/85974d98be6202902f21ce274418953f.png)
 
-请注意，我们在输入部分中设置的输入（`nz`，`ngf`和`nc`）如何影响代码中的生成器架构。 `nz`是 z 输入向量的长度，`ngf`与通过生成器传播的特征图的大小有关， `nc`是 输出图像中的通道（对于 RGB 图像设置为 3）。 下面是生成器的代码。
+请注意，我们在输入部分中设置的输入（`nz`，`ngf`和`nc`）如何影响代码中的生成器架构。 `nz`是`z`输入向量的长度，`ngf`与通过生成器传播的特征图的大小有关， `nc`是输出图像中的通道（对于 RGB 图像设置为 3）。 下面是生成器的代码。
 
 ```py
 # Generator Code
@@ -274,7 +274,7 @@ Generator(
 
 ### 判别器
 
-如前所述，鉴别符`D`是一个二分类网络，将图像作为输入并输出标量概率，即输入图像是真实的（与假的相对）。 在这里，`D`拍摄 3x64x64 的输入图像，通过一系列的 Conv2d，BatchNorm2d 和 LeakyReLU 层对其进行处理，然后通过 Sigmoid 激活函数输出最终概率。 如果需要解决此问题，可以用更多层扩展此架构，但是使用跨步卷积，BatchNorm 和 LeakyReLU 仍然很重要。 DCGAN 论文提到，使用跨步卷积而不是通过池化来进行下采样是一个好习惯，因为它可以让网络学习自己的池化功能。 批量规范和泄漏 relu 函数还可以促进健康的梯度流，这对于`G`和`D`的学习过程都是至关重要的。
+如前所述，鉴别符`D`是一个二分类网络，将图像作为输入并输出标量概率，即输入图像是真实的（与假的相对）。 在这里，`D`拍摄`3x64x64`的输入图像，通过一系列的`Conv2d`，`BatchNorm2d`和`LeakyReLU`层对其进行处理，然后通过 Sigmoid 激活函数输出最终概率。 如果需要解决此问题，可以用更多层扩展此架构，但是使用跨步卷积，BatchNorm 和 LeakyReLU 仍然很重要。 DCGAN 论文提到，使用跨步卷积而不是通过池化来进行下采样是一个好习惯，因为它可以让网络学习自己的池化功能。 批量规范和泄漏 relu 函数还可以促进健康的梯度流，这对于`G`和`D`的学习过程都是至关重要的。
 
 鉴别码
 
@@ -357,9 +357,9 @@ Discriminator(
 
 ![](img/tex22-2.gif)
 
-请注意，此函数如何提供目标函数中两个对数分量的计算（即`log D(x)`和`log(1 - D(G(z)))`）。 我们可以指定`y`输入使用 BCE 方程的哪一部分。 这是在即将到来的训练循环中完成的，但重要的是要了解我们如何仅通过更改`y`（即 GT 标签）即可选择希望计算的分量。
+请注意，此函数如何提供目标函数中两个对数分量的计算（即`log D(x)`和`log(1 - D(G(z)))`）。 我们可以指定`y`输入使用 BCE 方程的哪一部分。 这是在即将到来的训练循环中完成的，但重要的是要了解我们如何仅通过更改`y`（即`GT`标签）即可选择希望计算的分量。
 
-接下来，我们将实际标签定义为 1，将假标签定义为 0。这些标签将在计算`D`和`G`的损失时使用，这也是 GAN 原始论文中使用的惯例 。 最后，我们设置了两个单独的优化器，一个用于`D`，另一个用于`G`。 如 DCGAN 论文中所指定，这两个都是学习速度为 0.0002 和 Beta1 = 0.5 的 Adam 优化器。 为了跟踪生成器的学习进度，我们将生成一批固定的潜在向量，这些向量是从高斯分布（即 fixed_noise）中提取的。 在训练循环中，我们将定期将此 fixed_noise 输入到`G`中，并且在迭代过程中，我们将看到图像形成于噪声之外。
+接下来，我们将实际标签定义为 1，将假标签定义为 0。这些标签将在计算`D`和`G`的损失时使用，这也是 GAN 原始论文中使用的惯例 。 最后，我们设置了两个单独的优化器，一个用于`D`，另一个用于`G`。 如 DCGAN 论文中所指定，这两个都是学习速度为 0.0002 和`Beta1 = 0.5`的 Adam 优化器。 为了跟踪生成器的学习进度，我们将生成一批固定的潜在向量，这些向量是从高斯分布（即`fixed_noise`）中提取的。 在训练循环中，我们将定期将此`fixed_noise`输入到`G`中，并且在迭代过程中，我们将看到图像形成于噪声之外。
 
 ```py
 # Initialize BCELoss function
@@ -381,7 +381,7 @@ optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))
 
 ### 训练
 
-最后，既然我们已经定义了 GAN 框架的所有部分，我们就可以对其进行训练。 请注意，训练 GAN 某种程度上是一种艺术形式，因为不正确的超参数设置会导致模式崩溃，而对失败的原因几乎没有解释。 在这里，我们将严格遵循 Goodfellow 论文中的算法 1，同时遵守 [ganhacks](https://github.com/soumith/ganhacks) 中显示的一些最佳做法。 即，我们将“为真实和伪造构建不同的小批量”图像，并调整 G 的目标函数以最大化`log D(G(z))`。 训练分为两个主要部分。 第 1 部分更新了判别器，第 2 部分更新了生成器。
+最后，既然我们已经定义了 GAN 框架的所有部分，我们就可以对其进行训练。 请注意，训练 GAN 某种程度上是一种艺术形式，因为不正确的超参数设置会导致模式崩溃，而对失败的原因几乎没有解释。 在这里，我们将严格遵循 Goodfellow 论文中的算法 1，同时遵守 [ganhacks](https://github.com/soumith/ganhacks) 中显示的一些最佳做法。 即，我们将“为真实和伪造构建不同的小批量”图像，并调整`G`的目标函数以最大化`log D(G(z))`。 训练分为两个主要部分。 第 1 部分更新了判别器，第 2 部分更新了生成器。
 
 **第 1 部分-训练判别器**
 
@@ -389,14 +389,14 @@ optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))
 
 **第 2 部分-训练生成器**
 
-如原始论文所述，我们希望通过最小化`log(1 - D(G(z)))`来训练 Generator，以产生更好的假货。 如前所述，Goodfellow 证明这不能提供足够的梯度，尤其是在学习过程的早期。 作为解决方法，我们希望最大化`log D(G(z))`。 在代码中，我们通过以下步骤来实现此目的：将第 1 部分的 Generator 输出与 Discriminator 进行分类，使用实数标签 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 的训练进度。 报告的训练统计数据是：
+最后，我们将进行一些统计报告，并在每个时期结束时，将我们的`fixed_noise`批量推送到生成器中，以直观地跟踪`G`的训练进度。 报告的训练统计数据是：
 
 *   `Loss_D`-判别器损失，计算为所有真实批量和所有假批量的损失总和（`log D(x) + log D(G(z))`）。
 *   `Loss_G`-生成器损耗计算为`log D(G(z))`
-*   `D(x)`-所有真实批量的判别器的平均输出（整个批量）。 这应该从接近 1 开始，然后在 G 变得更好时理论上收敛到 0.5。 想想这是为什么。
-*   `D(G(z))`-所有假批量的平均判别器输出。 第一个数字在 D 更新之前，第二个数字在 D 更新之后。 这些数字应从 0 开始，并随着 G 的提高收敛到 0.5。 想想这是为什么。
+*   `D(x)`-所有真实批量的判别器的平均输出（整个批量）。 这应该从接近 1 开始，然后在`G`变得更好时理论上收敛到 0.5。 想想这是为什么。
+*   `D(G(z))`-所有假批量的平均判别器输出。 第一个数字在`D`更新之前，第二个数字在`D`更新之后。 这些数字应从 0 开始，并随着`G`的提高收敛到 0.5。 想想这是为什么。
 
 **注意**：此步骤可能需要一段时间，具体取决于您运行了多少个纪元以及是否从数据集中删除了一些数据。
 
@@ -654,11 +654,11 @@ Starting Training Loop...
 
 ## 结果
 
-最后，让我们看看我们是如何做到的。 在这里，我们将看三个不同的结果。 首先，我们将了解 D 和 G 的损失在训练过程中如何变化。 其次，我们将在每个时期将 G 的输出显示为 fixed_noise 批量。 第三，我们将查看一批真实数据以及来自 G 的一批伪数据。
+最后，让我们看看我们是如何做到的。 在这里，我们将看三个不同的结果。 首先，我们将了解`D`和`G`的损失在训练过程中如何变化。 其次，我们将在每个时期将`G`的输出显示为`fixed_noise`批量。 第三，我们将查看一批真实数据以及来自`G`的一批伪数据。
 
 **损失与训练迭代**
 
-下面是 D＆G 的损失与训练迭代的关系图。
+下面是`D&G`的损失与训练迭代的关系图。
 
 ```py
 plt.figure(figsize=(10,5))
@@ -676,7 +676,7 @@ plt.show()
 
 **可视化`G`的进度**
 
-请记住，在每次训练之后，我们如何将生成器的输出保存为 fixed_noise 批量。 现在，我们可以用动画形象化 G 的训练进度。 按下播放按钮开始动画。
+请记住，在每次训练之后，我们如何将生成器的输出保存为`fixed_noise`批量。 现在，我们可以用动画形象化`G`的训练进度。 按下播放按钮开始动画。
 
 ```py
 #%%capture

new/pt-tut-17/24.md

-# 音频 I / O 和 torchaudio 的预处理
+# 音频 I/O 和`torchaudio`的预处理
 
 > 原文：<https://pytorch.org/tutorials/beginner/audio_preprocessing_tutorial.html>
 
 PyTorch 是一个开源深度学习平台，提供了从研究原型到具有 GPU 支持的生产部署的无缝路径。
 
-解决机器学习问题的重要工作是准备数据。 `torchaudio`充分利用了 PyTorch 的 GPU 支持，并提供了许多工具来简化数据加载并使其更具可读性。 在本教程中，我们将看到如何从简单的数据集中加载和预处理数据。 请访问[音频 I / O 和 torchaudio](https://pytorch.org/tutorials/beginner/audio_preprocessing_tutorial.html) 的预处理，以了解更多信息。
+解决机器学习问题的重要工作是准备数据。 `torchaudio`充分利用了 PyTorch 的 GPU 支持，并提供了许多工具来简化数据加载并使其更具可读性。 在本教程中，我们将看到如何从简单的数据集中加载和预处理数据。 请访问[音频 I/O 和`torchaudio`](https://pytorch.org/tutorials/beginner/audio_preprocessing_tutorial.html)的预处理，以了解更多信息。
 
 对于本教程，请确保已安装`matplotlib`软件包，以便于查看。
 
@@ -144,7 +144,7 @@ Shape of transformed waveform: torch.Size([1, 27686])
 
 ```
 
-作为变换的另一个示例，我们可以基于 Mu-Law 编码对信号进行编码。 但是要这样做，我们需要信号在-1 和 1 之间。由于张量只是常规的 PyTorch 张量，因此我们可以在其上应用标准运算符。
+作为变换的另一个示例，我们可以基于 Mu-Law 编码对信号进行编码。 但是要这样做，我们需要信号在 -1 和 1 之间。由于张量只是常规的 PyTorch 张量，因此我们可以在其上应用标准运算符。
 
 ```py
 # Let's check if the tensor is in the interval [-1,1]
@@ -161,7 +161,7 @@ Mean of waveform: 9.293758921558037e-05
 
 ```
 
-由于波形已经在-1 和 1 之间，因此我们不需要对其进行归一化。
+由于波形已经在 -1 和 1 之间，因此我们不需要对其进行归一化。
 
 ```py
 def normalize(tensor):
@@ -245,7 +245,7 @@ Median relative difference between original and MuLaw reconstucted signals: 1.28
 *   `lowpass_biquad`：设计双二阶低通滤波器并执行滤波。
 *   `highpass_biquad`：设计双二阶高通滤波器并执行滤波。
 
-例如，让我们尝试 mu_law_encoding 功能：
+例如，让我们尝试`mu_law_encoding`功能：
 
 ```py
 mu_law_encoding_waveform = torchaudio.functional.mu_law_encoding(waveform, quantization_channels=256)
@@ -367,7 +367,7 @@ Mean of highpass_waveform: 1.8138147234170177e-11
 *   `read_mat_scp`
 *   `read_mat_ark`
 
-`torchaudio`为`spectrogram`，`fbank`，`mfcc`和[提供 Kaldi 兼容的转换。](#id2) resample_waveform 受益于 GPU 支持，有关更多信息，请参见[在此处](compliance.kaldi.html)。
+`torchaudio`为`spectrogram`，`fbank`，`mfcc`和[提供 Kaldi 兼容的转换](#id2)。 `resample_waveform`受益于 GPU 支持，有关更多信息，请参见[在此处](compliance.kaldi.html)。
 
 ```py
 n_fft = 400.0

new/pt-tut-17/25.md

-# 使用 torchaudio 的语音命令识别
+# 使用`torchaudio`的语音命令识别
 
 > 原文：<https://pytorch.org/tutorials/intermediate/speech_command_recognition_with_torchaudio.html>
 
@@ -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
@@ -42,9 +42,9 @@ print(device)
 
 ## 导入数据集
 
-我们使用 torchaudio 下载并表示数据集。 在这里，我们使用 [SpeechCommands](https://arxiv.org/abs/1804.03209) ，它是由不同人员说出的 35 个命令的数据集。 数据集`SPEECHCOMMANDS`是数据集的`torch.utils.data.Dataset`版本。 在此数据集中，所有音频文件的长度约为 1 秒（因此约为 16000 个时间帧）。
+我们使用`torchaudio`下载并表示数据集。 在这里，我们使用 [SpeechCommands](https://arxiv.org/abs/1804.03209) ，它是由不同人员说出的 35 个命令的数据集。 数据集`SPEECHCOMMANDS`是数据集的`torch.utils.data.Dataset`版本。 在此数据集中，所有音频文件的长度约为 1 秒（因此约为 16000 个时间帧）。
 
-实际的加载和格式化步骤是在访问数据点时发生的，torchaudio 负责将音频文件转换为张量。 如果想直接加载音频文件，可以使用`torchaudio.load()`。 它返回一个包含新创建的张量的元组以及音频文件的采样频率（SpeechCommands 为 16kHz）。
+实际的加载和格式化步骤是在访问数据点时发生的，`torchaudio`负责将音频文件转换为张量。 如果想直接加载音频文件，可以使用`torchaudio.load()`。 它返回一个包含新创建的张量的元组以及音频文件的采样频率（`SpeechCommands`为 16kHz）。
 
 回到数据集，这里我们创建一个子类，将其分为标准训练，验证和测试子集。
 
@@ -78,7 +78,7 @@ waveform, sample_rate, label, speaker_id, utterance_number = train_set[0]
 
 ```
 
-SPEECHCOMMANDS 数据集中的数据点是一个由波形（音频信号），采样率，发声（标签），讲话者的 ID，发声数组成的元组。
+`SPEECHCOMMANDS`数据集中的数据点是一个由波形（音频信号），采样率，发声（标签），讲话者的 ID，发声数组成的元组。
 
 ```py
 print("Shape of waveform: {}".format(waveform.size()))
@@ -96,7 +96,7 @@ labels
 
 ```
 
-35 个音频标签是用户说的命令。 前几个文件是人们所说的“ marvin”。
+35 个音频标签是用户说的命令。 前几个文件是人们所说的`marvin`。
 
 ```py
 waveform_first, *_ = train_set[0]
@@ -119,7 +119,7 @@ ipd.Audio(waveform_last.numpy(), rate=sample_rate)
 
 这是将转换应用于数据的好地方。 对于波形，我们对音频进行下采样以进行更快的处理，而不会损失太多的分类能力。
 
-我们无需在此应用其他转换。 对于某些数据集，通常必须通过沿通道维度取平均值或仅保留其中一个通道来减少通道数量（例如，从立体声到单声道）。 由于 SpeechCommands 使用单个通道进行音频，因此此处不需要。
+我们无需在此应用其他转换。 对于某些数据集，通常必须通过沿通道维度取平均值或仅保留其中一个通道来减少通道数量（例如，从立体声到单声道）。 由于`SpeechCommands`使用单个通道进行音频，因此此处不需要。
 
 ```py
 new_sample_rate = 8000
@@ -150,7 +150,7 @@ print(word_start, "-->", index, "-->", word_recovered)
 
 ```
 
-为了将由录音和语音构成的数据点列表转换为该模型的两个成批张量，我们实现了归类功能，PyTorch DataLoader 使用了该功能，允许我们分批迭代数据集。 有关使用整理功能的更多信息，请参见[文档](https://pytorch.org/docs/stable/data.html#working-with-collate-fn)。
+为了将由录音和语音构成的数据点列表转换为该模型的两个成批张量，我们实现了归类功能，PyTorch `DataLoader`使用了该功能，允许我们分批迭代数据集。 有关使用整理功能的更多信息，请参见[文档](https://pytorch.org/docs/stable/data.html#working-with-collate-fn)。
 
 在整理功能中，我们还应用了重采样和文本编码。
 
@@ -210,7 +210,7 @@ test_loader = torch.utils.data.DataLoader(
 
 ## 定义网络
 
-在本教程中，我们将使用卷积神经网络来处理原始音频数据。 通常，更高级的转换将应用于音频数据，但是 CNN 可以用于准确处理原始数据。 具体架构是根据本文[中描述的 M5 网络架构建模的。 模型处理原始音频数据的一个重要方面是其第一层过滤器的接收范围。 我们模型的第一个滤波器长度为 80，因此在处理以 8kHz 采样的音频时，接收场约为 10ms（而在 4kHz 时约为 20ms）。 此大小类似于语音处理应用程序，该应用程序通常使用 20ms 到 40ms 的接收域。](https://arxiv.org/pdf/1610.00087.pdf)
+在本教程中，我们将使用卷积神经网络来处理原始音频数据。 通常，更高级的转换将应用于音频数据，但是 CNN 可以用于准确处理原始数据。 具体架构是根据[本文](https://arxiv.org/pdf/1610.00087.pdf)中描述的 M5 网络架构建模的。 模型处理原始音频数据的一个重要方面是其第一层过滤器的接收范围。 我们模型的第一个滤波器长度为 80，因此在处理以 8kHz 采样的音频时，接收场约为 10ms（而在 4kHz 时约为 20ms）。 此大小类似于语音处理应用程序，该应用程序通常使用 20ms 到 40ms 的接收域。
 
 ```py
 class M5(nn.Module):
@@ -302,7 +302,7 @@ def train(model, epoch, log_interval):
 
 ```
 
-现在我们有了训练功能，我们需要制作一个用于测试网络准确率的功能。 我们将模型设置为`eval()`模式，然后对测试数据集进行推断。 调用`eval()`将网络中所有模块中的训练变量设置为 false。 某些层（例如批量归一化层和丢弃层）在训练期间的行为会有所不同，因此此步骤对于获取正确的结果至关重要。
+现在我们有了训练功能，我们需要制作一个用于测试网络准确率的功能。 我们将模型设置为`eval()`模式，然后对测试数据集进行推断。 调用`eval()`将网络中所有模块中的训练变量设置为`false`。 某些层（例如批量归一化层和丢弃层）在训练期间的行为会有所不同，因此此步骤对于获取正确的结果至关重要。
 
 ```py
 def number_of_correct(pred, target):
@@ -445,7 +445,7 @@ ipd.Audio(waveform.numpy(), rate=sample_rate)
 
 ## 结论
 
-在本教程中，我们使用了 torchaudio 来加载数据集并对信号进行重新采样。 然后，我们定义了经过训练的神经网络，以识别给定命令。 还有其他数据预处理方法，例如找到梅尔频率倒谱系数（MFCC），可以减小数据集的大小。 此变换也可以在[torchaudio]中作为`torchaudio.transforms.MFCC`使用。
+在本教程中，我们使用了`torchaudio`来加载数据集并对信号进行重新采样。 然后，我们定义了经过训练的神经网络，以识别给定命令。 还有其他数据预处理方法，例如找到梅尔频率倒谱系数（MFCC），可以减小数据集的大小。 此变换也可以在`torchaudio`中作为`torchaudio.transforms.MFCC`使用。
 
 **脚本的总运行时间**：（0 分钟 0.000 秒）