2020-12-22 14:34:42

new/handson-meta-learn-py/02.md

@@ -14,9 +14,9 @@
 
 连体网络是神经网络的一种特殊类型，它是最简单且使用最广泛的单发学习算法之一。 正如我们在上一章中学到的，单次学习是一种技术，其中我们每个班级仅从一个训练示例中学习。 因此，在每个类别中没有很多数据点的应用程序中主要使用连体网络。 例如，假设我们要为我们的组织建立一个人脸识别模型，并且在组织中有大约 500 个人在工作。 如果我们想从头开始使用**卷积神经网络**（**CNN**）建立人脸识别模型，那么我们需要这 500 人中的许多人来训练网络并获得良好的图像 准确性。 但是显然，我们不会为这 500 个人提供很多图像，因此除非有足够的数据点，否则使用 CNN 或任何深度学习算法构建模型都是不可行的。 因此，在这种情况下，我们可以求助于复杂的单次学习算法，例如连体网络，该算法可以从更少的数据点进行学习。
 
-但是，连体网络如何工作？ 连体网络基本上由两个对称的神经网络组成，它们共享相同的权重和结构，并且都使用能量函数`E`最终结合在一起。 我们的连体网络的目标是了解两个输入值是相似还是相异。 假设我们有两个图像 **X <sub>1</sub>** 和`X2`，我们想了解两个图像是相似还是相异。
+但是，连体网络如何工作？ 连体网络基本上由两个对称的神经网络组成，它们共享相同的权重和结构，并且都使用能量函数`E`最终结合在一起。 我们的连体网络的目标是了解两个输入值是相似还是相异。 假设我们有两个图像`X[1]`和`X2`，我们想了解两个图像是相似还是相异。
 
-如下图所示，我们将图像 **X <sub>1</sub>** 馈送到**网络**`A`和图像 **X <sub>2</sub>** 到另一个**网络 B** 。 这两个网络的作用是为输入图像生成嵌入（特征向量）。 因此，我们可以使用任何可以嵌入我们的网络。 由于我们的输入是图像，因此我们可以使用卷积网络来生成嵌入，即用于提取特征。 请记住，CNN 在这里的作用仅仅是提取特征而不是进行分类。 我们知道这些网络应该具有相同的权重和架构，如果我们的**网络 A** 是三层 CNN，那么我们的**网络 B** 也应该是三层 CNN，我们 这两个网络必须使用相同的权重集。 因此，**网络 A** 和**网络 B** 将为我们提供输入图像 **X <sub>1</sub>** 和 **X <sub>的嵌入 2</sub>** 。 然后，我们会将这些嵌入信息提供给能量函数，从而告诉我们两个输入的相似程度。 能量函数基本上是任何相似性度量，例如欧几里得距离和余弦相似性。
+如下图所示，我们将图像`X[1]`馈送到**网络**`A`和图像`X[2]`到另一个**网络 B** 。 这两个网络的作用是为输入图像生成嵌入（特征向量）。 因此，我们可以使用任何可以嵌入我们的网络。 由于我们的输入是图像，因此我们可以使用卷积网络来生成嵌入，即用于提取特征。 请记住，CNN 在这里的作用仅仅是提取特征而不是进行分类。 我们知道这些网络应该具有相同的权重和架构，如果我们的**网络 A** 是三层 CNN，那么我们的**网络 B** 也应该是三层 CNN，我们 这两个网络必须使用相同的权重集。 因此，**网络 A** 和**网络 B** 将为我们提供输入图像`X[1]`和 **X <sub>的嵌入 2</sub>** 。 然后，我们会将这些嵌入信息提供给能量函数，从而告诉我们两个输入的相似程度。 能量函数基本上是任何相似性度量，例如欧几里得距离和余弦相似性。
 
 ![](img/a7f1a41e-4291-4bec-87dd-fa6bc1d0c00b.png)
 
@@ -28,13 +28,13 @@
 
 ![](img/5b9384ce-2640-4df1-8d41-f668a5da1b79.png)
 
-如上图所示，连体网络由两个相同的网络组成，它们共享相同的权重和架构。 假设我们有两个输入， **X <sub>1</sub>** 和 **X <sub>2</sub>** 。 我们将输入 **X <sub>1</sub>** 馈送到**网络 A** ，即 **f <sub>w</sub> （X <sub>1</sub> ）**，然后将输入的 **X <sub>2</sub>** 馈送到**网络 B** ，即 **f <sub>w</sub> （ X <sub>2</sub> ）**。 您会注意到，这两个网络的权重相同`w`，它们将为我们的输入 **X <sub>1</sub>** 和 **X 生成嵌入 <sub>2</sub>** 。 然后，我们将这些嵌入提供给能量函数`E`，这将使我们在两个输入之间具有相似性。
+如上图所示，连体网络由两个相同的网络组成，它们共享相同的权重和架构。 假设我们有两个输入，`X[1]`和`X[2]`。 我们将输入`X[1]`馈送到**网络 A** ，即 **f <sub>w</sub> （X <sub>1</sub> ）**，然后将输入的`X[2]`馈送到**网络 B** ，即 **f <sub>w</sub> （ X <sub>2</sub> ）**。 您会注意到，这两个网络的权重相同`w`，它们将为我们的输入`X[1]`和 **X 生成嵌入 <sub>2</sub>** 。 然后，我们将这些嵌入提供给能量函数`E`，这将使我们在两个输入之间具有相似性。
 
 可以表示为：
 
 ![](img/bec7e4fe-5f04-4f09-8d62-0c2aac4e48fb.png)
 
-假设我们使用欧几里得距离作为能量函数，那么如果 **X <sub>1</sub>** 和 **X <sub>2</sub>** 相似。 如果输入值不相同，则`E`的值将很大。
+假设我们使用欧几里得距离作为能量函数，那么如果`X[1]`和`X[2]`相似。 如果输入值不相同，则`E`的值将很大。
 
 假设您有两个句子，句子 1 和句子 2。我们将句子 1 馈送到**网络 A** ，将句子 2 馈送到**网络 B** 。 假设我们的**网络 A** 和**网络 B** 都是 LSTM 网络，它们共享相同的权重。 因此，**网络 A** 和**网络 B** 将分别为句子 1 和句子 2 生成单词嵌入。 然后，我们将这些嵌入提供给能量函数，从而为我们提供两个句子之间的相似度得分。 但是我们如何训练我们的连体网络呢？ 数据应该如何？ 有哪些功能和标签？ 我们的目标功能是什么？
 

new/intel-proj-py/02.md

@@ -85,8 +85,8 @@
 在上式中，以下内容适用：
 
 *`N`代表类别数
-*   *O <sub>ij</sub>* 表示已被预测为`i`类的图像数量，其中图像的实际类别为`j`
-*   *E <sub>ij</sub>* 表示预测类别为`i`的预期观察次数，而实际类别为`j`，假设 预测班和实际班
+*  `O[ij]`表示已被预测为`i`类的图像数量，其中图像的实际类别为`j`
+*  `E[ij]`表示预测类别为`i`的预期观察次数，而实际类别为`j`，假设 预测班和实际班
 
 为了更好地了解 kappa 指标组件，让我们看一下苹果和橘子的二进制分类。 假设预测类和实际类的混淆矩阵如下图所示：
 
@@ -194,7 +194,7 @@ def get_im_cv2(path,dim=224):
 
 这里， *M = R <sup>2x2</sup>* 是仿射变换矩阵， *b = [b <sub>1</sub> b <sub>2</sub> ] <sup>T</sup> ∈R <sup>2</sup>* 是翻译向量。
 
-术语 *b <sub>1</sub>* 指定沿一个空间方向的翻译，而 *b <sub>2</sub>* 提供沿另一空间维度的翻译。
+术语`b[1]`指定沿一个空间方向的翻译，而`b[2]`提供沿另一空间维度的翻译。
 
 这些转换是必需的，因为神经网络通常不是平移不变，旋转不变或尺度不变。 合并操作确实提供了一些平移不变性，但是通常这还不够。 神经网络不会将图像中特定位置的一个对象和另一图像中平移位置的相同对象视为同一事物。 这就是为什么我们需要在不同平移位置的图像的多个实例，以使神经网络更好地学习。 相同的解释适用于旋转和缩放。
 
@@ -234,7 +234,7 @@ def get_im_cv2(path,dim=224):
 
 ![](img/f7892eff-50fc-4cf8-a629-271ad0cd18e3.png)
 
-这里， *S <sub>v</sub>* 表示沿垂直方向的比例因子， *S <sub>h</sub>* 表示沿水平方向的比例因子（请参见 “图 2.6”为插图）。 我们还可以选择通过具有非零转换向量`b`来跟随转换的缩放：
+这里，`S[v]`表示沿垂直方向的比例因子，`S[h]`表示沿水平方向的比例因子（请参见 “图 2.6”为插图）。 我们还可以选择通过具有非零转换向量`b`来跟随转换的缩放：
 
 ![](img/3b758265-dbb1-48fb-a744-4a08fef9ce08.png)
 

new/intel-proj-py/03.md

@@ -102,11 +102,11 @@
 
 ![](img/b00765b5-99f5-4dc3-a9cd-32f3ae13a51f.png)
 
-对于 bigram 模型，给定当前单词 *t <sub>1</sub>* 的下一个单词的条件概率为 *t <sub>2</sub>* 计算训练语料库中*对（t <sub>1</sub>* *，t <sub>2</sub> ）*的总数，并根据出现的次数归一化 语料库中 *t <sub>1</sub>* 的含义：
+对于 bigram 模型，给定当前单词`t[1]`的下一个单词的条件概率为`t[2]`计算训练语料库中*对（t <sub>1</sub>* *，t <sub>2</sub> ）*的总数，并根据出现的次数归一化 语料库中`t[1]`的含义：
 
 ![](img/4011e558-b4fc-468a-89cc-3ae457494668.png)
 
-对于三元模型，当前单词 *t <sub>3</sub>* 的条件概率为两个单词 *t <sub>1</sub> ，t <sub>2</sub>* 在此之前可以估算如下：
+对于三元模型，当前单词`t[3]`的条件概率为两个单词 *t <sub>1</sub> ，t <sub>2</sub>* 在此之前可以估算如下：
 
 ![](img/a4e37492-f2ae-4999-b8d1-53d9afac5fba.png)
 
@@ -158,9 +158,9 @@
 
 该翻译主要包括三个部分：
 
-*   **生育力** *：* 并非源语言中的所有单词在目标语言中都有对应的单词。 例如，英语句子 *Santanu 热爱数学*法语翻译为 *Santanu aim les maths* 。 如我们所见，英语中的`m`*ath* 一词已翻译成法文的两个单词，即 *les maths* 。 形式上，*生育力*定义为目标语言中源语言单词生成的单词数量上的概率分布，并且可以表示为`P`*（n / w <sub>s</sub> ）*，其中 *w <sub>s</sub>* 代表源词。 而不是使用硬编码的数字`n`，而是使用概率分布，因为相同的单词可能会根据上下文生成不同长度的翻译。
-*   **失真**：对于任何机器翻译系统，源句子和目标句子之间的单词到单词的对应关系都很重要。 但是，源语言句子中单词的位置可能并不总是与目标语言句子中对应单词的位置完全同步。 失真通过概率函数 *P（p <sub>t</sub> / p <sub>s</sub> ，l）*覆盖了对齐的概念，其中 *p <sub>t</sub>* 和 *P <sub>的</sub>* 分别代表目标词和源词的位置，而`l`代表目标句子的长度。 如果源语言是英语，目标语言是法语，则 *P（p <sub>t</sub> / p <sub>s</sub> ，l）*表示英语单词在 位置 *p <sub>s</sub>* 对应于位置 *p <sub>s</sub>* 中的法语单词，其长度为`l`。
-*   **单词到单词的翻译**：最后，我们来进行单词到单词的翻译，这通常由给定源语言单词的目标语言单词的概率分布表示。 对于给定的源语言单词 *w <sub>s</sub>* ，概率可以表示为 *P（w <sub>t</sub> / w <sub>s</sub> ）*，其中 *w <sub>t</sub>* 代表目标语言单词。
+*   **生育力** *：* 并非源语言中的所有单词在目标语言中都有对应的单词。 例如，英语句子 *Santanu 热爱数学*法语翻译为 *Santanu aim les maths* 。 如我们所见，英语中的`m`*ath* 一词已翻译成法文的两个单词，即 *les maths* 。 形式上，*生育力*定义为目标语言中源语言单词生成的单词数量上的概率分布，并且可以表示为`P`*（n / w <sub>s</sub> ）*，其中`w[s]`代表源词。 而不是使用硬编码的数字`n`，而是使用概率分布，因为相同的单词可能会根据上下文生成不同长度的翻译。
+*   **失真**：对于任何机器翻译系统，源句子和目标句子之间的单词到单词的对应关系都很重要。 但是，源语言句子中单词的位置可能并不总是与目标语言句子中对应单词的位置完全同步。 失真通过概率函数 *P（p <sub>t</sub> / p <sub>s</sub> ，l）*覆盖了对齐的概念，其中`p[t]`和`p[t]`分别代表目标词和源词的位置，而`l`代表目标句子的长度。 如果源语言是英语，目标语言是法语，则 *P（p <sub>t</sub> / p <sub>s</sub> ，l）*表示英语单词在 位置`p[s]`对应于位置`p[s]`中的法语单词，其长度为`l`。
+*   **单词到单词的翻译**：最后，我们来进行单词到单词的翻译，这通常由给定源语言单词的目标语言单词的概率分布表示。 对于给定的源语言单词`w[s]`，概率可以表示为 *P（w <sub>t</sub> / w <sub>s</sub> ）*，其中`w[t]`代表目标语言单词。
 
 对于语言模型，需要在训练过程中估计生育率，失真率和单词到单词的翻译率。
 
@@ -177,11 +177,11 @@
 
 由于这是一个概率模型，因此该算法将尝试使用具有不同对齐方式的不同英语句子，在给定法语句子的情况下，其中具有正确对齐方式的正确英语句子应该具有最高的概率。
 
-让我们将第一个英语单词考虑为 *e <sub>1</sub>* -它与法语单词 *f <sub>6</sub>* 对齐，并且还会发出一个法语 这个词，如下：
+让我们将第一个英语单词考虑为`e[1]`-它与法语单词`f[6]`对齐，并且还会发出一个法语 这个词，如下：
 
 ![](img/688b2388-8434-4d98-8d00-66ea374148b9.png)
 
-现在，让我们将对齐方式作为两个成分的组合：失真 *a <sub>d</sub>* 和生育力 *f <sub>d</sub>* 。 *（1）*中的表达式可以重写如下：
+现在，让我们将对齐方式作为两个成分的组合：失真`a[d]`和生育力`f[d]`。 *（1）*中的表达式可以重写如下：
 
 ![](img/edaf41f6-4172-4397-b791-f714571e57ca.png) ![](img/546bd7e5-37e3-44ba-a006-3378e4664053.png)
 
@@ -204,7 +204,7 @@ NMT 与其他传统方法相比的一些优点如下：
 
 # 编码器-解码器型号
 
-下图说明了一种神经翻译机的体系结构，该结构使用一个 LSTM 作为编码器，将输入源语言序列编码为最终隐藏状态 *h <sub>f</sub>* 和最终存储单元状态[ *c <sub>f</sub>* 。 最终的隐藏状态和单元状态 *[h <sub>f</sub> ，c <sub>f</sub> ]* 将捕获整个输入序列的上下文。 因此， *[h <sub>f</sub> ，c <sub>f</sub> ]* 成为解码器网络可适应的良好候选者。
+下图说明了一种神经翻译机的体系结构，该结构使用一个 LSTM 作为编码器，将输入源语言序列编码为最终隐藏状态`h[f]`和最终存储单元状态[`c[f]`。 最终的隐藏状态和单元状态 *[h <sub>f</sub> ，c <sub>f</sub> ]* 将捕获整个输入序列的上下文。 因此， *[h <sub>f</sub> ，c <sub>f</sub> ]* 成为解码器网络可适应的良好候选者。
 
 此隐藏状态和单元状态信息 *[h <sub>f</sub> ，c <sub>f</sub> ]* 作为初始隐藏状态和单元状态被馈送到解码器网络，然后解码器 在目标序列上训练序列，其中输入目标序列相对于输出目标序列滞后一。 根据解码器，输入序列的第一个字是伪字`[START]`，而输出标签是字 *c'est* 。 解码器网络仅被训练为一种生成语言模型，在任何时候，输出标签`t`t 都是相对于输入的下一个单词，即 *y <sub>t</sub> = x <sub>t + 1</sub>* 。 唯一的新变化是编码器的最终隐藏状态和单元状态（即 *[h <sub>f</sub> ，c <sub>f</sub> ]* ） 解码器的隐藏状态和单元状态为翻译提供内容。
 
@@ -234,7 +234,7 @@ NMT 与其他传统方法相比的一些优点如下：
 
 # 处理输入数据
 
-文本数据不能直接输入任何神经网络，因为神经网络只能理解数字。 我们将每个单词视为一个单编码的矢量，其长度等于每个语料库中出现的单词的数量。 如果英语语料库包含 1,000 个单词，则一键编码的矢量 *v <sub>e</sub>* 的尺寸为 1,000，即 *v <sub>e</sub> ∈R <sup>1000 x 1</sup>* 。
+文本数据不能直接输入任何神经网络，因为神经网络只能理解数字。 我们将每个单词视为一个单编码的矢量，其长度等于每个语料库中出现的单词的数量。 如果英语语料库包含 1,000 个单词，则一键编码的矢量`v[e]`的尺寸为 1,000，即 *v <sub>e</sub> ∈R <sup>1000 x 1</sup>* 。
 
 我们将通读英语和法语语料库，并确定它们各自中唯一词的数量。 我们还将通过索引来表示单词，对于该单词的单编码向量，该单词对应的索引将设置为 1，而其余索引将设置为 0。 例如，假设在英语语料库中，我们有四个词：*全球变暖是真实的*。 我们可以如下定义每个单词的索引：
 
@@ -415,7 +415,7 @@ NMT 与其他传统方法相比的一些优点如下：
 
 # 定义神经机器翻译的模型
 
-如前所述，编码器将通过 LSTM 处理源输入序列，并将源文本编码为有意义的摘要。 有意义的摘要将存储在最后的序列步骤中，即隐藏和单元状态 *h <sub>f</sub>* 和 *c <sub>f</sub>* 。 这些向量在一起（即 *[h <sub>f</sub> ； c <sub>f</sub> ]* ）提供了有关源文本的有意义上下文，并且训练了解码器以产生其 具有隐藏和细胞状态向量的目标序列 *[h <sub>f</sub> ； c <sub>f</sub> ]* 。
+如前所述，编码器将通过 LSTM 处理源输入序列，并将源文本编码为有意义的摘要。 有意义的摘要将存储在最后的序列步骤中，即隐藏和单元状态`h[f]`和`c[f]`。 这些向量在一起（即 *[h <sub>f</sub> ； c <sub>f</sub> ]* ）提供了有关源文本的有意义上下文，并且训练了解码器以产生其 具有隐藏和细胞状态向量的目标序列 *[h <sub>f</sub> ； c <sub>f</sub> ]* 。
 
 下图所示“图 3.5”是英语到法语翻译的训练过程的详细图。 英文句子*这是美好的一天*通过 LSTM 转换为含义摘要，然后存储在隐藏和单元格状态向量 *[h <sub>f</sub> 中； c <sub>f</sub> ]* 。 然后使解码器根据嵌入在 *[h <sub>f</sub> 中的信息，以输入源语句为条件，生成自己的目标序列； c <sub>f</sub> ]* 。 给定源句，使在时间步`t`的解码器预测下一个目标单词，即在时间步 *t +1* 的单词。 这就是为什么目标输入字和目标输出字之间有一个时间步长的滞后的原因。 对于第一步，解码器在目标文本序列中没有任何先前的单词，因此可用于预测目标单词的唯一信息是以 *[h <sub>f</sub> ； c <sub>f</sub> ]* ，作为初始隐藏和单元状态向量提供。 像编码器一样，解码器也使用 LSTM，并且如上所述，输出目标序列比输入目标序列提前一个时间步长：
 
@@ -532,7 +532,7 @@ def train_test_split(self,num_recs,train_frac=0.8):
 
 # 建立推理模型
 
-让我们尝试回顾推理模型的工作机制，并了解如何使用已经训练的模型的组件来构建它。 该模型的编码器部分应通过以源语言中的文本句子作为输入来工作，并提供最终的隐藏和单元状态向量 *[h <sub>f；</sub> c <sub>f</sub> ]* 作为输出。 我们不能按原样使用解码器网络，因为目标语言输入字不再可以馈送到解码器。 相反，我们将解码器网络折叠为一个步骤，并将该步骤的输出作为下一步的输入。 我们以虚拟字`[START]`作为解码器的第一个输入字，以及 *[h <sub>f；</sub> c <sub>f</sub> ]* ，用作其初始隐藏状态和单元格状态。 目标输出字 *w <sub>1</sub>* 以及隐藏和单元状态 *[h <sub>1;</sub> c <sub>1</sub> ]* 由解码器使用`[START]`和 *[h <sub>f</sub> c <sub>f</sub>* ，因为输入再次馈送到解码器以生成下一个字，然后重复该过程，直到解码器输出伪字`[END]`为止。 下图说明了推理过程的逐步表示形式，以便于解释：
+让我们尝试回顾推理模型的工作机制，并了解如何使用已经训练的模型的组件来构建它。 该模型的编码器部分应通过以源语言中的文本句子作为输入来工作，并提供最终的隐藏和单元状态向量 *[h <sub>f；</sub> c <sub>f</sub> ]* 作为输出。 我们不能按原样使用解码器网络，因为目标语言输入字不再可以馈送到解码器。 相反，我们将解码器网络折叠为一个步骤，并将该步骤的输出作为下一步的输入。 我们以虚拟字`[START]`作为解码器的第一个输入字，以及 *[h <sub>f；</sub> c <sub>f</sub> ]* ，用作其初始隐藏状态和单元格状态。 目标输出字`w[1]`以及隐藏和单元状态 *[h <sub>1;</sub> c <sub>1</sub> ]* 由解码器使用`[START]`和 *[h <sub>f</sub> c <sub>f</sub>* ，因为输入再次馈送到解码器以生成下一个字，然后重复该过程，直到解码器输出伪字`[END]`为止。 下图说明了推理过程的逐步表示形式，以便于解释：
 
 ![](img/32c9e729-5872-4e25-bf42-0f87c5ba9d4d.png)
 

new/intel-proj-py/04.md

@@ -29,15 +29,15 @@
 
 图 4.1：DiscoGAN 的架构图
 
-域 B 中生成的图像在样式和样式上都类似于域 A 中的图像。 无需在训练过程中显式配对来自两个域的图像就可以学习这种关系。 鉴于项目的配对是一项耗时的任务，因此这是一项非常强大的功能。 在较高的水平上，它尝试学习神经网络 *G <sub>AB</sub>* 和 *G <sub>BA</sub>* 形式的两个生成器函数。 图像 *x <sub>A</sub>* ，当通过发生器馈入时 *G <sub>AB</sub>* ，产生图像 *x <sub>AB</sub>* ，在域 B 中看起来很真实。此外，当此图像 *x <sub>AB</sub>* 通过其他生成器网络馈送时 *G <sub>BA</sub>* ，它应产生图像 *x <sub>ABA</sub>* ，理想情况下应与原始图像 *x <sub>A</sub>* 相同。 关于生成器功能，以下关系应成立：
+域 B 中生成的图像在样式和样式上都类似于域 A 中的图像。 无需在训练过程中显式配对来自两个域的图像就可以学习这种关系。 鉴于项目的配对是一项耗时的任务，因此这是一项非常强大的功能。 在较高的水平上，它尝试学习神经网络`G[AB]`和`G[BA]`形式的两个生成器函数。 图像`x[A]`，当通过发生器馈入时`G[AB]`，产生图像`x[AB]`，在域`B`中看起来很真实。此外，当此图像`x[AB]`通过其他生成器网络`G[BA]`馈送时，它应产生图像`x[ABA]`，理想情况下应与原始图像`x[A]`相同。 关于生成器功能，以下关系应成立：
 
 ![](img/b12bb426-7c2a-4116-be5b-98a133536497.png)
 
-但是实际上，生成器函数 *G <sub>AB</sub>* 和 *G <sub>BA</sub>* 不可能彼此相反，因此 我们尝试通过选择 L1 或 L2 归一化的损失来尽量减少重建图像和原始图像之间的损失。 L1 规范损耗基本上是每个数据点的绝对误差之和，而 L2 规范损耗表示每个数据点的平方误差的和。 我们可以如下表示单个图像的 L2 范数损失：
+但是实际上，生成器函数`G[AB]`和`G[BA]`不可能彼此相反，因此 我们尝试通过选择 L1 或 L2 归一化的损失来尽量减少重建图像和原始图像之间的损失。 L1 规范损耗基本上是每个数据点的绝对误差之和，而 L2 规范损耗表示每个数据点的平方误差的和。 我们可以如下表示单个图像的 L2 范数损失：
 
 ![](img/09ada4ef-4d12-45db-a6b8-19064db767e9.png)
 
-仅使前面的损失最小化是不够的。 我们必须确保在域 B 中创建的图像 *x <sub>B</sub>* 看起来逼真。例如，如果我们将域 A 中的衣服映射到域 B 中的鞋子，我们将 确保 *x <sub>B</sub>* 类似于鞋子。 如果图像不够真实，则在域 B 侧的鉴别符 *D <sub>B</sub>* 将检测为 *x <sub>B</sub>* 为假。 鞋子，因此也要考虑与此有关的损失。 通常，在训练过程中，向鉴别器提供生成的图像 *x <sub>AB</sub> = G <sub>AB</sub> （x <sub>A</sub> ）* 域 B，我们选择在这里用 *y <sub>B</sub>* 表示，以便它学习从假图像中对真实图像进行分类。 您可能还记得，在 GAN 中，生成器和判别器相互进行*零和最小极大值游戏*，以便不断变得更好，直到达到平衡为止。 如果伪造的图像看起来不够逼真，则鉴别器将对其进行惩罚，这意味着生成器必须学习产生更好的图像 *x <sub>AB</sub>* ，如果输入图像 *x <sub>A</sub>* 。 考虑到所有这些因素，我们可以将我们希望最小化的生成器损耗公式化为重建损耗，以及鉴别器将 *x <sub>AB</sub>* 识别为假冒的损耗。 第二种损失将试图使生成器在域 B 中生成逼真的图像。将域 A 中的图像 *x <sub>A</sub>* 映射到域 B 中的图像的生成器损失可以表示为 如下：
+仅使前面的损失最小化是不够的。 我们必须确保在域 B 中创建的图像`x[B]`看起来逼真。例如，如果我们将域 A 中的衣服映射到域 B 中的鞋子，我们将 确保`x[B]`类似于鞋子。 如果图像不够真实，则在域 B 侧的鉴别符`D[B]`将检测为`x[B]`为假。 鞋子，因此也要考虑与此有关的损失。 通常，在训练过程中，向鉴别器提供生成的图像 *x <sub>AB</sub> = G <sub>AB</sub> （x <sub>A</sub> ）* 域 B，我们选择在这里用`y[B]`表示，以便它学习从假图像中对真实图像进行分类。 您可能还记得，在 GAN 中，生成器和判别器相互进行*零和最小极大值游戏*，以便不断变得更好，直到达到平衡为止。 如果伪造的图像看起来不够逼真，则鉴别器将对其进行惩罚，这意味着生成器必须学习产生更好的图像`x[AB]`，如果输入图像`x[A]`。 考虑到所有这些因素，我们可以将我们希望最小化的生成器损耗公式化为重建损耗，以及鉴别器将`x[AB]`识别为假冒的损耗。 第二种损失将试图使生成器在域 B 中生成逼真的图像。将域 A 中的图像`x[A]`映射到域 B 中的图像的生成器损失可以表示为 如下：
 
 ![](img/f2cdd9c3-d4d4-4c89-a533-e5044ea37592.png)
 
@@ -45,17 +45,17 @@ L2 范数下的重建损失可以表示为：
 
 ![](img/db0f4732-8246-4e5f-ab9f-d680b444e478.png)
 
-由于我们正在处理图像，因此可以假设 *x <sub>A</sub>* 是所有像素的扁平向量，以符合 L2 规范术语。 如果我们假设 *x <sub>A</sub>* 是矩阵，则最好将![](img/6e698b45-8fde-420b-8ada-ee9b7b1f13c9.png)称为 **Frobenius 范数**。 但是，这些只是数学术语，实质上，我们只是将原始图像和重建图像之间的像素值差的平方和求和。
+由于我们正在处理图像，因此可以假设`x[A]`是所有像素的扁平向量，以符合 L2 规范术语。 如果我们假设`x[A]`是矩阵，则最好将![](img/6e698b45-8fde-420b-8ada-ee9b7b1f13c9.png)称为 **Frobenius 范数**。 但是，这些只是数学术语，实质上，我们只是将原始图像和重建图像之间的像素值差的平方和求和。
 
-让我们考虑一下生成器在使变换后的图像 *x <sub>AB</sub>* 追求时要尽量降低成本的做法。 鉴别者将尝试将图像标记为伪图像，因此生成器 *G <sub>AB</sub>* 应当在这种情况下产生 *x <sub>AB</sub>* 使其成为假图片的对数丢失的方式尽可能小。 如果域 B 中的鉴别符 *D <sub>B</sub>* 将真实图像标记为`1`，将伪图像标记为`0`，则图像真实的概率由 *D <sub>B</sub> （。）*，则发生器应使 *x <sub>AB</sub>* 在鉴别器网络下极有可能出现，从而使 *D <sub>B</sub> （x <sub>B</sub> ）= D <sub>B</sub> （G <sub>AB</sub> （x <sub>A</sub> ））*接近`1`）。 就对数损失而言，生成器应使先前概率的负对数最小化，这基本上使我们得到 *C <sub>D（AB）</sub>* ，如下所示：
+让我们考虑一下生成器在使变换后的图像`x[AB]`追求时要尽量降低成本的做法。 鉴别者将尝试将图像标记为伪图像，因此生成器`G[AB]`应当在这种情况下产生`x[AB]`使其成为假图片的对数丢失的方式尽可能小。 如果域 B 中的鉴别符`D[B]`将真实图像标记为`1`，将伪图像标记为`0`，则图像真实的概率由 *D <sub>B</sub> （。）*，则发生器应使`x[AB]`在鉴别器网络下极有可能出现，从而使 *D <sub>B</sub> （x <sub>B</sub> ）= D <sub>B</sub> （G <sub>AB</sub> （x <sub>A</sub> ））*接近`1`）。 就对数损失而言，生成器应使先前概率的负对数最小化，这基本上使我们得到 *C <sub>D（AB）</sub>* ，如下所示：
 
 ![](img/549bd16c-1bd7-4f76-b4c1-6179369f92c7.png)
 
-结合*（3）*和*（4）*，我们可以获得将映像从域 A 映射到域 A 的总生成器成本 *C_G <sub>AB</sub>* 域 B，如下所示：
+结合*（3）*和*（4）*，我们可以获得将映像从域 A 映射到域 A 的总生成器成本`C_G[AB]`域 B，如下所示：
 
 ![](img/581b9be4-661a-41e9-a9f3-597d1116c2c7.png) ![](img/7d74f982-9649-4c22-a18e-d20e9b27d51c.png)
 
-最大的问题是，我们可以在这里停下来吗？ 由于我们有来自两个域的图像，因此要获得更好的映射，我们也可以从域 B 拍摄图像，并通过生成器 *G <sub>BA</sub>* 将它们映射到域 A。 如果我们在域 B 中拍摄 *x <sub>B</sub>* 图像，并通过生成器 *G 将其转换为图像 *x <sub>BA</sub>* HTG13] BA* ，而域 A 上的标识符由 *D <sub>A</sub>* 给出，则与这种转换相关的成本函数由以下给出：
+最大的问题是，我们可以在这里停下来吗？ 由于我们有来自两个域的图像，因此要获得更好的映射，我们也可以从域 B 拍摄图像，并通过生成器`G[BA]`将它们映射到域 A。 如果我们在域 B 中拍摄`x[B]`图像，并通过生成器 *G 将其转换为图像`x[BA]`HTG13] BA* ，而域 A 上的标识符由`D[A]`给出，则与这种转换相关的成本函数由以下给出：
 
 ![](img/e8a983da-5a03-453d-8317-eff82e4164e6.png) ![](img/0812b062-6e92-4e91-b725-747ac4b61f31.png)
 
@@ -63,19 +63,19 @@ L2 范数下的重建损失可以表示为：
 
 ![](img/bd4d5890-a506-4180-b680-4c842cca1286.png) ![](img/bcb0c1db-84a7-44ac-864c-4e7545fb6016.png)
 
-现在，让我们构建成本函数，这些判别器将尝试最小化以建立零和最小/最大游戏。 每个域中的鉴别符都会尝试将真实图像与伪图像区分开，因此鉴别符 *G <sub>B</sub>* 会尝试将成本降到最低 *C_D <sub>B</sub>* ，如下所示：
+现在，让我们构建成本函数，这些判别器将尝试最小化以建立零和最小/最大游戏。 每个域中的鉴别符都会尝试将真实图像与伪图像区分开，因此鉴别符`G[B]`会尝试将成本降到最低`C_D[B]`，如下所示：
 
 ![](img/c8b74f9b-c8cb-47d4-99e1-00c9b35eef05.png)
 
-同样，鉴别符 *D <sub>A</sub>* 会尝试将成本降到最低。 *C_D <sub>A</sub>* 如下所示：
+同样，鉴别符`D[A]`会尝试将成本降到最低。`C_D[A]`如下所示：
 
 ![](img/78578465-7cc8-40c5-9662-21aa263baa81.png)
 
-结合*（8）*和*（9）*的总鉴别器成本由 *C <sub>D</sub>* 给出，如下：
+结合*（8）*和*（9）*的总鉴别器成本由`C[D]`给出，如下：
 
 ![](img/8907ca7c-ae87-4a4b-80e3-37c4bfb678cc.png)
 
-如果我们表示 *G <sub>AB</sub>* 的参数，则 *G <sub>BA</sub>* ， *D <sub>A</sub>* 和 *D <sub>B</sub>* 设为![](img/add08803-366e-44a6-9f62-c665aace690f.png)，![](img/f35e2820-b2e9-4677-8efd-553527f6b982.png)，![](img/8a81454a-fef2-4725-8f9f-d1cdb30ea8ae.png)和![](img/fec915b9-292c-4e75-9e7f-6cf4872bb1a7.png)，则网络的优化参数可以表示为：
+如果我们表示`G[AB]`的参数，则`G[BA]`，`D[A]`和`D[B]`设为![](img/add08803-366e-44a6-9f62-c665aace690f.png)，![](img/f35e2820-b2e9-4677-8efd-553527f6b982.png)，![](img/8a81454a-fef2-4725-8f9f-d1cdb30ea8ae.png)和![](img/fec915b9-292c-4e75-9e7f-6cf4872bb1a7.png)，则网络的优化参数可以表示为：
 
 ![](img/3d609715-cecb-4823-8ce5-87fda4d8846f.png)
 
@@ -189,7 +189,7 @@ the number of input images processed : 30000
 
 # DiscoGAN 的发电机
 
-DiscoGAN 的生成器是前馈卷积神经网络，其中输入和输出是图像。 在网络的第一部分中，图像在空间维度上按比例缩小，而输出要素图的数量随图层的进展而增加。 在网络的第二部分中，图像沿空间维度按比例放大，而输出特征图的数量则逐层减少。 在最终输出层中，将生成具有与输入相同的空间尺寸的图像。 如果生成器将图像 *x <sub>A</sub>* 转换为 *x <sub>AB</sub>* 从*域 A* 到*域 B* 表示为 *G <sub>AB</sub>* ，则我们有![](img/6c5507b6-7666-4601-8730-0b89c4a198fc.png)。
+DiscoGAN 的生成器是前馈卷积神经网络，其中输入和输出是图像。 在网络的第一部分中，图像在空间维度上按比例缩小，而输出要素图的数量随图层的进展而增加。 在网络的第二部分中，图像沿空间维度按比例放大，而输出特征图的数量则逐层减少。 在最终输出层中，将生成具有与输入相同的空间尺寸的图像。 如果生成器将图像`x[A]`转换为`x[AB]`从*域 A* 到*域 B* 表示为`G[AB]`，则我们有![](img/6c5507b6-7666-4601-8730-0b89c4a198fc.png)。
 
 此处显示的是`build_generator`函数，我们可以使用它来构建 DiscoGAN 网络的生成器：
 
@@ -471,12 +471,12 @@ def build_network(self):
 下表显示了我们需要跟踪的不同损耗变量。 就发生器或鉴别器的参数而言，所有这些损失都需要最小化：
 
 | **不同损失的变量** | **说明** |
-| `self.D_B_loss_real` | 在对域 B 中的真实图像进行分类时，鉴别符 *D <sub>B</sub>* 的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator *D<sub>B.</sub>*) |
-| `self.D_B_loss_fake` | 在对域 B 中的伪造图像进行分类时，鉴别符 *D <sub>B</sub>* 的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator *D<sub>B.</sub>*) |
-| `self.D_A_loss_real` | 在对域 A 中的真实图像进行分类时，鉴别符 *D <sub>A</sub>* 的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator *D<sub>A.</sub>*) |
-| `self.D_A_loss_fake` | 在对域 A 中的伪造图像进行分类时，鉴别符 *D <sub>A</sub>* 的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator *D<sub>A.</sub>*) |
-| `self.loss_GABA` | 通过两个生成器 *G <sub>AB</sub>* 和 *G <sub>BA</sub>* 将域 A 中的图像映射到 B，然后再映射回 A 的重建损失 ）加上假图片 *G <sub>AB</sub> （x <sub>A</sub> ）*的二进制交叉熵，并由域 B 中的鉴别器标记为真实图像。(This loss is to be minimized with respect to the parameters of the generators *G<sub>AB</sub>* and *G<sub>BA.</sub>*) |
-| `self.loss_GBAB` | 通过两个生成器 *G <sub>BA</sub>* 和 *G <sub>AB</sub>* 将域 B 中的图像映射到 A，然后再映射回 B 的重建损失 加上伪图片 *G <sub>BA</sub> （x <sub>B</sub> ）*的二元交叉熵，由域 A 中的鉴别器标记为真实图像。(This loss is to be minimized with respect to the parameters of the generators *G<sub>AB</sub>* and *G<sub>BA.</sub>*) |
+| `self.D_B_loss_real` | 在对域 B 中的真实图像进行分类时，鉴别符`D[B]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator *D<sub>B.</sub>*) |
+| `self.D_B_loss_fake` | 在对域 B 中的伪造图像进行分类时，鉴别符`D[B]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator *D<sub>B.</sub>*) |
+| `self.D_A_loss_real` | 在对域 A 中的真实图像进行分类时，鉴别符`D[A]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator *D<sub>A.</sub>*) |
+| `self.D_A_loss_fake` | 在对域 A 中的伪造图像进行分类时，鉴别符`D[A]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator *D<sub>A.</sub>*) |
+| `self.loss_GABA` | 通过两个生成器`G[AB]`和`G[BA]`将域 A 中的图像映射到 B，然后再映射回 A 的重建损失 ）加上假图片 *G <sub>AB</sub> （x <sub>A</sub> ）*的二进制交叉熵，并由域 B 中的鉴别器标记为真实图像。(This loss is to be minimized with respect to the parameters of the generators *G<sub>AB</sub>* and *G<sub>BA.</sub>*) |
+| `self.loss_GBAB` | 通过两个生成器`G[BA]`和`G[AB]`将域 B 中的图像映射到 A，然后再映射回 B 的重建损失 加上伪图片 *G <sub>BA</sub> （x <sub>B</sub> ）*的二元交叉熵，由域 A 中的鉴别器标记为真实图像。(This loss is to be minimized with respect to the parameters of the generators *G<sub>AB</sub>* and *G<sub>BA.</sub>*) |
 
 前四个损耗组成了鉴别器损耗，需要根据鉴别器的参数将其最小化。 ]。 最后两个损耗组成了发电机损耗，需要根据发电机的参数将其最小化。 。
 
@@ -578,7 +578,7 @@ def sample_model(self, sample_dir, epoch, id_):
                     './{}/B_{:02d}_{:04d}.jpg'.format(sample_dir, epoch, id_))
 ```
 
-在此`sample_model`函数中，从域 A 随机选择的图像被拍摄并馈送到生成器 *G <sub>AB</sub>* ，以在域 B 中生成图像。类似地，从域 B 随机选择的图像是 馈送到生成器 *G <sub>BA</sub>* 中，以在域 A 中生成图像。这些输出图像由两个生成器在不同时期生成，并将批次保存在样本文件夹中以查看是否 生成器在训练过程中随着时间的推移而不断改进，以产生更好的图像质量。
+在此`sample_model`函数中，从域 A 随机选择的图像被拍摄并馈送到生成器`G[AB]`，以在域 B 中生成图像。类似地，从域 B 随机选择的图像是 馈送到生成器`G[BA]`中，以在域 A 中生成图像。这些输出图像由两个生成器在不同时期生成，并将批次保存在样本文件夹中以查看是否 生成器在训练过程中随着时间的推移而不断改进，以产生更好的图像质量。
 
 使用 TensorFlow saver 功能保存模型的`save_model`函数如下所示：
 

new/intel-proj-py/05.md

@@ -37,7 +37,7 @@
 
 图 5.1：使用预训练的神经网络提取视频图像特征
 
-从上图可以看出，从视频中顺序采样的图像经过预训练的卷积神经网络，并且最后一个完全连接层中的 **`4,096`** 单元的激活为 输出。 如果将`t`时的视频图像表示为 *x <sub>t</sub>* ，并且最后一个完全连接层的输出表示为 *f <sub>t</sub> ∈R <sup>4096</sup>* ，然后 *f <sub>t =</sub> f <sub>w</sub> （x <sub>t</sub> ）* [ <sub>。</sub> 此处，`W`表示直到最后一个完全连接层的卷积神经网络的权重。
+从上图可以看出，从视频中顺序采样的图像经过预训练的卷积神经网络，并且最后一个完全连接层中的 **`4,096`** 单元的激活为 输出。 如果将`t`时的视频图像表示为`x[t]`，并且最后一个完全连接层的输出表示为 *f <sub>t</sub> ∈R <sup>4096</sup>* ，然后 *f <sub>t =</sub> f <sub>w</sub> （x <sub>t</sub> ）* [ <sub>。</sub> 此处，`W`表示直到最后一个完全连接层的卷积神经网络的权重。
 
 这些系列的输出功能 *f <sub>1，</sub> f <sub>2，...。 。 。 。 。</sub> f <sub>t。 。 。</sub> f <sub>N</sub>* 可以作为递归神经网络的输入，该神经网络学习根据输入特征生成文本标题，如下图所示（“图 5.2”]）：
 
@@ -63,11 +63,11 @@
 
 序列到序列模型通过像以前一样通过预训练的卷积神经网络处理视频图像帧，最后一个完全连接层的输出激活被视为要馈送到后续 LSTM 的特征。 如果我们在时间步`t`表示预训练卷积神经网络的最后一个完全连接层的输出激活为 *f <sub>t</sub> ∈R <sup>4096</sup>* ，那么我们将为视频中的`N`个图像帧使用`N`个这样的特征向量。 这些`N`个特征向量 *f1，f2，...。 。 。 。 。 f <sub>t</sub> 。 。 。 f <sub>N</sub>* 依次输入 LSTM，以生成文本标题。
 
-背靠背有两个 LSTM，LSTM 中的序列数是来自视频的图像帧数与字幕词汇表中文本字幕的最大长度之和。 如果在视频的`N`个图像帧上训练网络，并且词汇表中的最大文本标题长度为`M`，则 LSTM 在*（N + M）上训练[* 时间步长。 在`N`个时间步中，第一个 LSTM 处理特征向量 *f1，f2，...。 。 。 。 。 f <sub>t</sub> 。 。 。 f <sub>N</sub>* 依次生成，并将其生成的隐藏状态馈送到第二 LSTM。 在这些`N`个时间步中，第二个 LSTM 不需要文本输出目标。 如果我们将第一个 LSTM 在时间步`t`的隐藏状态表示为 *h <sub>t</sub>* ，则对于第二个 LSTM，第一个 *N [* 时间步长为 *h <sub>t</sub>* 。 请注意，从 N + 1 时间步长到第一个 LSTM 的输入是零填充的，因此该输入对 *t [ *h <sub>t</sub>* 没有隐藏状态的影响。 > N* 。 请注意，这并不保证 t > N 的隐藏状态 *h <sub>t</sub>* 总是相同的。 实际上，我们可以选择在任何时间步长 *t >中将 *h <sub>t</sub>* 作为 *h <sub>T</sub>* 送入第二个 LSTM。 ] N.*
+背靠背有两个 LSTM，LSTM 中的序列数是来自视频的图像帧数与字幕词汇表中文本字幕的最大长度之和。 如果在视频的`N`个图像帧上训练网络，并且词汇表中的最大文本标题长度为`M`，则 LSTM 在*（N + M）上训练[* 时间步长。 在`N`个时间步中，第一个 LSTM 处理特征向量 *f1，f2，...。 。 。 。 。 f <sub>t</sub> 。 。 。 f <sub>N</sub>* 依次生成，并将其生成的隐藏状态馈送到第二 LSTM。 在这些`N`个时间步中，第二个 LSTM 不需要文本输出目标。 如果我们将第一个 LSTM 在时间步`t`的隐藏状态表示为`h[t]`，则对于第二个 LSTM，第一个 *N [* 时间步长为`h[t]`。 请注意，从 N + 1 时间步长到第一个 LSTM 的输入是零填充的，因此该输入对 *t [`h[t]`没有隐藏状态的影响。 > N* 。 请注意，这并不保证 t > N 的隐藏状态`h[t]`总是相同的。 实际上，我们可以选择在任何时间步长 *t >中将`h[t]`作为`h[T]`送入第二个 LSTM。 ] N.*
 
-从*（N + 1）*时间步长开始，第二个 LSTM 需要文本输出目标。 在任何时间步长 *t > N* 的输入是 *[h <sub>t</sub> ，w <sub>t-1</sub> ]* ，其中 *h <sub>t</sub>* 是第一个 LSTM 在时间步`t`的隐藏状态，而 *w <sub>t-1</sub>* 是 时间步*（t-1）*中的文本标题词。
+从*（N + 1）*时间步长开始，第二个 LSTM 需要文本输出目标。 在任何时间步长 *t > N* 的输入是 *[h <sub>t</sub> ，w <sub>t-1</sub> ]* ，其中`h[t]`是第一个 LSTM 在时间步`t`的隐藏状态，而 *w <sub>t-1</sub>* 是 时间步*（t-1）*中的文本标题词。
 
-在*（N + 1）*时间步长处，馈送到第二 LSTM 的单词 *w <sub>N</sub>* 是由`<bos>`表示的句子的开头。 一旦生成句子符号`<eos>`的结尾，就训练网络停止生成标题词。 总而言之，两个 LSTM 的设置方式是，一旦它们处理完所有视频图像帧特征 *![](img/8ad769e2-57c1-4581-98e1-7c7f70a12413.png)* ，它们便开始产生文本标题词。
+在*（N + 1）*时间步长处，馈送到第二 LSTM 的单词`w[N]`是由`<bos>`表示的句子的开头。 一旦生成句子符号`<eos>`的结尾，就训练网络停止生成标题词。 总而言之，两个 LSTM 的设置方式是，一旦它们处理完所有视频图像帧特征 *![](img/8ad769e2-57c1-4581-98e1-7c7f70a12413.png)* ，它们便开始产生文本标题词。
 
 处理时间步 *t > N* 的第二个 LSTM 输入的另一种方法是只喂 *[w <sub>t-1</sub> ]* 而不是 HTG6] [h <sub>t</sub> ，w <sub>t-1</sub> ] ，并在时间步`T`传递第一个 LSTM 的隐藏状态和单元状态。 *[h <sub>T</sub> ，c <sub>T</sub> ]* 到第二个 LSTM 的初始隐藏和细胞状态。 这样的视频字幕网络的体系结构可以说明如下（请参见“图 5.4”）：
 
@@ -89,7 +89,7 @@
 
 # 处理视频图像以创建 CNN 功能
 
-从指定位置下载数据后，下一个任务是处理视频图像帧，以从预训练的卷积神经网络的最后完全连接的层中提取特征。 我们使用在 ImageNet 上预训练的`VGG16`卷积神经网络。 我们将激活从`VGG16`的最后一个完全连接的层中取出。 由于`VGG16`的最后一个完全连接的层具有`4096`单位，因此每个时间步`t`的特征向量 *f <sub>t</sub>* 为`4096`， *f <sub>t</sub> ∈R <sup>4096</sup>* 的维向量。
+从指定位置下载数据后，下一个任务是处理视频图像帧，以从预训练的卷积神经网络的最后完全连接的层中提取特征。 我们使用在 ImageNet 上预训练的`VGG16`卷积神经网络。 我们将激活从`VGG16`的最后一个完全连接的层中取出。 由于`VGG16`的最后一个完全连接的层具有`4096`单位，因此每个时间步`t`的特征向量`f[t]`为`4096`， *f <sub>t</sub> ∈R <sup>4096</sup>* 的维向量。
 
 在通过`VGG16`处理视频中的图像之前，需要从视频中对其进行采样。 我们从视频中采样图像，使每个视频具有`80`帧。 处理来自`VGG16`的`80`图像帧后，每个视频将具有`80`特征向量 *f1，f2，...。 。 。 。 。 f <sub>t</sub> 。 。 。 f <sub>80</sub>* 。 这些功能将被馈送到 LSTM 以生成文本序列。 我们在 Keras 中使用了预训练的`VGG16`模型。 我们创建一个`VideoCaptioningPreProcessing`类，该类首先通过函数`video_to_frames`从每个视频中提取`80`视频帧作为图像，然后通过功能`extract_feats_pretrained_cnn`中的预训练`VGG16`卷积神经网络处理这些视频帧。 。
 
@@ -261,17 +261,17 @@ def get_clean_caption_data(self,text_path,feat_path):
 
 # 建立模型
 
-在本节中，说明了核心模型构建练习。 我们首先为文本标题的词汇表中的单词定义一个嵌入层，然后是两个 LSTM。 权重`self.encode_W`和`self.encode_b`用于减少卷积神经网络中特征 *f <sub>t</sub>* 的尺寸。 对于第二个 LSTM（LSTM 2），在任何时间步长处的其他输入之一 *t > N* 是前一个单词 *w <sub>t-1</sub>* 从第一个 LSTM（LSTM 1）输出 *h <sub>t</sub>* 。 将`w`<sub>*t-1*</sub> 嵌入的单词送入 LSTM 2，而不是原始的一个热编码矢量。 对于第一个 N `(self.video_lstm_step)`，LSTM 1 处理来自 CNN 的输入特征 *f <sub>t</sub>* ，以及输出隐藏状态 *<sup>h <sub>t [</sub></sup> （输出 1）*被馈送到 LSTM2。在此编码阶段，LSTM 2 不会接收任何单词 *w <sub>t-1</sub>* 作为 输入。
+在本节中，说明了核心模型构建练习。 我们首先为文本标题的词汇表中的单词定义一个嵌入层，然后是两个 LSTM。 权重`self.encode_W`和`self.encode_b`用于减少卷积神经网络中特征`f[t]`的尺寸。 对于第二个 LSTM（LSTM 2），在任何时间步长处的其他输入之一 *t > N* 是前一个单词 *w <sub>t-1</sub>* 从第一个 LSTM（LSTM 1）输出`h[t]`。 将`w`<sub>*t-1*</sub> 嵌入的单词送入 LSTM 2，而不是原始的一个热编码矢量。 对于第一个 N `(self.video_lstm_step)`，LSTM 1 处理来自 CNN 的输入特征`f[t]`，以及输出隐藏状态 *<sup>h <sub>t [</sub></sup> （输出 1）*被馈送到 LSTM2。在此编码阶段，LSTM 2 不会接收任何单词 *w <sub>t-1</sub>* 作为 输入。
 
-从*（N + 1）*时间步长，我们进入解码阶段，在此阶段，连同 *<sup>h <sub>t</sub></sup> （输出 1）* 从 LSTM 1 开始，先前的时间步字嵌入矢量 *w <sub>t-1</sub>* 被馈送到 LSTM2。在这一阶段，没有输入到 LSTM 1，因为所有 特征 *f <sub>t</sub>* 在时间步`N`耗尽。 解码阶段的时间步长由`self.caption_lstm_step`确定。
+从*（N + 1）*时间步长，我们进入解码阶段，在此阶段，连同 *<sup>h <sub>t</sub></sup> （输出 1）* 从 LSTM 1 开始，先前的时间步字嵌入矢量 *w <sub>t-1</sub>* 被馈送到 LSTM2。在这一阶段，没有输入到 LSTM 1，因为所有 特征`f[t]`在时间步`N`耗尽。 解码阶段的时间步长由`self.caption_lstm_step`确定。
 
-现在，如果我们用函数 *f2，*表示 LSTM 2 的活动，则 *f <sub>2</sub> （h <sub>t，</sub> w <sub>t- 1</sub> ）= h <sub>2t</sub>* ，其中 *h <sub>2t</sub>* 是 LSTM 2 在时间步`t`的隐藏状态 ]。 该隐藏状态 *h <sub>2t</sub>* 在时间`t`时，通过 *softmax* 函数转换为输出单词的概率分布， 选择最高概率的单词作为下一个单词![](img/a18e98b6-e400-4784-9452-c7ab8bc9a7cc.png)：
+现在，如果我们用函数 *f2，*表示 LSTM 2 的活动，则 *f <sub>2</sub> （h <sub>t，</sub> w <sub>t- 1</sub> ）= h <sub>2t</sub>* ，其中`h[2t]`是 LSTM 2 在时间步`t`的隐藏状态 ]。 该隐藏状态`h[2t]`在时间`t`时，通过 *softmax* 函数转换为输出单词的概率分布， 选择最高概率的单词作为下一个单词![](img/a18e98b6-e400-4784-9452-c7ab8bc9a7cc.png)：
 
 ![](img/09b71b6c-5a27-49ae-965b-98e8810fbdb9.png) = ![](img/9ae080a8-cf15-45f5-ad50-b98244404366.png)
 
 ![](img/aa71833b-2882-4ace-abe6-d6dad3254469.png)
 
-这些权重 *W <sub>ho</sub>* 和 *b，*在以下代码块中定义为`self.word_emb_W`和`self.word_emb_b`。 有关更多详细信息，请参考`build_model`功能。 为了方便解释，构建功能分为三部分。 构建模型有 3 个主要单元
+这些权重`W[ho]`和 *b，*在以下代码块中定义为`self.word_emb_W`和`self.word_emb_b`。 有关更多详细信息，请参考`build_model`功能。 为了方便解释，构建功能分为三部分。 构建模型有 3 个主要单元
 
 *   **定义阶段**：定义变量，标题词的嵌入层和序列到序列模型的两个 LSTM。
 *   **编码阶段**：在这一阶段中，我们将视频帧图像特征传递给 LSTM1 的时间步长，并将每个时间步长的隐藏状态传递给 LSTM2。此活动一直进行到时间步长 *] N* 其中`N`是从每个视频中采样的视频帧图像的数量。