2021-01-21 16:19:40

new/dl-pt-workshop/4.md

@@ -563,7 +563,7 @@ test_loader = torch.utils.data.DataLoader(test_data, \
 
     展平图像后，滤除项设置为 20%。
 
-    Linear1：一个全连接层，接收上一层的展平矩阵作为输入，并生成 100 个单位的输出。 为此层使用 ReLU 激活函数。 此处，辍学期限设置为 20%。
+    Linear1：一个全连接层，接收上一层的展平矩阵作为输入，并生成 100 个单位的输出。 为此层使用 ReLU 激活函数。 此处，丢弃期限设置为 20%。
 
     Linear2：一个全连接层，可生成 10 个输出，每个类标签一个。 将`log_softmax`激活函数用于输出层。
 

new/dl-pt-workshop/7.md

@@ -883,7 +883,7 @@
 
     展平图像后，使用掉落项设置为 20%。
 
-    Linear1：一个全连接层，接收上一层的展平矩阵作为输入，并生成 100 个单位的输出。 为此层使用 ReLU 激活函数。 此处的辍学期限设置为 20%。
+    Linear1：一个全连接层，接收上一层的展平矩阵作为输入，并生成 100 个单位的输出。 为此层使用 ReLU 激活函数。 此处的丢弃期限设置为 20%。
 
     Linear2：一个全连接层，可生成 10 个输出，每个类标签一个。 将`log_softmax`激活函数用于输出层：
 
@@ -1247,7 +1247,7 @@
 
     注意
 
-    尽管本章未对此进行探讨，但理想的步骤是为网络架构添加辍学以减少高方差。 随意尝试一下，看看您是否能够进一步提高性能。
+    尽管本章未对此进行探讨，但理想的步骤是为网络架构添加丢弃以减少高方差。 随意尝试一下，看看您是否能够进一步提高性能。
 
 4.  计算所得模型在测试集上的精度。
 

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

@@ -240,7 +240,7 @@ class MNISTClassifier(nn.Module):
 
 在这里，我们可以看到我们的最后一层输出了`10`个单位。 这是因为我们希望预测每个图像是否为 0 到 9 之间的数字，总共是 10 种不同的可能分类。 我们的输出是长度为`10`的向量，并且包含图像的 10 种可能值中的每一个的预测。 在进行最终分类时，我们将数值最高的数字分类作为模型的最终预测。 例如，对于给定的预测，我们的模型可能会预测图像类型为 1 的概率为 10%，类型 2 的概率为 10%，类型 3 的概率为 80%。 因此，我们将类型 3 作为预测，因为它以最高概率被预测。
 
-## 实现辍学
+## 实现丢弃
 
 在我们的`MNISTClassifier`类的`__init__`方法中，我们还定义了一种丢弃方法，以帮助规范网络：
 
@@ -248,7 +248,7 @@ class MNISTClassifier(nn.Module):
 self.dropout = nn.Dropout(p=0.2)
 ```
 
-辍学是一种规范化我们的神经网络以防止过拟合的方法。 在每个训练纪元上，对于已应用丢包的层中的每个节点，都有可能（此处定义为`p`= 20%）该层内的每个节点将不用于训练/反向传播 。 这意味着，在训练时，我们的网络会针对过拟合变得健壮，因为在训练过程的每次迭代中都不会使用每个节点。 这可以防止我们的网络过于依赖网络中特定节点的预测。
+丢弃是一种规范化我们的神经网络以防止过拟合的方法。 在每个训练纪元上，对于已应用丢包的层中的每个节点，都有可能（此处定义为`p`= 20%）该层内的每个节点将不用于训练/反向传播 。 这意味着，在训练时，我们的网络会针对过拟合变得健壮，因为在训练过程的每次迭代中都不会使用每个节点。 这可以防止我们的网络过于依赖网络中特定节点的预测。
 
 ## 定义前向通行证
 

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

@@ -305,7 +305,7 @@ class SentimentLSTM(nn.Module):
         self.n_hidden = n_hidden
 ```
 
-然后，我们定义网络的每个层。 首先，我们定义嵌入层，该层的词汇量为字长，嵌入向量的大小为`n_embed`超参数。 我们的 LSTM 层是使用嵌入层的输出向量大小，模型的隐藏状态的长度以及 LSTM 层将具有的层数来定义的。 我们还添加了一个参数来指定可以对 LSTM 进行批量数据训练，并添加一个参数以允许我们通过辍学实现网络正则化。 我们用概率`drop_p`（将在模型创建时指定的超参数）定义另外一个辍学层，以及对最终全连接层和输出/预测节点的定义（具有 Sigmoid 激活函数） ：
+然后，我们定义网络的每个层。 首先，我们定义嵌入层，该层的词汇量为字长，嵌入向量的大小为`n_embed`超参数。 我们的 LSTM 层是使用嵌入层的输出向量大小，模型的隐藏状态的长度以及 LSTM 层将具有的层数来定义的。 我们还添加了一个参数来指定可以对 LSTM 进行批量数据训练，并添加一个参数以允许我们通过丢弃实现网络正则化。 我们用概率`drop_p`（将在模型创建时指定的超参数）定义另外一个丢弃层，以及对最终全连接层和输出/预测节点的定义（具有 Sigmoid 激活函数） ：
 
 ```py
 self.embedding = nn.Embedding(n_vocab, n_embed)
@@ -451,7 +451,7 @@ if (step % print_every) == 0:
             net.train()
 ```
 
-这意味着在每个时期结束时，我们的模型都会调用`net.eval()`冻结模型的权重，并像以前一样使用我们的数据进行前向传递。 请注意，当我们处于评估模式时，也不会应用辍学。 但是，这次，我们使用验证加载程序，而不是使用训练数据加载程序。 通过这样做，我们可以在我们的验证数据集中计算模型当前状态的总损失。 最后，我们打印结果并调用`net.train()`解冻模型的权重，以便我们可以在下一个纪元再次进行训练。 我们的输出看起来像，如下所示：
+这意味着在每个时期结束时，我们的模型都会调用`net.eval()`冻结模型的权重，并像以前一样使用我们的数据进行前向传递。 请注意，当我们处于评估模式时，也不会应用丢弃。 但是，这次，我们使用验证加载程序，而不是使用训练数据加载程序。 通过这样做，我们可以在我们的验证数据集中计算模型当前状态的总损失。 最后，我们打印结果并调用`net.train()`解冻模型的权重，以便我们可以在下一个纪元再次进行训练。 我们的输出看起来像，如下所示：
 
 ![Figure 5.18 – Training the model ](img/B12365_05_18.jpg)
 

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

@@ -345,7 +345,7 @@ model = CNN(input_dimensions, embedding_dimensions, number_of_filters, filter_si
 
 输入维度将始终是词汇量的长度，而输出维度将是我们希望预测的类的数量。 在这里，我们从六个不同的类别进行预测，因此我们的输出向量的长度为`6`。 我们的嵌入维数是 GLoVe 向量的长度（在这种情况下为`200`）。 填充索引可以从我们的词汇表中手动获取。
 
-可以手动调整接下来的三个超参数，因此您不妨尝试选择不同的值，以了解这如何影响网络的最终输出。 我们传递了一个过滤器大小列表，以便我们的模型将使用大小为`2`，`3`和`4`的卷积训练卷积层。 我们将针对每种滤镜尺寸训练 100 个滤镜，因此总共将有 300 个滤镜。 我们还为我们的网络定义了 50% 的辍学率，以确保其充分正规化。 如果模型似乎容易过拟合或过拟合，则可以升高/降低此值。 一般的经验法则是，如果模型欠拟合，则尝试降低辍学率；如果模型过拟合，则尝试提高辍学率。
+可以手动调整接下来的三个超参数，因此您不妨尝试选择不同的值，以了解这如何影响网络的最终输出。 我们传递了一个过滤器大小列表，以便我们的模型将使用大小为`2`，`3`和`4`的卷积训练卷积层。 我们将针对每种滤镜尺寸训练 100 个滤镜，因此总共将有 300 个滤镜。 我们还为我们的网络定义了 50% 的丢弃率，以确保其充分正规化。 如果模型似乎容易过拟合或过拟合，则可以升高/降低此值。 一般的经验法则是，如果模型欠拟合，则尝试降低丢弃率；如果模型过拟合，则尝试提高丢弃率。
 
 初始化模型后，我们需要将权重加载到嵌入层中。 可以很容易地完成以下操作：
 

new/pt-ai-fund/1.md

@@ -330,7 +330,7 @@ tensor([[3, 3],
 
 要了解更多信息，请在[这个页面](https://pytorch.org/docs/stable/tensors.html#torch.Tensor)上阅读 PyTorch 的官方文档以了解张量创建选项。
 
-# 探索 NumPy 桥
+# 探索 NumPy 桥接
 
 NumPy 是 Python 中科学计算的基本软件包。 它是一个 Python 库，提供多维数组对象和各种派生对象。 除此之外，NumPy 用作通用多维数据的有效容器。 NumPy 允许与各种数据库进行无缝，快速的集成。
 

new/pt-ai-fund/2.md

-# 与神经网络打交道
+# 与神经网络协作
 
 深度学习是一类机器学习算法，旨在粗略地模拟大脑中的神经元。 神经元从周围神经元的多个输入中获取一个输入并将其求和，如果总和超过某个阈值，则神经元将触发。 每个神经元之间有一个间隙，称为突触。 神经递质化学物质在这些突触中传递信号，这些化学物质的数量和类型将决定神经元输入的强度。 生物神经网络的功能可以通过人工神经网络使用权重，偏差（偏差定义为权重乘以 1 的恒定输入）和激活函数来复制。
 
@@ -20,7 +20,7 @@
 *   创建一个全连接网络
 *   定义损失函数
 *   实现优化器
-*   实现辍学
+*   实现丢弃
 *   实现函数式 API
 
 # 技术要求
@@ -473,19 +473,19 @@ Training loss: 0.2596
 
 您可以在[这个页面](https://pytorch.org/docs/stable/optim.html#torch.optim.Optimizer)上了解有关优化程序的更多信息。
 
-# 实现辍学
+# 实现丢弃
 
-在本秘籍中，我们将研究实现辍学。 在训练神经网络模型或一般任何机器学习模型时，我们可能会遇到的一种较常见的现象是过拟合。 当模型学习提供给训练的数据而不是在求解空间上进行泛化时，就会发生过拟合，也就是说，模型学习的是训练数据的细微细节和噪声，而不是掌握全局，因此在效果上表现不佳。 新数据。 正则化是防止模型过拟合的过程。
+在本秘籍中，我们将研究实现丢弃。 在训练神经网络模型或一般任何机器学习模型时，我们可能会遇到的一种较常见的现象是过拟合。 当模型学习提供给训练的数据而不是在求解空间上进行泛化时，就会发生过拟合，也就是说，模型学习的是训练数据的细微细节和噪声，而不是掌握全局，因此在效果上表现不佳。 新数据。 正则化是防止模型过拟合的过程。
 
-使用辍学是神经网络中最流行的正则化技术之一，在这种技术中，训练时会关闭随机选择的神经元，也就是说，神经元的作用会暂时从正向传递中移除，而向后传递不会影响权重 ，因此没有一个神经元或神经元子集能获得模型的所有决定力； 相反，所有神经元都被迫为预测做出积极贡献。
+使用丢弃是神经网络中最流行的正则化技术之一，在这种技术中，训练时会关闭随机选择的神经元，也就是说，神经元的作用会暂时从正向传递中移除，而向后传递不会影响权重 ，因此没有一个神经元或神经元子集能获得模型的所有决定力； 相反，所有神经元都被迫为预测做出积极贡献。
 
-辍学可以直观地理解为创建大量集成模型，学习在一个模型的大定义下捕获各种功能。
+丢弃可以直观地理解为创建大量集成模型，学习在一个模型的大定义下捕获各种功能。
 
-在本秘籍中，我们将研究如何在模型定义中添加缺失，以通过防止过拟合来改善整体模型性能。 应当记住，辍学仅在训练时才适用； 但是，在测试和实际预测期间，我们希望所有神经元都做出贡献。
+在本秘籍中，我们将研究如何在模型定义中添加缺失，以通过防止过拟合来改善整体模型性能。 应当记住，丢弃仅在训练时才适用； 但是，在测试和实际预测期间，我们希望所有神经元都做出贡献。
 
 # 操作步骤
 
-在本节中，我们将学习如何为我们的初始模型类`FashionNetwork`添加辍学：
+在本节中，我们将学习如何为我们的初始模型类`FashionNetwork`添加丢弃：
 
 1.我们将从初始模型定义开始：
 
@@ -527,7 +527,7 @@ Training loss: 0.2596
         self.drop = nn.Dropout(p=0.25)
 ```
 
-3.现在，我们将在`forward()`方法中添加辍学：
+3.现在，我们将在`forward()`方法中添加丢弃：
 
 ```py
 >>def forward(self, x):
@@ -542,11 +542,11 @@ Training loss: 0.2596
         return output
 ```
 
-现在，我们有了一个带有辍学的网络。
+现在，我们有了一个带有丢弃的网络。
 
 # 工作原理
 
-在此秘籍中，我们更改了`__init__()`方法，以 0.25 的丢失率添加了该丢失层，这意味着将应用该丢失的层中 25% 的神经元将被随机关闭。 然后，我们编辑`forward`函数，将其应用于其中具有 256 个单位的第一个隐藏层，然后对第二个层（具有 128 个单位）应用该滤除。 在完成激活函数之后，我们在两个层中都应用了激活。 我们必须牢记，必须仅在隐藏层上应用辍学，以防止我们丢失输入数据和丢失输出。
+在此秘籍中，我们更改了`__init__()`方法，以 0.25 的丢失率添加了该丢失层，这意味着将应用该丢失的层中 25% 的神经元将被随机关闭。 然后，我们编辑`forward`函数，将其应用于其中具有 256 个单位的第一个隐藏层，然后对第二个层（具有 128 个单位）应用该滤除。 在完成激活函数之后，我们在两个层中都应用了激活。 我们必须牢记，必须仅在隐藏层上应用丢弃，以防止我们丢失输入数据和丢失输出。
 
 # 更多
 
@@ -554,7 +554,7 @@ Training loss: 0.2596
 
 # 另见
 
-您可以在[这个页面](https://arxiv.org/abs/1207.0580)上了解有关辍学的更多信息。
+您可以在[这个页面](https://arxiv.org/abs/1207.0580)上了解有关丢弃的更多信息。
 
 # 实现函数式 API
 
@@ -596,7 +596,7 @@ Training loss: 0.2596
 
 # 更多
 
-您可以通过使用`functional.linear()`和`functional.dropout()`来控制辍学，从而对线性层使用函数式 API，但是必须注意传递模型状态以指示其处于训练还是评估/预测模式。
+您可以通过使用`functional.linear()`和`functional.dropout()`来控制丢弃，从而对线性层使用函数式 API，但是必须注意传递模型状态以指示其处于训练还是评估/预测模式。
 
 # 另见
 

new/pt-ai-fund/3.md

@@ -136,7 +136,7 @@ Conv2d(3, 16, kernel_size=(3, 4), stride=(3, 3), padding=(1, 2))
 
 您可以在[这个页面](https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d)了解有关 PyTorch 卷积的其他参数。
 
-# 探索池
+# 探索池化
 
 现在，我们进入 CNN 的下一个关键层-池化层。 到目前为止，我们一直在处理图像而不改变帧的空间尺寸（考虑相同的填充）； 相反，我们一直在增加通道/过滤器的数量。 池化层用于减小输入的空间尺寸，并保留其深度。 当我们从 CNN 的初始层移到后面的层时，我们希望在图像中识别出比实际逐个像素信息更多的概念意义，因此我们想从输入和抛出中识别并保留关键信息 剩下的。 池化层可以帮助我们做到这一点。
 
@@ -263,7 +263,7 @@ Conv2d(3, 16, kernel_size=(3, 4), stride=(3, 3), padding=(1, 2))
 
 您可以在[这个页面](https://pytorch.org/docs/stable/nn.html#pooling-layers)上找到有关池和各种池的更多信息。
 
-# 探索变换
+# 探索转换
 
 PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为了解决这个问题，`torchvision`是一个专门处理视觉和图像相关任务的库，提供了一个名为`transform`的模块，该模块提供了将像素转换为张量，标准化标准缩放等的 API。 在本秘籍中，我们将探索转换模块中的各种方法。 因此，您需要安装`torchvision`才能阅读此秘籍。
 
@@ -678,9 +678,9 @@ CNN(
 
 此秘籍的工作方式与第 2 章，“处理神经网络”时非常相似，当我们研究一个全连接神经网络时。 我们从`__init__()`方法和父类的构造函数开始，定义了从 PyTorch 中的`nn.Module`继承的 CNN 类。 之后，我们通过传入与每一层相关的参数来定义 CNN 中的各个层。 对于我们的第一卷积层，输入通道的数量为 3（RGB），输出通道的数量定义为 16，其平方核大小为 3。第二卷积层采用上一层的张量，并具有 16 个输入通道和 32 个输出通道，内核尺寸为`3 x 3`。类似地，第三卷积层具有 32 个输入通道和 64 个输出通道，内核尺寸为`3 x 3`。 我们还需要一个最大池化层，并使用 2 的内核大小和 2 的步幅。我们使用`.view()`将张量的三个维度展平为一个维度，以便可以将其传递到全连接网络中。 `view`函数中的 -1 通过确保`view`函数之前和之后的元素数量保持相同（在本例中为批量大小）来确保将正确的尺寸自动分配给该尺寸。
 
-对于第一个全连接层，我们有 1,024 个输入（通过将最大池后的`64 x 4 x 4`张量展平而获得）和 512 个输出。 对于最后一个全连接层，我们有 512 个输入和 10 个输出，代表输出类别的数量。 我们还为全连接层定义了一个辍学层，概率为 0.3。
+对于第一个全连接层，我们有 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 x 64`。此后，我们将图像展平为 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 x 64`。此后，我们将图像展平为 1,024 个元素的向量，并将其通过丢弃层传递到第一个全连接层，提供 512 个输出，然后是 ReLU 和 在最后一个全连接层中删除，以提供所需的输出数量，本例中为 10。
 
 然后，我们从 CNN 类实例化该模型并打印该模型。
 

new/pt-ai-fund/4.md

@@ -409,7 +409,7 @@ self.rnn = nn.LSTM(embedding_dim, hidden_dim)
 self.fc = nn.Linear(hidden_dim, output_dim)
 ```
 
-6.  接下来，我们定义辍学层：
+6.  接下来，我们定义丢弃层：
 
 ```py
 self.dropout = nn.Dropout(dropout)

new/pt-dl-handson/5.md

@@ -329,15 +329,15 @@ class RNNClassifier(nn.Module):
 *   使用`RNNCell`的编码器层，该层存储在`self.encoder`中
 *   `self.classifier`中存储的`nn.Sequential`层的实例
 
-最后的顺序层从`Merger`节点开始。 合并后的输出的序列长度维度将增大四倍，因为我们将两个句子，它们的差和它们的乘积都附加到`Merger`的输出中。 然后将其穿过一个全连接层，然后在`ReLU`非线性之后使用`batchnorm1d`将其标准化。 之后的辍学减少了过拟合的机会，过拟合的机会随后传递到另一个全连接层，该层为我们的输入数据创建了得分。 输入数据决定数据点所属的包围，矛盾或中性类​​别。
+最后的顺序层从`Merger`节点开始。 合并后的输出的序列长度维度将增大四倍，因为我们将两个句子，它们的差和它们的乘积都附加到`Merger`的输出中。 然后将其穿过一个全连接层，然后在`ReLU`非线性之后使用`batchnorm1d`将其标准化。 之后的丢弃减少了过拟合的机会，过拟合的机会随后传递到另一个全连接层，该层为我们的输入数据创建了得分。 输入数据决定数据点所属的包围，矛盾或中性类​​别。
 
-##### 辍学
+##### 丢弃
 
-辍学是 Apple 的机器学习工程师 Nitish Srivastava 提出的革命性想法。 它消除了对通常的正则化技术的需要，该技术在引入辍学之前一直很普遍。 借助丢弃，我们丢弃了网络中神经元之间的随机连接，因此网络必须泛化并且不能偏向任何类型的外部因素。 要删除神经元，只需将​​其输出设置为零即可。 丢弃随机神经元可防止网络共同适应，因此在很大程度上减少了过拟合。
+丢弃是 Apple 的机器学习工程师 Nitish Srivastava 提出的革命性想法。 它消除了对通常的正则化技术的需要，该技术在引入丢弃之前一直很普遍。 借助丢弃，我们丢弃了网络中神经元之间的随机连接，因此网络必须泛化并且不能偏向任何类型的外部因素。 要删除神经元，只需将​​其输出设置为零即可。 丢弃随机神经元可防止网络共同适应，因此在很大程度上减少了过拟合。
 
 ![Dropout](img/B09475_05_05.jpg)
 
-图 5.5：辍学
+图 5.5：丢弃
 
 PyTorch 作为`torch.nn`程序包的一部分提供了更高级别的丢弃层，该层在初始化时接受退出因子。 它的`forward`功能只是关闭一些输入。
 
@@ -437,7 +437,7 @@ class Encoder(nn.Module):
 
 与`LSTMCell`和`GRUCell`相似，LSTM 和 GRU 具有相似的功能 API，以使它们彼此兼容。 此外，与细胞对应物相比，LSTM 和 GRU 接受更多的参数，其中`num_layers`，`dropout`和`bidirectional`很重要。
 
-如果将`True`作为参数，则`dropout`参数将为网络实现添加一个辍学层，这有助于避免过拟合和规范化网络。 使用 LSTM 之类的高级 API 消除了对 Python 循环的需要，并一次接受了完整的序列作为输入。 尽管可以接受常规序列作为输入，但始终建议传递打包（掩码）输入，这样可以提高性能，因为 cuDNN 后端希望输入如此。
+如果将`True`作为参数，则`dropout`参数将为网络实现添加一个丢弃层，这有助于避免过拟合和规范化网络。 使用 LSTM 之类的高级 API 消除了对 Python 循环的需要，并一次接受了完整的序列作为输入。 尽管可以接受常规序列作为输入，但始终建议传递打包（掩码）输入，这样可以提高性能，因为 cuDNN 后端希望输入如此。
 
 ##### 增加层数
 

new/pt-tut-17/29.md

@@ -116,7 +116,7 @@ O'Neal
 
 我们将输出解释为下一个字母的概率。 采样时，最可能的输出字母用作下一个输入字母。
 
-我添加了第二个线性层`o2o`（在合并了隐藏和输出之后），以使其有更多的肌肉可以使用。 还有一个辍学层，[以给定的概率](https://arxiv.org/abs/1207.0580)（此处为 0.1）将输入的部分随机归零，通常用于模糊输入以防止过拟合。 在这里，我们在网络的末端使用它来故意添加一些混乱并增加采样种类。
+我添加了第二个线性层`o2o`（在合并了隐藏和输出之后），以使其有更多的肌肉可以使用。 还有一个丢弃层，[以给定的概率](https://arxiv.org/abs/1207.0580)（此处为 0.1）将输入的部分随机归零，通常用于模糊输入以防止过拟合。 在这里，我们在网络的末端使用它来故意添加一些混乱并增加采样种类。
 
 ![](img/28a4f1426695fb55f1f6bc86278f6547.png)
 

new/rl-tf/13.md

@@ -154,7 +154,7 @@ YOLO 还可以预测训练中所有班级每个盒子的班级得分。 因此
 
 对于 Image-Zooms 模型，每个区域的大小调整为`224x224`，并通过 Pool5 层馈入 VGG-16，以获得特征图。 对于 Pool45-Crops 模型，全分辨率的图像通过 Pool5 层输入到 VGG-16。 合并从整个图像中提取的所有**兴趣区域**（**ROI**）的特征图。
 
-这两个用于特征提取的模型输出`7x7`的特征图，该图被馈送到公共块中（如以下架构所示）。 这些特征图和存储向量（前面讨论过）被馈入由两个全连接层组成的深层 Q 网络，每个层各有 1024 个神经元。 每个全连接层都具有 ReLU 激活函数，并经过辍学训练：
+这两个用于特征提取的模型输出`7x7`的特征图，该图被馈送到公共块中（如以下架构所示）。 这些特征图和存储向量（前面讨论过）被馈入由两个全连接层组成的深层 Q 网络，每个层各有 1024 个神经元。 每个全连接层都具有 ReLU 激活函数，并经过丢弃训练：
 
 ![](img/c804ff2f-7264-4eac-99a1-8aeb5a3fd5a7.png)