2021-01-18 16:18:30

new/pt-ai-fund/2.md

@@ -232,7 +232,7 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机
 
 当传递输入时，将引用模型对象的名称自动调用 forward 方法。 `nn.Module`自动创建将在正向方法中使用的权重和偏差张量。 线性单位本身定义了线性函数，例如`xW + B`； 要具有非线性功能，我们需要插入非线性激活函数，在这里我们使用最流行的激活函数之一 ReLU，尽管您可以在 PyTorch 中使用其他可用的激活函数。
 
-我们的输入层有 784 个单位（从 28 x 28 像素开始），第一层具有 ReLU 激活的 256 个单位，然后具有 ReLU 激活的 128 个单位，最后有 softmax 激活的 10 个单位。 我们通过 softmax 压缩最终层输出的原因是因为我们希望有 1 个输出类的概率高于所有其他类，并且输出概率之和应等于 1。softmax 函数的参数`dim=1`为 确保在输出的各列中采用 softmax。 然后，我们使用模型类创建一个对象，并使用`print(model)`打印该类的详细信息。
+我们的输入层有 784 个单位（从`28 x 28`像素开始），第一层具有 ReLU 激活的 256 个单位，然后具有 ReLU 激活的 128 个单位，最后有 softmax 激活的 10 个单位。 我们通过 softmax 压缩最终层输出的原因是因为我们希望有 1 个输出类的概率高于所有其他类，并且输出概率之和应等于 1。softmax 函数的参数`dim=1`为 确保在输出的各列中采用 softmax。 然后，我们使用模型类创建一个对象，并使用`print(model)`打印该类的详细信息。
 
 # 还有更多...
 

new/pt-ai-fund/3.md

@@ -126,7 +126,7 @@ Conv2d(3, 16, kernel_size=(3, 4), stride=(3, 3), padding=(1, 2))
 
 在本食谱中，我们研究了创建 2D 卷积的多种方法，其中第一个参数是给定输入图像中的通道数，对于彩色图像，通道数将为`3`，对于灰度图像将为`1`。 第二个参数是输出通道的数量，换句话说，就是我们要从给定层获得的滤波器的数量。 第三个参数是内核大小（即内核大小），或者是要使用滤镜卷积的图像的补丁大小。
 
-然后，我们创建了一个`Con2d`对象，并将输入传递到 2D 卷积层以获取输出。 使用`nn.Conv2d(3, 16, 3)`，我们创建了一个卷积层，该卷积层接受 3 个通道的输入并输出 16 个通道。 该层的大小为 3 x 3 的正方形核，其高度和宽度的默认跨度为 1。 我们可以使用`padding`参数添加填充，该参数可以具有整数或元组值。 在这里，整数值将为高度和宽度创建相同的填充，而元组值将为高度和宽度创建不同的填充-这对于内核大小和跨度都是正确的。
+然后，我们创建了一个`Con2d`对象，并将输入传递到 2D 卷积层以获取输出。 使用`nn.Conv2d(3, 16, 3)`，我们创建了一个卷积层，该卷积层接受 3 个通道的输入并输出 16 个通道。 该层的大小为`3 x 3`的正方形核，其高度和宽度的默认跨度为 1。 我们可以使用`padding`参数添加填充，该参数可以具有整数或元组值。 在这里，整数值将为高度和宽度创建相同的填充，而元组值将为高度和宽度创建不同的填充-这对于内核大小和跨度都是正确的。
 
 # 还有更多...
 
@@ -253,7 +253,7 @@ Conv2d(3, 16, kernel_size=(3, 4), stride=(3, 3), padding=(1, 2))
 
 # 这个怎么运作...
 
-在前面的代码中，我们研究了一个张量的示例，以了解实际的池化层。 我们使用大小为 3 x 3 的方形内核。池的第一个应用发生在[0,0,0]到[0,3,3]的面片上。 由于步幅为 1，因此下一个要操作的音色为[0,0,1]至[0,3,4]。 一旦碰到水平端，就对下面的张量进行运算。 `nn.MaxPool2d(3, stride=1)`和`nn.AvgPool2d(3, stride=1)`都创建了大小为`3x3`的最大和平均池方核，步幅为`1`，将其应用于随机张量`a`。
+在前面的代码中，我们研究了一个张量的示例，以了解实际的池化层。 我们使用大小为`3 x 3`的方形内核。池的第一个应用发生在[0,0,0]到[0,3,3]的面片上。 由于步幅为 1，因此下一个要操作的音色为[0,0,1]至[0,3,4]。 一旦碰到水平端，就对下面的张量进行运算。 `nn.MaxPool2d(3, stride=1)`和`nn.AvgPool2d(3, stride=1)`都创建了大小为`3x3`的最大和平均池方核，步幅为`1`，将其应用于随机张量`a`。
 
 # 还有更多...
 
@@ -448,7 +448,7 @@ PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为
 
 # 加载图像数据
 
-在本食谱中，我们将研究如何将图像数据从文件加载到张量中。 在本食谱中，我们将使用 CIFAR-10 数据集，该数据集由数据集中 10 个类别中的每个类别的 60,000 个 32 x 32 像素彩色图像组成。 这些类别是飞机，汽车，鸟，猫，鹿，狗，青蛙，马，船和卡车。
+在本食谱中，我们将研究如何将图像数据从文件加载到张量中。 在本食谱中，我们将使用 CIFAR-10 数据集，该数据集由数据集中 10 个类别中的每个类别的 60,000 个`32 x 32`像素彩色图像组成。 这些类别是飞机，汽车，鸟，猫，鹿，狗，青蛙，马，船和卡车。
 
 # 做好准备
 
@@ -680,7 +680,7 @@ CNN(
 
 对于第一个全连接层，我们有 1,024 个输入（通过将最大池后的`64 x 4 x 4`张量展平而获得）和 512 个输出。 对于最后一个全连接层，我们有 512 个输入和 10 个输出，代表输出类别的数量。 我们还为全连接层定义了一个辍学层，概率为 0.3。
 
-接下来，我们定义`forward()`方法，将`__init__()`方法中定义的组件连接在一起。 因此，输入批量的 16 个张量（每个张量为 32 x 32 x 3）经过第一个卷积层，然后经过 ReLU，然后是最大合并层，以形成尺寸为 16 x 16 的输出张量。 x 16，然后通过第二个卷积层，然后是 ReLU 和最大池层，输出的尺寸为 8 x 8 x 32，然后是第三个卷积层，然后是 ReLU 和最大池 层，尺寸为 4 x 4 x64。此后，我们将图像展平为 1,024 个元素的向量，并将其通过辍学层传递到第一个全连接层，提供 512 个输出，然后是 ReLU 和 在最后一个全连接层中删除，以提供所需的输出数量，本例中为 10。
+接下来，我们定义`forward()`方法，将`__init__()`方法中定义的组件连接在一起。 因此，输入批量的 16 个张量（每个张量为 32 x 32 x 3）经过第一个卷积层，然后经过 ReLU，然后是最大合并层，以形成尺寸为`16 x 16`的输出张量。 x 16，然后通过第二个卷积层，然后是 ReLU 和最大池层，输出的尺寸为 8 x 8 x 32，然后是第三个卷积层，然后是 ReLU 和最大池 层，尺寸为 4 x 4 x64。此后，我们将图像展平为 1,024 个元素的向量，并将其通过辍学层传递到第一个全连接层，提供 512 个输出，然后是 ReLU 和 在最后一个全连接层中删除，以提供所需的输出数量，本例中为 10。
 
 然后，我们从 CNN 类实例化该模型并打印该模型。
 

new/pt-ai-fund/6.md

@@ -36,7 +36,7 @@ GAN 中的两个模型称为生成器和判别器，其中生成器负责创建
 
 在本食谱及其后续食谱中，我们将实现 DCGAN。 DCGAN 代表“深度卷积 GAN”； 与香草 GAN 相比，它们有很大的改进。 在 DCGAN 中，我们使用卷积神经网络，而不是香草 GAN 中的全连接网络。 在第 3 章，“用于计算机视觉的卷积神经网络”中，我们看到了第 2 章“处理神经网络”中全连接分类器是什么样，是该领域的一项改进； DCGAN 与香草 GAN 的情况相同。 在 DCGAN 中，我们将使用批量归一化，这是一种技术，它可以将作为输入输入到下一层的层的输出归一化。 批量归一化允许网络的每一层独立于其他层进行学习，从而减少了协变量偏移。
 
-批量归一化是通过缩放来实现的，以使平均值为 0，方差为 1。在此配方中，我们将生成类似于 MNIST 数据集的手写数字，其中包含来自噪声向量的数据。 我们将扩展此噪声向量，将其转换为 2D 矩阵，最后将其转换为 28 x 28 黑白图像。 为了增加高度和宽度，我们必须执行与卷积操作相反的操作，这称为反卷积。 我们将在使用卷积执行分类任务时执行此操作。 在执行反卷积时，我们将增加高度和宽度，同时减少通道数。
+批量归一化是通过缩放来实现的，以使平均值为 0，方差为 1。在此配方中，我们将生成类似于 MNIST 数据集的手写数字，其中包含来自噪声向量的数据。 我们将扩展此噪声向量，将其转换为 2D 矩阵，最后将其转换为`28 x 28`黑白图像。 为了增加高度和宽度，我们必须执行与卷积操作相反的操作，这称为反卷积。 我们将在使用卷积执行分类任务时执行此操作。 在执行反卷积时，我们将增加高度和宽度，同时减少通道数。
 
 以下是我们的 DCGAN 生成器的架构图：
 
@@ -656,9 +656,9 @@ pip install numpy
 
 # 使用 PyTorch 集线器运行 PGGAN
 
-在本食谱中，我们将研究**渐进 GAN**（**PGGAN**），与 DCGAN 相比它们是高级 GAN，并且能够生成逼真的图像。 PGGAN 分多个阶段训练 GAN 网络。 它具有`z`的潜在特征，并使用两个反卷积层生成 4×4 图像。 在判别器方面，网络使用两个卷积层训练生成的 4 x 4 图像。 网络稳定后，它会在判别器中再增加两个卷积层以将图像上采样到 8 x 8，再增加两个卷积层以对图像下采样。
+在本食谱中，我们将研究**渐进 GAN**（**PGGAN**），与 DCGAN 相比它们是高级 GAN，并且能够生成逼真的图像。 PGGAN 分多个阶段训练 GAN 网络。 它具有`z`的潜在特征，并使用两个反卷积层生成 4×4 图像。 在判别器方面，网络使用两个卷积层训练生成的`4 x 4`图像。 网络稳定后，它会在判别器中再增加两个卷积层以将图像上采样到 8 x 8，再增加两个卷积层以对图像下采样。
 
-经过 9 个这样的级数后，生成器将生成 1024 x 1024 个图像。 PGGAN 的渐进式训练策略相对于常规 GAN 具有优势，因为它可以加快并稳定训练。 之所以如此，是因为大多数训练都是在较低的分辨率下进行的，而在网络达到各个阶段的稳定性之后，会逐渐发展为较高的分辨率。
+经过 9 个这样的级数后，生成器将生成`1024 x 1024`个图像。 PGGAN 的渐进式训练策略相对于常规 GAN 具有优势，因为它可以加快并稳定训练。 之所以如此，是因为大多数训练都是在较低的分辨率下进行的，而在网络达到各个阶段的稳定性之后，会逐渐发展为较高的分辨率。
 
 以下是 PGGAN 的抽象表示形式：
 

new/pt-ai-fund/8.md

@@ -573,7 +573,7 @@ CNN(
 
 在此食谱中，我们将正常的 PyTorch 模型导出为 ONNX 格式，并使用 ONNX 运行时运行`onnx`模型。 为此，我们采用了权重模型。 在这里，我们使用了第 3 章“卷积神经网络”的 CIFAR-10 模型，用于计算机视觉*。 我们从训练中使用了模型的权重，并将模型设置为评估模式，以进行快速，轻便的计算。
 
-然后，我们使用了一个随机变量，其形状与输入张量的形状相同，在本例中为三通道 32 x 32 像素图像。 我们将此随机输入传递到模型中并获得输出。 然后，我们使用输出将其与模型的 ONNX 版本中的模型进行比较。
+然后，我们使用了一个随机变量，其形状与输入张量的形状相同，在本例中为三通道`32 x 32`像素图像。 我们将此随机输入传递到模型中并获得输出。 然后，我们使用输出将其与模型的 ONNX 版本中的模型进行比较。
 
 在 PyTorch 中使用跟踪或脚本导出模型。 在本食谱中，我们在`torch.onnx.export()`的帮助下使用了跟踪。 跟踪跟踪用于获取输出的操作。 这就是为什么我们提供`x`的原因-因此可以进行跟踪。 `x`必须具有正确的类型和大小。 输入尺寸在导出的 ONNX 图形中固定为所有输入尺寸，我们必须指定所有动态轴。 在此配方中，我们使用第一维的输入导出模型，将批量大小设置为 1，并在`torch.onnx.export()`的`dynamic_axes`参数中将第一维指定为动态。
 

new/pt-dl-handson/1.md

@@ -414,7 +414,7 @@ tensor([[6.],
 
 ```
 
-变量`x`和`y`为 3 x 2 张量，Python 乘法运算符执行逐元素乘法并给出相同形状的张量。 这个张量和形状为 2 x 1 的`z`张量正在通过 Python 的矩阵乘法运算符，并吐出 3 x 1 矩阵。
+变量`x`和`y`为`3 x 2`张量，Python 乘法运算符执行逐元素乘法并给出相同形状的张量。 这个张量和形状为`3 x 2`的`z`张量正在通过 Python 的矩阵乘法运算符，并吐出`3 x 2`矩阵。
 
 如上例所示，张量-张量操作有多个选项，例如普通的 Python 运算符，原地 PyTorch 函数和原地 PyTorch 函数。
 
@@ -454,15 +454,15 @@ tensor([[0.5594, 0.8875, 0.9234, 1.1294],
 
 索引张量就像索引普通的 Python 列表一样。 可以通过递归索引每个维度来索引多个维度。 索引从第一个可用维中选择索引。 索引时可以使用逗号分隔每个维度。 切片时可以使用此方法。 起始和结束索引可以使用完整的冒号分隔。 可以使用属性`t`访问矩阵的转置。 每个 PyTorch 张量对象都具有`t`属性。
 
-串联是工具箱中需要执行的另一项重要操作。 PyTorch 出于相同的目的制作了功能`cat`。 所有尺寸上的两个张量相同的张量（一个张量除外）可以根据需要使用`cat`进行连接。 例如，大小为 3 x 2 x 4 的张量可以与另一个大小为 3 x 5 x 4 的张量在第一维上级联，以获得大小为 3 x 7 x 4 的张量。`stack`操作看起来非常类似于 串联，但这是完全不同的操作。 如果要向张量添加新尺寸，则可以使用`stack`。 与`cat`相似，您可以将轴传递到要添加新尺寸的位置。 但是，请确保两个张量的所有尺寸都与附着尺寸相同。
+串联是工具箱中需要执行的另一项重要操作。 PyTorch 出于相同的目的制作了功能`cat`。 所有尺寸上的两个张量相同的张量（一个张量除外）可以根据需要使用`cat`进行连接。 例如，大小为`3 x 2 x 4`的张量可以与另一个大小为`3 x 2 x 4`的张量在第一维上级联，以获得大小为`3 x 2 x 4`的张量。`stack`操作看起来非常类似于 串联，但这是完全不同的操作。 如果要向张量添加新尺寸，则可以使用`stack`。 与`cat`相似，您可以将轴传递到要添加新尺寸的位置。 但是，请确保两个张量的所有尺寸都与附着尺寸相同。
 
-`split`和`chunk`是用于拆分张量的类似操作。 `split`接受每个输出张量要的大小。 例如，如果要在第 0 个维度上拆分大小为 3 x 2 的张量，尺寸为 1，则将得到三个大小均为 1 x 2 的张量。但是，如果在第 0 个维度上使用 2 作为大小，则将 会得到 2 x 2 的张量和另一个 1 x 2 的张量。
+`split`和`chunk`是用于拆分张量的类似操作。 `split`接受每个输出张量要的大小。 例如，如果要在第 0 个维度上拆分大小为`3 x 2`的张量，尺寸为 1，则将得到三个大小均为`3 x 2`的张量。但是，如果在第 0 个维度上使用 2 作为大小，则将 会得到`3 x 2`的张量和另一个`3 x 2`的张量。
 
 `squeeze`功能有时可以节省您的时间。 在某些情况下，您将具有一个或多个尺寸为 1 的张量。有时，您的张量中不需要那些多余的尺寸。 这就是`squeeze`将为您提供帮助的地方。 `squeeze`删除值为 1 的维。例如，如果您正在处理句子，并且有 10 个句子的批量，每个句子包含 5 个单词，则将其映射到张量对象时，将得到 10 x 的张量 5.然后，您意识到必须将其转换为一热向量，以便神经网络进行处理。
 
-您可以使用大小为 100 的单热点编码向量为张量添加另一个维度（因为词汇量为 100 个单词）。 现在，您有了一个尺寸为 10 x 5 x 100 的张量对象，并且每个批量和每个句子一次传递一个单词。
+您可以使用大小为 100 的单热点编码向量为张量添加另一个维度（因为词汇量为 100 个单词）。 现在，您有了一个尺寸为`10 x 5 x 100`的张量对象，并且每个批量和每个句子一次传递一个单词。
 
-现在，您必须对句子进行拆分和切分，最有可能的结果是，张量的大小为 10 x 1 x 100（每 10 个单词中的一个单词带有 100 维向量）。 您可以使用 10 x 100 的张量处理它，这使您的生活更加轻松。 继续使用`squeeze`从 10 x 1 x 100 张量得到 10 x 100 张量。
+现在，您必须对句子进行拆分和切分，最有可能的结果是，张量的大小为 10 x 1 x 100（每 10 个单词中的一个单词带有 100 维向量）。 您可以使用`10 x 100`的张量处理它，这使您的生活更加轻松。 继续使用`squeeze`从`10 x 1 x 100`张量得到`10 x 100`张量。
 
 PyTorch 具有称为`unsqueeze`的防挤压操作，该操作会为张量对象添加另一个伪尺寸。 不要将`unsqueeze`与`stack`混淆，这也会增加另一个维度。 `unsqueeze`添加了伪尺寸，并且不需要其他张量，但是`stack`正在将其他形状相同的张量添加到参考张量的另一个尺寸中。
 
@@ -534,7 +534,7 @@ print(with_fake_dimension)        # added a fake zeroth dimension
 
 正如您可能已经假设的那样，`THStorage`层不是一个智能数据结构，它实际上并不知道张量的元数据。 `THStorage`层负责保持指向原始数据和分配器的指针。 分配器完全是另一个主题，中有用于 CPU，GPU，共享内存等的不同分配器。 来自`THStorage`的指向**原始数据**的指针是互操作性的关键。 **原始数据**是存储实际数据的位置，但没有任何结构。 每个张量对象的这种三层表示使 PyTorch 的实现内存效率更高。 以下是一些示例。
 
-将变量`x`创建为 2 x 2 的张量，并填充 1s。 然后，我们创建另一个变量`xv`，它是同一张量`x`的另一个视图。 我们将 2 x 2 张量展平为大小为 4 的单维张量。我们还通过调用`.NumPy()`方法并将其存储在变量`xn`中来创建 NumPy 数组：
+将变量`x`创建为`2 x 2`的张量，并填充 1s。 然后，我们创建另一个变量`xv`，它是同一张量`x`的另一个视图。 我们将`2 x 2`张量展平为大小为 4 的单维张量。我们还通过调用`.NumPy()`方法并将其存储在变量`xn`中来创建 NumPy 数组：
 
 ```py
 >>> import torch

new/pt-dl-handson/2.md

@@ -185,7 +185,7 @@ print(w1.grad, w1.grad_fn, w1)
 # None None tensor([[...]])
 ```
 
-我们的输入`x`和第一层权重矩阵`w1`目前没有`grad`或`grad_fn`。 我们将很快看到这些属性的更新方式和时间。 `x`的`.data`属性为 900 x 10 形状，因为我们传递了 900 个数据点，每个数据点的大小均为 10（二进制编码数）。 现在，您可以准备进行数据迭代了。
+我们的输入`x`和第一层权重矩阵`w1`目前没有`grad`或`grad_fn`。 我们将很快看到这些属性的更新方式和时间。 `x`的`.data`属性为`900 x 10`形状，因为我们传递了 900 个数据点，每个数据点的大小均为 10（二进制编码数）。 现在，您可以准备进行数据迭代了。
 
 我们已经准备好输入，权重和偏差，并等待数据输入。如前所述，PyTorch 是一个基于动态图的网络，该网络在每次迭代时构建计算图。 因此，当我们遍历数据时，我们实际上是在动态构建图形，并在到达最后一个或根节点时对其进行反向传播。 这是显示此代码段：
 
@@ -294,7 +294,7 @@ print(a2.grad, a2.grad_fn, a2)
 
 前面描述的训练策略称为梯度下降。 诸如亚当之类的更复杂的训练策略将在下一章中讨论。 梯度下降本身已从其他两个变体演变而来。 梯度下降的最原始版本是 SGD，如前所述。 使用 SGD，每个网络执行都在单个样本上运行，并使用从一个样本获得的梯度更新模型，然后继续进行下一个样本。
 
-SGD 的主要缺点是效率低下。 例如，考虑我们的 *FizzBu​​zz* 数据集，每个数据集包含 1,000 个大小为 10 的样本。一次执行一个样本要求我们将大小为 1 x 10 的张量传递给隐藏层，并使用权重张量 10 x 100 的像素，将 1 x 10 的输入转换为 1 x 100 的隐藏状态。 为了处理整个数据集，我们必须运行 1,000 次迭代。 通常，我们会在具有数千个内核的 GPU 上运行我们的模型，但是一次只有一个样本，我们就不会使用 GPU 的全部功能。 现在考虑一次传递整个数据集。 第一层获得大小为 1,000 x 10 的输入，该输入将转移到大小为 1,000 x 100 的隐藏状态。现在这很有效，因为张量乘法将在多核 GPU 上并行执行。
+SGD 的主要缺点是效率低下。 例如，考虑我们的 *FizzBu​​zz* 数据集，每个数据集包含 1,000 个大小为 10 的样本。一次执行一个样本要求我们将大小为`1 x 10`的张量传递给隐藏层，并使用权重张量`1 x 10`的像素，将`1 x 10`的输入转换为`1 x 10`的隐藏状态。 为了处理整个数据集，我们必须运行 1,000 次迭代。 通常，我们会在具有数千个内核的 GPU 上运行我们的模型，但是一次只有一个样本，我们就不会使用 GPU 的全部功能。 现在考虑一次传递整个数据集。 第一层获得大小为`1,000 x 10`的输入，该输入将转移到大小为`1,000 x 100`的隐藏状态。现在这很有效，因为张量乘法将在多核 GPU 上并行执行。
 
 使用完整数据集的梯度下降的变种称为批梯度下降。 它并不比 SGD 更好。 批量梯度下降实际上提高了效率，但降低了网络的泛化能力。 SGD 必须逐个通过噪声，因此它将具有很高的抖动率，这会导致网络移出局部最小值，而分批梯度下降避免了陷入局部最小值的机会。
 

new/pt-dl-handson/3.md

@@ -115,14 +115,14 @@ pip install torchvision
 
  |
 | --- | --- |
-| MNIST | 70,000 28 x 28 手写数字的数据集。 |
+| MNIST | 70,000 `28 x 28`手写数字的数据集。 |
 | KMNIST | 平假名字符的排列方式与普通 MNIST 相同。 |
-| 时尚 MNIST | 类似于 MNIST 的数据集，包含 70,000 张 28 x 28 张标记的时尚图片。 |
-| 恩尼斯 | 该数据集是一组 28 x 28 个手写字符数字。 |
+| 时尚 MNIST | 类似于 MNIST 的数据集，包含 70,000 张`28 x 28`张标记的时尚图片。 |
+| 恩尼斯 | 该数据集是一组`28 x 28`个手写字符数字。 |
 | 可可 | 大规模对象检测，分割和字幕数据集。 |
 | LSUN | 类似于 COCO 的大规模“场景理解挑战”数据集。 |
 | Imagenet-12 | 2012 年大规模视觉识别挑战赛的 1400 万张图像的数据集。 |
-| CIFAR | 以 10/100 类标记的 60,000 张 32 x 32 彩色图像的数据集。 |
+| CIFAR | 以 10/100 类标记的 60,000 张`32 x 32`彩色图像的数据集。 |
 | STL10 | 另一个受 CIFAR 启发的图像数据集。 |
 | SVHN | 街景门牌号码的数据集，类似于 MNIST。 |
 | 摄影之旅 | 华盛顿大学提供的旅游景点数据集。 |

new/pt-dl-handson/8.md

@@ -154,7 +154,7 @@ Flask 为我们提供了`request`实用程序，它是一个全局变量，但
 
 在 HTTP `POST`请求中，我们传递了输入数字为`14`的 JSON 对象，我们的服务器返回了下一个数字`FizBuz`。 所有这些魔术都发生在我们的`app.py`调用的`controller.run()`方法中。 现在，让我们看看该函数在做什么。
 
-接下来是使用`run()`方法的`controller`文件。 在这里，我们将输入数字转换为 10 位二进制数（请记住，这是我们作为输入传递给第 2 章，“简单神经网络”的 fizzbuzz 网络）的函数 火炬张量。 然后将二进制张量传递给我们模型的正向函数，以得到具有预测的 1 x 4 张量。
+接下来是使用`run()`方法的`controller`文件。 在这里，我们将输入数字转换为 10 位二进制数（请记住，这是我们作为输入传递给第 2 章，“简单神经网络”的 fizzbuzz 网络）的函数 火炬张量。 然后将二进制张量传递给我们模型的正向函数，以得到具有预测的`1 x 4`张量。
 
 通过从加载了保存的`.pth`文件的模型文件中调用`FizBuz`类来创建我们的模型。 我们使用 Torch 的`load_state_dict`方法将参数加载到初始化的模型中。 之后，我们将模型转换为`eval()`模式，这将模型设置为评估模式（它在评估模式下关闭了 batchnorm 丢弃层）。 模型的输出是运行`max`并确定哪个索引具有最大值，然后将其转换为可读输出的概率分布。
 
@@ -231,9 +231,9 @@ graph(%input.1 : Float(1, 10)
 }
 ```
 
-表示清楚地表明了整个网络的结构。 前五行显示参数和输入张量，并为每一个标记一个名称。 例如，整个网络将输入张量定为`input.i`，它是形状为 1 x 10 的浮点张量。然后，它显示了我们第一层和第二层的权重和偏差张量。
+表示清楚地表明了整个网络的结构。 前五行显示参数和输入张量，并为每一个标记一个名称。 例如，整个网络将输入张量定为`input.i`，它是形状为`1 x 10`的浮点张量。然后，它显示了我们第一层和第二层的权重和偏差张量。
 
-从第六行开始，显示了图形的结构。 每行的第一部分（以`%`符号开头的全冒号之前的字符）是每行的标识符，这是其他行中用来引用这些行的标识符。 例如，以`%5`作为标识符的线对`aten::t(%weight.i)`表示的第一层的权重进行转置，从而输出形状为 10 x 100 的浮点张量。
+从第六行开始，显示了图形的结构。 每行的第一部分（以`%`符号开头的全冒号之前的字符）是每行的标识符，这是其他行中用来引用这些行的标识符。 例如，以`%5`作为标识符的线对`aten::t(%weight.i)`表示的第一层的权重进行转置，从而输出形状为`10 x 100`的浮点张量。
 
 ![ONNX](img/B09475_08_02.jpg)
 
@@ -448,7 +448,7 @@ def preprocess(self, batch):
     self.error = 'InvalidData'
 ```
 
-`handle()`函数获取已处理的数据，并将其传递给`inference()`函数，该函数将使用已处理的数据调用保存在`initialize()`函数上的 MXNet 模型。 `inference()`函数返回大小为 1 x 4 的输出张量，然后将其返回到`handle()`函数。
+`handle()`函数获取已处理的数据，并将其传递给`inference()`函数，该函数将使用已处理的数据调用保存在`initialize()`函数上的 MXNet 模型。 `inference()`函数返回大小为`1 x 4`的输出张量，然后将其返回到`handle()`函数。
 
 ```py
 def inference(self, model_input):

new/pt-tut-17/37.md

@@ -83,7 +83,7 @@ def predict():
 
 ### 准备图像
 
-DenseNet 模型要求图像为尺寸为 224 x 224 的 3 通道 RGB 图像。我们还将使用所需的均值和标准差值对图像张量进行归一化。 您可以在上阅读有关它的更多信息。
+DenseNet 模型要求图像为尺寸为`224 x 224`的 3 通道 RGB 图像。我们还将使用所需的均值和标准差值对图像张量进行归一化。 您可以在上阅读有关它的更多信息。
 
 我们将使用`torchvision`库中的`transforms`并建立一个转换管道，该转换管道可根据需要转换图像。 您可以在上阅读有关变换[的更多信息。](https://pytorch.org/docs/stable/torchvision/transforms.html)
 

new/rl-tf/01.md

@@ -591,7 +591,7 @@ Hinton 等人从 ImageNet 分类到深度卷积神经网络的 AlexNet 架构。
 
 # VGG-Net 模型
 
-VGG-Net 由牛津大学**视觉几何组**（**VGG**）的 Karen Simonyan 和 Andrew Zisserman 引入。 他们使用大小为 3 x 3 的小型卷积滤波器训练深度为 16 和 19 的网络。他们的团队分别在 ImageNet Challenge 2014 的本地化和分类任务中获得了第一和第二名。
+VGG-Net 由牛津大学**视觉几何组**（**VGG**）的 Karen Simonyan 和 Andrew Zisserman 引入。 他们使用大小为`3 x 3`的小型卷积滤波器训练深度为 16 和 19 的网络。他们的团队分别在 ImageNet Challenge 2014 的本地化和分类任务中获得了第一和第二名。
 
 通过向模型添加更多非线性来设计更深层的神经网络的想法导致合并了较小的滤波器，以确保网络没有太多参数。 在训练时，很难收敛模型，因此首先使用预先训练的简单神经网络模型来初始化较深架构的权重。 但是，现在我们可以直接使用 xavier 初始化方法，而无需训练神经网络来初始化权重。 由于模型的深度，训练起来很慢。
 

new/rl-tf/08.md

@@ -192,18 +192,18 @@ Google DeepMind 已经开始使用 AlphaGo Zero 来了解蛋白质折叠，因
 
 网络输入包括：
 
-*   19 x 19 矩阵平面，代表棋盘
+*   `19 x 19`矩阵平面，代表棋盘
 *   一个用于白色宝石的特征图（在具有白色宝石的位置具有 1，在其他位置具有 0 的二进制矩阵）
 *   一个用于黑宝石的特征图（在具有黑宝石的位置具有 1，在其他位置具有 0 的二进制矩阵）
 *   七个使用白色石头的玩家过去的特征图（代表历史，因为它捕获了过去的七个动作）
 *   七个使用黑石头的玩家过去特征地图（代表历史，因为它捕获了过去七个动作）
 *   一个用于转弯指示的特征图（转弯可以用 1 位表示，但此处已在整个特征图上重复出现）
 
-因此，网络输入由 19 x 19 x（1 + 1 + 7 + 7 + 1）= 19 x 19 x 17 张量表示。 使用过去七个动作的特征图的原因在于，这段历史就像一个注意力机制。
+因此，网络输入由`19 x 19 x (1 + 1 + 7 + 7 + 1) = 19 x 19 x 17`张量表示。 使用过去七个动作的特征图的原因在于，这段历史就像一个注意力机制。
 
 为什么我们使用残差架构而不是普通卷积架构？ 其背后的原因是残留的架构允许梯度信号直接穿过层。 此外，即使在卷积层没有做任何有用的学习的早期阶段，重要的学习信号也会进入卷积层并直接进入其他层。 详细解释残留架构超出了本书的范围。
 
-因此，我们采用板的 19 x 19 x 17 张量表示形式的输入，并将其通过残差卷积网络，从而生成特征向量。 该特征向量通过全连接层传递，以进行最终的特征提取，其中包含两件事：
+因此，我们采用板的`19 x 19 x 17`张量表示形式的输入，并将其通过残差卷积网络，从而生成特征向量。 该特征向量通过全连接层传递，以进行最终的特征提取，其中包含两件事：
 
 *   **值表示形式**：AlphaGo 的可能性在当前棋盘位置赢得零的游戏。
 *   **策略向量**：AlphaGo 可以在当前位置播放的所有可能动作的概率分布。
@@ -212,7 +212,7 @@ Google DeepMind 已经开始使用 AlphaGo Zero 来了解蛋白质折叠，因
 
 # AlphaGo Zero 中的训练过程
 
-接收板表示的输入，它是 19 x 19 x 17 张量。 它经过残差卷积网络，然后全连接层最终输出策略向量和值表示。 最初，策略向量将包含随机值，因为网络最初以随机权重开始。 在获得给定状态下所有可能动作的策略向量后，假设具有高概率的动作也可能是强力动作，它会选择一组概率很高的可能动作：
+接收板表示的输入，它是`19 x 19 x 17`张量。 它经过残差卷积网络，然后全连接层最终输出策略向量和值表示。 最初，策略向量将包含随机值，因为网络最初以随机权重开始。 在获得给定状态下所有可能动作的策略向量后，假设具有高概率的动作也可能是强力动作，它会选择一组概率很高的可能动作：
 
 ![](img/31213861-ace9-4d22-806f-cff174f04933.png)