2021-01-18 16:15:42

new/pt-ai-fund/0.md

@@ -14,7 +14,7 @@
 
 第 1 章，“使用 PyTorch 处理张量”介绍 PyTorch 及其安装，然后继续使用 PyTorch 处理张量。
 
-第 2 章，“处理神经网络”全面介绍了开始和训练全连接神经网络的所有要求，从而对基本神经网络的所有组件进行了详尽的解释。 ：层，前馈网络，反向传播，损失函数，梯度，权重更新以及使用 CPU / GPU。
+第 2 章，“处理神经网络”全面介绍了开始和训练全连接神经网络的所有要求，从而对基本神经网络的所有组件进行了详尽的解释。 ：层，前馈网络，反向传播，损失函数，梯度，权重更新以及使用 CPU/GPU。
 
 第 3 章，“用于计算机视觉的卷积神经网络”首先介绍了用于更高级任务的一类神经网络，即卷积神经网络。 在这里，我们将与 PyTorch 一起探索 TorchVision，训练 CNN 模型，并使用 TensorBoard 可视化其进度。 我们还将介绍与卷积网络构建块相关的各种任务。 卷积神经网络（CNN 或 ConvNet）是一类 DNN，最常用于分析图像。
 
@@ -46,9 +46,9 @@
 
 下载文件后，请确保使用以下最新版本解压缩或解压缩文件夹：
 
-*   Windows 的 WinRAR / 7-Zip
-*   Mac 版 Zipeg / iZip / UnRarX
-*   适用于 Linux 的 7-Zip / PeaZip
+*   Windows 的 WinRAR/7-Zip
+*   Mac 版 Zipeg/iZip/UnRarX
+*   适用于 Linux 的 7-Zip/PeaZip
 
 本书的代码包也托管在 [GitHub](https://github.com/PacktPublishing/PyTorch-Artificial-Intelligence-Fundamentals) 上。 如果代码有更新，它将在现有的 GitHub 存储库中进行更新。
 

new/pt-ai-fund/1.md

@@ -24,7 +24,7 @@ PyTorch 与 Python 深度集成，具有命令式风格，使用类似 Python
 
 NumPy 是本章必不可少的库，在您安装 PyTorch 时，NumPy 会自动为您安装它的依赖项。 这意味着我们无需显式安装 NumPy。
 
-您可以将 PyTorch 与其他软件包管理器一起安装，例如 conda，如[这个页面](https://pytorch.org/)中所述。
+您可以将 PyTorch 与其他软件包管理器一起安装，例如 Conda，如[这个页面](https://pytorch.org/)中所述。
 
 要为 Python3 CPU 安装 PyTorch，我们可以使用以下命令：
 
@@ -60,7 +60,7 @@ pip3 install torch
 pip3 install https://download.pytorch.org/whl/cu90/torch-1.1.0-cp36-cp36m-win_amd64.whl
 ```
 
-MacOS Binaries 不支持 CUDA，因此如果需要 CUDA，则应从源代码安装它。 您也可以使用其他软件包管理器进行安装，甚至可以从源代码进行构建。 有关其他软件包管理器和 Python 版本，请访问[这个页面](https://pytorch.org/)。
+MacOS 二进制不支持 CUDA，因此如果需要 CUDA，则应从源代码安装它。 您也可以使用其他软件包管理器进行安装，甚至可以从源代码进行构建。 有关其他软件包管理器和 Python 版本，请访问[这个页面](https://pytorch.org/)。
 
 您可以通过转到 Python 终端并键入以下命令来快速验证安装是否正常：
 
@@ -75,7 +75,7 @@ import numpy
 
 首先让我们了解张量是什么。 **标量**是单个独立值，一维值数组称为**向量**，二维值数组称为**矩阵**，并且任何 大于 2D 的值简称为**张量**。 张量是一个广义的术语，包含标量，向量和矩阵。
 
-标量是第 0 <sup xmlns:epub="http://www.idpf.org/2007/ops">次张量，向量是 1 <sup xmlns:epub="http://www.idpf.org/2007/ops">st</sup> 次张量，矩阵是 2 <sup xmlns:epub="http://www.idpf.org/2007/ops">nd</sup> 次张量。</sup>
+标量是 0 阶张量，向量是 1 阶张量，矩阵是 2 阶张量。
 
 以下是各种张量：
 
@@ -112,7 +112,7 @@ import torch
 torch.ones((2,3))
 ```
 
-这将返回一个张量，该张量包含一个张量，并且具有默认的 float 数据类型，如下所示：
+这将返回一个张量，该张量包含一个张量，并且具有默认的`float`数据类型，如下所示：
 
 ```py
 tensor([[1., 1., 1.],
@@ -189,7 +189,7 @@ tensor([[2.5620e-01, 4.5773e-41, 2.5620e-01],
 torch.rand((2,3))
 ```
 
-2.  这将根据[0，1]的均匀分布绘制具有随机值的张量：
+2.  这将根据`[0, 1]`的均匀分布绘制具有随机值的张量：
 
 ```py
 tensor([[0.6714, 0.0930, 0.4395],
@@ -316,7 +316,7 @@ tensor([[3, 3],
 
 在本食谱中，我们介绍了从各种数据源创建张量的各种方法。 在我们开始探索使用 PyTorch 进行深度学习的概念及其原理之前，必须了解一些最常用的功能来处理数据的基本单位张量。 我们可以使用`torch.tensor()`方法创建具有各种值和形状的张量。 我们甚至可以从均匀分布或标准正态分布中得出张量，这对于初始化神经网络以获得最佳性能和训练时间至关重要，所有这些张量都具有默认的`torch.FloatTensor` 数据类型，并使用`dtype`更新数据类型。 参数。
 
-`.ones()`方法创建一个包含给定形状的张量的张量，`.zeros()`用所有零填充该张量，`full()`方法将给定形状的张量填充。 `.empty()`方法创建一个空张量，`.rand()`从[0，1）的均匀分布中绘制一个具有随机值的张量，`.randn()`从正态分布中绘制均值为 0 和方差 1 的一个具有随机值的张量 ，也称为标准正态分布。
+`.ones()`方法创建一个包含给定形状的张量的张量，`.zeros()`用所有零填充该张量，`full()`方法将给定形状的张量填充。 `.empty()`方法创建一个空张量，`.rand()`从`[0, 1]`的均匀分布中绘制一个具有随机值的张量，`.randn()`从正态分布中绘制均值为 0 和方差 1 的一个具有随机值的张量 ，也称为标准正态分布。
 
 `rand_int()`方法从给定范围绘制随机整数，并以给定形状创建张量。 我们可以创建具有其他张量形状的张量，也可以具有所有张量的张量，但是可以使用`ones_like()`方法创建其他张量的形状和数据类型。 我们可以使用`torch.new_*`格式创建一个张量，其类型与另一个张量相似，但大小不同。
 
@@ -334,7 +334,7 @@ tensor([[3, 3],
 
 NumPy 是 Python 中科学计算的基本软件包。 它是一个 Python 库，提供多维数组对象和各种派生对象。 除此之外，NumPy 用作通用多维数据的有效容器。 NumPy 允许与各种数据库进行无缝，快速的集成。
 
-NumPy 是标准的 Python 库，用于处理数字数据。 Python 中许多著名的 ML / DS 库，例如 pandas（用于从许多来源读取数据的库）和 scikit-learn（用于读取和写入图像的最重要的 ML 库之一）都使用 NumPy 引擎盖。 例如，在处理表格数据，使用`pandas`库加载表格数据并将`numpy`数组移出数据框时，您将处理很多`numpy`。 读取图像，许多现有库都具有内置的 API，可以将它们读取为`numpy`数组； 并将`numpy`数组转换为图像以及文本和其他形式的数据。 同样，它们都使用`scikit-learn`（机器学习库）支持`numpy`数组。 如您所见，在`numpy`阵列和 PyTorch 张量之间建立桥梁非常重要。
+NumPy 是标准的 Python 库，用于处理数字数据。 Python 中许多著名的 ML/DS 库，例如 pandas（用于从许多来源读取数据的库）和 scikit-learn（用于读取和写入图像的最重要的 ML 库之一）都使用 NumPy 引擎盖。 例如，在处理表格数据，使用`pandas`库加载表格数据并将`numpy`数组移出数据框时，您将处理很多`numpy`。 读取图像，许多现有库都具有内置的 API，可以将它们读取为`numpy`数组； 并将`numpy`数组转换为图像以及文本和其他形式的数据。 同样，它们都使用`scikit-learn`（机器学习库）支持`numpy`数组。 如您所见，在`numpy`阵列和 PyTorch 张量之间建立桥梁非常重要。
 
 # 怎么做...
 
@@ -642,7 +642,7 @@ tensor([[1., 2., 3.],
 
 *   `.reshape()`方法：`.reshape(a, b)`返回一个新张量，该张量具有与原始张量`(a, b)`相同的数据，因为它会将数据复制到内存的另一部分； `.reshape()`可以在连续和非连续张量上运行，并且可以返回原始张量的副本或视图。
 *   `.resize()`方法：`.resize_(a, b)`返回相同的张量，而不创建具有新给定形状的副本。 但是我们应该记住，如果新形状产生的元素少于原始张量，那么它将不会引发任何错误，并且某些元素将从张量中删除，但不会从内存中删除。 如果新形状产生的元素多于原始张量，则新元素将在内存中未初始化而不会引发任何错误。
-*   `.view()`方法：`.view(a, b)`将返回一个新的张量，其张量与权重为（a，b）的数据相同； `.view()`只能在连续的张量上运行，并返回与输入相同的存储。
+*   `.view()`方法：`.view(a, b)`将返回一个新的张量，其张量与权重为`(a, b)`的数据相同； `.view()`只能在连续的张量上运行，并返回与输入相同的存储。
 
 # 还有更多...
 

new/pt-ai-fund/2.md

@@ -21,7 +21,7 @@
 *   定义损失函数
 *   实施优化器
 *   实施辍学
-*   实施功能性 API
+*   实施函数式 API
 
 # 技术要求
 
@@ -39,7 +39,7 @@ pip install torchvision
 
 在本食谱中，我们将从了解 TorchVision 的一些重要功能开始，这些功能使它能够处理图像数据并进行处理。 然后，我们将通过定义一个类来定义神经网络的基本架构，并查看可用于此的模块和方法。 在本食谱中，我们将专注于全连接神经网络类。 它的属性是各个层，其目的是对各种类型的衣服进行分类。
 
-我们将使用 Fashion–MNIST 数据集。 这是 Zalando 文章图片的数据集，包括 6 万个示例的训练集和 10,000 个示例的测试集。 我们将拍摄一张尺寸为 28 x 28 的灰度图像，并将其转换为 784 的向量。
+我们将使用 Fashion–MNIST 数据集。 这是 Zalando 文章图片的数据集，包括 6 万个示例的训练集和 10,000 个示例的测试集。 我们将拍摄一张尺寸为`28 x 28`的灰度图像，并将其转换为 784 的向量。
 
 以下是来自数据集的示例：
 
@@ -134,7 +134,7 @@ pip install torchvision
 
 # 这个怎么运作...
 
-在本食谱中，我们开始使用`torchvision`。 `torchvision`中有实用程序来支持与视觉有关的任务。 有一个名为`transforms`的模块可以帮助完成许多图像预处理任务。 对于我们正在处理的特殊情况，一个由 28 x 28 灰度像素组成的图像，我们首先需要从图像中读取并使用`transforms.ToTensor()`变换将其转换为张量。 然后，我们分别将像素值的平均值和标准差设为 0.5 和 0.5，以便模型更易于训练； 为此，我们使用`transforms.Normalize((0.5,),(0.5,))`。 我们将所有转换与`transform.Compose()`结合在一起。
+在本食谱中，我们开始使用`torchvision`。 `torchvision`中有实用程序来支持与视觉有关的任务。 有一个名为`transforms`的模块可以帮助完成许多图像预处理任务。 对于我们正在处理的特殊情况，一个由`28 x 28`灰度像素组成的图像，我们首先需要从图像中读取并使用`transforms.ToTensor()`变换将其转换为张量。 然后，我们分别将像素值的平均值和标准差设为 0.5 和 0.5，以便模型更易于训练； 为此，我们使用`transforms.Normalize((0.5,),(0.5,))`。 我们将所有转换与`transform.Compose()`结合在一起。
 
 准备好转换后，我们定义了合适的批量大小。 较高的批量大小意味着该模型具有较少的训练步骤并且学习速度更快，而较高的批量大小会导致对内存的高要求。
 
@@ -461,7 +461,7 @@ Training loss: 0.2596
 
 在本食谱中，我们首先使用`Adam`优化器定义优化器，然后为优化器设置学习率，并查看默认参数。 我们设置一个时期`10`，并为每个时期开始迭代，在每次迭代中将`running_loss`设置为 0，并在该时期内对每个图像进行迭代（模型看到数据集的次数）。 我们首先使用`.zero_grad()`方法清除梯度。 PyTorch 在每次向后传递时都会累积梯度，这在某些情况下很有用，因此将其导入以将梯度归零，以正确更新模型参数。
 
-接下来，我们通过将每批 64 幅图像（每幅图像由 28 x 28 像素组成）展平到 784 来重塑图像，从而将张量形状从 64 x 28 x 28 更改为 64 x 784，因为我们的模型期望这种形状 输入。 接下来，我们将此输入发送到模型，并从模型中获得该批量的输出预测，然后将其传递给损失函数，也称为`criterion`； 在那里，它评估了预测班级与实际班级之间的差异。
+接下来，我们通过将每批 64 幅图像（每幅图像由`28 x 28`像素组成）展平到 784 来重塑图像，从而将张量形状从`64 x 28 x 28`更改为`64 x 784`，因为我们的模型期望这种形状 输入。 接下来，我们将此输入发送到模型，并从模型中获得该批量的输出预测，然后将其传递给损失函数，也称为`criterion`； 在那里，它评估了预测班级与实际班级之间的差异。
 
 `loss.backward()`函数计算了梯度（即，误差相对于权重的偏导数），我们调用了`optimizer.step()`函数来更新模型的权重，以适应评估的误差。 `.item()`方法从单个元素张量中拉出标量，因此使用`loss.item()`从批量中获得`error`的标量值，将其累加到所有批量的损失中，最后将损失打印在 时代的结束。
 
@@ -508,7 +508,7 @@ Training loss: 0.2596
         return output
 ```
 
-2.然后，我们将为模型`__init__`添加一个 dropout：
+2.然后，我们将为模型`__init__`添加一个丢弃：
 
 ```py
 >>self.drop = nn.Dropout(p=0.25)
@@ -556,13 +556,13 @@ Training loss: 0.2596
 
 您可以在[这个页面](https://arxiv.org/abs/1207.0580)上了解有关辍学的更多信息。
 
-# 实施功能性 API
+# 实施函数式 API
 
-在本食谱中，我们将探索 PyTorch 中的功能性 API。 这样做将使我们能够编写更简洁的网络架构和组件。 我们将研究功能性 API，并使用功能性 API 定义模型或模型的一部分。
+在本食谱中，我们将探索 PyTorch 中的函数式 API。 这样做将使我们能够编写更简洁的网络架构和组件。 我们将研究函数式 API，并使用函数式 API 定义模型或模型的一部分。
 
 # 怎么做...
 
-在以下步骤中，我们使用现有的神经网络类定义，然后使用功能性 API 重写它：
+在以下步骤中，我们使用现有的神经网络类定义，然后使用函数式 API 重写它：
 
 1.我们将首先进行导入：
 
@@ -588,15 +588,15 @@ Training loss: 0.2596
 
 ```
 
-我们使用功能性 API 重新定义了模型
+我们使用函数式 API 重新定义了模型
 
 # 这个怎么运作...
 
-在此配方中，我们定义了与以前完全相同的网络，但是用`function.relu`和`function.log_softmax`代替了激活函数和 log softmax，这使我们的代码看起来更加简洁明了。
+在此配方中，我们定义了与以前完全相同的网络，但是用`function.relu`和`function.log_softmax`代替了激活函数和对数 softmax，这使我们的代码看起来更加简洁明了。
 
 # 还有更多...
 
-您可以通过使用`functional.linear()`和`functional.dropout()`来控制辍学，从而对线性层使用功能性 API，但是必须注意传递模型状态以指示其处于训练还是评估/预测模式。
+您可以通过使用`functional.linear()`和`functional.dropout()`来控制辍学，从而对线性层使用函数式 API，但是必须注意传递模型状态以指示其处于训练还是评估/预测模式。
 
 # 也可以看看
 

new/pt-ai-fund/3.md

@@ -359,7 +359,7 @@ PyTorch 无法直接处理图像像素，需要将其内容作为张量。 为
 
 # 还有更多...
 
-`transforms.functional`模块中有用于转换的功能性 API。 它们通过提供对转换的细粒度控制来帮助我们建立复杂的转换管道。
+`transforms.functional`模块中有用于转换的函数式 API。 它们通过提供对转换的细粒度控制来帮助我们建立复杂的转换管道。
 
 还有其他有用的转换，例如灰度转换，它使用`Grayscale()`作为输出通道数作为参数。 我们将在下一部分中探索更多的转换。
 
@@ -609,7 +609,7 @@ pip install torchvision==0.x.x
 
 我们将在此食谱中完成模型类的定义：
 
-1.首先，我们将导入`nn.Module`和`torch`功能性 API：
+1.首先，我们将导入`nn.Module`和`torch`函数式 API：
 
 ```py
 >>import torch.nn as nn

new/pt-dl-handson/5.md

@@ -384,7 +384,7 @@ GRU 是一个相对较新的设计，与 LSTM 相比，它效率高且复杂度
 
 #### 架构
 
-我们的模型架构与`RNNClassifier`相似，但是`RNNCell`被 LSTM 或 GRU 单元所替代。 PyTorch 具有功能性 API，可用于将 LSTM 单元或 GRU 单元用作循环网络的最小单元。 借助动态图功能，使用 PyTorch 完全可以遍历序列并调用单元。
+我们的模型架构与`RNNClassifier`相似，但是`RNNCell`被 LSTM 或 GRU 单元所替代。 PyTorch 具有函数式 API，可用于将 LSTM 单元或 GRU 单元用作循环网络的最小单元。 借助动态图功能，使用 PyTorch 完全可以遍历序列并调用单元。
 
 高级 RNN 和简单 RNN 之间的唯一区别在于编码器网络。 `RNNCell`类已替换为`torch.nn.LSTMCell`或`torch.nn.GRUCell`，并且`Encoder`类使用了这些预建单元，而不是我们上次创建的自定义`RNNCell`：
 
@@ -407,7 +407,7 @@ class Encoder(nn.Module):
 
 ##### LSTMCell 和 GRUCell
 
-`LSTMCell`和`GRUCell`的功能性 API 绝对相似，这也正是定制`RNNCell`的方式。 它们接受输入大小和初始化程序的隐藏大小。 `forward`调用接受具有输入大小的微型输入批量，并为该实例创建单元状态和隐藏状态，然后将其传递给下一个执行输入。 在静态图框架中实现这种的实现非常困难，因为该图在整个执行期间都是预先编译的并且是静态的。 循环语句也应作为图节点作为图的一部分。 这需要用户学习那些额外的 op 节点或其他在内部处理循环的功能性 API。
+`LSTMCell`和`GRUCell`的函数式 API 绝对相似，这也正是定制`RNNCell`的方式。 它们接受输入大小和初始化程序的隐藏大小。 `forward`调用接受具有输入大小的微型输入批量，并为该实例创建单元状态和隐藏状态，然后将其传递给下一个执行输入。 在静态图框架中实现这种的实现非常困难，因为该图在整个执行期间都是预先编译的并且是静态的。 循环语句也应作为图节点作为图的一部分。 这需要用户学习那些额外的 op 节点或其他在内部处理循环的函数式 API。
 
 #### LSTM 和 GRU