2021-01-16 17:40:55

new/dl-pt-workshop/4.md

@@ -28,7 +28,7 @@ CNN 是处理图像数据问题时的理想架构。 但是，由于它们通常
 
 ## 为什么将 CNN 用于图像处理？
 
-图像是像素矩阵，那么为什么不将矩阵展平为矢量并使用传统的神经网络架构对其进行处理呢？ 答案是，即使使用最简单的图像，也存在一些像素相关性会改变图像的含义。 例如，猫眼，汽车轮胎甚至物体边缘的表示都是由以某种方式布置的几个像素构成的。 如果我们将图像展平，则这些依赖关系将丢失，传统模型的准确率也会丢失：
+图像是像素矩阵，那么为什么不将矩阵展平为向量并使用传统的神经网络架构对其进行处理呢？ 答案是，即使使用最简单的图像，也存在一些像素相关性会改变图像的含义。 例如，猫眼，汽车轮胎甚至物体边缘的表示都是由以某种方式布置的几个像素构成的。 如果我们将图像展平，则这些依赖关系将丢失，传统模型的准确率也会丢失：
 
 ![Figure 4.1: Representation of a flattened matrix ](img/B15778_04_01.jpg)
 

new/dl-pt-workshop/5.md

@@ -350,13 +350,13 @@ for index, layer in model._modules.items():
 
 为了确定目标图像是否包含与内容图像相同的内容，我们需要检查两个图像中是否存在某些特征。 但是，为了检查目标图像和样式图像的样式表示，必须检查相关性而不是两个图像的特征是否严格存在。 这是因为两个图像的样式特征都不精确，而是近似的。
 
-语法矩阵用于检查这些相关性。 它包括创建一个矩阵，该矩阵查看给定层中不同样式特征的相关性。 这是通过将卷积层的矢量化输出乘以相同的转置矢量化输出来完成的，如下图所示：
+语法矩阵用于检查这些相关性。 它包括创建一个矩阵，该矩阵查看给定层中不同样式特征的相关性。 这是通过将卷积层的向量化输出乘以相同的转置向量化输出来完成的，如下图所示：
 
 ![Figure 5.4: Calculation of the gram matrix ](img/B15778_05_04.jpg)
 
 图 5.4：克矩阵的计算
 
-在上图中，A 表示具有 4x4 尺寸（高度和宽度）的输入样式图像，而 B 表示将图像通过具有五个滤镜的卷积层后的输出。 最后，C 表示语法矩阵的计算，其中左侧的图像表示 B 的矢量化版本，右侧的图像是其转置版本。 从矢量化输出的乘法中，创建一个 5x5 克矩阵，其值表示沿不同通道（过滤器）的样式特征方面的相似性（相关性）。
+在上图中，A 表示具有 4x4 尺寸（高度和宽度）的输入样式图像，而 B 表示将图像通过具有五个滤镜的卷积层后的输出。 最后，C 表示语法矩阵的计算，其中左侧的图像表示 B 的向量化版本，右侧的图像是其转置版本。 从向量化输出的乘法中，创建一个 5x5 克矩阵，其值表示沿不同通道（过滤器）的样式特征方面的相似性（相关性）。
 
 这些相关性可以用于确定与图像的样式表示相关的那些特征，然后可以将其用于更改目标图像。 考虑到在五个不同的层中获得了样式特征，可以安全地假定网络能够从样式图像中检测大小特征，并考虑到必须为每个层创建一个 gram 矩阵。
 
@@ -416,7 +416,7 @@ style_features = features_extractor(style_img, model, \
         style_grams[i] = gram
     ```
 
-    对于每一层，都将获得样式特征矩阵的形状以对其进行矢量化。 接下来，通过将矢量化输出乘以其转置版本来创建 gram 矩阵。
+    对于每一层，都将获得样式特征矩阵的形状以对其进行向量化。 接下来，通过将向量化输出乘以其转置版本来创建 gram 矩阵。
 
 7.  Create an initial target image. This image will be compared against the content and style images later and be changed until the desired similarity is achieved:
 

new/handson-1shot-learn-py/2.md

@@ -202,7 +202,7 @@ Logistic 回归是**判别式分类器**的一种形式，在判别式分类器
 例如，如果我们有 2 个类，分别为 0 和 1，则 2 个示例（`k = 2`）如下：
 <sub>![](img/c7fe5273-416a-40fb-9fe1-d82792a71a7f.png)</sub>
 
-通过将![](img/da9905e0-8ddb-4f7a-a0e2-da4fcb2b81a6.png)变成一键编码矢量，我们将获得以下信息：
+通过将![](img/da9905e0-8ddb-4f7a-a0e2-da4fcb2b81a6.png)变成一键编码向量，我们将获得以下信息：
 
 ![](img/725b5feb-44c8-43ed-8a13-b4c530b590e8.png)
 

new/handson-1shot-learn-py/3.md

@@ -60,7 +60,7 @@
 
 读取和写入操作的关键是权重向量，该权重向量指示要从中读取/写入的行。 控制器分四个阶段生成此权重向量。 每个阶段都会产生一个中间向量，该向量将传递到下一个阶段：
 
-*   第一步是基于内容的寻址，其目的是基于每一行与给定的长度为`C`的给定关键字向量`k[t]`的相似度来生成权重向量。 更精确地说，控制器发出矢量`k[t]`，并使用余弦相似性度量将其与`M[t]`的每一行进行比较。 如下：
+*   第一步是基于内容的寻址，其目的是基于每一行与给定的长度为`C`的给定关键字向量`k[t]`的相似度来生成权重向量。 更精确地说，控制器发出向量`k[t]`，并使用余弦相似性度量将其与`M[t]`的每一行进行比较。 如下：
 
 ![](img/d338c2ca-2226-4543-abc4-5ab988fc0a28.png)
 
@@ -225,8 +225,8 @@ MANN 的读取操作与 NTM 的读取操作非常相似，唯一的区别是此
 
 任务目标如下：
 
-*   NTM 模型显示为`T`时间步长的随机`k`维矢量。
-*   网络的工作是在每个时间步从零矢量输出这些`T[k]`维随机矢量。
+*   NTM 模型显示为`T`时间步长的随机`k`维向量。
+*   网络的工作是在每个时间步从零向量输出这些`T[k]`维随机向量。
 
 执行以下步骤来实现 NTM：
 

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

@@ -241,11 +241,11 @@ The dog sat on the cat -> [2,1,1,1,1,0]
 
 ## 顺序表示
 
-我们将在本书的后面看到，更复杂的神经网络模型，包括 RNN 和 LSTM，不仅将一个矢量作为输入，而且可以采用矩阵形式的整个矢量序列。 因此，为了更好地捕获单词的顺序，从而更好地捕获任何句子的含义，我们能够以一键编码的矢量序列的形式来表示它：
+我们将在本书的后面看到，更复杂的神经网络模型，包括 RNN 和 LSTM，不仅将一个向量作为输入，而且可以采用矩阵形式的整个向量序列。 因此，为了更好地捕获单词的顺序，从而更好地捕获任何句子的含义，我们能够以一键编码的向量序列的形式来表示它：
 
 ![Figure 1.16 – One-hot encoded vectors ](img/B12365_01_16.jpg)
 
-图 1.16 –一键编码矢量
+图 1.16 –一键编码向量
 
 # 总和玛丽
 

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

@@ -250,7 +250,7 @@ x = self.dropout（F.relu（self.fc3（x）））
 
 x = F.log_softmax（self.fc4（x），dim = 1）
 
-分类器中的`forward()`方法是我们在其中应用激活函数并定义在我们的网络中应用 dropout 的位置的方法。 我们的`forward()`方法定义了输入将通过网络的路径。 首先，它获取我们的输入`x`，并将其整形以在网络中使用，并将其转换为一维矢量。 然后，我们将其通过我们的第一个全连接层，并将其包装在 **ReLU** 激活函数中，以使其为非线性。 我们也将其包装在我们的[drop]中，如`__init__`方法中所定义。 我们对网络中的所有其他层重复此过程。
+分类器中的`forward()`方法是我们在其中应用激活函数并定义在我们的网络中应用 dropout 的位置的方法。 我们的`forward()`方法定义了输入将通过网络的路径。 首先，它获取我们的输入`x`，并将其整形以在网络中使用，并将其转换为一维向量。 然后，我们将其通过我们的第一个全连接层，并将其包装在 **ReLU** 激活函数中，以使其为非线性。 我们也将其包装在我们的[drop]中，如`__init__`方法中所定义。 我们对网络中的所有其他层重复此过程。
 
 对于我们的最终预测层，我们将其包装在`log_softmax`层中。 我们将使用它来轻松计算我们的损失函数，如下所示。
 
@@ -488,7 +488,7 @@ preds = len（预测标签）
 
 首先，我们建立一个循环，该循环由希望模型运行的时期数组成。 在这种情况下，我们将选择 100 个纪元。
 
-在此循环中，我们首先将梯度归零（否则，PyTorch 会累积计算梯度），然后对于每个句子/标签对，分别将其转换为词袋矢量和目标。 然后，通过使数据向前通过模型的当前状态，我们计算出该特定句子对的预测输出。
+在此循环中，我们首先将梯度归零（否则，PyTorch 会累积计算梯度），然后对于每个句子/标签对，分别将其转换为词袋向量和目标。 然后，通过使数据向前通过模型的当前状态，我们计算出该特定句子对的预测输出。
 
 然后使用此预测，获取我们的预测标签和实际标签，并在两者上调用定义的`loss_function`，以获取此句子的损失度量。 通过向后调用`backward()`，我们通过模型反向传播此损失，并在优化器上调用`step()`，从而更新模型参数。 最后，我们每 10 个训练步骤打印一次损失：
 

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

@@ -19,11 +19,11 @@
 
 # NLP 的嵌入
 
-单词没有表示其含义的自然方式。 在图像中，我们已经具有丰富的向量表示形式（包含图像中每个像素的值），因此显然具有单词的类似丰富的向量表示形式将是有益的。 当语言的部分以高维向量格式表示时，它们称为**嵌入**。 通过分析单词的语料库，并确定哪些单词经常出现在一起，我们可以获得每个单词的`n`长度向量，它可以更好地表示每个单词与所有其他单词的语义关系。 先前我们看到，我们可以轻松地将单词表示为一键编码的矢量：
+单词没有表示其含义的自然方式。 在图像中，我们已经具有丰富的向量表示形式（包含图像中每个像素的值），因此显然具有单词的类似丰富的向量表示形式将是有益的。 当语言的部分以高维向量格式表示时，它们称为**嵌入**。 通过分析单词的语料库，并确定哪些单词经常出现在一起，我们可以获得每个单词的`n`长度向量，它可以更好地表示每个单词与所有其他单词的语义关系。 先前我们看到，我们可以轻松地将单词表示为一键编码的向量：
 
 ![Figure 3.1 – One-hot encoded vectors ](img/B12365_03_1.jpg)
 
-图 3.1 –一键编码矢量
+图 3.1 –一键编码向量
 
 另一方面，嵌入是长度为`n`（在以下示例中为`n`= 3）的向量，可以采用任何值：
 
@@ -31,11 +31,11 @@
 
 图 3.2 – n = 3 的向量
 
-这些嵌入表示`n`-维空间中的单词向量（其中`n`是嵌入向量的长度），并且在该空间中具有相似向量的单词被认为更相似。 含义。 尽管这些嵌入可以是任何大小，但它们的尺寸通常比 BoW 表示的尺寸低得多。 BOW 表示需要矢量，该矢量的长度为整个语料库的长度，当以一种整体语言查看时，它们可能很快变得非常大。 尽管嵌入的维数足够高以表示单个单词，但它们通常不超过几百个维。 此外，BOW 向量通常非常稀疏，主要由零组成，而嵌入则包含大量数据，并且每个维度都有助于单词的整体表示。 较低的维数和它们不稀疏的事实使得对嵌入执行深度学习比对 BOW 表示执行深度学习要有效得多。
+这些嵌入表示`n`-维空间中的单词向量（其中`n`是嵌入向量的长度），并且在该空间中具有相似向量的单词被认为更相似。 含义。 尽管这些嵌入可以是任何大小，但它们的尺寸通常比 BoW 表示的尺寸低得多。 BOW 表示需要向量，该向量的长度为整个语料库的长度，当以一种整体语言查看时，它们可能很快变得非常大。 尽管嵌入的维数足够高以表示单个单词，但它们通常不超过几百个维。 此外，BOW 向量通常非常稀疏，主要由零组成，而嵌入则包含大量数据，并且每个维度都有助于单词的整体表示。 较低的维数和它们不稀疏的事实使得对嵌入执行深度学习比对 BOW 表示执行深度学习要有效得多。
 
 ## GLoVe
 
-我们可以下载一组预先计算的词嵌入，以演示它们如何工作。 为此，我们将使用**用于词表示的全局矢量**（**GLoVe**）嵌入，[可以从此处下载](https://nlp.stanford.edu/projects/glove/)。 这些嵌入是在非常大的 NLP 数据集上计算的，并且在词共现矩阵上训练了。 这是基于这样的概念，即在一起出现的单词更有可能具有相似的含义。 例如，单词`sun`与单词`hot`相对于单词`cold`更有可能出现，因此`sun`和`hot`被认为更相似。
+我们可以下载一组预先计算的词嵌入，以演示它们如何工作。 为此，我们将使用**用于词表示的全局向量**（**GLoVe**）嵌入，[可以从此处下载](https://nlp.stanford.edu/projects/glove/)。 这些嵌入是在非常大的 NLP 数据集上计算的，并且在词共现矩阵上训练了。 这是基于这样的概念，即在一起出现的单词更有可能具有相似的含义。 例如，单词`sun`与单词`hot`相对于单词`cold`更有可能出现，因此`sun`和`hot`被认为更相似。
 
 我们可以通过检查单个 GLoVe 向量来验证这是正确的：
 
@@ -125,7 +125,7 @@ projection_king_embedding =手套['女王']-手套['女人'] +手套['男人']
 
 # 探索 CBOW
 
-**连续词袋（CBOW）**模型构成 Word2Vec 的一部分–由 Google 创建的模型，用于获取单词的矢量表示 。 通过在非常大的语料库上运行这些模型，我们能够获得单词的详细表示，这些单词表示它们的语义和上下文相似性。 Word2Vec 模型包含两个主要组件：
+**连续词袋（CBOW）**模型构成 Word2Vec 的一部分–由 Google 创建的模型，用于获取单词的向量表示 。 通过在非常大的语料库上运行这些模型，我们能够获得单词的详细表示，这些单词表示它们的语义和上下文相似性。 Word2Vec 模型包含两个主要组件：
 
 *   **CBOW**：给定周围的单词，该模型尝试预测文档中的目标单词。
 *   **SkipGram**：这与 CBOW 相反； 该模型尝试在给定目标词的情况下预测周围的词。
@@ -150,7 +150,7 @@ PyTorch is a {target_word} learning framework
 
 对于我们的 CBOW 模型，我们将使用长度为 2 的窗口，这意味着对于模型的`(X, y)`输入/输出对，我们将使用`[n-2, n-1, n+1, n+2, n]`*，其中`n`是我们要预测的目标词。
 
-使用这些作为模型输入，我们将训练一个包含嵌入层的模型。 此嵌入层自动形成我们语料库中单词的`n`维表示。 但是，首先，使用随机权重初始化该层。 这些参数是使用我们的模型学习的，因此，在我们的模型完成训练之后，可以使用此嵌入层来将我们的语料库编码为嵌入式矢量表示形式。
+使用这些作为模型输入，我们将训练一个包含嵌入层的模型。 此嵌入层自动形成我们语料库中单词的`n`维表示。 但是，首先，使用随机权重初始化该层。 这些参数是使用我们的模型学习的，因此，在我们的模型完成训练之后，可以使用此嵌入层来将我们的语料库编码为嵌入式向量表示形式。
 
 ## CBOW 架构
 
@@ -336,7 +336,7 @@ X = ["is", "a", "learning", "framework"]; y = "deep"
 
     句子拆分=句子。替换（'。'，''）。更低（）。 分裂（）
 
-    句子矢量= make_sentence_vector（sentence_ split，word_dict）
+    句子向量= make_sentence_vector（sentence_ split，word_dict）
 
     projection_array = model（sentence_vector）.data。 numpy（）
 
@@ -646,7 +646,7 @@ This is a small giraffe
 
 ## 实施 TF-IDF
 
-在这里，我们将使用 NLTK 数据集中的 Emma 语料对数据集实施 TF-IDF。 该数据集由 Jane Austen 的书《Emma》中的句子组成，我们希望为这些句子中的每一个计算一个嵌入式矢量表示：
+在这里，我们将使用 NLTK 数据集中的 Emma 语料对数据集实施 TF-IDF。 该数据集由 Jane Austen 的书《Emma》中的句子组成，我们希望为这些句子中的每一个计算一个嵌入式向量表示：
 
 1.  We start by importing our dataset and looping through each of the sentences, removing any punctuation and non-alphanumeric characters (such as astericks). We choose to leave stopwords in our dataset to demonstrate how TF-IDF accounts for these as these words appear in many documents and so have a very low IDF. We create a list of parsed sentences and a set of the distinct words in our corpus:
 

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

 # “第 5 章”：循环神经网络和情感分析
 
-在本章中，我们将研究**循环神经网络**（**RNN**），这是 PyTorch 中基本前馈神经网络的变体，我们在第 1 章“机器学习基础”中学习了如何构建它。 通常，RNN 可用于任何可以将数据表示为序列的任务。 其中包括使用以序列表示的历史数据的时间序列进行股票价格预测之类的事情。 我们通常在 NLP 中使用 RNN，因为可以将文本视为单个单词的序列，并可以对其进行建模。 传统的神经网络将单个矢量作为模型的输入，而 RNN 可以采用整个矢量序列。 如果我们将文档中的每个单词表示为矢量嵌入，则可以将整个文档表示为矢量序列（或 3 阶张量）。 然后，我们可以使用 RNN（以及更复杂的 RNN 形式，称为**长短期记忆**（**LSTM**））从我们的数据中学习。
+在本章中，我们将研究**循环神经网络**（**RNN**），这是 PyTorch 中基本前馈神经网络的变体，我们在第 1 章“机器学习基础”中学习了如何构建它。 通常，RNN 可用于任何可以将数据表示为序列的任务。 其中包括使用以序列表示的历史数据的时间序列进行股票价格预测之类的事情。 我们通常在 NLP 中使用 RNN，因为可以将文本视为单个单词的序列，并可以对其进行建模。 传统的神经网络将单个向量作为模型的输入，而 RNN 可以采用整个向量序列。 如果我们将文档中的每个单词表示为向量嵌入，则可以将整个文档表示为向量序列（或 3 阶张量）。 然后，我们可以使用 RNN（以及更复杂的 RNN 形式，称为**长短期记忆**（**LSTM**））从我们的数据中学习。
 
 在本章中，我们将介绍 RNN 的基础知识和更高级的 LSTM。 然后，我们将研究情绪分析，并通过一个实际的示例来研究如何使用 PyTorch 构建 LSTM 对文档进行分类。 最后，我们将在简单的云应用程序平台 Heroku 上托管我们的简单模型，这将使​​我们能够使用我们的模型进行预测。
 
@@ -295,9 +295,9 @@ encode_sentences [0]
 
 ## 模型架构
 
-我们的模型将由几个主要部分组成。 除了许多神经网络通用的输入和输出层之外，我们首先需要一个**嵌入层**。 这样我们的模型就可以学习正在训练的单词的矢量表示形式。 我们可以选择使用预先计算的嵌入（例如 GLoVe），但是出于演示目的，我们将训练自己的嵌入层。 我们的输入序列通过输入层进行馈送，并作为矢量序列出现。
+我们的模型将由几个主要部分组成。 除了许多神经网络通用的输入和输出层之外，我们首先需要一个**嵌入层**。 这样我们的模型就可以学习正在训练的单词的向量表示形式。 我们可以选择使用预先计算的嵌入（例如 GLoVe），但是出于演示目的，我们将训练自己的嵌入层。 我们的输入序列通过输入层进行馈送，并作为向量序列出现。
 
-将这些向量序列送入我们的 **LSTM 层**。 如本章前面所详细解释的那样，LSTM 层从我们的嵌入序列中顺序学习，并输出代表 LSTM 层最终隐藏状态的单个矢量输出。 在最终输出节点预测值介于 0 到 1 之间之前，该最终隐藏状态最终通过另一个**隐藏层**传递，指示输入序列是肯定还是否定。 这意味着我们的模型架构看起来像这样：
+将这些向量序列送入我们的 **LSTM 层**。 如本章前面所详细解释的那样，LSTM 层从我们的嵌入序列中顺序学习，并输出代表 LSTM 层最终隐藏状态的单个向量输出。 在最终输出节点预测值介于 0 到 1 之间之前，该最终隐藏状态最终通过另一个**隐藏层**传递，指示输入序列是肯定还是否定。 这意味着我们的模型架构看起来像这样：
 
 ![Figure 5.17 – Model architecture ](img/B12365_05_17.jpg)
 
@@ -317,7 +317,7 @@ self.n_layers = n_layers
 
 self.n_hidden = n_hidden
 
-然后，我们定义网络的每个层。 首先，我们定义嵌入层，该层的词汇量为字长，嵌入向量的大小为`n_embed`超参数。 我们的 LSTM 层是使用嵌入层的输出矢量大小，模型的隐藏状态的长度以及 LSTM 层将具有的层数来定义的。 我们还添加了一个参数来指定可以对 LSTM 进行批量数据训练，并添加一个参数以允许我们通过辍学实现网络正则化。 我们用概率`drop_p`（将在模型创建时指定的超参数）定义另外一个辍学层，以及对最终全连接层和输出/预测节点的定义（具有 S 型激活函数） ：
+然后，我们定义网络的每个层。 首先，我们定义嵌入层，该层的词汇量为字长，嵌入向量的大小为`n_embed`超参数。 我们的 LSTM 层是使用嵌入层的输出向量大小，模型的隐藏状态的长度以及 LSTM 层将具有的层数来定义的。 我们还添加了一个参数来指定可以对 LSTM 进行批量数据训练，并添加一个参数以允许我们通过辍学实现网络正则化。 我们用概率`drop_p`（将在模型创建时指定的超参数）定义另外一个辍学层，以及对最终全连接层和输出/预测节点的定义（具有 S 型激活函数） ：
 
 self.embedding = nn.Embedding（n_vocab，n_embed）
 

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

@@ -23,11 +23,11 @@ CNN 的基础来自计算机视觉领域，但可以从概念上扩展到 NLP。
 
 CNN 的一个很好的类比是人的思维如何处理图片而不是句子。 考虑句子`This is a sentence about a cat.`。 当您阅读该句子时，您将阅读第一个单词，然后阅读第二个单词，依此类推。 现在，考虑一张猫的照片。 通过先看第一个像素，再看第二个像素，吸收图片中的信息是愚蠢的。 取而代之的是，当我们看着某物时，我们会立即感知到整个图像，而不是一个序列。
 
-例如，如果我们对图像进行黑白表示（在本例中为数字 1），则可以看到可以将其转换为矢量表示，其中每个像素的颜色由 0 或 a 表示 1：
+例如，如果我们对图像进行黑白表示（在本例中为数字 1），则可以看到可以将其转换为向量表示，其中每个像素的颜色由 0 或 a 表示 1：
 
 ![Figure 6.1 – Vector representation of an image](img/B12365_06_01.jpg)
 
-图 6.1 –图像的矢量表示
+图 6.1 –图像的向量表示
 
 但是，如果我们从机器学习的角度考虑这一问题并将此向量视为模型的特征，那么单个像素为黑色或白色的事实是否会使图像具有给定位数的可能性更大或更小？ 右上角的白色像素会使图片更可能是四或七吗？ 想象一下，如果我们试图检测更复杂的事物，例如图片是狗还是猫。 屏幕中间的棕色像素会使照片更有可能是猫还是狗？ 直观地，我们看到，在图像分类方面，单个像素值没有多大意义。 但是，我们感兴趣的是像素彼此之间的关系。
 
@@ -61,11 +61,11 @@ CNN 背后的基本概念是卷积。 **卷积**本质上是一个滑动窗口
 
 ## 用于 NLP 的卷积
 
-正如我们在本书中多次看到的那样，我们可以将单个单词在数字上表示为矢量，将整个句子和文档表示为矢量序列。 当我们将句子表示为向量序列时，我们可以将其表示为矩阵。 如果我们具有给定句子的矩阵表示形式，我们会立即注意到，这类似于我们在图像卷积中卷积的图像。 因此，只要我们可以将文本表示为矩阵，就可以以类似于图像的方式将卷积应用于 NLP。
+正如我们在本书中多次看到的那样，我们可以将单个单词在数字上表示为向量，将整个句子和文档表示为向量序列。 当我们将句子表示为向量序列时，我们可以将其表示为矩阵。 如果我们具有给定句子的矩阵表示形式，我们会立即注意到，这类似于我们在图像卷积中卷积的图像。 因此，只要我们可以将文本表示为矩阵，就可以以类似于图像的方式将卷积应用于 NLP。
 
 让我们首先考虑使用这种方法的基础。 以前查看 n-gram 时，我们发现句子中一个单词的上下文取决于其前面的单词和后面的单词。 因此，如果我们能够以允许我们捕获一个单词与其周围单词的关系的方式对一个句子进行卷积，那么我们就可以从理论上检测语言中的模式并将其用于更好地对句子进行分类。
 
-还值得注意的是，我们的卷积方法与图像卷积略有不同。 在我们的图像矩阵中，我们希望捕获相对于周围像素的单个像素的上下文，而在句子中，我们希望捕获相对于其周围其他向量的整个单词矢量的上下文。 因此，在 NLP 中，我们希望在整个单词向量上而不是在单词向量内执行卷积。 下图中演示了。
+还值得注意的是，我们的卷积方法与图像卷积略有不同。 在我们的图像矩阵中，我们希望捕获相对于周围像素的单个像素的上下文，而在句子中，我们希望捕获相对于其周围其他向量的整个单词向量的上下文。 因此，在 NLP 中，我们希望在整个单词向量上而不是在单词向量内执行卷积。 下图中演示了。
 
 我们首先将句子表示为单个单词向量：
 
@@ -511,7 +511,7 @@ tokenized = [nlp.tokenizer（句子）中 tok 的 tok.text]
 
 张量= tensor.unsqueeze（0）
 
-我们首先将输入语句传递到令牌生成器中以获取令牌列表。 然后，如果此句子的长度小于最小句子长度，则将其添加到该句子中。 然后，在最终创建由这些索引的向量组成的张量之前，我们将使用词汇表获取所有这些单独标记的索引。 我们将其传递给我们的 GPU（如果可用），然后取消压缩输出，因为我们的模型需要三维张量输入而不是单个矢量。
+我们首先将输入语句传递到令牌生成器中以获取令牌列表。 然后，如果此句子的长度小于最小句子长度，则将其添加到该句子中。 然后，在最终创建由这些索引的向量组成的张量之前，我们将使用词汇表获取所有这些单独标记的索引。 我们将其传递给我们的 GPU（如果可用），然后取消压缩输出，因为我们的模型需要三维张量输入而不是单个向量。
 
 接下来，我们做出预测：
 
@@ -523,7 +523,7 @@ pred_index = labels.vocab.itos [预测]
 
 返回 pred_index
 
-我们首先将模型设置为评估模式（与评估步骤一样），以便不计算模型的梯度并且不调整权重。 然后，我们将句子张量传递到模型中，并获得长度为`6`的预测矢量，该预测矢量由六个类别中每个类别的单独预测组成。 然后，我们获取最大预测值的索引，并在标签索引中使用该索引以返回预测类的名称。
+我们首先将模型设置为评估模式（与评估步骤一样），以便不计算模型的梯度并且不调整权重。 然后，我们将句子张量传递到模型中，并获得长度为`6`的预测向量，该预测向量由六个类别中每个类别的单独预测组成。 然后，我们获取最大预测值的索引，并在标签索引中使用该索引以返回预测类的名称。
 
 为了进行预测，我们只需在任何给定的句子上调用`Forecast_class()`函数。 让我们使用以下代码：
 

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

@@ -39,7 +39,7 @@
 为了训练一个序列到序列模型，该模型捕获输入句子的上下文并将其转换为输出句子，我们将实质上训练两个较小的模型，使我们能够做到这一点：
 
 *   **编码器**模型，其中捕获句子的上下文并将其作为单个上下文向量输出
-*   **解码器**，它使用原始句子的上下文矢量表示并将其翻译成另一种语言
+*   **解码器**，它使用原始句子的上下文向量表示并将其翻译成另一种语言
 
 因此，实际上，我们完整的序列到序列翻译模型实际上将如下所示：
 

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

@@ -210,7 +210,7 @@ E0 = Embedding with Time Signal
 x0 + t0 = E0
 ```
 
-我们的模型为每个位置学习不同的位置编码矢量（`t`0，`t`1，依此类推），然后我们将应用于输入句子中的每个单词，然后再输入 甚至输入我们的编码器：
+我们的模型为每个位置学习不同的位置编码向量（`t`0，`t`1，依此类推），然后我们将应用于输入句子中的每个单词，然后再输入 甚至输入我们的编码器：
 
 ![Figure 9.8 – Adding input to the encoder ](img/B12365_09_8.jpg)
 
@@ -558,9 +558,9 @@ A: No
 
 图 9.24 –模型的架构
 
-我们的模型将要回答的问题和包含问题的文档作为输入。 然后将它们传递给嵌入层以形成每个张量的基于张量的表示，然后传递给编码层以形成进一步的缩减的矢量表示。
+我们的模型将要回答的问题和包含问题的文档作为输入。 然后将它们传递给嵌入层以形成每个张量的基于张量的表示，然后传递给编码层以形成进一步的缩减的向量表示。
 
-现在，我们的问题和文档都表示为矢量，我们的匹配层将尝试确定在文档矢量中应寻找哪些位置以获得问题的答案。 这是通过一种注意机制来完成的，在该机制中，我们的问题确定了我们应该查看文档向量的哪些部分才能回答问题。
+现在，我们的问题和文档都表示为向量，我们的匹配层将尝试确定在文档向量中应寻找哪些位置以获得问题的答案。 这是通过一种注意机制来完成的，在该机制中，我们的问题确定了我们应该查看文档向量的哪些部分才能回答问题。
 
 最后，我们的融合层旨在捕获匹配层的长期依赖性，合并从匹配层收到的所有信息，并执行解码步骤以获得最终答案。 该层采用双向 RNN 的形式，它将我们的匹配层输出解码为最终预测。 我们在这里使用多类分类预测两个值 –起点和终点。 这代表了我们文档中包含初始问题答案的起点和终点。 如果我们的文档包含 100 个单词，而单词 40 和单词 50 之间的句子包含我们问题的答案，则我们的模型将理想地预测起点和终点的值分别为 40 和 50。 这些值然后可以很容易地用于从输入文档中返回相关段落。
 
@@ -601,7 +601,7 @@ What day is it today?
 我们可以在此处进行以下观察：
 
 *   如前所述，模型的**输入**是问题，答案和上下文，也是向右移动的问题和答案。
-*   我们的**嵌入**层跨字符和单词的 GLoVe 嵌入式矢量进行卷积，以创建组合的表示形式。
+*   我们的**嵌入**层跨字符和单词的 GLoVe 嵌入式向量进行卷积，以创建组合的表示形式。
 *   我们的**编码器**由 LSTM 组成，需要引起注意。
 *   我们的**输出**也是基于 RNN 的，并且一次将我们的输出解码一个单词，以产生最终的问题和答案。
 

new/pt-ai-fund/1.md

@@ -80,7 +80,7 @@ import numpy
 以下是各种张量：
 
 *   **标量**：这是一个零阶张量。 标量的示例是 <sub>![](img/28a0205b-6df0-43e3-aa3d-636e2874d00f.png)</sub> 。
-*   **矢量**：这是一阶张量； 以下是向量的示例：
+*   **向量**：这是一阶张量； 以下是向量的示例：
 
 ![](img/bc4636e9-4110-4074-8ac5-420cdab8ce74.png)
 
@@ -88,7 +88,7 @@ import numpy
 
 ![](img/dc9d1b48-fc56-4787-8afe-ff809ea12284.png)
 
-*   **张量：**这些高于二阶张量，如以下示例所示：
+*   **张量**：这些高于二阶张量，如以下示例所示：
 
 ![](img/ccc2bd36-f510-4adf-ac38-c7c185d40e53.png)
 
@@ -426,7 +426,7 @@ tensor([[2., 2., 2.],
 
 # 探索渐变
 
-让我们简要介绍一下什么是渐变。 为此，我们需要首先了解什么是梯度下降。 在机器学习问题中，我们提供一个输入和期望的输出对，并要求我们的模型概括给定输入和输出对之间的关​​系。 但是有时模型会得知其预测会与期望的输出相去甚远（这种差异称为**损耗**）。 那么什么是梯度下降？
+让我们简要介绍一下什么是渐变。 为此，我们需要首先了解什么是梯度下降。 在机器学习问题中，我们提供一个输入和期望的输出对，并要求我们的模型概括给定输入和输出对之间的关​​系。 但是有时模型会得知其预测会与期望的输出相去甚远（这种差异称为**损失**）。 那么什么是梯度下降？
 
 **梯度下降**是一种优化算法，用于通过在梯度的负值所定义的最陡下降方向上反复移动来使函数最小化。 我们在训练模型时会使用它，以使损失最小化。 它用于查找使成本或损失函数最小化的函数参数值（机器学习中的系数或权重）。
 
@@ -640,9 +640,9 @@ tensor([[1., 2., 3.],
 
 在前面的食谱中，我们基于网络架构操纵了张量以改变其形状，研究了三种不同的方法，每种方法都适用于不同的用例：
 
-*   `.reshape()` **方法**：`.reshape(a, b)`返回一个新张量，该张量具有与原始张量`(a, b)`相同的数据，因为它会将数据复制到内存的另一部分； `.reshape()`可以在连续和非连续张量上运行，并且可以返回原始张量的副本或视图。
-*   `.resize()` **方法**：`.resize_(a, b)`返回相同的张量，而不创建具有新给定形状的副本。 但是我们应该记住，如果新形状产生的元素少于原始张量，那么它将不会引发任何错误，并且某些元素将从张量中删除，但不会从内存中删除。 如果新形状产生的元素多于原始张量，则新元素将在内存中未初始化而不会引发任何错误。
-*   `.view()` **方法**：`.view(a, b)`将返回一个新的张量，其张量与权重为（a，b）的数据相同； `.view()`只能在连续的张量上运行，并返回与输入相同的存储。
+*   `.reshape()`方法：`.reshape(a, b)`返回一个新张量，该张量具有与原始张量`(a, b)`相同的数据，因为它会将数据复制到内存的另一部分； `.reshape()`可以在连续和非连续张量上运行，并且可以返回原始张量的副本或视图。
+*   `.resize()`方法：`.resize_(a, b)`返回相同的张量，而不创建具有新给定形状的副本。 但是我们应该记住，如果新形状产生的元素少于原始张量，那么它将不会引发任何错误，并且某些元素将从张量中删除，但不会从内存中删除。 如果新形状产生的元素多于原始张量，则新元素将在内存中未初始化而不会引发任何错误。
+*   `.view()`方法：`.view(a, b)`将返回一个新的张量，其张量与权重为（a，b）的数据相同； `.view()`只能在连续的张量上运行，并返回与输入相同的存储。
 
 # 还有更多...
 

new/pt-ai-fund/2.md

@@ -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 的向量。
 
 以下是来自数据集的示例：
 

new/pt-ai-fund/4.md

@@ -605,7 +605,7 @@ class BiLSTMClassifier(nn.Module):
 
 在此配方中，我们在 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,:,:]`。 串联后，在挤出额外的尺寸后，我们将隐藏的矢量传递到全连接层中。
+在`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,:,:]`。 串联后，在挤出额外的尺寸后，我们将隐藏的向量传递到全连接层中。
 
 # 还有更多...
 

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 生成器的架构图：
 
@@ -116,11 +116,11 @@ def forward(self, input):
 
 在此食谱中，我们进行了变换以将图像转换为张量并对其进行归一化，就像在第 3 章，“用于计算机视觉的卷积神经网络”中所做的一样。 然后，我们确定了机器上的设备：CPU 或 GPU。 然后，我们定义了从`nn.Module`类继承的`Generator_model`类，就像在所有以前的架构中所做的一样。
 
-在构造函数中，我们传递了`z_dim`参数，这是我们的噪声矢量大小。 然后，我们定义了一个全连接单元`self.fc`，我们将噪声矢量传递给该单元，并为其提供了`256 * 7 * 7`输出。 然后，我们定义了一个称为`self.gen`的`nn.Sequential`单元，其中包含用于定义生成器的关键组件。 我们使用 PyTorch 中提供的`nn.ConvTranspose2d`，`nn.BatchNorm2d`和`nn.LeakyReLU`使用一组反卷积，批处理规范化和激活层。 `ConvTranspose2d`接受输入通道，输出通道，内核大小，步幅和填充等参数。 `BatchNorm2d`接受上一层的要素/通道数作为其参数，而 LeakyReLU 接受负斜率的角度。
+在构造函数中，我们传递了`z_dim`参数，这是我们的噪声向量大小。 然后，我们定义了一个全连接单元`self.fc`，我们将噪声向量传递给该单元，并为其提供了`256 * 7 * 7`输出。 然后，我们定义了一个称为`self.gen`的`nn.Sequential`单元，其中包含用于定义生成器的关键组件。 我们使用 PyTorch 中提供的`nn.ConvTranspose2d`，`nn.BatchNorm2d`和`nn.LeakyReLU`使用一组反卷积，批处理规范化和激活层。 `ConvTranspose2d`接受输入通道，输出通道，内核大小，步幅和填充等参数。 `BatchNorm2d`接受上一层的要素/通道数作为其参数，而 LeakyReLU 接受负斜率的角度。
 
 与 ReLU 不同，LeakyReLU 允许传递小的梯度信号以获取负值。 它使来自鉴别器的梯度流入发生器。 我们在输出层中使用了 tanh 激活，但是从 DCGAN 论文中我们观察到，使用有界激活可以使模型学会快速饱和并覆盖训练分布的色彩空间。 tanh 的对称性在这里可能是一个优势，因为网络应该以对称方式处理较深的颜色和较浅的颜色。
 
-让我们看一下`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`张量； 这些只是我们需要的尺寸。 然后，我们创建生成器对象并将其移动到设备。
+让我们看一下`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`张量； 这些只是我们需要的尺寸。 然后，我们创建生成器对象并将其移动到设备。
 
 # 也可以看看
 
@@ -393,13 +393,13 @@ derror_real = criterion(d_output, label)
 derror_real.backward()
 ```
 
-18.  现在我们将创建一个噪声矢量：
+18.  现在我们将创建一个噪声向量：
 
 ```py
 noise = torch.randn(size, z_dim, device=device)
 ```
 
-19.  接下来，我们将噪声矢量传递给生成器：
+19.  接下来，我们将噪声向量传递给生成器：
 
 ```py
 fake_images = generator(noise)
@@ -547,7 +547,7 @@ Epoch : | 005 / 050 |
 
 我们还创建了固定噪声，用于可视化 GAN 模型在迭代过程中的改进。 我们使用 ADAM 优化器分别更新了生成器和鉴别器`goptimizer`和`doptimizer`的权重。 然后，我们进行了准备以存储一些模型指标，以查看模型在迭代过程中的变化，然后开始训练循环。
 
-我们遍历了每个迷你批量并开始训练鉴别器。 我们仅从 MNIST 数据集中获取图像，然后使用`real_images = data[0].to(device)`将其移动到设备中； 由于图像全部来自 MNIST 数据集，因此我们知道它们是真实的，因此我们创建了与小批量相同大小的标签矢量，并用真实图像标签 1 进行填充。然后，将这些真实图像传递到 预测的鉴别符，然后使用此预测从准则中得出误差`derror_real`并计算梯度。 然后，我们创建了相等数量的噪声矢量，并将它们传递给生成器以生成图像，然后将这些生成的图像传递给鉴别器以获取预测，然后从准则`derror_fake`中获取误差。 然后，我们再次进行此操作以计算和累积梯度。 然后，我们从真实图像和伪图像中获得了误差之和，以得出总的鉴别器误差，并更新鉴别器的权重。
+我们遍历了每个迷你批量并开始训练鉴别器。 我们仅从 MNIST 数据集中获取图像，然后使用`real_images = data[0].to(device)`将其移动到设备中； 由于图像全部来自 MNIST 数据集，因此我们知道它们是真实的，因此我们创建了与小批量相同大小的标签向量，并用真实图像标签 1 进行填充。然后，将这些真实图像传递到 预测的鉴别符，然后使用此预测从准则中得出误差`derror_real`并计算梯度。 然后，我们创建了相等数量的噪声向量，并将它们传递给生成器以生成图像，然后将这些生成的图像传递给鉴别器以获取预测，然后从准则`derror_fake`中获取误差。 然后，我们再次进行此操作以计算和累积梯度。 然后，我们从真实图像和伪图像中获得了误差之和，以得出总的鉴别器误差，并更新鉴别器的权重。
 
 然后，我们开始训练生成器，并且生成器应该能够欺骗鉴别器。 生成器必须纠正鉴别者正确预测生成的图像为假的情况。 因此，只要来自鉴别器的预测将生成的图像标记为伪造，就会增加生成器损耗`gerror`。 然后，我们计算梯度并更新发生器权重。
 
@@ -644,7 +644,7 @@ pip install numpy
 
 在本食谱中，我们使用 matplotlib 绘制图形和图像。 我们使用`figure()`和`title()`方法设置图形尺寸和标题，然后使用`plot()`方法绘制发生器和鉴别器损耗。 我们还使用`xlabel`和`ylabel`方法添加了`x`和*和*标签。 我们还使用`legend()`方法为图添加了图例，最后使用`show()`方法显示了图。
 
-我们遍历训练期间保存在`image_list`中的图像，并使用 NumPy 的`transpose()`方法以所需顺序固定图像的尺寸。 `image_list`中的图像是使用`torchvision.util.make_grid()`方法生成的，我们根据噪声矢量创建了生成图像的网格。
+我们遍历训练期间保存在`image_list`中的图像，并使用 NumPy 的`transpose()`方法以所需顺序固定图像的尺寸。 `image_list`中的图像是使用`torchvision.util.make_grid()`方法生成的，我们根据噪声向量创建了生成图像的网格。
 
 # 还有更多...
 
@@ -733,7 +733,7 @@ Nvidia 最初执行 PGGAN 的过程要花一到两个月的时间。 但是，
 
 # 这个怎么运作...
 
-在此配方中，我们加载了在`celebAHQ`数据集上训练的 PGGAN 预训练模型； 为此，我们使用了`torch.hub`中的`load()`方法。 然后，我们定义了创建和生成尺寸为`num_images x 512`的噪声矢量所需的图像数量，因为此模型使用大小为 512 的噪声矢量进行训练，所有噪声矢量都由`buildNoiseData()`方法内部处理 在模型对象中可用。
+在此配方中，我们加载了在`celebAHQ`数据集上训练的 PGGAN 预训练模型； 为此，我们使用了`torch.hub`中的`load()`方法。 然后，我们定义了创建和生成尺寸为`num_images x 512`的噪声向量所需的图像数量，因为此模型使用大小为 512 的噪声向量进行训练，所有噪声向量都由`buildNoiseData()`方法内部处理 在模型对象中可用。
 
 `model.test()`方法生成了我们用来制作网格的图像。 钳位方法将所有值限制在`min`和`max`定义的范围内。 `.cpu()`方法将生成的图像移至 CPU，我们使用`permute`固定尺寸。 最后，`plt.imshow()`显示了我们创建的网格。
 

new/pt-dl-handson/1.md

@@ -278,7 +278,7 @@ RNN 是最常见的深度学习算法之一，它们席卷全球。 我们现在
 
 ![Recursive neural networks](img/B09475_01_14.jpg)
 
-图 1.14：递归网络中单词的矢量表示
+图 1.14：递归网络中单词的向量表示
 
 #### 卷积神经网络
 
@@ -460,7 +460,7 @@ tensor([[0.5594, 0.8875, 0.9234, 1.1294],
 
 `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 张量。
 

new/pt-dl-handson/3.md

@@ -249,7 +249,7 @@ pip install torchtext
 
 `torchtext`有两个主要模块：`Data`模块和`Datasets`模块。 如官方文档所述，`Data`模块承载了多个数据加载器，抽象和文本迭代器（包括词汇和单词向量），而`Datasets`模块则为常见的 NLP 任务预先构建了数据集。
 
-在此示例中，我们将使用`Data`模块加载以制表符分隔的数据，并使用 spaCy 的令牌化对其进行预处理，然后再将文本转换为矢量。
+在此示例中，我们将使用`Data`模块加载以制表符分隔的数据，并使用 spaCy 的令牌化对其进行预处理，然后再将文本转换为向量。
 
 ```py
 spacy_en = spacy.load('en')
@@ -276,7 +276,7 @@ train, val, test = data.TabularDataset.splits(
 
 `Field`的官方文档详细介绍了所有参数。 因为我们只有一个单词作为标签，所以`LABEL`字段的`sequential`设置为`False`。 这对于不同的实例非常方便，尤其是在语言翻译（输入和输出均为序列）的情况下。
 
-`Field`的另一个重要参数是`use_vocab`，默认情况下将其设置为`True`。 此参数告诉`Field`实例是否对数据使用词汇表生成器。 在示例数据集中，我们将输入和输出都用作单词，甚至将输出转换为单词向量也是有意义的，但是在几乎所有情况下，输出将是单编码的矢量或将其数字化。 在`torchtext`不会尝试将其转换为单词嵌入词典的索引的情况下，将`use_vocab`设置为`False`很有帮助。
+`Field`的另一个重要参数是`use_vocab`，默认情况下将其设置为`True`。 此参数告诉`Field`实例是否对数据使用词汇表生成器。 在示例数据集中，我们将输入和输出都用作单词，甚至将输出转换为单词向量也是有意义的，但是在几乎所有情况下，输出将是单编码的向量或将其数字化。 在`torchtext`不会尝试将其转换为单词嵌入词典的索引的情况下，将`use_vocab`设置为`False`很有帮助。
 
 一旦使用`Field`设置了预处理机制，我们就可以将它们与数据位置一起传递给`DataLoader`。 现在`DataLoader`负责从磁盘加载数据并将其通过预处理管道。
 

new/pt-dl-handson/5.md

@@ -94,7 +94,7 @@ array([[O., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
 
 #### 词嵌入
 
-使用自然语言（或由离散的单个单元组成的任何序列）的标准方法是将每个单词转换为一个热编码矢量，并将其用于网络的后期。 这种方法的明显缺点是，随着词汇量的增加，输入层的大小也会增加。
+使用自然语言（或由离散的单个单元组成的任何序列）的标准方法是将每个单词转换为一个热编码向量，并将其用于网络的后期。 这种方法的明显缺点是，随着词汇量的增加，输入层的大小也会增加。
 
 词嵌入是减少阵列或张量维数的数十年历史的想法。 **潜在 Dirichlet 分配**（**LDA**）和**潜在语义分析**（**LSA**）是我们用来进行嵌入的两个此类示例。 但是，在 Facebook 研究科学家 Tomas Mikolov 和他的团队于 2013 年实施 word2vec 之后，就开始将嵌入视为前提。
 

new/pt-dl-handson/6.md

@@ -2,7 +2,7 @@
 
 生成网络得到了加州理工学院理工学院本科物理学教授理查德·费曼（Richard Feynman）和诺贝尔奖获得者的名言的支持：*“我无法创造，我无法理解。”* 生成网络是拥有可以理解世界并在其中存储知识的系统的最有前途的方法之一。 顾名思义，生成网络学习真实数据分布的模式，并尝试生成看起来像来自此真实数据分布的样本的新样本。
 
-生成模型是无监督学习的子类别，因为它们通过尝试生成样本来学习基本模式。 他们通过推送低维潜矢量和参数矢量来了解生成图像所需的重要特征，从而实现了这一目的。 网络在生成图像时获得的知识本质上是关于系统和环境的知识。 从某种意义上说，我们通过要求网络做某事来欺骗网络，但是网络必须在不了解自己正在学习的情况下学习我们的需求。
+生成模型是无监督学习的子类别，因为它们通过尝试生成样本来学习基本模式。 他们通过推送低维潜向量和参数向量来了解生成图像所需的重要特征，从而实现了这一目的。 网络在生成图像时获得的知识本质上是关于系统和环境的知识。 从某种意义上说，我们通过要求网络做某事来欺骗网络，但是网络必须在不了解自己正在学习的情况下学习我们的需求。
 
 生成网络已经在不同的深度学习领域，特别是在计算机视觉领域显示出了可喜的成果。 去模糊或提高图像的分辨率，图像修补以填充缺失的片段，对音频片段进行降噪，从文本生成语音，自动回复消息以及从文本生成图像/视频是一些研究的活跃领域。
 
@@ -31,7 +31,7 @@ GAN 的创建者 Ian Goodfellow 描述了几类生成网络：
 *   自回归模型
 *   鹅
 
-自回归模型是从先前的值推断当前值的模型，正如我们在第 5 章，*顺序数据处理*中使用 RNN 所讨论的那样。 **可变自动编码器**（**VAE**）是自动编码器的一种变体，由编码器和解码器组成，其中编码器将输入编码为低维潜在空间矢量， 解码器解码潜矢量以生成类似于输入的输出。
+自回归模型是从先前的值推断当前值的模型，正如我们在第 5 章，*顺序数据处理*中使用 RNN 所讨论的那样。 **可变自动编码器**（**VAE**）是自动编码器的一种变体，由编码器和解码器组成，其中编码器将输入编码为低维潜在空间向量， 解码器解码潜向量以生成类似于输入的输出。
 
 整个研究界都同意，GAN 是人工智能世界中的下一个重要事物之一。 GAN 具有生成网络和对抗网络，并且两者相互竞争以生成高质量的输出图像。 GAN 和自回归模型都基于不同的原理工作，但是每种方法都有其自身的优缺点。 在本章中，我们将使用这两种方法开发一个基本示例。
 

new/pt-tut-17/04.md

@@ -115,9 +115,9 @@ tensor([True, True])
 
 ```
 
-### 可选阅读-使用`autograd`的矢量演算（docs / modern-java-zh /
+### 可选阅读-使用`autograd`的向量演算（docs / modern-java-zh /
 
-从数学上讲，如果您具有矢量值函数\（\ vec {y} = f（\ vec {x}）\），则\（\ vec {y} \）相对于\（\ vec {x } \）是雅可比矩阵\（J \）：
+从数学上讲，如果您具有向量值函数\（\ vec {y} = f（\ vec {x}）\），则\（\ vec {y} \）相对于\（\ vec {x } \）是雅可比矩阵\（J \）：
 
 \[\begin{split}J = \left(\begin{array}{cc} \frac{\partial \bf{y}}{\partial x_{1}} & ... & \frac{\partial \bf{y}}{\partial x_{n}} \end{array}\right) = \left(\begin{array}{ccc} \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{1}}{\partial x_{n}}\\ \vdots & \ddots & \vdots\\ \frac{\partial y_{m}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}} \end{array}\right)\end{split}\]
 

new/pt-tut-17/16.md

@@ -117,7 +117,7 @@ bias = torch.zeros(10, requires_grad=True)
 
 ```
 
-由于 PyTorch 具有自动计算梯度的功能，我们可以将任何标准的 Python 函数（或可调用对象）用作模型！ 因此，我们只需编写一个普通矩阵乘法和广播加法即可创建一个简单的线性模型。 我们还需要激活函数，因此我们将编写并使用 <cite>log_softmax</cite> 。 请记住：尽管 PyTorch 提供了许多预写的损失函数，激活函数等，但是您可以使用纯 Python 轻松编写自己的函数。 PyTorch 甚至会自动为您的功能创建快速 GPU 或矢量化的 CPU 代码。
+由于 PyTorch 具有自动计算梯度的功能，我们可以将任何标准的 Python 函数（或可调用对象）用作模型！ 因此，我们只需编写一个普通矩阵乘法和广播加法即可创建一个简单的线性模型。 我们还需要激活函数，因此我们将编写并使用 <cite>log_softmax</cite> 。 请记住：尽管 PyTorch 提供了许多预写的损失函数，激活函数等，但是您可以使用纯 Python 轻松编写自己的函数。 PyTorch 甚至会自动为您的功能创建快速 GPU 或向量化的 CPU 代码。
 
 ```py
 def log_softmax(x):

new/pt-tut-17/22.md

@@ -16,7 +16,7 @@ GAN 是用于教授 DL 模型以捕获训练数据分布的框架，因此我们
 
 现在，让我们从鉴别符开始定义一些在整个教程中使用的符号。 令\（x \）为代表图像的数据。 \（D（x）\）是鉴别器网络，其输出\（x \）来自训练数据而不是生成器的（标量）概率。 在这里，由于我们要处理图像，因此\（D（x）\）的输入是 CHW 大小为 3x64x64 的图像。 直观地，当\（x \）来自训练数据时，\（D（x）\）应该为高，而当\（x \）来自发生器时，它应该为低。 \（D（x）\）也可以被认为是传统的二进制分类器。
 
-对于生成器的表示法，令\（z \）是从标准正态分布中采样的潜在空间矢量。 \（G（z）\）表示将隐向量\（z \）映射到数据空间的生成器函数。 \（G \）的目标是估计训练数据来自（\（p_ {data} \））的分布，以便它可以从该估计分布（\（p_g \））生成假样本。
+对于生成器的表示法，令\（z \）是从标准正态分布中采样的潜在空间向量。 \（G（z）\）表示将隐向量\（z \）映射到数据空间的生成器函数。 \（G \）的目标是估计训练数据来自（\（p_ {data} \））的分布，以便它可以从该估计分布（\（p_g \））生成假样本。
 
 因此，\（D（G（z））\）是发生器\（G \）的输出是真实图像的概率（标量）。 如 [Goodfellow 的论文](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)中所述，\（D \）和\（G \）玩一个 minimax 游戏，其中\（D \）试图最大化其正确分类实物和假物（\（logD（ x）\）），并且\（G \）尝试最小化\（D \）预测其输出为假的概率（\（log（1-D（G（g（x）））\））。 从本文来看，GAN 损失函数为
 
@@ -26,7 +26,7 @@ GAN 是用于教授 DL 模型以捕获训练数据分布的框架，因此我们
 
 ### 什么是 DCGAN？]（docs / modern-java-zh /
 
-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
@@ -73,7 +73,7 @@ Random Seed:  999
 *   **batch_size** -训练中使用的批量大小。 DCGAN 纸使用的批处理大小为 128
 *   **image_size** -用于训练的图像的空间大小。 此实现默认为 64x64。 如果需要其他尺寸，则必须更改 D 和 G 的结构。 有关更多详细信息，请参见此处的[。](https://github.com/pytorch/examples/issues/70)
 *   **nc** -输入图像中的彩色通道数。 对于彩色图像，这是 3
-*   **nz** -潜矢量的长度
+*   **nz** -潜向量的长度
 *   **ngf** -与通过生成器传送的特征图的深度有关
 *   **ndf** -设置通过鉴别器传播的特征图的深度
 *   **num_epochs** -要运行的训练时期数。 训练更长的时间可能会导致更好的结果，但也会花费更长的时间
@@ -188,7 +188,7 @@ def weights_init(m):
 
 ### 生成器]（docs / modern-java-zh /
 
-生成器\（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)
 
@@ -359,7 +359,7 @@ Discriminator(
 
 请注意，此函数如何提供目标函数中两个对数分量的计算（即\（log（D（x（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

new/pt-tut-17/29.md

@@ -112,7 +112,7 @@ O'Neal
 
 ## 创建网络]（docs / modern-java-zh /
 
-该网络使用最后一个教程的 RNN 扩展了[，并为类别张量附加了一个参数，该参数与其他张量串联在一起。 类别张量就像字母输入一样是一个单向矢量。](#Creating-the-Network)
+该网络使用最后一个教程的 RNN 扩展了[，并为类别张量附加了一个参数，该参数与其他张量串联在一起。 类别张量就像字母输入一样是一个单向向量。](#Creating-the-Network)
 
 我们将输出解释为下一个字母的概率。 采样时，最可能的输出字母用作下一个输入字母。
 

new/pt-tut-17/30.md

@@ -98,7 +98,7 @@ I am cold.    J'ai froid.
 
 从的下载数据，并将其提取到当前目录。
 
-与字符级 RNN 教程中使用的字符编码类似，我们将一种语言中的每个单词表示为一个单向矢量，或零个大矢量（除单个单向索引外）（在单词的索引处）。 与某种语言中可能存在的数十个字符相比，单词更多很多，因此编码向量要大得多。 但是，我们将作弊并整理数据以使每种语言仅使用几千个单词。
+与字符级 RNN 教程中使用的字符编码类似，我们将一种语言中的每个单词表示为一个单向向量，或零个大向量（除单个单向索引外）（在单词的索引处）。 与某种语言中可能存在的数十个字符相比，单词更多很多，因此编码向量要大得多。 但是，我们将作弊并整理数据以使每种语言仅使用几千个单词。
 
 ![](img/7fa129004e942671707f8f2d4fb80a20.png)
 
@@ -254,7 +254,7 @@ eng 2803
 
 考虑一下句子“ Je ne suis pas le chat noir”→“我不是黑猫”。 输入句子中的大多数单词在输出句子中具有直接翻译，但是顺序略有不同，例如 “黑猫聊天”和“黑猫”。 由于采用“ ne / pas”结构，因此在输入句子中还有一个单词。 直接从输入单词的序列中产生正确的翻译将是困难的。
 
-使用 seq2seq 模型，编码器创建单个矢量，在理想情况下，该矢量将输入序列的“含义”编码为单个矢量—在句子的 N 维空间中的单个点。
+使用 seq2seq 模型，编码器创建单个向量，在理想情况下，该向量将输入序列的“含义”编码为单个向量—在句子的 N 维空间中的单个点。
 
 ### 编码器]（docs / modern-java-zh /
 
@@ -284,7 +284,7 @@ class EncoderRNN(nn.Module):
 
 ### 解码器]（docs / modern-java-zh /
 
-解码器是另一个 RNN，它采用编码器输出矢量并输出单词序列来创建翻译。
+解码器是另一个 RNN，它采用编码器输出向量并输出单词序列来创建翻译。
 
 #### 简单解码器]（docs / modern-java-zh /
 

new/pt-tut-17/44.md

@@ -531,7 +531,7 @@ DCGANGenerator generator(kNoiseSize);
 
 现在我们可以在`DCGANGenerator`上调用`forward()`将噪声样本映射到图像。
 
-选择的特定模块，例如`nn::ConvTranspose2d`和`nn::BatchNorm2d`，遵循前面概述的结构。 `kNoiseSize`常数确定输入噪声矢量的大小，并将其设置为`100`。 当然，超参数是通过研究生的血统发现的。
+选择的特定模块，例如`nn::ConvTranspose2d`和`nn::BatchNorm2d`，遵循前面概述的结构。 `kNoiseSize`常数确定输入噪声向量的大小，并将其设置为`100`。 当然，超参数是通过研究生的血统发现的。
 
 Attention
 

new/pt-tut-17/49.md

@@ -133,7 +133,7 @@ std::cout << x.grad() << std::endl;
 
 您应该具有`4.5`的矩阵。 有关如何获得此值的说明，请参见[本教程](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html#gradients)中的相应部分。
 
-现在，让我们来看一个矢量雅各布产品的示例：
+现在，让我们来看一个向量雅各布产品的示例：
 
 ```py
 x = torch::randn(3, torch::requires_grad());

new/rl-tf/01.md

@@ -375,7 +375,7 @@ Xavier 初始化是神经网络中权重的初始化，是遵循高斯分布的
 
 *   对聚合信号进行激活以创建更深层的内部表示，这些表示又是相应隐藏节点的值
 
-参考上图，我们有三个输入功能![](img/08e07c6f-3487-48cf-9da0-ac1d5b589468.png)和![](img/45d82003-1dd4-4384-8964-96bab8e65d9c.png)。 显示值为 1 的节点被视为偏置单元。 除输出外，每一层通常都有一个偏置单元。 偏差单位可以看作是一个拦截项，在左右激活函数中起着重要作用。 请记住，隐藏层和其中的节点的数量是我们一开始定义的超参数。 在这里，我们将![](img/b27e3bd1-340c-4576-8805-b25a426e35b0.png)和![](img/dc417ad4-d548-4176-b05e-e4193e26620d.png)的隐藏层数定义为 1，将隐藏节点的数数定义为 3。 因此，可以说我们有三个输入单元，三个隐藏单元和三个输出单元（![](img/e0f0f3bb-5953-45d2-8a1a-cd0303871581.png)和![](img/7ccfb224-70cf-4cf8-b027-7d1eebdb7c8e.png)，因为我们要预测的类别是三类）。 这将为我们提供与层关联的权重和偏差的形状。 例如，第 0 层具有 3 个单位，第 1 层具有 3 个单位。与第 i 层相关联的权重矩阵和偏差矢量的形状如下：
+参考上图，我们有三个输入功能![](img/08e07c6f-3487-48cf-9da0-ac1d5b589468.png)和![](img/45d82003-1dd4-4384-8964-96bab8e65d9c.png)。 显示值为 1 的节点被视为偏置单元。 除输出外，每一层通常都有一个偏置单元。 偏差单位可以看作是一个拦截项，在左右激活函数中起着重要作用。 请记住，隐藏层和其中的节点的数量是我们一开始定义的超参数。 在这里，我们将![](img/b27e3bd1-340c-4576-8805-b25a426e35b0.png)和![](img/dc417ad4-d548-4176-b05e-e4193e26620d.png)的隐藏层数定义为 1，将隐藏节点的数数定义为 3。 因此，可以说我们有三个输入单元，三个隐藏单元和三个输出单元（![](img/e0f0f3bb-5953-45d2-8a1a-cd0303871581.png)和![](img/7ccfb224-70cf-4cf8-b027-7d1eebdb7c8e.png)，因为我们要预测的类别是三类）。 这将为我们提供与层关联的权重和偏差的形状。 例如，第 0 层具有 3 个单位，第 1 层具有 3 个单位。与第 i 层相关联的权重矩阵和偏差向量的形状如下：
 
 ![](img/491169f7-46c4-469b-93cd-1cb8f4f01162.png)
 
@@ -537,7 +537,7 @@ CNN 在计算机视觉和自然语言处理领域具有广泛的应用。 就行
 
 就像神经网络中的神经元（或节点）从最后一层接收输入信号的加权聚合一样，最后一层接受激活函数导致输出。 然后我们反向传播以最小化损失函数。 这是应用于任何类型的神经网络的基本操作，因此适用于 CNN。
 
-与输入为矢量形式的神经网络不同，CNN 的输入图像是多通道的，即 RGB（三个通道：红色，绿色和蓝色）。 假设有一个像素大小为 *a×b* 的图像，则实际张量表示将为 *a×b×3* 形状。
+与输入为向量形式的神经网络不同，CNN 的输入图像是多通道的，即 RGB（三个通道：红色，绿色和蓝色）。 假设有一个像素大小为 *a×b* 的图像，则实际张量表示将为 *a×b×3* 形状。
 
 假设您的图片与此处显示的图片相似：
 
@@ -734,7 +734,7 @@ Q 学习涉及的步骤：
 
 为简化起见，我们可以说，给定状态`s`和动作`a`的 Q 值由当前奖励`r`以及新状态在其所有操作中的折现（![](img/5a4faa30-228a-416e-90cf-69810aca8cbd.png)）最大`Q`最大值。 与当前奖励相比，折扣因子延迟了来自未来的奖励。 例如，今天的 100 奖励在将来的价值将超过 100。 同样，将来的 100 奖励必须今天价值不到 100。 因此，我们将折现未来的奖励。 连续重复此更新过程会导致 Q 表值收敛到给定状态下给定操作的预期未来奖励的准确度量。
 
-当状态空间和动作空间的数量增加时，很难维护 Q 表。 在现实世界中，状态空间无限大。 因此，需要另一种无需 Q 表即可生成 *Q（s，a）*的方法。 一种解决方案是用功能替换 Q 表。 该函数将状态作为矢量形式的输入，并输出给定​​状态下所有动作的 Q 值矢量。 该函数逼近器可以由神经网络表示，以预测 Q 值。 因此，当状态和动作空间变大时，我们可以添加更多的层并适合于深度神经网络，以更好地预测 Q 值，这对于 Q 表来说似乎是不可能的。 这样就产生了 Q 网络，如果使用了更深层的神经网络（例如卷积神经网络），那么它会导致**深层 Q 网络**（**DQN**）。
+当状态空间和动作空间的数量增加时，很难维护 Q 表。 在现实世界中，状态空间无限大。 因此，需要另一种无需 Q 表即可生成 *Q（s，a）*的方法。 一种解决方案是用功能替换 Q 表。 该函数将状态作为向量形式的输入，并输出给定​​状态下所有动作的 Q 值向量。 该函数逼近器可以由神经网络表示，以预测 Q 值。 因此，当状态和动作空间变大时，我们可以添加更多的层并适合于深度神经网络，以更好地预测 Q 值，这对于 Q 表来说似乎是不可能的。 这样就产生了 Q 网络，如果使用了更深层的神经网络（例如卷积神经网络），那么它会导致**深层 Q 网络**（**DQN**）。
 
 有关 Q 学习和深度 Q 网络的更多详细信息，将在第 5 章， *Q 学习和深度 Q 网络*中进行介绍。
 

new/rl-tf/02.md

@@ -404,7 +404,7 @@ HFFG
 
 维护少数州的表是可能的，但在现实世界中，州会变得无限。 因此，需要一种解决方案，其合并状态信息并输出动作的 Q 值而不使用 Q 表。 这是神经网络充当函数逼近器的地方，该函数逼近器针对不同状态信息的数据及其所有动作的相应 Q 值进行训练，从而使它们能够预测任何新状态信息输入的 Q 值。 用于预测 Q 值而不是使用 Q 表的神经网络称为 Q 网络。
 
-在这里，对于`FrozenLake-v0`环境，让我们使用一个将状态信息作为输入的单个神经网络，其中状态信息表示为一个 **1 x 状态**形状的热编码矢量（此处为 1 x 16）并输出 **1 x 动作数**形状为的矢量（此处为 1 x 4）。 输出是所有操作的 Q 值：
+在这里，对于`FrozenLake-v0`环境，让我们使用一个将状态信息作为输入的单个神经网络，其中状态信息表示为一个 **1 x 状态**形状的热编码向量（此处为 1 x 16）并输出 **1 x 动作数**形状为的向量（此处为 1 x 4）。 输出是所有操作的 Q 值：
 
 ```py
 *# considering there are 16 states numbered from state 0 to state 15, then state number 4 will be # represented in one hot encoded vector as*

new/rl-tf/04.md

@@ -278,7 +278,7 @@ Output: final
 这产生了著名的 **actor-critic 算法**。 顾名思义，actor-critic 算法出于以下目的维护两个网络：
 
 *   一个网络充当评论者，它更新状态动作函数逼近器的权重`w`参数向量
-*   其他网络充当 Actor，它根据批评者给出的方向更新策略参数矢量![](img/49aece0d-9f5a-4d27-8ccc-13b01329f2de.png)
+*   其他网络充当 Actor，它根据批评者给出的方向更新策略参数向量![](img/49aece0d-9f5a-4d27-8ccc-13b01329f2de.png)
 
 下图代表了 actor-critic 算法：
 
@@ -441,7 +441,7 @@ def relu(x):
     return x
 ```
 
-*   **预处理功能**：`preprocess(image)`功能将图像像素作为参数，并通过裁剪，下采样，使其成为灰度，擦除背景并将图像展平为一维矢量来对其进行预处理。 我们将使用以下代码定义函数：
+*   **预处理功能**：`preprocess(image)`功能将图像像素作为参数，并通过裁剪，下采样，使其成为灰度，擦除背景并将图像展平为一维向量来对其进行预处理。 我们将使用以下代码定义函数：
 
 ```py
 #preprocessing function
@@ -471,7 +471,7 @@ def discount_rewards(r):
     return discount_r
 ```
 
-*   **正向传播**：`policy_forward(x)`函数接收预处理的图像矢量`x`，返回动作概率为`UP`，并且矢量包含隐藏状态节点的值，如 以下代码：
+*   **正向传播**：`policy_forward(x)`函数接收预处理的图像向量`x`，返回动作概率为`UP`，并且向量包含隐藏状态节点的值，如 以下代码：
 
 ```py
 def policy_forward(x):

new/rl-tf/05.md

@@ -330,7 +330,7 @@ Episode 10 completed with total reward 222.356805259 in 843 steps
 
 # 深度 Q 网络
 
-如果我们回想起第 2 章和*使用 OpenAI Gym 训练强化学习代理，*我们曾尝试在其中实现基本的 Q 网络，那么我们就针对一个实际问题研究了 Q 学习 由于连续的状态和动作空间，使用 Q 表不是可行的解决方案。 而且，Q 表是特定于环境的，而不是通用的。 因此，我们需要一个模型，该模型可以将作为输入提供的状态信息映射到可能的一组动作的 Q 值。 在这里，神经网络开始发挥函数逼近器的作用，函数逼近器可以接受矢量形式的状态信息输入，并学习将其映射为所有可能动作的 Q 值。
+如果我们回想起第 2 章和*使用 OpenAI Gym 训练强化学习代理，*我们曾尝试在其中实现基本的 Q 网络，那么我们就针对一个实际问题研究了 Q 学习 由于连续的状态和动作空间，使用 Q 表不是可行的解决方案。 而且，Q 表是特定于环境的，而不是通用的。 因此，我们需要一个模型，该模型可以将作为输入提供的状态信息映射到可能的一组动作的 Q 值。 在这里，神经网络开始发挥函数逼近器的作用，函数逼近器可以接受向量形式的状态信息输入，并学习将其映射为所有可能动作的 Q 值。
 
 让我们讨论游戏环境中的 Q 学习问题以及深度 Q 网络的发展。 考虑将 Q 学习应用于游戏环境，该状态将由玩家，障碍物，对手等的位置来定义，但这将是特定于游戏的，即使在我们创建时也不能在其他游戏环境中推广 一个以某种方式表示该游戏所有可能状态的 Q 表。
 

new/rl-tf/09.md

@@ -126,7 +126,7 @@
 
 # 传感器融合
 
-此步骤包括融合来自不同传感器和过程的输入，并准备将其输入到深度神经网络。 每个传感器信息以原始矢量的形式捕获环境状态。 完成所有这些原始向量的分组，并将其馈入深度神经网络。 每个感官输入将形成一个单独的特征向量。 因此，作为学习的结果，即成本最小化，发生了与那些传感器特征中的每一个相关联的权重的优化。 这些学习的权重量化了相应传感器功能的相关性。 就深度神经网络而言，CNN 是完成任务的最佳选择。
+此步骤包括融合来自不同传感器和过程的输入，并准备将其输入到深度神经网络。 每个传感器信息以原始向量的形式捕获环境状态。 完成所有这些原始向量的分组，并将其馈入深度神经网络。 每个感官输入将形成一个单独的特征向量。 因此，作为学习的结果，即成本最小化，发生了与那些传感器特征中的每一个相关联的权重的优化。 这些学习的权重量化了相应传感器功能的相关性。 就深度神经网络而言，CNN 是完成任务的最佳选择。
 
 # 空间特征
 

new/rl-tf/10.md

@@ -194,7 +194,7 @@ EIIE 通过**在线随机批处理学习**（**OSBL**）进行训练，其中强
 *   **周期性特征提取**：将时间离散化为多个时段，然后提取每个时段的开盘价，最高价，最低价和收盘价
 *   **数据切片**：仅考虑最近时间段的数据，并避免使用较旧的历史数据，以便进行环境的当前状态表示
 
-代理根据时段输出的投资组合权重向量![](img/ae0ed081-d2b6-4980-bda0-ab8224c0ed3f.png)，在时段 *t，*结束时，即在时段 *t + 1* 的开始进行了一些买卖交易。 神经网络。 因此，主体在时间`t`的动作仅由投资组合权重向量![](img/ae0ed081-d2b6-4980-bda0-ab8224c0ed3f.png)表示。 因此，在当前框架中，![](img/ca7f8384-0365-47e5-8367-e72df668cd15.png)被视为环境的一部分，并作为输入输入到代理中，以输出下一个时间段即![](img/ae0ed081-d2b6-4980-bda0-ab8224c0ed3f.png)的代理的操作策略。 因此，在时期 *t，*，即![](img/0d59408e-76cd-47f8-a007-793daf7e29dd.png)的状态由价格张量![](img/f6107c6c-1964-4070-adb7-ba3ab87b87f0.png)和前一时期![](img/ca7f8384-0365-47e5-8367-e72df668cd15.png)的投资组合权重矢量表示：
+代理根据时段输出的投资组合权重向量![](img/ae0ed081-d2b6-4980-bda0-ab8224c0ed3f.png)，在时段 *t，*结束时，即在时段 *t + 1* 的开始进行了一些买卖交易。 神经网络。 因此，主体在时间`t`的动作仅由投资组合权重向量![](img/ae0ed081-d2b6-4980-bda0-ab8224c0ed3f.png)表示。 因此，在当前框架中，![](img/ca7f8384-0365-47e5-8367-e72df668cd15.png)被视为环境的一部分，并作为输入输入到代理中，以输出下一个时间段即![](img/ae0ed081-d2b6-4980-bda0-ab8224c0ed3f.png)的代理的操作策略。 因此，在时期 *t，*，即![](img/0d59408e-76cd-47f8-a007-793daf7e29dd.png)的状态由价格张量![](img/f6107c6c-1964-4070-adb7-ba3ab87b87f0.png)和前一时期![](img/ca7f8384-0365-47e5-8367-e72df668cd15.png)的投资组合权重向量表示：
 
 ![](img/64a779b3-9055-47fd-831e-92c8c108a54d.png)