2021-01-21 16:18:13

2e0c9c8e · wizardforcel · ffaf5a4e · 2e0c9c8e · 2e0c9c8e · 2e0c9c8e
9 changed file
--- a/new/pt-ai-fund/0.md
+++ b/new/pt-ai-fund/0.md
@@ -96,23 +96,23 @@ pip3 install https://download.pytorch.org/whl/cu90/torch-1.1.0-cp36-cp36m-win_am

 要给出有关如何完成秘籍的明确说明，请按以下说明使用这些部分：

-# 做好准备
+# 准备

 本节告诉您在秘籍中会有什么期望，并介绍如何设置秘籍所需的任何软件或任何初步设置。

-# 怎么做…
+# 操作步骤

 本节包含遵循秘籍所需的步骤。

-# 这个怎么运作…
+## 工作原理

 本节通常包括对上一节中发生的情况的详细说明。

-# 还有更多…
+# 更多

 本节包含有关秘籍的其他信息，以使您对秘籍有更多的了解。

-# 也可以看看
+# 另见

 本节提供了指向该秘籍其他有用信息的有用链接。

--- a/new/pt-ai-fund/1.md
+++ b/new/pt-ai-fund/1.md
@@ -94,7 +94,7 @@ import numpy

 这样，我们将继续介绍如何使用张量的秘籍。

-# 怎么做...
+# 操作步骤

 在 PyTorch 中有多种创建张量的方法。 我们将在本节中介绍其中一些：

@@ -312,7 +312,7 @@ tensor([[3, 3],

 这些是在 PyTorch 中创建张量的不同方法。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们介绍了从各种数据源创建张量的各种方法。 在我们开始探索使用 PyTorch 进行深度学习的概念及其原理之前，必须了解一些最常用的功能来处理数据的基本单位张量。 我们可以使用`torch.tensor()`方法创建具有各种值和形状的张量。 我们甚至可以从均匀分布或标准正态分布中得出张量，这对于初始化神经网络以获得最佳性能和训练时间至关重要，所有这些张量都具有默认的`torch.FloatTensor` 数据类型，并使用`dtype`更新数据类型。 参数。

@@ -322,11 +322,11 @@ tensor([[3, 3],

 我们还可以从现有源中获取数据并将其转换为张量，并且存在先进的张量创建技术，这些技术可以减少内存占用并使用现有张量的形状和/或张量的数据类型。

-# 还有更多...
+# 更多

 您可以使用`shape`属性或`size()`方法找到张量的形状，并使用张量的`dtype`属性找到数据类型。 您也可以使用`torch.numel()`来获取张量中的元素总数。

-# 也可以看看
+# 另见

 要了解更多信息，请在[这个页面](https://pytorch.org/docs/stable/tensors.html#torch.Tensor)上阅读 PyTorch 的官方文档以了解张量创建选项。

@@ -336,7 +336,7 @@ NumPy 是 Python 中科学计算的基本软件包。 它是一个 Python 库，

 NumPy 是标准的 Python 库，用于处理数字数据。 Python 中许多著名的 ML/DS 库，例如 pandas（用于从许多来源读取数据的库）和 scikit-learn（用于读取和写入图像的最重要的 ML 库之一）都使用 NumPy 引擎盖。 例如，在处理表格数据，使用`pandas`库加载表格数据并将`numpy`数组移出数据框时，您将处理很多`numpy`。 读取图像，许多现有库都具有内置的 API，可以将它们读取为`numpy`数组； 并将`numpy`数组转换为图像以及文本和其他形式的数据。 同样，它们都使用`scikit-learn`（机器学习库）支持`numpy`数组。 如您所见，在`numpy`阵列和 PyTorch 张量之间建立桥梁非常重要。

-# 怎么做...
+# 操作步骤

 让我们从导入`numpy`开始：

@@ -389,13 +389,13 @@ array([[1., 1., 1.],

 有了这个秘籍，我们现在可以在 NumPy 和 Torch 张量之间来回移动了。

-# 这个怎么运作...
+# 工作原理

 我们首先导入`numpy`以创建`numpy`数组。 然后，我们使用`np.ones()`创建了仅包含一个数组的`numpy`数组，并使用`from_numpy()`方法将其转换为 PyTorch 张量。 然后，我们使用`.numpy()`方法将张量转换为`numpy`数组。

 在 PyTorch 张量和 NumPy 之间切换非常容易； 实际上，只有两种方法可以实现。 这使得可以获取预测的张量并从 NumPy 转换为图像（使用支持 NumPy 到图像转换的库），并类似地从 NumPy 返回张量。

-# 还有更多...
+# 更多

 基础内存在 NumPy 数组和 PyTorch 张量之间共享，因此任何一个更改都会影响另一个。

@@ -420,7 +420,7 @@ tensor([[2., 2., 2.],

 我们可以看到`numpy`的变化也反映在张量中。

-# 也可以看看
+# 另见

 要了解更多信息，[请单击 NyPy 桥的 PyTorch 官方文档链接](https://pytorch.org/tutorials/beginner/blitz/tensor_tutorial.html#numpy-bridge)。

@@ -432,7 +432,7 @@ tensor([[2., 2., 2.],

 那么什么是梯度呢？ 梯度度量的是当输入改变很小的时候给定函数的输出有多少变化，这与微积分中的导数概念相同。 梯度会计算所有权重相对于误差变化的变化。 梯度是函数的斜率。 较高的坡度意味着坡度更陡，并且模型可以更快地学习。 梯度指向最陡的倾斜方向。 PyTorch 中的`Autograd`模块在 PyTorch 中执行所有梯度计算。 它是自动差异化的核心 Torch 软件包。 它使用基于磁带的系统进行自动区分。 在前进阶段，`Autograd`磁带将记住它执行的所有操作，而在倒退阶段，它将重放它们。

-# 怎么做...
+# 操作步骤

 让我们从创建张量开始。

@@ -544,7 +544,7 @@ False

 有了这个，我们探索了`Autograd`包的一些功能。

-# 这个怎么运作...
+# 工作原理

 我们可以看到，Autograd 可以跟踪操作。 当我们从`x`，`y=2*x+3`创建张量`y`时，我们会看到一个梯度函数`grad_fn`被附加到张量上。

@@ -554,11 +554,11 @@ PyTorch 有一个名为`autograd`的软件包，可以对张量上的所有操

 我们可以禁用代码之间的梯度计算，也可以暂时禁用对张量的跟踪以进行梯度计算，从而提高计算速度。 禁用计算主要在评估期间使用。

-# 还有更多...
+# 更多

 您可以使用`torch.set_grad_enabled()`方法启用和禁用梯度计算，以及使用`detach()`方法来将来跟踪计算。 使用`grad_fn`属性查看附加到张量的梯度函数。

-# 也可以看看
+# 另见

 要了解更多信息，可以在[这里](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html)和[这里](https://pytorch.org/docs/stable/autograd.html)查看官方文档。

@@ -568,7 +568,7 @@ PyTorch 有一个名为`autograd`的软件包，可以对张量上的所有操

 在本秘籍中，我们将学习如何使张量看起来像我们想要的样子。

-# 怎么做...
+# 操作步骤

 让我们看一下如何改变张量的形状：

@@ -636,7 +636,7 @@ tensor([[1., 2., 3.],

 这些是重塑张量的不同方法。

-# 这个怎么运作...
+# 工作原理

 在前面的秘籍中，我们基于网络架构操纵了张量以改变其形状，研究了三种不同的方法，每种方法都适用于不同的用例：

@@ -644,7 +644,7 @@ tensor([[1., 2., 3.],
 *   `.resize()`方法：`.resize_(a, b)`返回相同的张量，而不创建具有新给定形状的副本。 但是我们应该记住，如果新形状产生的元素少于原始张量，那么它将不会引发任何错误，并且某些元素将从张量中删除，但不会从内存中删除。 如果新形状产生的元素多于原始张量，则新元素将在内存中未初始化而不会引发任何错误。
 *   `.view()`方法：`.view(a, b)`将返回一个新的张量，其张量与权重为`(a, b)`的数据相同； `.view()`只能在连续的张量上运行，并返回与输入相同的存储。

-# 还有更多...
+# 更多

 您可以使用另一个张量的尺寸，并使给定的张量类似于该张量的尺寸，而不会影响其中任何一个的实际尺寸。

@@ -669,6 +669,6 @@ tensor([[4., 5., 6.],

 由此可见，张量`b`呈张量`a`的形状。

-# 也可以看看
+# 另见

 有关更多信息，您可以在[这里](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.view)和[这里](https://pytorch.org/docs/stable/torch.html#torch.reshape)查看文档。
\ No newline at end of file
--- a/new/pt-ai-fund/2.md
+++ b/new/pt-ai-fund/2.md
@@ -47,7 +47,7 @@ pip install torchvision

 现在，我们将研究定义网络所需采取的步骤。

-# 怎么做...
+# 操作步骤

 让我们定义我们的网络：

@@ -132,7 +132,7 @@ pip install torchvision

 通过这些步骤，我们已经完成了网络单元。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们开始使用`torchvision`。 `torchvision`中有实用程序来支持与视觉有关的任务。 有一个名为`transforms`的模块可以帮助完成许多图像预处理任务。 对于我们正在处理的特殊情况，一个由`28 x 28`灰度像素组成的图像，我们首先需要从图像中读取并使用`transforms.ToTensor()`变换将其转换为张量。 然后，我们分别将像素值的平均值和标准差设为 0.5 和 0.5，以便模型更易于训练； 为此，我们使用`transforms.Normalize((0.5,),(0.5,))`。 我们将所有转换与`transform.Compose()`结合在一起。

@@ -144,11 +144,11 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机

 我们使用`nn.Linear()`通过输入和输出尺寸来定义全连接层。 我们将 softmax 层用于最后一层输出，因为有 10 个输出类。 我们在输出层之前的层中使用 ReLU 激活来学习数据中的非线性。 `hidden1`层采用 784 个输入单元，并给出 256 个输出单元。 `hidden2`短语输出 128 个单位，输出层有 10 个输出单位，代表 10 个输出类别。 softmax 层将激活转换为概率，以便沿维度 1 加 1。

-# 还有更多...
+# 更多

 我们可以使用另一种方法来使用`nn.Sequential()`定义模型并传递所需的层，而无需定义类。 还有其他一些可应用于输入图像的转换，我们将在后续章节中进行探讨。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/torchvision/transforms.html)上查看有关转换的更多详细信息，还可以在[这个页面](https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html#sphx-glr-beginner-blitz-neural-networks-tutorial-py)上了解有关定义模型类的更多信息。

@@ -158,7 +158,7 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机

 在本秘籍中，我们将使用类的构造函数中定义的组件来研究网络架构。 然后，我们将完成网络类定义并创建其对象。

-# 怎么做...
+# 操作步骤

 我们将继续上一节中的类定义，并在其上进行扩展：

@@ -226,7 +226,7 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机

 现在，我们已经为 Fashion-MNIST 数据集完成了神经网络模型。

-# 这个怎么运作...
+# 工作原理

 在秘籍中，通过建立前向网络来完成网络，其中我们将构造函数中定义的网络组件捆绑在一起。 用`nn.Module`定义的网络需要定义`forward()`方法。 它采用输入张量，并按照正向方法中定义的操作顺序，将其通过网络类中`__init__()`方法中定义的网络组件。

@@ -234,11 +234,11 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机

 我们的输入层有 784 个单位（从`28 x 28`像素开始），第一层具有 ReLU 激活的 256 个单位，然后具有 ReLU 激活的 128 个单位，最后有 softmax 激活的 10 个单位。 我们通过 softmax 压缩最终层输出的原因是因为我们希望有 1 个输出类的概率高于所有其他类，并且输出概率之和应等于 1。softmax 函数的参数`dim=1`为 确保在输出的各列中采用 softmax。 然后，我们使用模型类创建一个对象，并使用`print(model)`打印该类的详细信息。

-# 还有更多...
+# 更多

 我们可以在不使用`nn.Sequential`模块定义网络类的情况下定义网络架构，并且尽管`__init__`中的序列无关紧要，但重要的是要确保`forward`方法中的操作顺序正确排序。 。 您可以使用`nn.Tanh`进行 tanh 激活。 您可以使用`model.hidden.weight`和`model.hidden.bias`从模型对象访问权重和偏差张量。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/nn.html)上查看`nn.Module`和`nn.Sequential`的官方文档。

@@ -248,7 +248,7 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机

 在本秘籍中，我们将使用 PyTorch 中可用的损失函数为我们的时装数据集定义损失函数。

-# 怎么做...
+# 操作步骤

 让我们定义损失函数：

@@ -307,17 +307,17 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机

 现在我们已经准备好损失函数。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们用对数 softmax 替换了 softmax，以便随后可以使用概率对数而不是概率的对数，这具有很好的理论解释。 这样做有多种原因，包括改进的数值性能和梯度优化。 在训练可能具有计算挑战性和昂贵成本的模型时，这些优势非常重要。 此外，当它没有预测正确的类别时，它具有很高的惩罚作用。

 因此，在处理对数 softmax 时，我们会使用负对数似然率，因为 softmax 不兼容。 在`n`类数之间的分类中很有用。 该对数将确保我们不会处理 0 到 1 之间的非常小的值，而负值将确保小于 1 的概率的对数非零。 我们的目标是减少这种负的对数丢失误差函数。 在 PyTorch 中，损失函数称为**标准**，因此我们将损失函数命名为`criterion`。

-# 还有更多...
+# 更多

 我们可以提供一个可选参数`weight`，它必须是一维张量，该张量为每个输出类分配权重以处理不平衡的训练集。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/master/nn.html#loss-functions)上查看更多损失函数的官方文档。

@@ -333,7 +333,7 @@ TorchVision 的`datasets`模块附带了许多受欢迎的数据集； 如果机

 在本秘籍中，我们将学习如何在 PyTorch 中使用优化器功能，以及一些常见的优化功能以及如何处理学习率。

-# 怎么做...
+# 操作步骤

 在本节中，我们从上一节中保留代码的位置开始，在定义条件的那一点：

@@ -457,7 +457,7 @@ Training loss: 0.2596

 现在我们已经完成了训练。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们首先使用`Adam`优化器定义优化器，然后为优化器设置学习率，并查看默认参数。 我们设置一个时期`10`，并为每个时期开始迭代，在每次迭代中将`running_loss`设置为 0，并在该时期内对每个图像进行迭代（模型看到数据集的次数）。 我们首先使用`.zero_grad()`方法清除梯度。 PyTorch 在每次向后传递时都会累积梯度，这在某些情况下很有用，因此将其导入以将梯度归零，以正确更新模型参数。

@@ -465,11 +465,11 @@ Training loss: 0.2596

 `loss.backward()`函数计算了梯度（即，误差相对于权重的偏导数），我们调用了`optimizer.step()`函数来更新模型的权重，以适应评估的误差。 `.item()`方法从单个元素张量中拉出标量，因此使用`loss.item()`从批量中获得`error`的标量值，将其累加到所有批量的损失中，最后将损失打印在 时代的结束。

-# 还有更多...
+# 更多

 我们可以使用称为`closure`的回调函数作为`.step(closure)`的参数来计算损失并通过传入函数作为参数来更新权重。 您还可以探索 PyTorch 提供的其他优化器功能，例如 Adadelta，Adagrad，SGD 等。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/optim.html#torch.optim.Optimizer)上了解有关优化程序的更多信息。

@@ -483,7 +483,7 @@ Training loss: 0.2596

 在本秘籍中，我们将研究如何在模型定义中添加缺失，以通过防止过拟合来改善整体模型性能。 应当记住，辍学仅在训练时才适用； 但是，在测试和实际预测期间，我们希望所有神经元都做出贡献。

-# 怎么做...
+# 操作步骤

 在本节中，我们将学习如何为我们的初始模型类`FashionNetwork`添加辍学：

@@ -544,15 +544,15 @@ Training loss: 0.2596

 现在，我们有了一个带有辍学的网络。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们更改了`__init__()`方法，以 0.25 的丢失率添加了该丢失层，这意味着将应用该丢失的层中 25% 的神经元将被随机关闭。 然后，我们编辑`forward`函数，将其应用于其中具有 256 个单位的第一个隐藏层，然后对第二个层（具有 128 个单位）应用该滤除。 在完成激活函数之后，我们在两个层中都应用了激活。 我们必须牢记，必须仅在隐藏层上应用辍学，以防止我们丢失输入数据和丢失输出。

-# 还有更多...
+# 更多

 我们可以通过调用`model.eval()`禁用退出，并使用`model.train().`启用退出

-# 也可以看看
+# 另见

 您可以在[这个页面](https://arxiv.org/abs/1207.0580)上了解有关辍学的更多信息。

@@ -560,7 +560,7 @@ Training loss: 0.2596

 在本秘籍中，我们将探索 PyTorch 中的函数式 API。 这样做将使我们能够编写更简洁的网络架构和组件。 我们将研究函数式 API，并使用函数式 API 定义模型或模型的一部分。

-# 怎么做...
+# 操作步骤

 在以下步骤中，我们使用现有的神经网络类定义，然后使用函数式 API 重写它：

@@ -590,14 +590,14 @@ Training loss: 0.2596

 我们使用函数式 API 重新定义了模型

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们定义了与以前完全相同的网络，但是用`function.relu`和`function.log_softmax`代替了激活函数和对数 softmax，这使我们的代码看起来更加简洁明了。

-# 还有更多...
+# 更多

 您可以通过使用`functional.linear()`和`functional.dropout()`来控制辍学，从而对线性层使用函数式 API，但是必须注意传递模型状态以指示其处于训练还是评估/预测模式。

-# 也可以看看
+# 另见

 您可以通过[这个页面](https://pytorch.org/docs/stable/nn.html#torch-nn-functional)了解更多有关功能 API 的信息。
\ No newline at end of file
--- a/new/pt-ai-fund/3.md
+++ b/new/pt-ai-fund/3.md
@@ -49,7 +49,7 @@ CNN 使用过滤器从输入图像中拾取特征； 具有足够数量的滤镜

 在本秘籍中，我们将学习如何在 PyTorch 中使用卷积神经网络。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将探讨卷积：

@@ -122,17 +122,17 @@ Conv2d(3, 16, kernel_size=(3, 4), stride=(3, 3), padding=(1, 2))

 通过此秘籍，我们学习了如何在 PyTorch 中使用卷积。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们研究了创建 2D 卷积的多种方法，其中第一个参数是给定输入图像中的通道数，对于彩色图像，通道数将为`3`，对于灰度图像将为`1`。 第二个参数是输出通道的数量，换句话说，就是我们要从给定层获得的滤波器的数量。 第三个参数是内核大小（即内核大小），或者是要使用滤镜卷积的图像的补丁大小。

 然后，我们创建了一个`Con2d`对象，并将输入传递到 2D 卷积层以获取输出。 使用`nn.Conv2d(3, 16, 3)`，我们创建了一个卷积层，该卷积层接受 3 个通道的输入并输出 16 个通道。 该层的大小为`3 x 3`的正方形核，其高度和宽度的默认跨度为 1。 我们可以使用`padding`参数添加填充，该参数可以具有整数或元组值。 在这里，整数值将为高度和宽度创建相同的填充，而元组值将为高度和宽度创建不同的填充-这对于内核大小和跨度都是正确的。

-# 还有更多...
+# 更多

 通过将`padding`参数设置为`0`（默认设置），可以有效填充。 您还可以通过更改`padding_mode`参数将零填充更改为圆形填充。 您可以使用`bias`布尔参数（默认为`True`）添加或删除偏差。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d)了解有关 PyTorch 卷积的其他参数。

@@ -152,7 +152,7 @@ Conv2d(3, 16, kernel_size=(3, 4), stride=(3, 3), padding=(1, 2))

 池的类型很多，例如最大池，平均池，和池等。 但是，最大池化是最受欢迎的。 以与处理卷积层相同的方式，我们将定义一个窗口并在该窗口中应用所需的池化操作。 我们将根据层的跨度水平和垂直地滑动窗口。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将研究如何在 PyTorch 中实现池化层：

@@ -251,15 +251,15 @@ Conv2d(3, 16, kernel_size=(3, 4), stride=(3, 3), padding=(1, 2))

 通过此秘籍，我们了解了 PyTorch 中的池化操作。

-# 这个怎么运作...
+# 工作原理

 在前面的代码中，我们研究了一个张量的示例，以了解实际的池化层。 我们使用大小为`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`。

-# 还有更多...
+# 更多

 在本秘籍中，我们研究了正方形核，但是我们可以选择使用非正方形核并大步前进，就像我们进行卷积一样。 还有另一种流行的池化方法，称为全局平均池化，可以通过输入的维数通过平均池化来实现。 例如`avg_pool2d(a, a.size()[2:]0)`。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/nn.html#pooling-layers)上找到有关池和各种池的更多信息。

@@ -267,7 +267,7 @@ Conv2d(3, 16, kernel_size=(3, 4), stride=(3, 3), padding=(1, 2))

 PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为了解决这个问题，`torchvision`是一个专门处理视觉和图像相关任务的库，提供了一个名为`transform`的模块，该模块提供了将像素转换为张量，标准化标准缩放等的 API。 在本秘籍中，我们将探索转换模块中的各种方法。 因此，您需要安装`torchvision`才能阅读此秘籍。

-# 怎么做...
+# 操作步骤

 在本节中，我们将探讨`torchvision`中的各种转换：

@@ -342,7 +342,7 @@ PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为

 在此秘籍中，我们了解了`torchvision`中使用的一些转换。

-# 这个怎么运作...
+# 工作原理

 在前面的代码段中，我们研究了`torchvision`中可用的各种转换。 这些使我们可以获取输入图像并将其格式化为所需尺寸和属性的张量，然后将其输入到割炬模型中。 我们研究的第一种方法是`toTensor()`方法，该方法将给定的输入图像转换为张量。 然后我们可以使用`Normalize()`方法对该输入图像张量进行归一化。 `Normalize()`方法采用两个元组，其中第一个元组是输入图像中每个通道的均值序列，第二个元组是每个通道的标准差序列。

@@ -357,13 +357,13 @@ PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为

 最后，我们研究了`Compose()`转换，该转换通过将一系列转换对象作为参数传递来组合各种转换以构建转换管道。

-# 还有更多...
+# 更多

 `transforms.functional`模块中有用于转换的函数式 API。 它们通过提供对转换的细粒度控制来帮助我们建立复杂的转换管道。

 还有其他有用的转换，例如灰度转换，它使用`Grayscale()`作为输出通道数作为参数。 我们将在下一部分中探索更多的转换。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/torchvision/transforms.html#functional-transforms)上了解有关功能转换的更多信息。

@@ -373,7 +373,7 @@ PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为

 通常，光量，亮度，方向或颜色变化不会影响模型所做的推论。 但是，当模型在现实世界中部署时，输入数据可能会有这些变化。 对于模型来说，知道其做出的决定必须相对于输入中的这些变化是不变的，这很有用，因此数据扩充可以提高模型的性能。 在本秘籍中，我们将使用 PyTorch 的`transform`模块执行数据扩充。

-# 怎么做...
+# 操作步骤

 为了充分利用此秘籍，您应该完成“探索转换”秘籍，因为此秘籍是我们对转换工作的延续。 在本秘籍中，我们将介绍一些我们可以使用`torchvision`中的`transform`模块执行的流行数据扩充：

@@ -430,7 +430,7 @@ PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为

 在此秘籍中，我们在数据上创建了转换以从现有数据创建更多数据。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们了解了如何通过执行对手头问题有意义的某些转换来为数据添加变化。 选择正确的数据扩充以模仿我们在现实生活中会遇到的图像变化时，我们必须小心。 例如，在构建汽车分类器时，有意义的是使用颜色和亮度的变化来增加数据，或者水平翻转汽车图像，等等。 但是，除非我们要解决汽车上下颠倒的问题，否则使用垂直翻转的汽车图像来增强数据是没有意义的。

@@ -438,11 +438,11 @@ PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为

 我们通过设置参数来控制每种颜色的变化量，其中颜色，对比度和饱和度在`[max(0, 1-parameter), 1 + parameter]`值之间变化，而色相在`[-hue, hue]`之间，其中色调介于 0 到 0.5 之间。 我们还向图像添加了随机旋转，并提供了最大旋转角度。 最后，选择正确的数据扩充策略后，将其添加到`transforms.compose()`中。

-# 还有更多...
+# 更多

 我们还可以自定义定义图像数据所需的转换。 为此，我们将使用`transforms.Lambda()`并将函数或 lambda 传递给所需的自定义转换。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/torchvision/transforms.html)了解有关仿射变换等其他变换的信息。

@@ -450,7 +450,7 @@ PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为

 在本秘籍中，我们将研究如何将图像数据从文件加载到张量中。 在本秘籍中，我们将使用 CIFAR-10 数据集，该数据集由数据集中 10 个类别中的每个类别的 60,000 个`32 x 32`像素彩色图像组成。 这些类别是飞机，汽车，鸟，猫，鹿，狗，青蛙，马，船和卡车。

-# 做好准备
+# 准备

 我们将使用`torchvision`加载数据。 CIFAR-10 可以作为`torchvision`中的数据集使用。 您应该已经安装了`torchvision`。 如果没有，则可以使用以下代码进行安装：

@@ -460,7 +460,7 @@ pip install torchvision==0.x.x

 有了这个设置，我们很高兴选择这个秘籍。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将在 PyTorch 中加载 CIFAR-10 数据集：

@@ -583,7 +583,7 @@ pip install torchvision==0.x.x

 这样，我们已经加载了数据并对其进行了预处理，以便可以将其发送到模型进行训练。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们使用了 PyTorch 中的`datasets`模块来获取 CIFAR10 数据集。 然后，我们定义了对数据集中的图像有意义的转换，这些图像是与 10 个不同类别相对应的动物的图像。 我们对某些图像进行了水平翻转，并随机对某些图像进行了旋转，范围为 -20 至 20 度。

@@ -593,11 +593,11 @@ pip install torchvision==0.x.x

 然后，我们使用`numpy`中的`random.shuffle()`方法对索引列表进行混排。 指标列表随机化后，我们将指标的前 20% 移至验证集，将其余 80% 的指标移至训练集。 我们通过将原始训练量乘以原始训练集的百分比用作验证集来找到分割索引。 我们使用`split_index`进行拆分。 然后，我们使用`torch.utils.data`中的`SubsetRandomSampler()`方法从给定的索引列表中随机抽取元素，而不进行替换。 最后，我们使用`DataLoader()`组合了数据集和采样器，以对数据集进行迭代。 然后，我们将数据加载器用于训练，验证和测试集，以在训练模型时对数据进行迭代。

-# 还有更多...
+# 更多

 `DataLoader()`模块中还有许多功能-例如，`DataLoader()`可用于多进程数据加载，而`num_workers`控制在加载数据时要使用的子进程数。 在我们的示例中，我们使用了默认值`0`，这意味着数据已在主进程中加载，这对于小型数据集是理想的选择，并为我们提供了更具可读性的错误跟踪。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/data.html#module-torch.utils.data)上了解有关数据加载工具的更多信息。

@@ -605,7 +605,7 @@ pip install torchvision==0.x.x

 到目前为止，在本章中，我们一直在研究 CNN 的不同组成部分，以及如何将数据集中的数据加载到可以馈入 CNN 模型的格式中。 在本秘籍中，我们将通过到目前为止已经看到的完成模型的组件来定义 CNN 模型架构。 这与我们在第 2 章，“处理神经网络”中介绍的全连接神经网络非常相似。 为了更好地理解此秘籍，从第 2 章，“处理神经网络”修改全连接神经网络的模型定义将是一个好主意。 我们将在 CIFAR10 数据集上建立图像分类模型，我们在“加载图像数据”秘籍中对此进行了讨论。

-# 怎么做...
+# 操作步骤

 我们将在此秘籍中完成模型类的定义：

@@ -674,7 +674,7 @@ 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`函数之前和之后的元素数量保持相同（在本例中为批量大小）来确保将正确的尺寸自动分配给该尺寸。

@@ -684,11 +684,11 @@ CNN(

 然后，我们从 CNN 类实例化该模型并打印该模型。

-# 还有更多...
+# 更多

 您可以尝试不同的配置以用于丢失，卷积和池化层，甚至可以更改每种类型的层数。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#define-a-convolutional-neural-network)上看到使用 CNN 训练 CIFAR10 的不同模型。

@@ -696,7 +696,7 @@ CNN(

 现在我们已经定义了模型，接下来的主要步骤是使用手头的数据训练该模型。 这将与我们在第 2 章，“处理神经网络”和我们全连接神经网络中进行的训练非常相似。 在本秘籍中，我们将完成训练图像分类器的工作。 如果您在完成本秘籍之前，先阅读了第 2 章的“实现优化器”秘籍，那将非常有用。

-# 怎么做...
+# 操作步骤

 让我们通过以下秘籍完成模型的训练：

@@ -859,7 +859,7 @@ valid_loss = valid_loss/len(valid_loader.sampler)

 有了这个秘籍，我们就完成了图像分类器的训练。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们找到并训练了我们的模型。 为此，我们进行了导入，首先要确定模型并将模型分配给我们在计算机上拥有的适当设备。 我们使用`model.to(device)`方法移动模型，这比使用`model.cuda()`或`model.cpu()`更为优雅。

@@ -867,10 +867,10 @@ valid_loss = valid_loss/len(valid_loader.sampler)

 此后，我们使用`loss.backward()`进行了反向传播，并使用`optimizer.step()`步骤更新了模型权重。 然后，我们使用总历时损失来汇总批量中的损失。 然后，我们使用`model.eval()`将模型转换为评估模型，因为该模型的性能需要在验证集上进行评估，并且该模型在此阶段中不会学习，因此我们也需要关闭退出项。 遍历验证批量，我们获得了模型输出，并在整个时期累积了验证批量之间的损失。 此后，我们格式化了模型性能，以查看每个时期模型的变化。 我们注意到，模型训练和验证损失随时间的推移而减少，这表明模型正在学习。

-# 还有更多...
+# 更多

 我们已经运行了训练有素的模型，我们需要根据保持数据或测试数据（即该模型尚未看到的数据）评估模型。 通过这样做，我们可以评估模型的真实性能。 为此，您将必须进入模型测试批量，并且对于每个批量，必须执行`_, prediction = torch.max(output, 1)`将 softmax 概率转换为实际预测，并使用`prediction.eq(target.data.view_as(prediction))`将预测与真实输出标签进行比较，其中 我们确保预测张量和输出张量的尺寸相同。 这将返回一个张量，其中匹配的张量为 1，不匹配的张量为 0。 我们可以使用它来计算每个批量中模型的准确率，并将其汇总到整个测试数据集中。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#test-the-network-on-the-test-data)上看到测试模型的示例实现。
\ No newline at end of file
--- a/new/pt-ai-fund/4.md
+++ b/new/pt-ai-fund/4.md
@@ -71,7 +71,7 @@ pip install torchtext

 在处理自然语言处理任务时，我们采用文本语料库并将其分解为较小的单元。 在本秘籍中，我们将句子分解为单个单词，其中每个单词代表一个意思，其他单词与它附近的其他单词一起表达一个句子的意图。 计算机只能理解数字，因此为这些单词分配了唯一的整数值来表示单词。 将句子分解为标记的过程称为标记化。 在本秘籍中，我们将执行单词标记化。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将编写一个标记器，将在本章的“创建字段”部分中使用：

@@ -90,11 +90,11 @@ pip install torchtext

 在此秘籍中，我们成功实现了单词标记化。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们编写了一个简单的分词器 lambda 函数，该函数可用于英语和类似英语的语言。 我们使用单词之间的空格来标记句子。 然后，我们通过将句子传递给`tokenizer()`函数来测试标记器。 我们将在下一个秘籍中使用此标记生成器来创建字段。

-# 还有更多...
+# 更多

 我们还可以使用`nltk`库对句子进行标记化：

@@ -106,7 +106,7 @@ pip install torchtext

 此外，还有其他类型的标记化，例如字符串标记化，其中涉及将字符串标记化为子字符串。

-# 也可以看看
+# 另见

 可以在[这个页面](https://www.nltk.org/api/nltk.tokenize.html)上探索使用`nltk`对字符串进行的各种标记化。

@@ -116,7 +116,7 @@ pip install torchtext

 在本秘籍中，我们将研究如何使用`Field`类定义各种文本处理任务。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将探讨使用字段的各种示例：

@@ -164,7 +164,7 @@ pip install torchtext

 通过此秘籍，我们探索了可用于在`torchtext`中创建字段的不同方法。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们根据手头的特定任务，使用`field`类对给定的输入文本执行了各种文本处理任务。 在审阅分类的示例中，在`review`字段中，我们将`sequential`参数设置为`True`，因为它是顺序数据。 对于标签字段，我们将其设置为`False`，因为它们不是顺序的。 我们可以将文本设置为小写，这样就不会根据标记的大小写为相同的单词分配单独的标记 ID。 在评论分类的情况下，这不会影响含义； 这可以通过将`lower`设置为`True`来实现。

@@ -172,11 +172,11 @@ pip install torchtext

 然后，将`batch_first`设置为`True`，以使输出张量的第一维为批量维，如果`fix_length`参数设置为整数值，则将对输入设置固定长度 使用此字段。

-# 还有更多...
+# 更多

 我们可以为特定于某种语言的分词设置用于分词的语言，该语言支持 spacy 支持的语言。 我们可以使用`pad_token`参数设置自定义填充令牌。 我们可以在标记化之后但在数字化之前使用该字段定义将应用于示例的处理管道，在数字化之后但使用`preprocessing`和`postprocessing`参数将数字转换为张量之前，我们可以执行相同的操作。 `stop_words`参数可用于删除在预处理时需要删除的令牌。 此外，还有一种专门用于标签字段的字段类型`LabelField`，它可以代替普通字段使用。

-# 也可以看看
+# 另见

 您可以通过[这个页面](https://torchtext.readthedocs.io/en/latest/data.html#field)了解更多有关字段的信息。

@@ -184,7 +184,7 @@ pip install torchtext

 在本秘籍中，我们将研究读取文本数据并使用各种数据源。`torchtext`可以从文本文件，CSV/TSV 文件，JSON 文件和目录中读取数据，并将其转换为数据集。 数据集是已预处理的数据块，可读取到内存中，并可由其他数据结构使用。

-# 做好准备
+# 准备

 我们将使用此秘籍的新闻分类数据集，您可以从[这里](https://github.com/jibinmathew69/PyTorch1.0-Tutorial/tree/master/NewsClassification)下载该数据集。

@@ -197,7 +197,7 @@ pip install torchtext
 *   `Sports`
 *   `World`

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将读取有毒评论数据集，该数据集存储为一组`.csv`文件：

@@ -251,7 +251,7 @@ pip install torchtext

 通过此秘籍，我们定义了数据集的格式。

-# 这个怎么运作...
+# 工作原理

 我们使用`torchtext`中的`TabularDataset`模块读取 CSV 文件，该文件也可以用于读取 TSV，JSON 和 Python 字典中的输入，这些字典定义了列的数据集。 然后，我们定义了一个元组数组，其中每个元组都是一对列和`Field`对象（定义要应用的文本转换），但是在最终数据集中不需要特定的列。 然后，我们将在 ID 列中看到的该列的相应`Field`对象设置为`None`。

@@ -259,11 +259,11 @@ pip install torchtext

 我们将文件格式指定为`csv`，并通过将`skip_header`设置为`True`以及`fields`参数中的必需列来删除标题行，并且对数据集进行了相同的测试。 最后，我们在`Fields`对象中调用了`build_vocab()`方法，以建立可能的单词库，在数据集中的出现次数最少为两次。 不在词汇表中的单词将在验证和测试集中分配一个未知标签。

-# 还有更多...
+# 更多

 您可以使用`Vocab`模块在`torchtext`中构建词汇表。 除了`TabularDataset`之外，还有其他类型的数据集可以使用，具体取决于手头的 NLP 任务-例如，对于语言翻译任务，我们可以使用`TranslationDataset`类。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://torchtext.readthedocs.io/en/latest/data.html#torchtext-data)上了解有关数据集的更多信息。

@@ -271,7 +271,7 @@ pip install torchtext

 迭代器用于从数据集中加载一批数据。 它们提供了使加载数据和将数据移动到适当设备的方法更加容易。 我们可以使用这些迭代器对象遍历历元时对数据进行迭代。 在本秘籍中，我们将从数据集中开发这些迭代器。 您将需要完成“开发数据集”秘籍中的步骤，因为我们将在此处使用该秘籍中的`Dataset`对象。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将数据集转换为迭代器，以便在每个纪元准备好要迭代的适当批量：

@@ -307,17 +307,17 @@ pip install torchtext

 通过此秘籍，我们为训练，测试和验证数据集创建了迭代器。

-# 这个怎么运作...
+# 工作原理

 我们使用迭代器来构建训练，测试和验证批量，并将数据集移动到适当的 CPU 或 GPU 设备中。 `Iterators`使执行这些任务变得非常优雅。 我们使用了称为`BucketIterator`的专门迭代器类，该类将输入序列分组为相似长度的序列，并自动对其进行随机排序。 我们定义了批量大小，并找到了机器上可用的设备。

 然后，我们使用`BucketIterator`的`splits`方法创建训练，测试和验证迭代器。 我们将`sort_within_batch`参数设置为`False`，如果使用`pack_padded_sequence`则将其设置为`True`，这将阻止 LSTM 看到输入序列的填充部分。 当`True`使用`sort_key`参数时，它将按降序对批量中的序列进行排序。

-# 还有更多...
+# 更多

 还有其他类型的迭代器可用。 一个简单的迭代器从`Dataset`对象中加载一批数据，而`BPTTIterator`定义了用于语言建模任务的迭代器，其中一对序列彼此相距一个时间步长。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://torchtext.readthedocs.io/en/latest/data.html?highlight=bucketiter#iterators)上找到有关迭代器参数的更多信息。

@@ -331,7 +331,7 @@ pip install torchtext

 在这里，我们能够从`king`向量中减去`man`向量，并将其与`woman`向量相加，所得向量将接近该向量`Queen`的表示形式。 我们将在本秘籍中探讨此实现。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将对`torchtext`使用预训练的嵌入：

@@ -355,17 +355,17 @@ pip install torchtext

 通过此秘籍，我们已加载了预训练的单词嵌入。

-# 这个怎么运作...
+# 工作原理

 `torchtext`具有用于处理嵌入的`vocab`模块。 我们可以通过在此秘籍中提及需要的嵌入名称来下载预训练的嵌入。 我们使用了预先训练的 GloVe（GloVe 是词向量技术）模型，该模型使用 60 亿个令牌和 100 个嵌入维向量`glove.6B.50d`进行训练。

 然后，我们从缓存位置加载向量。 如果所需的嵌入不在高速缓存中，那么它将自动从 URL 下载并作为嵌入向量传递。 然后，我们使用`Review`字段对象的`build_vocab`方法从这些预训练的嵌入中建立词汇表，然后将其添加到训练数据的词汇表中。

-# 还有更多...
+# 更多

 我们还可以使用训练数据中的预训练嵌入词汇表-例如，我们可以使用使用 gensim 创建的嵌入向量作为嵌入向量。 我们还可以使用`torch.nn`模块创建嵌入； 我们将在下一个秘籍中了解如何执行此操作。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://torchtext.readthedocs.io/en/latest/vocab.html?highlight=embedding#module-torchtext.vocab)上了解有关嵌入的更多信息。

@@ -373,7 +373,7 @@ pip install torchtext

 **长短期记忆**（**LSTM**）网络是一种循环神经网络，具有内部门控，有助于更好地保持信息。 这些门是微小的神经网络，用于控制何时需要保存信息以及何时可以擦除或忘记信息。 RNN 受梯度消失和爆炸的影响，因此很难学习长期依赖关系。 LSTM 可以抵抗爆炸和消失的梯度，尽管在数学上仍然可行。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将定义 LSTM 分类器：

@@ -462,7 +462,7 @@ return self.fc(hidden)

 通过此秘籍，我们创建了一个 LSTM 模型。

-# 这个怎么运作...
+# 工作原理

 我们使用`torch.nn`模块创建了从`torch.nn.Module`继承的模型类`LSTMClassifier`，并初始化了基类构造函数。 然后，我们定义嵌入层，其中输入维与词汇量大小相同，输出为嵌入维，然后将嵌入层输出传递到 LSTM 层，其中输入维为嵌入维，然后 定义隐藏状态维度。

@@ -470,11 +470,11 @@ return self.fc(hidden)

 隐藏状态张量保存了到目前为止 LSTM 所见过的所有序列的信息，因此我们采用了隐藏状态，应用了`dropout`，并将其通过全连接层传递给最终输出向量，其大小等于 类数。 例如，对于有毒评论数据集，输出类别的数量为六； 但是，对于具有两个状态（正向和负向）的情感分析器，我们甚至可以考虑只具有一个输出，以便`1`代表积极情感，`0`代表消极情感。

-# 还有更多...
+# 更多

 对于具有两个以上状态的毒性审查任务，我们将使用`CrossEntropyLoss()`，对于仅具有一个输出的情感分析器，我们将使用`BCEWithLogitsLoss()`。 其余训练与我们在第 3 章，“用于计算机视觉的卷积神经网络”中看到的内容相同，我们在其中训练了卷积神经网络。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/nn.html#lstm)上了解有关 LSTM 的更多信息。

@@ -484,7 +484,7 @@ return self.fc(hidden)

 我们在先前的秘籍中介绍了简单的 LSTM。 在本秘籍中，我们将为多层 LSTM 升级该简单的 LSTM 定义。 您需要完成“构建 LSTM 网络”秘籍才能了解此秘籍。

-# 怎么做...
+# 操作步骤

 该秘籍是基于 LSTM 秘籍的修改。

@@ -531,17 +531,17 @@ class MultiLSTMClassifier(nn.Module):

 通过此秘籍，我们修改了用于多层 LSTM 的网络。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们在构造函数中添加了`num_layers`和参数以控制模型中 LSTM 的层数，并将其作为关键字参数`num_layers`传递给 LSTM 定义。

 然后，在`forward()`方法中，由于隐藏状态的形状是`[num_layers * num_directions, batch, hidden_dim]`（默认情况下`num_direction`是`1`），因此我们仅使用`hidden[-1]`从最后一个 LSTM 层获取了隐藏状态。 这意味着`hidden[-1]`给出了最后一层的隐藏状态。 通过这样做，我们可以选择`num_layers`作为超参数。 来自较低层的隐藏状态输出作为较高状态的输入传递。

-# 还有更多...
+# 更多

 在本秘籍中，我们仅考虑了最后一个 LSTM 层的隐藏状态。 但是，可能存在使用所有隐藏层的复杂架构。 有一个`dropout`参数，可用于在多层 LSTM 的各层之间施加丢弃。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/nn.html#lstm)上了解有关多层 LSTM 的更多信息。

@@ -549,11 +549,11 @@ class MultiLSTMClassifier(nn.Module):

 该秘籍以多层 LSTM 秘籍为基础。 在正常的 LSTM 中，LSTM 会从头到尾读取输入序列。 但是，在双向 LSTM 中，有第二个 LSTM 从最后到第一个读取序列，即反向 RNN。 当当前时间戳的预测取决于序列中进一步输入时，这种类型的 LSTM 可以提高模型性能。 考虑示例“我看过漫画”和“我昨天看过漫画”。 在这种情况下，基于将来出现的令牌，相同的令牌（即`read`）具有不同的含义。 我们将在本秘籍中探讨其实现。

-# 做好准备
+# 准备

 该秘籍建立在“多层 LSTM”秘籍的基础上，因此在尝试该秘籍之前，请务必先完成该秘籍。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将修改“多层 LSTM”秘籍中的类定义，使其成为双向 LSTM：

@@ -601,16 +601,16 @@ class BiLSTMClassifier(nn.Module):

 通过此秘籍，我们修改了网络，使其现在是双向 LSTM。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们在 LSTM 定义中将`bidirectional`标志设置为`True`。 我们将前向和后向 LSTM 的隐藏状态串联起来，并将它们传递到全连接层中。 因此，全连接层的输入尺寸增加了一倍，以适应前向和后向隐藏状态张量。

 在`forward()`方法中，我们使用`torch.cat()`连接了向前和向后隐藏状态，并使用了向前和向后 LSTM 的最后一个隐藏状态。 在 PyTorch 中，隐藏状态堆叠为`[forward_layer_0, backward_layer_0, forward_layer_1, backward_layer_1, ..., forward_layer_n, backward_layer_n]`，因此所需的张量为`hidden[-2,:,:], hidden[-1,:,:]`。 串联后，在挤出额外的尺寸后，我们将隐藏的向量传递到全连接层中。

-# 还有更多...
+# 更多

 我们选择了最后的前向和后向隐藏状态并将它们连接起来，这就是我们选择的架构。 但是，根据手头的任务，我们可以选择任何或所有隐藏状态。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/nn.html#lstm)上了解有关多层 LSTM 的更多信息。
\ No newline at end of file
--- a/new/pt-ai-fund/5.md
+++ b/new/pt-ai-fund/5.md
@@ -29,11 +29,11 @@

 在本秘籍中，我们将采用经过预训练的 ResNet 模型，并修改最后一层以适合我们所需的输出。 与 ImageNet 数据集中用于训练 ResNet-50 模型的类的数量相比，我们只需要两个类。 我们将修改 ResNet 模型的最后一个池化层和全连接分类器。 我们将进一步将模型的训练限制为仅添加新添加的分类器单元，并且将保留所有其余层以免更新权重。 这称为冻结模型。 让我们看一下如何实现秘籍。

-# 做好准备
+# 准备

 此秘籍要求我们下载特定的数据集。 我们将从[这里](https://www.kaggle.com/paultimothymooney/chest-xray-pneumonia/download)获取数据集。 为了完成此秘籍，您的 PyTorch 安装应为 1.2 或更高版本，强烈建议您使用支持 CUDA 的设备。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将训练我们的神经网络，并从在 ImageNet 数据集上训练的预训练模型 ResNet-50 开始：

@@ -98,7 +98,7 @@ return model

 有了这个秘籍，我们已经准备好要获取模型的功能。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们定义了一个子模块`AdaptiveConcatPool2d`，该子模块在平均 2D 池和最大 2D 池之间执行级联，以便从卷积层到具有最大特征信息的全连接层的平滑过渡。

@@ -108,7 +108,7 @@ return model

 在本秘籍中，我们将实现一个在单个时期内训练模型的功能。 此功能进一步记录模型的训练指标并将其绘制到 TensorBoard 上。 我们将传入模型，训练数据，优化器和模型训练准则，并将返回训练损失。

-# 怎么做...
+# 操作步骤

 我们将在此秘籍中实现训练功能：

@@ -149,7 +149,7 @@ return model

 通过此秘籍，我们完成了训练功能。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们定义了执行训练时期的功能。 在开始训练过程之前，我们使用`.train()`将模型设置为训练模式，并将训练损失设置为`0`。 然后，我们遍历训练数据并将输入数据点及其对应的标签移到可用设备（CPU 或 GPU）上。

@@ -161,7 +161,7 @@ return model

 在此秘籍中，我们将定义一个函数以在一个时期内根据验证数据测试模型。 此功能还将测试指标记录到 TensorBoard 上。 我们还将添加实用程序功能，通过绘制图像并以可读的方式标记这些图像来记录模型中的一些错误分类。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将实现模型测试以及实用程序功能：

@@ -224,7 +224,7 @@ return model

 通过此秘籍，我们完成了测试功能。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们编写了逆归一化函数以撤消在将图像转换为具有 ImageNet 统计信息的张量时建立的归一化。 我们还定义了`misclassified_images()`方法，用于记录预测错误的图像。 然后使用`SummaryWriter`对象中的`add_image()`方法将分类错误的图像添加到 TensorBoard 中，该方法将输入图像名称，图像和计数器。

@@ -234,7 +234,7 @@ return model

 在此秘籍中，我们将加载肺炎数据集并将其转换为张量。 该模型需要张量形式的数据，因此我们将需要对图像进行预处理以为其提供所需的数据。 我们将执行数据扩充以增加数据集的大小。 在将其输入模型之前，我们还将根据 ImageNet 数据集执行图像归一化。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将加载数据集：

@@ -331,7 +331,7 @@ return model

 有了这个秘籍，我们就可以准备好数据集。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们定义了训练，验证和测试数据集中图像所需的转换。 根据数据集选择变换，并且归一化变换中的值来自 ImageNet 统计信息。 然后，我们定义了数据集路径，模型名称，批量大小和日志目录。 然后，我们使用`datasets.ImageFolder()`方法根据文件夹名称加载数据，并为每个数据集创建一个迭代器。

@@ -343,7 +343,7 @@ return model

 在此秘籍中，我们将创建一个写入 TensorBoard 的对象。 我们使用`SummaryWriter`对象写入 TensorBoard。 我们可以使用 TensorBoard 编写标量值，绘图图和绘图图像以及其他功能。 我们将定义一个返回 TensorBoard `SummaryWriter`对象以记录我们的模型指标的函数。

-# 做好准备
+# 准备

 此秘籍要求我们安装 TensorBoard 库。

@@ -355,7 +355,7 @@ pip install tb-nightly

 这样，我们准备实现该秘籍。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将创建编写器对象以将数据登录到 TensorBoard。

@@ -395,7 +395,7 @@ tensorboard --logdir=log_dir/ --port 6006

 这样，我们就为 TensorBoard 做好了准备。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们首先从命令行加载 TensorBoard 以从`logdir/`目录中读取。 即使目录不存在，TensorBoard 也不抛出错误，而是等待目录出现，因此传递正确的目录很重要。

@@ -407,7 +407,7 @@ tensorboard --logdir=log_dir/ --port 6006

 在本秘籍中，我们将为数据集的预定义迭代次数完成模型训练。 我们将在模型训练期间保存最佳模型。 一旦针对给定的时期数训练了模型，我们将使用最佳模型的权重加载模型。 然后，我们将解冻模型的先前冻结的 ResNet 层，并训练模型以较低的学习速率微调权重。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将完成模型训练。

@@ -561,7 +561,7 @@ Epoch |        Training Loss |            Test Loss |  Accuracy  |

 通过此秘籍，我们已经训练了模型并在 TensorBoard 中可视化了其结果。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们创建了模型并将其移至可用设备，并分别使用负对数损耗和 Adam 作为我们的标准和优化器。 `train_epochs()`方法用于在定义的时期范围内训练模型。 在每个时期结束时，我们使用`writer.flush()`方法来确保所有未决事件已写入磁盘。 最后，我们使用`writer.close()`刷新关闭编写器。 我们还在此功能中保存了最佳模型，以供日后重新加载。

@@ -571,11 +571,11 @@ Epoch |        Training Loss |            Test Loss |  Accuracy  |

 我们看到训练和测试损失在各个时期都减少了，准确率提高了。

-# 还有更多...
+# 更多

 在此秘籍中，我们可以进一步编写一个函数来确定测试数据集指标，使用`add_histogram()`方法将直方图添加到 TensorBoard 中，并使用其他预训练的网络训练模型。

-# 也可以看看
+# 另见

 有关更多详细信息，请参阅以下内容：


--- a/new/pt-ai-fund/6.md
+++ b/new/pt-ai-fund/6.md
@@ -44,7 +44,7 @@ GAN 中的两个模型称为生成器和判别器，其中生成器负责创建

 请注意，我们将使用第 3 章，“用于计算机视觉的卷积神经网络”中的概念，因此再次阅读这些秘籍将非常有用。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将实现 GAN 网络的生成器端：

@@ -112,7 +112,7 @@ def forward(self, input):

 完成此过程后，我们已经准备好 DCGAN 发生器。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们进行了变换以将图像转换为张量并对其进行归一化，就像在第 3 章，“用于计算机视觉的卷积神经网络”中所做的一样。 然后，我们确定了机器上的设备：CPU 或 GPU。 然后，我们定义了从`nn.Module`类继承的`Generator_model`类，就像在所有以前的架构中所做的一样。

@@ -122,7 +122,7 @@ def forward(self, input):

 让我们看一下`forward`方法的工作方式。 `z_dim`维度的输入噪声向量经过全连接层以提供 12544 输出。 然后，我们将 12544 输出调整为`256 x 7 x 7`，其中 256 是通道数。 `256 x 7 x 7`张量然后通过反卷积层以提供`128 x 14 x 14`输出，然后通过具有 128 个特征和泄漏 ReLU 的`Batchnorm`层。 `128 x 14 x 14`然后在第二次反卷积中转换为`64 x 14 x 14`张量，在第三次反卷积中变为`1 x 28 x 28`张量； 这些只是我们需要的尺寸。 然后，我们创建生成器对象并将其移动到设备。

-# 也可以看看
+# 另见

 您可以通过[这个页面](https://arxiv.org/pdf/1511.06434.pdf)了解更多有关 DCGAN 的信息。

@@ -138,7 +138,7 @@ def forward(self, input):

 在本秘籍中，我们将严重依赖第 3 章，“用于计算机视觉的卷积神经网络”的秘籍，因此最好快速浏览 第 3 章，“用于计算机视觉的卷积神经网络”。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将构建 GAN 的判别器端：

@@ -193,11 +193,11 @@ def forward(self, input):

 现在我们已经准备好判别器。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们定义了一个分类器； 使用`nn.Sequential()`定义卷积，激活和批量规范化单元的数组； 并且还定义了最后一个全连接层，该层采用平坦的张量并给出通过 Sigmoid 层的单个输出。 由于只有两个类，因此我们最后使用了 Sigmoid 层。 输入是尺寸为`1 x 28 x 28`的图像张量，并经过第一卷积单元以给出尺寸为`32 x 14 x 14`的输出张量。 第二个卷积层使它成为`64 x 7 x 7`张量，然后从那里变成`128 x 4 x 4`。 之后，我们将拉平并使张量穿过全连接层。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://arxiv.org/pdf/1511.06434.pdf)上了解有关 DCGAN 的信息。

@@ -215,7 +215,7 @@ pip install torchsummary

 准备好此安装后，我们将继续进行下一步。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将完成 GAN 训练：

@@ -539,7 +539,7 @@ Epoch : | 005 / 050 |

 至此，我们已经完成了 DCGAN 的训练。

-# 这个怎么运作...
+# 工作原理

 我们从`weights_init`函数开始，该函数用于从均值 0 和标准差 0.02 的正态分布中随机初始化所有权重。 初始化模型后，函数将模型作为输入，并重新初始化所有卷积，卷积转置和批归一化层。

@@ -553,11 +553,11 @@ Epoch : | 005 / 050 |

 然后，我们定期显示模型指标，并保存固定噪声生成器生成的图像，以可视化模型在各个时期的性能。

-# 还有更多...
+# 更多

 您可以利用网络的超参数发挥更多的作用-例如，您可以对判别器优化器使用与生成器不同的学习率，或者对判别器的每次更新训练生成器两次或三次。

-# 也可以看看
+# 另见

 您可以在 [这个页面](https://pytorch.org/tutorials/beginner/dcgan_faces_tutorial.html)和[这个页面](https://iq.opengenus.org/deep-convolutional-gans-pytorch/)上看到训练和架构 DCGAN 的另一个示例。

@@ -578,7 +578,7 @@ pip install numpy

 安装这些工具后，我们将继续进行操作。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将快速绘制 GAN 中的图形和图像：

@@ -640,17 +640,17 @@ pip install numpy

 在这里，我们看到了 DCGAN 生成的手写图像。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们使用 matplotlib 绘制图形和图像。 我们使用`figure()`和`title()`方法设置图形尺寸和标题，然后使用`plot()`方法绘制发生器和判别器损耗。 我们还使用`xlabel`和`ylabel`方法添加了`x`和`y`标签。 我们还使用`legend()`方法为图添加了图例，最后使用`show()`方法显示了图。

 我们遍历训练期间保存在`image_list`中的图像，并使用 NumPy 的`transpose()`方法以所需顺序固定图像的尺寸。 `image_list`中的图像是使用`torchvision.util.make_grid()`方法生成的，我们根据噪声向量创建了生成图像的网格。

-# 还有更多...
+# 更多

 您可以使用其他库（例如 plotly 和 seaborn）来绘制和美化图形。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/tutorials/beginner/dcgan_faces_tutorial.html#results)上看到 DCGAN 的可视化效果和动画。

@@ -673,11 +673,11 @@ PGGAN 的关键创新可以总结如下：

 Nvidia 最初执行 PGGAN 的过程要花一到两个月的时间。 但是，为了让我们看到 PGGAN 的性能，我们将使用 PyTorch 集线器，它是使用 PyTorch 构建的预训练模型的存储库。

-# 做好准备
+# 准备

 为了使割炬轮毂正常工作，您需要拥有 PyTorch 版本 1.1.0 或更高版本。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将从火炬中心运行 PGGAN：

@@ -731,17 +731,17 @@ Nvidia 最初执行 PGGAN 的过程要花一到两个月的时间。 但是，

 通过前面的步骤，我们学习了如何使用 PyTorch Hub 运行 PGGAN。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们加载了在`celebAHQ`数据集上训练的 PGGAN 预训练模型； 为此，我们使用了`torch.hub`中的`load()`方法。 然后，我们定义了创建和生成尺寸为`num_images x 512`的噪声向量所需的图像数量，因为此模型使用大小为 512 的噪声向量进行训练，所有噪声向量都由`buildNoiseData()`方法内部处理 在模型对象中可用。

 `model.test()`方法生成了我们用来制作网格的图像。 钳位方法将所有值限制在`min`和`max`定义的范围内。 `.cpu()`方法将生成的图像移至 CPU，我们使用`permute`固定尺寸。 最后，`plt.imshow()`显示了我们创建的网格。

-# 还有更多...
+# 更多

 您可以在[这里](https://github.com/github-pengge/PyTorch-progressive_growing_of_gans)探索完整的 PGGAN 实现。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/hub.html)上了解有关割炬轮毂的更多信息。


--- a/new/pt-ai-fund/7.md
+++ b/new/pt-ai-fund/7.md
@@ -48,7 +48,7 @@ RL 解决方案涉及将反复试验的结果存储在查找表中，当环境

 对于杆保持直立的每个时间步，都会获得+1 的奖励。 现在我们有了上下文，我们将尝试解决 OpenAI Gym 的 Cartpole 问题的代码。

-# 做好准备
+# 准备

 首先，我们需要安装`gym`。 我们将使用`pip`管理器安装它：

@@ -58,7 +58,7 @@ pip install gym

 现在我们已经安装了`gym`，让我们跳入`gym`库。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将了解棘突环境。 请按照以下步骤操作：

@@ -114,7 +114,7 @@ pip install gym

 这样，您将看到一个窗口，该窗口显示不稳定的枢轴，并且枢轴点随机移动。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们探讨了 OpenAI Gym 的一些功能。 我们首先使用`Cartpole-v0`创建一个环境，该环境的最高可得分为 200，然后环境终止。 我们使用`env.reset()`命令将环境置于初始状态，即线杆处于直立位置。 然后，我们开始执行 1000 个步骤的循环，其中使用`render()`渲染了当前环境的开始，并且使用`env.action_space.sample()`为当前状态选择了一个随机动作。 然后，我们将选定的动作传递到环境的`step`方法中。 `step`方法告诉我们在对环境的当前状态执行当前操作时环境发生了什么。 `step`方法返回以下内容：

@@ -127,11 +127,11 @@ pip install gym

 最后，我们关闭了环境。 我们使用`env.action_space.n`查看了环境中可能采取的行动，并使用`env.observation_space.shape[0]`查看了处于观察状态的参数。 现在我们已经了解了环境，我们可以开始实现各种深度 RL 算法。

-# 还有更多...
+# 更多

 您可以通过更改环境名称来尝试其他环境。 试用`Cartpole-v1`对您来说将是有益的。

-# 也可以看看
+# 另见

 您可以在[这个页面](http://gym.openai.com/docs/)上了解有关 OpenAI 体育馆的更多信息。

@@ -151,7 +151,7 @@ Q 值可以更新如下：

 通过深度 Q 学习，我们可以使用深度神经网络来预测动作的 Q 值，并使用深度神经网络来选择动作，而不是使用 Q 表查找给定状态下具有最大可能 Q 值的动作。 给定动作的最大 Q 值。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将为卡特彼勒问题定义神经网络模型。 请按照以下步骤操作：

@@ -177,15 +177,15 @@ def cartpole_model(observation_space, action_space):

 此函数返回模型。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们定义了一个名为`cartpole_model`的函数，该函数接受`observation_ space`和`action_space`参数，并返回一个神经网络模型。 在这里，我们使用了`torch.nn`，`nn.Linear`和`nn.ReLU`中的`Sequential`模块来完成模型。 给定一个观察值，我们使用该模型来训练和预测每个动作的 Q 值。

-# 还有更多...
+# 更多

 我们还可以训练将状态作为图像并学习从图像预测 Q 值的模型。 完成此操作后，我们将使用`nn.Conv2d()`来使用卷积神经网络。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html#q-network)上查看替代架构。

@@ -193,11 +193,11 @@ def cartpole_model(observation_space, action_space):

 在本秘籍中，我们将使用神经网络完成 DQN。 为此，我们将执行一些关键任务，包括创建目标和策略网络，损失函数和网络优化器，存储学习过程的状态和奖励，预测行为，经验回放以及控制学习过程。 探索率。

-# 做好准备
+# 准备

 在完成本秘籍之前，您应该完成本章的“OpenAI Gym 介绍 – Cartpole”秘籍，以便设置`gym`程序包。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将研究可用于执行 DQN 的所有关键功能。 按着这些次序：

@@ -312,7 +312,7 @@ if not self.explore_limit:

 至此，我们完成了 DQN 课程。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们完成了 DQN 类，并添加了所有必需的功能来训练 DQN。 在构造函数中，我们初始化了探索的初始状态，观察空间和动作空间，然后定义了一个存储单元来保存 DQN 的经验。 我们创建了称为`policy_net`和`target_net`的软骨模型的两个实例。 我们需要两个网络，因为在训练的每个步骤中，Q 网络的值都会移动，并且如果我们使用不断变化的目标值来调整我们的网络，则该网络可能会由于陷入此变化的目标与估计的 Q 值之间的反馈回路而变得不稳定。 网络值。 如果发生这种情况，价值估算将失去控制。 因此，我们使用了两个网络并将`target_net`保持在`eval`模式。 然后，我们使用`MSELoss()`作为损失函数以及`Adam`优化器来更新权重。

@@ -320,11 +320,11 @@ if not self.explore_limit:

 最后，我们实现了`experience_replay`方法。 在这里，我们等待数据点的数量至少为`BATCH_SIZE`，然后从内存中随机抽样一批。 这使它可以从一系列不同的观察中学习，而不是从一系列紧密相关的观察中学习。 遍历批量时，我们使用`target_net`根据 Q 值更新公式更新了 Q 值。 然后，我们根据新 Q 值与`policy_net`预测的 Q 值之间的误差训练了`policy_net`。 之后，通过将其乘以探索衰减量逐渐降低探索速率，直到获得最低探索速率。 我们这样做是因为，在训练的初始阶段，我们希望代理人进行更多探索； 但是，随着训练的进行，我们希望算法能够收敛。 至此，我们已经完成了 DQN 类的所有功能。

-# 还有更多...
+# 更多

 您可以在 DQN 类中添加一种方法，以用策略网络更新目标网络的权重。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://github.com/gsurma/cartpole/blob/master/cartpole.py)上的 Keras 中查看此实现。

@@ -332,7 +332,7 @@ if not self.explore_limit:

 在此秘籍中，我们将完成训练 DQN 增强算法的过程，并在训练模型后可视化我们的小车。 我们将使用 DQN 类来预测操作并将该操作应用于环境以获得奖励。 此秘籍的目的是使奖励最大化。 我们将使用经验重播来训练我们的模型以预测 Q 值。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将继续使用“DQN 类”秘籍。 按着这些次序：

@@ -479,17 +479,17 @@ Rewards: 160.0

 这样，我们就对 DQN 进行了训练和可视化。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们首先使用超参数导入并初始化环境。 然后，我们创建了`DQN`类的实例，并开始训练循环，重置环境，并对状态数组进行整形，以便可以将其作为浮点张量输入到模型中。 然后，我们开始了一个无限循环，当`env.step()`方法的返回值将`terminal`设置为`True`时终止。 `predict_action()`方法预测在给定环境当前状态下要采取的措施。 然后，我们使用环境的`step()`方法应用了此操作。 我们采用`step`方法返回的下一个状态，并将其从`numpy`转换为`torch.FloatTensor`，并保存了环境参数。 我们一次又一次地将此新状态传递给模型。 我们还每隔几步就将权重从我们的策略网复制到目标网。

 最后，我们编写了一个简单的`play_agent`函数来可视化平衡并在重置环境后运行循环。 我们要求目标网络预测每个可能动作的 Q 值，选择具有最高 Q 值的动作，并使用`step()`将其导入环境。 之后，我们不断增加奖励。 此函数返回柱状体直立的时间步数和柱状体执行平衡动作的视频。

-# 还有更多...
+# 更多

 您可以编写一个函数来绘制算法的性能，并且仅在模型的得分始终在 450-500 之间时才停止训练过程。

-# 也可以看看
+# 另见

 您可以在[这里](https://github.com/gsurma/cartpole/blob/master/cartpole.py)的 Keras 中看到此实现。

@@ -501,7 +501,7 @@ Rewards: 160.0

 在本秘籍中，我们将定义模型的网络维度，该网络维度将用于预测给定状态时应采取的措施。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将完成网络模型定义。 您需要安装 OpenAI 的体育馆库。 按着这些次序：

@@ -526,15 +526,15 @@ Rewards: 160.0

 这样，我们就完成了模型的定义。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，函数处于观察状态，并通过两个线性层和一个 ReLU 单元（在隐藏层中有 128 个单元）运行它。 最后一层的输出通过 softmax 函数传递，以将激活转换为概率，并选择概率最高的动作。

-# 还有更多...
+# 更多

 对于复杂模型，您还可以具有多个层和不同数量的单元。

-# 也可以看看
+# 另见

 您也可以将复杂的网络与卷积层一起使用。 在[这个页面](https://github.com/IBM/distributed-evolutionary-ml/blob/master/nn.py)中显示了一个示例。

@@ -542,7 +542,7 @@ Rewards: 160.0

 在本秘籍中，我们将着眼于创建一组代理以开始我们的进化过程，然后初始化这些代理的权重。 我们将使用这些代理来评估模型的性能并生成下一代代理。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将创建给定数量的代理。 按着这些次序：

@@ -588,11 +588,11 @@ agents.append(agent)

 现在，我们的代理商已准备好进行评估。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们编写了两个函数-第一个函数初始化模型层的权重。 对于模型权重，我们使用`torch.nn.init`中的`xavier_uniform`并用`0`填充偏差。 第二个函数创建`num_agents`个代理，并使用`cartpole_model()`函数返回它们。 我们使用`init_weight`初始化权重。 然后，对于模型的参数，我们禁用梯度计算，将代理设置为`eval()`模式，然后返回所有代理。

-# 也可以看看
+# 另见

 您可以在[这个页面](https://pytorch.org/docs/stable/nn.init.html)上找到有关其他初始化方法的信息。

@@ -600,7 +600,7 @@ agents.append(agent)

 在本秘籍中，我们将基于适应度函数着眼于代理商选择，在我们的案例中，这意味着在平衡卡特波勒方面得分很高。 这意味着我们将传播得分最高的代理，而忽略其余的代理。 我们将评估给定一代中的每个代理，并多次评估它们，以确保奖励不是偶然的。 最后，我们将使用每个代理商的平均分数来确定表现最佳的代理商。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将编写用于评估代理，多次评估以及按给定序列评估所有代理的功能。 按着这些次序：

@@ -658,7 +658,7 @@ return total_reward

 现在，我们的功能已准备好进行评估。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们完成了深度遗传算法的一些关键功能。 我们研究了三个不同的功能-第一个功能`eval_agent()`与我们在“训练 DQN”秘籍中看到的功能非常相似，其中我们使用了代理，该代理是一种神经网络模型，可以预测 并执行直到`MAX_STEP`（对于`cartpole-v1`为 500）或终端为`True`并返回分数的动作。

@@ -668,7 +668,7 @@ return total_reward

 在本秘籍中，我们将介绍突变剂。 在从给定的一代中选择性能最佳的模型之后，然后再创建下一代代理，我们将对这些选定代理的权重进行轻微的随机变化，这使代理可以探索更多区域以获得更好的回报，只是 就像生物进化如何运作。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将识别精英特工并向这些特工添加突变。 按着这些次序：

@@ -750,7 +750,7 @@ return copy.deepcopy(agents[top_id])

 在这里，我们定义了识别精英特工的功能和为特工增加噪音的功能。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们研究了四个不同的函数-`mutation`函数为一个代理创建一个重复项，并为每个参数附加一个受`MUTATION_POWER`限制的小的随机值。 `rand_like`方法从间隔`[0, 1)`上以与`param`相同的大小从均匀分布返回具有随机值的张量。 最后，该函数返回突变的子代理。 接下来，我们看到`elite`函数返回性能最佳的代理中最佳代理的副本。 在`elite`功能中，我们重新评估代理以确保得分最高的代理被选为精英，并作为子代理传递给下一代。

@@ -762,7 +762,7 @@ return copy.deepcopy(agents[top_id])

 在本秘籍中，我们将完成深度遗传算法的演化，并可视化执行平衡操作的关键。 我们将使用在本章的秘籍中了解到的所有功能，并针对给定的代数运行这些功能。 这将创建代理，获取他们的分数，选择性能最佳的代理，并将其突变为下一代。 在几代人中，我们将看到代理商的分数增加。

-# 怎么做...
+# 操作步骤

 按着这些次序：

@@ -883,7 +883,7 @@ Rewards: 350.0

 至此，我们已经完成了 DGA 的训练和可视化。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们改进了深度遗传算法。 根据论文《深度神经进化：遗传算法是用于训练深度神经网络以进行强化学习的一种竞争选择》，我们将超参数`MUTATION_POWER`设置为`0.02`。 我们不需要使用 PyTorch 来进行梯度计算，因为我们不需要依靠梯度下降来改善模型和创建环境。

@@ -891,10 +891,10 @@ Rewards: 350.0

 最后，我们使用了与“训练 DQN”秘籍中相同的`play_agent`函数，并进行了较小的修改，以补偿模型预测值的差异。 在这里，我们使用精英模型来显示卡特彼勒的性能，每一代之后。 位于代理商列表的末尾。 这是使用`play_agent`功能完成的。

-# 还有更多...
+# 更多

 您可以控制深度遗传算法的各种超参数，以查看性能差异并将分数存储到图表中。

-# 也可以看看
+# 另见

 您可以在[这里](https://arxiv.org/pdf/1712.06567.pdf)和[这里](https://github.com/uber-research/deep-neuroevolution)阅读更多有关 DGA 的信息。
\ No newline at end of file
--- a/new/pt-ai-fund/8.md
+++ b/new/pt-ai-fund/8.md
@@ -16,7 +16,7 @@

 在本秘籍中，我们将使用 Flask 微框架部署图像分类器。 我们使用 Flask 的原因是因为它是一个易于使用的微框架，可用于构建 RESTful 微服务，它是一个非常流行的框架，并且有据可查。 我们将部署一个使用 Densenet-161 预训练模型构建的图像分类器模型，以完成此秘籍。

-# 做好准备
+# 准备

 我们将需要为此秘籍安装 Flask。 使用`pip`管理器安装`flask`：

@@ -26,7 +26,7 @@ pip install flask

 这样，我们就可以开始了。

-# 怎么做...
+# 操作步骤

 我们将把这个秘籍分成多个文件。 请按照以下步骤操作：

@@ -158,7 +158,7 @@ python imageapp.py

 在此秘籍中，我们使用 Flask 进行了简单的应用部署。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们使用 Flask Python 框架部署了使用 RESTful API 进行推理的模型。 我们首先创建`image_classifier.py`并从`idx_class.json`加载类名。

@@ -168,11 +168,11 @@ python imageapp.py

 最后，我们将此图像数据传递到我们先前定义的`predict_image`函数中。 Flask 中的`jsonify`方法可确保响应为`.json`格式。 `app.run(debug=True)`启动 Flask 服务器并处理请求。

-# 还有更多...
+# 更多

 在本秘籍中，我们使用`debug=True`将调试模式设置为开启，这在生产中不建议使用。 Flask 服务器的功能不足以支持生产负载。 相反，应使用`gunicorn`和`nginx`进行正确的部署。

-# 也可以看看
+# 另见

 [您可以在以下位置阅读有关 Flask 的更多信息](http://flask.palletsprojects.com/en/1.1.x/)。

@@ -184,7 +184,7 @@ python imageapp.py

 TorchScript 为最初用 PyTorch 编写的模型提供中间表示。 这样，您就可以在高性能环境（例如 C++）中运行模型。 TorchScript 通过 PyTorch 代码创建模型的可序列化和优化版本。 使用 TorchScript 编写的代码可以加载到进程中，而无需任何 Python 依赖项。 TorchScript 提供了可用于捕获模型定义的工具，而 PyTorch 具有动态和灵活的特性，因此足以支持此定义。 可以通过两种方式创建 TorchScript：跟踪或使用脚本编译器。 在本秘籍中，我们将使用跟踪和脚本编译器将 PyTorch 模型转换为 TorchScript。

-# 怎么做...
+# 操作步骤

 在此秘籍中，我们将创建一个 TorchScript。 请按照以下步骤操作：

@@ -371,7 +371,7 @@ def forward(self,

 这样，我们研究了创建 TorchScript 的两种不同方法。

-# 这个怎么运作...
+# 工作原理

 在本秘籍中，我们使用了跟踪方法来创建 TorchScript。 我们定义了一个简单的模块`MyCell`转换为`Torchscript`，并创建了两个采样张量`x`和`h`传递给网络模块的正向方法。 然后，我们使用`jit.trace`跟踪 Python 代码并创建 TorchScript。

@@ -416,11 +416,11 @@ my_cell = MyCell(MyDecisionGate())

 当使用`print(traced_cell.code)`打印 TorchScript 代码时，我们看到仍然保留了控制流。

-# 还有更多...
+# 更多

 我们可以将跟踪和脚本编写方法混合在一起。

-# 也可以看看
+# 另见

 [您可以在以下网址找到有关混合跟踪和脚本的更多信息](https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html#mixing-scripting-and-tracing)。

@@ -430,7 +430,7 @@ my_cell = MyCell(MyDecisionGate())

 ONNX 得到了广泛的支持，可以在许多框架，工具和硬件中找到，因为它可以实现不同框架之间的互操作性，并可以实现从研究到生产的过渡。

-# 做好准备
+# 准备

 对于此秘籍，我们需要安装 ONNX，可以使用以下命令进行安装：

@@ -442,7 +442,7 @@ pip install onnx

 对于此秘籍，我们还将需要在第 3 章，“用于计算机视觉的卷积神经网络”中在`CIFAR-10`上训练的模型的训练权重。

-# 怎么做...
+# 操作步骤

 在本秘籍中，我们将 CIFAR-1o 模型导出为 ONNX 格式，并使用`onnxruntime`运行它。 请按照以下步骤操作：

@@ -569,7 +569,7 @@ CNN(

 通过此秘籍，我们已导出为`onnx`格式，并使用 ONNX 运行时以`onnx`格式运行了模型。

-# 这个怎么运作...
+# 工作原理

 在此秘籍中，我们将正常的 PyTorch 模型导出为 ONNX 格式，并使用 ONNX 运行时运行`onnx`模型。 为此，我们采用了权重模型。 在这里，我们使用了第 3 章“卷积神经网络”的 CIFAR-10 模型，用于计算机视觉*。 我们从训练中使用了模型的权重，并将模型设置为评估模式，以进行快速，轻便的计算。

@@ -581,11 +581,11 @@ CNN(

 然后，我们将模型加载到`onnx`运行时中，并为模型创建一个推理会话。 创建会话后，我们使用`run()` API 评估了模型，其中第一个参数是输出名称的列表，第二个参数是输入字典。 此调用的输出是计算 ONNX 运行时之后模型输出的列表。 最后，我们使用`numpy.testing.assert_allclose()`比较了 PyTorch 模型和`onnx`模型的输出值，如果两个对象不等于期望的公差，则会提高`AssertionError`。

-# 还有更多...
+# 更多

 我们可以导出`onnx`模型，加载其他受支持的框架，并使用`torch.onnx.export()`中的其他参数配置导出。

-# 也可以看看
+# 另见

 [您可以在以下位置阅读有关 ONNX 的更多信息](https://pytorch.org/tutorials/advanced/super_resolution_with_onnxruntime.html)。