From 34761518d27d5d24f6e9df8c6371dd395f015af2 Mon Sep 17 00:00:00 2001
From: wizardforcel <562826179@qq.com>
Date: Wed, 23 Dec 2020 22:51:12 +0800
Subject: [PATCH] 2020-12-23 22:51:12

---
 new/handson-meta-learn-py/09.md |  2 +-
 new/handson-meta-learn-py/10.md |  2 +-
 new/handson-rl-py/13.md         |  4 +-
 new/handson-rl-py/14.md         |  2 +-
 new/intel-proj-py/00.md         |  8 ++--
 new/intel-proj-py/01.md         | 38 +++++++++---------
 new/intel-proj-py/02.md         | 12 +++---
 new/intel-proj-py/03.md         | 10 ++---
 new/intel-proj-py/04.md         | 68 ++++++++++++++++-----------------
 new/intel-proj-py/05.md         |  8 ++--
 new/intel-proj-py/06.md         | 24 ++++++------
 new/intel-proj-py/10.md         | 12 +++---
 12 files changed, 95 insertions(+), 95 deletions(-)

diff --git a/new/handson-meta-learn-py/09.md b/new/handson-meta-learn-py/09.md
index f63286a2..2186326c 100644
--- a/new/handson-meta-learn-py/09.md
+++ b/new/handson-meta-learn-py/09.md
@@ -189,7 +189,7 @@ MIL 中涉及的步骤如下：
 *   概念鉴别器
 *   元学习者
 
-概念生成器的作用是提取数据集中每个数据点的特征表示，捕获其高级概念，概念鉴别器的作用是识别和分类由概念生成器生成的概念，而 元学习者学习由概念生成器生成的概念。 先前的所有组件（即概念生成器，概念鉴别器和元学习器）都可以一起学习。 因此，我们通过将元学习与深度学习相集成来改善香草元学习。 我们的概念生成器随着新的传入数据而发展，因此我们可以将我们的框架视为终身学习系统。
+概念生成器的作用是提取数据集中每个数据点的特征表示，捕获其高级概念，概念鉴别器的作用是识别和分类由概念生成器生成的概念，而 元学习者学习由概念生成器生成的概念。 先前的所有组件（即概念生成器，概念鉴别器和元学习器）都可以一起学习。 因此，我们通过将元学习与深度学习相集成来改善原始元学习。 我们的概念生成器随着新的传入数据而发展，因此我们可以将我们的框架视为终身学习系统。
 
 但是这里到底发生了什么？ 看下图； 如您所见，我们对一组任务进行采样，并将其提供给概念生成器，该概念生成器将学习概念（即嵌入），然后将这些概念提供给元学习器，后者将学习这些概念并将损失回馈给 概念生成器。 同时，我们还将一些外部数据集提供给概念生成器，概念生成器学习这些输入的概念并将这些概念发送给概念识别器。 概念识别器预测这些概念的标签，计算损失，然后将损失发送回概念生成器。 通过这样做，我们增强了概念生成器概括概念的能力：
 
diff --git a/new/handson-meta-learn-py/10.md b/new/handson-meta-learn-py/10.md
index 503ff443..f1c69b7d 100644
--- a/new/handson-meta-learn-py/10.md
+++ b/new/handson-meta-learn-py/10.md
@@ -31,7 +31,7 @@
 2.  我们为每个数据点计算嵌入以学习特征。
 3.  一旦我们了解了每个数据点的嵌入，就可以将每个类中数据点的均值嵌入并形成类原型。 因此，类原型基本上就是在类中数据点的平均嵌入。
 4.  在高斯原型网络中，连同为数据点生成嵌入，我们在它们周围添加一个置信区域，该区域由高斯协方差矩阵表征。 拥有置信区域有助于表征单个数据点的质量，并且对于嘈杂且不太均匀的数据很有用。
-5.  高斯原型网络与香草原型网络的不同之处在于，在香草原型网络中，我们仅学习数据点的嵌入，但在高斯原型网络中，除了学习嵌入之外，我们还为其添加了置信区域。
+5.  高斯原型网络与原始原型网络的不同之处在于，在原始原型网络中，我们仅学习数据点的嵌入，但在高斯原型网络中，除了学习嵌入之外，我们还为其添加了置信区域。
 6.  半径和对角线是高斯原型网络中使用的协方差矩阵的不同组成部分。
 
 # 第 4 章：使用 TensorFlow 的关系和匹配网络
diff --git a/new/handson-rl-py/13.md b/new/handson-rl-py/13.md
index fc5bd9c9..608cfd68 100644
--- a/new/handson-rl-py/13.md
+++ b/new/handson-rl-py/13.md
@@ -66,7 +66,7 @@ I2A 的架构如下：
 
 # 从演示中进行深度 Q 学习
 
-我们已经了解了很多有关 DQN 的知识。 我们从香草 DQN 开始，然后看到了各种改进，例如双重 DQN，决斗的网络架构和优先级的经验回放。 我们还学会了构建 DQN 来玩 Atari 游戏。 我们将代理与环境的交互存储在经验缓冲区中，并使代理从这些经验中学习。 但是问题是，我们花了很多培训时间来提高性能。 对于在模拟环境中学习，这很好，但是当我们让代理在现实环境中学习时，会引起很多问题。 为了克服这个问题，谷歌公司 DeepMind 的研究人员在演示（**DQfd**）的基础上，对 DQN 进行了改进，称为**深度 Q 学习**。
+我们已经了解了很多有关 DQN 的知识。 我们从原始 DQN 开始，然后看到了各种改进，例如双重 DQN，决斗的网络架构和优先级的经验回放。 我们还学会了构建 DQN 来玩 Atari 游戏。 我们将代理与环境的交互存储在经验缓冲区中，并使代理从这些经验中学习。 但是问题是，我们花了很多培训时间来提高性能。 对于在模拟环境中学习，这很好，但是当我们让代理在现实环境中学习时，会引起很多问题。 为了克服这个问题，谷歌公司 DeepMind 的研究人员在演示（**DQfd**）的基础上，对 DQN 进行了改进，称为**深度 Q 学习**。
 
 如果我们已经有了一些演示数据，则可以将这些演示直接添加到经验回放缓冲区中。 例如，考虑一个学习玩 Atari 游戏的特工。 如果我们已经有了一些演示数据来告诉我们的代理，哪个状态更好，哪个动作可以提供良好的回报，那么代理可以直接使用此数据进行学习。 即使是少量的演示，也可以提高智能体的表现并最大程度地减少培训时间。 由于演示的数据将直接添加到优先经验重放缓冲区中，因此代理可以从演示数据中使用的数据量以及代理可以从其自己的交互中用于学习的数据量将由优先经验重放来控制 缓冲，因为经验将被优先考虑。
 
@@ -76,7 +76,7 @@ DQfd 中的损失函数将是各种损失的总和。 为了防止我们的代
 
 # 事后经验回放
 
-我们已经了解了如何在 DQN 中使用经验回放来避免相关经验。 此外，我们了解到，优先经验回放是对香草经验回放的一种改进，因为它优先考虑 TD 错误的每个经验。 现在，我们将研究由 OpenAI 研究人员提出的一种用于处理稀疏奖励的名为**事后经验回放**（**HER**）的新技术。 您还记得如何学习骑自行车吗？ 第一次尝试时，您将无法正确平衡自行车。 您可能多次无法正确平衡。 但是，所有这些失败并不意味着您没有学到任何东西。 失败会教你如何不平衡自行车。 即使您没有学会骑自行车（目标），您也学习了一个不同的目标，即，您学会了如何不平衡自行车。 这是我们人类学习的方式，对吗？ 我们从失败中学习，这就是事后回顾经验的想法。
+我们已经了解了如何在 DQN 中使用经验回放来避免相关经验。 此外，我们了解到，优先经验回放是对原始经验回放的一种改进，因为它优先考虑 TD 错误的每个经验。 现在，我们将研究由 OpenAI 研究人员提出的一种用于处理稀疏奖励的名为**事后经验回放**（**HER**）的新技术。 您还记得如何学习骑自行车吗？ 第一次尝试时，您将无法正确平衡自行车。 您可能多次无法正确平衡。 但是，所有这些失败并不意味着您没有学到任何东西。 失败会教你如何不平衡自行车。 即使您没有学会骑自行车（目标），您也学习了一个不同的目标，即，您学会了如何不平衡自行车。 这是我们人类学习的方式，对吗？ 我们从失败中学习，这就是事后回顾经验的想法。
 
 让我们考虑本文中给出的相同示例。 如图所示，查看 FetchSlide 环境。 在这种环境下的目标是移动机械臂并在桌子上滑动冰球以击中目标，这是一个红色的小圆圈（来自[的图表 https://blog.openai.com/ingredients-for-robotics-research /](https://blog.openai.com/ingredients-for-robotics-research/) ）：
 
diff --git a/new/handson-rl-py/14.md b/new/handson-rl-py/14.md
index 271e3c0e..7bd238ba 100644
--- a/new/handson-rl-py/14.md
+++ b/new/handson-rl-py/14.md
@@ -85,7 +85,7 @@
 
 # 第九章
 
-1.  DRQN 利用**循环神经网络**（**RNN**），其中 DQN 利用香草神经网络。
+1.  DRQN 利用**循环神经网络**（**RNN**），其中 DQN 利用原始神经网络。
 2.  当可以部分观察 MDP 时，不使用 DQN。
 3.  请参阅“DRQN 的Doom”部分。
 4.  与 DRQN 不同，DARQN 利用注意力机制。
diff --git a/new/intel-proj-py/00.md b/new/intel-proj-py/00.md
index 2aae5da4..85f7ee75 100644
--- a/new/intel-proj-py/00.md
+++ b/new/intel-proj-py/00.md
@@ -14,7 +14,7 @@
 
 第 3 章，“神经机器翻译”涵盖了**循环神经网络**（**RNN**）架构的基础。 我们还将学习三种不同的机器翻译系统：基于规则的机器翻译，统计机器翻译和神经机器翻译。
 
-第 4 章，“在 GAN 中使用 GAN” 进行时尚行业中的样式迁移，说明如何创建智能 AI 模型以生成具有与给定手袋相似样式的鞋子，反之亦然。 我们将使用 Vanilla GAN 通过 GAN 的定制版本（例如 DiscoGAN 和 CycleGAN）来实施项目。
+第 4 章，“在 GAN 中使用 GAN” 进行时尚行业中的样式迁移，说明如何创建智能 AI 模型以生成具有与给定手袋相似样式的鞋子，反之亦然。 我们将使用原始 GAN 通过 GAN 的定制版本（例如 DiscoGAN 和 CycleGAN）来实施项目。
 
 第 5 章，“视频字幕应用程序”讨论了 CNN 和 LSTM 在视频字幕中的作用，并说明了如何利用序列到视频（视频到文本）架构来构建视频字幕系统。
 
@@ -45,9 +45,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/Intelligent-Projects-using-Python) 上。 如果代码有更新，它将在现有的 GitHub 存储库中进行更新。
 
diff --git a/new/intel-proj-py/01.md b/new/intel-proj-py/01.md
index 42930e9a..cab91c7e 100644
--- a/new/intel-proj-py/01.md
+++ b/new/intel-proj-py/01.md
@@ -10,7 +10,7 @@
 
 许多人会认为机器永远无法达到人类的智能水平，因为用来学习或执行智能任务的 AI 逻辑是由人类编程的，并且它们缺乏人类所拥有的意识和自我意识。 但是，一些研究人员提出了另一种想法，即人类意识和自我意识就像无限循环程序，可以通过反馈从周围的环境中学习。 因此，也有可能将意识和自我意识编程到机器中。 但是，就目前而言，我们将把 AI 的这一哲学方面再留一天，并简单地讨论我们所知道的 AI。
 
-简而言之，AI 可以定义为机器（通常是计算机或机器人）以类人的智力执行任务的能力，例如具有推理，学习经验，归纳，破译含义和拥有的能力等属性。 视觉感知。 我们将坚持这个更实际的定义，而不是关注 AI 效应所带来的哲学内涵以及 AI 奇异性的前景。 尽管可能存在关于 AI 可以实现和不能实现的争论，但基于 AI 的系统的最新成功故事却令人 over 目。 下图描述了 AI 的一些较新的主流应用程序：
+简而言之，AI 可以定义为机器（通常是计算机或机器人）以类人的智力执行任务的能力，例如具有推理，学习经验，归纳，破译含义和拥有的能力等属性。 视觉感知。 我们将坚持这个更实际的定义，而不是关注 AI 效应所带来的哲学内涵以及 AI 奇异性的前景。 尽管可能存在关于 AI 可以实现和不能实现的争论，但基于 AI 的系统的最新成功故事却令人瞩目。 下图描述了 AI 的一些较新的主流应用程序：
 
 ![](img/623d9065-122c-4066-bfed-634f7ac3cd75.png)
 
@@ -82,7 +82,7 @@
 
 # 神经激活单位
 
-取决于架构和当前的问题，在神经网络中使用了几种神经激活单元。 我们将讨论最常用的激活函数，因为它们在确定网络架构和性能方面起着重要作用。 线性和 S 形单位激活函数主要用于人工神经网络，直到 Hinton 等人发明的**整流线性单元**（**ReLUs**）彻底改变了神经网络的性能。
+取决于架构和当前的问题，在神经网络中使用了几种神经激活单元。 我们将讨论最常用的激活函数，因为它们在确定网络架构和性能方面起着重要作用。 线性和 Sigmoid 单元激活函数主要用于人工神经网络，直到 Hinton 等人发明的**整流线性单元**（**ReLUs**）彻底改变了神经网络的性能。
 
 # 线性激活单元
 
@@ -106,13 +106,13 @@
 
 ![](img/f54ce333-0cdb-400f-b9d1-22d60475291f.png)
 
-图 1.6：Sigmoid激活函数
+图 1.6：Sigmoid 激活函数
 
-自然界中任何复杂的过程通常在输入输出关系上都是非线性的，因此，我们需要非线性激活函数通过神经网络对其进行建模。 两类分类的神经网络的输出概率通常由 S 型神经单元的输出给定，因为它的输出值从零到一。 输出概率可以表示如下：
+自然界中任何复杂的过程通常在输入输出关系上都是非线性的，因此，我们需要非线性激活函数通过神经网络对其进行建模。 两类分类的神经网络的输出概率通常由 Sigmoid 神经单元的输出给定，因为它的输出值从零到一。 输出概率可以表示如下：
 
 ![](img/4e502901-d686-46cf-ba1c-e0b11d2c2707.png)
 
-在这里，`x`代表输出层中 S 型单元的总输入量。
+在这里，`x`代表输出层中 Sigmoid 单元的总输入量。
 
 # 双曲正切激活函数
 
@@ -126,11 +126,11 @@ tanh 激活函数输出的值在`[-1, 1]`范围内，如下图所示：
 
 图 1.7：Tanh 激活函数
 
-需要注意的一件事是 S 型和 tanh 激活函数在很小的输入范围内都是线性的，超过该范围输出就会饱和。 在饱和区，激活函数（相对于输入）的梯度非常小或接近零； 这意味着它们非常容易消失梯度问题。 正如您将在后面看到的那样，神经网络将从反向传播方法中学习，在该方法中，层的梯度取决于后续层中直至最终输出层中激活单元的梯度。 因此，如果激活单元中的单元在饱和区域中工作，则将更少的误差反向传播到神经网络的早期层。 神经网络通过利用梯度来最小化预测误差，以学习权重和偏差（`W`）。 这意味着，如果梯度很小或消失为零，则神经网络将无法正确学习这些权重。
+需要注意的一件事是 Sigmoid 和 tanh 激活函数在很小的输入范围内都是线性的，超过该范围输出就会饱和。 在饱和区，激活函数（相对于输入）的梯度非常小或接近零； 这意味着它们非常容易消失梯度问题。 正如您将在后面看到的那样，神经网络将从反向传播方法中学习，在该方法中，层的梯度取决于后续层中直至最终输出层中激活单元的梯度。 因此，如果激活单元中的单元在饱和区域中工作，则将更少的误差反向传播到神经网络的早期层。 神经网络通过利用梯度来最小化预测误差，以学习权重和偏差（`W`）。 这意味着，如果梯度很小或消失为零，则神经网络将无法正确学习这些权重。
 
 # 整流线性单元（ReLU）
 
-当神经元的总输入大于零时，ReLU 的输出为线性，而当神经元的总输入为负时，ReLU 的输出为零。 这个简单的激活函数为神经网络提供了非线性，同时，它相对于总输入提供了一个恒定的梯度。 这个恒定的梯度有助于防止神经网络出现饱和或消失的梯度问题，如激活函数（如 S 型和 tanh 激活单元）所示。 ReLU 函数输出（如图“图 1.8”所示）可以表示如下：
+当神经元的总输入大于零时，ReLU 的输出为线性，而当神经元的总输入为负时，ReLU 的输出为零。 这个简单的激活函数为神经网络提供了非线性，同时，它相对于总输入提供了一个恒定的梯度。 这个恒定的梯度有助于防止神经网络出现饱和或消失的梯度问题，如激活函数（如 Sigmoid 和 tanh 激活单元）所示。 ReLU 函数输出（如图“图 1.8”所示）可以表示如下：
 
 ![](img/f3c8b630-6ebc-4f71-903a-d192d27621f7.png)
 
@@ -146,11 +146,11 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 ![](img/66329819-1528-4067-afc8-bf3e505ecb09.png)
 
-将为泄漏的 ReLU 激活函数提供![](img/7e701921-1d53-4bbb-9ed7-e386eacc553c.png)参数，而对于参数 ReLU，![](img/21c3900a-a283-44ba-b15e-21d1faf0b243.png)是神经网络将通过训练学习的参数。 下图显示了泄漏的 ReLU 激活函数的输出：
+将为LReLU 激活函数提供![](img/7e701921-1d53-4bbb-9ed7-e386eacc553c.png)参数，而对于参数 ReLU，![](img/21c3900a-a283-44ba-b15e-21d1faf0b243.png)是神经网络将通过训练学习的参数。 下图显示了LReLU 激活函数的输出：
 
 ![](img/908a6fec-a34a-4e27-a0a4-27dd3b5d84cc.png)
 
-图 1.9：泄漏的 ReLU 激活函数
+图 1.9：LReLU 激活函数
 
 # softmax 激活单元
 
@@ -186,7 +186,7 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 图 1.10：说明反向传播的网络
 
-令网络输入为二维向量， `x = [x1, x2]^T`， 输出标签和预测分别为 ![](img/df5f56eb-23da-40f8-900d-1da3eecfb2d3.png) 和 ![](img/b3cffb09-935e-4bc2-a6d1-330919797695.png) 。 另外，我们假设神经网络中的所有激活单元都是 S 型。 让广义权重将层`l-1`中的任何单元`i`连接到层`l`中的单元`j`表示为 ![](img/29efb244-a597-41d7-baee-9826abbacd0b.png) ，而`l`层中任何单位`i`的偏置应表示为 ![](img/99d2725a-1b33-4aea-a0b1-7631b21edbc1.png) 。 让我们得出一个数据点的梯度； 总梯度可以计算为训练（或小批量）中使用的所有数据点的总和。 如果输出是连续的，则可以选择损失函数`C`作为预测误差的平方：
+令网络输入为二维向量， `x = [x1, x2]^T`， 输出标签和预测分别为 ![](img/df5f56eb-23da-40f8-900d-1da3eecfb2d3.png) 和 ![](img/b3cffb09-935e-4bc2-a6d1-330919797695.png) 。 另外，我们假设神经网络中的所有激活单元都是 Sigmoid。 让广义权重将层`l-1`中的任何单元`i`连接到层`l`中的单元`j`表示为 ![](img/29efb244-a597-41d7-baee-9826abbacd0b.png) ，而`l`层中任何单位`i`的偏置应表示为 ![](img/99d2725a-1b33-4aea-a0b1-7631b21edbc1.png) 。 让我们得出一个数据点的梯度； 总梯度可以计算为训练（或小批量）中使用的所有数据点的总和。 如果输出是连续的，则可以选择损失函数`C`作为预测误差的平方：
 
 ![](img/bb6a924b-9414-4008-b7a8-ee6cc0d11649.png)
 
@@ -232,7 +232,7 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 ![](img/ff5d7314-4a37-458c-933b-25a883f492bd.png)
 
-由于神经网络的所有单元（输出单元除外）均为 S 型激活函数，因此情况如下：
+由于神经网络的所有单元（输出单元除外）均为 Sigmoid 激活函数，因此情况如下：
 
 ![](img/665d5aaa-1fa7-4ab0-a7a8-5961d7faaf77.png)
 
@@ -262,13 +262,13 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 当卷积运算涉及在输入的每个位置上覆盖滤波器内核时，该卷积被称为跨度为 1。 如果我们选择在覆盖过滤器内核时跳过一个位置，那么卷积将以两个步幅执行。 通常，如果将`n`位置跳过而将滤波器内核覆盖在输入上，则表示卷积以`n + 1`的步幅执行。 大于 1 的步幅会减小卷积输出的空间尺寸。
 
-通常，卷积层之后是池化层，池化层基本上总结了由池化的接收场确定的邻域中的输出特征映射激活。 例如，一个 2 x 2 的接收场将收集四个相邻的输出特征映射激活的本地信息。 对于最大池操作，将选择四个激活的最大值作为输出，而对于平均池化，将选择四个激活的平均值。 合并降低了特征映射的空间分辨率。 例如，对于具有 2 x 2 接收场的 224 x 224 尺寸的特征映射池化操作，特征映射的空间尺寸将减小为 112 x 112。
+通常，卷积层之后是池化层，池化层基本上总结了由池化的接收场确定的邻域中的输出特征映射激活。 例如，一个`2 x 2`的接收场将收集四个相邻的输出特征映射激活的本地信息。 对于最大池操作，将选择四个激活的最大值作为输出，而对于平均池化，将选择四个激活的平均值。 合并降低了特征映射的空间分辨率。 例如，对于具有`2 x 2`接收场的`224 x 224`尺寸的特征映射池化操作，特征映射的空间尺寸将减小为`112 x 112`。
 
-要注意的一件事是，卷积运算减少了每层要学习的权重数。 例如，如果我们有一个空间尺寸为 224 x 224 的输入图像，而下一层的期望输出为尺寸为 224 x 224 的尺寸，那么对于具有完整连接的传统神经网络来说，要学习的权重数 是 224 x 224 x 224 x 224.对于具有相同输入和输出尺寸的卷积层，我们需要学习的只是滤波器内核的权重。 因此，如果我们使用 3 x 3 过滤器内核，我们只需要学习 9 个权重即可，而不是 224 x 224 x 224 x 224 权重。 这种简化是有效的，因为局部空间邻域中的图像和音频之类的结构之间具有高度相关性。
+要注意的一件事是，卷积运算减少了每层要学习的权重数。 例如，如果我们有一个空间尺寸为`224 x 224`的输入图像，而下一层的期望输出为尺寸为` 224 x 224 `的尺寸，那么对于具有完整连接的传统神经网络来说，要学习的权重数是`224 x 224 x 224 x 224`。对于具有相同输入和输出尺寸的卷积层，我们需要学习的只是滤波器内核的权重。 因此，如果我们使用`3 x 3`过滤器内核，我们只需要学习 9 个权重即可，而不是`224 x 224 x 224 x 224`权重。 这种简化是有效的，因为局部空间邻域中的图像和音频之类的结构之间具有高度相关性。
 
 输入图像经过多层卷积和池化操作。 随着网络的发展，特征映射的数量增加，而图像的空间分辨率降低。 在卷积池层的末端，要素图的输出被馈送到全连接层，然后是输出层。
 
-输出单位取决于手头的任务。 如果执行回归，则输出激活单位是线性的，而如果是二进制分类问题，则输出单位是 S 形的。 对于多类别分类，输出层是 softmax 单位。
+输出单位取决于手头的任务。 如果执行回归，则输出激活单位是线性的，而如果是二进制分类问题，则输出单位是 Sigmoid 的。 对于多类别分类，输出层是 softmax 单位。
 
 在本书的所有图像处理项目中，我们都将使用一种或另一种形式的卷积神经网络。
 
@@ -378,7 +378,7 @@ Figure 1.14: GAN architecture 
 
 ![](img/b9cb9aa1-7eac-4174-983d-cb5be41b1eff.png)
 
-生成器将尝试最大化由`(1)`给出的相同成本函数。 这意味着，优化问题可以表示为具有效用函数 `U(G, D)`的 minimax 播放器，如下所示：
+生成器将尝试最大化由`(1)`给出的相同成本函数。 这意味着，优化问题可以表示为具有效用函数 `U(G, D)`的 minimax 玩家，如下所示：
 
 ![](img/56db8673-21ba-456d-94a5-f78f8d33506b.png)
 
@@ -398,7 +398,7 @@ Figure 1.14: GAN architecture 
 
 ![](img/f5932e0c-dc8c-4041-abe9-24e33bcfc95f.png)
 
-对于固定的发电机分配，如果满足以下条件，则`G(x)`对于鉴别器的效用函数将最小。
+对于固定的生成器分配，如果满足以下条件，则`G(x)`对于鉴别器的效用函数将最小。
 
 ![](img/ec1949f8-e469-4633-9aaf-d857c5f0831c.png)
 
@@ -416,7 +416,7 @@ Figure 1.14: GAN architecture 
 
 因此，我们可以看到生成器最小化![](img/18728b2c-5f24-4bbc-888d-541116e69eeb.png)等于最小化实际分布`P(x)`与生成器生成的样本分布之间的 Jensen Shannon 散度`G`（即`G(x)`）。
 
-训练 GAN 并不是一个简单的过程，在训练这样的网络时我们需要考虑几个技术方面的考虑。 我们将使用高级 GAN 网络在第 4 章“使用 GANs* 的时装行业中的风格迁移”中构建跨域风格迁移应用程序。
+训练 GAN 并不是一个简单的过程，在训练这样的网络时我们需要考虑几个技术方面的考虑。 我们将使用高级 GAN 网络在第 4 章“使用 GANs 的时装行业中的风格迁移”中构建跨域风格迁移应用程序。
 
 # 强化学习
 
@@ -424,7 +424,7 @@ Figure 1.14: GAN architecture 
 
 ![](img/13aa6565-1619-42b6-a595-a2bf486f0a6e.png)
 
-图 1.15：强化学习模型中的 Agent 与环境交互
+图 1.15：强化学习模型中的智能体与环境交互
 
 # Q 学习
 
@@ -488,7 +488,7 @@ Figure 1.14: GAN architecture 
 
 图 1.18：使用预训练的 VGG 16 网络进行迁移学习
 
-以`x`表示的输入图像被馈送到**预训练的 VGG 16** 网络，以及`4096`维输出特征向量`x'`，是从最后一个全连接层中提取的。 提取的特征`x'`以及相应的类别标签`y`用于训练简单的分类网络，从而减少解决问题所需的数据。*
+以`x`表示的输入图像被馈送到**预训练的 VGG 16** 网络，以及`4096`维输出特征向量`x'`，是从最后一个全连接层中提取的。 提取的特征`x'`以及相应的类别标签`y`用于训练简单的分类网络，从而减少解决问题所需的数据。
 
 我们将通过使用第 2 章，“迁移学习”中的迁移学习来解决医疗保健领域中的图像分类问题。
 
diff --git a/new/intel-proj-py/02.md b/new/intel-proj-py/02.md
index 5cb7647f..abafd085 100644
--- a/new/intel-proj-py/02.md
+++ b/new/intel-proj-py/02.md
@@ -110,7 +110,7 @@
 
 如果我们观察二次权重的表达式`w[ij]`，我们可以看到，当实际标签与预测标签之间的差异较大时，权重的值会更高 更伟大。 由于类的序数性质，这是有道理的。 例如，让我们用类别标签 0 表示完美状态的眼睛; 患有轻度糖尿病性视网膜病的患者; 中度糖尿病视网膜病变伴两个; 并伴有严重的糖尿病性视网膜病变。 当轻度糖尿病性视网膜病被错误地分类为严重糖尿病性视网膜病而不是中度糖尿病性视网膜病时，这个二次项权重`w[ij]`将会更高。 这是有道理的，因为即使我们没有设法预测实际类别，我们也希望预测一个尽可能接近实际状况的状况。
 
-我们将使用`sklearn.metrics.cohen_kappa_score`和`weights= "quadratic"` 来计算 kappa 得分。 权重越高，kappa 得分越低。
+我们将使用`sklearn.metrics.cohen_kappa_score`和`weights= "quadratic"`来计算 kappa 得分。 权重越高，kappa 得分越低。
 
 # 制定损失函数
 
@@ -166,7 +166,7 @@ Softmax 将是表示输出层中不同类别的概率的最佳激活函数，而
 
 # 预处理图像
 
-不同类别的图像将存储在不同的文件夹中，因此可以轻松标记其类别。 我们将使用`Opencv`函数读取图像，并将其调整为不同的尺寸，例如 224 x 224 x3。我们将基于 ImageNet 数据集从每个图像的通道方向上减去平均像素强度。 这意味着减法将使糖尿病性视网膜病变图像达到与在其上训练了预训练模型的处理过的 ImageNet 图像相同的强度范围。 提出每个图像后，它们将存储在`numpy`数组中。 图像预处理功能可以定义如下：
+不同类别的图像将存储在不同的文件夹中，因此可以轻松标记其类别。 我们将使用`Opencv`函数读取图像，并将其调整为不同的尺寸，例如`224 x 224 x3`。我们将基于 ImageNet 数据集从每个图像的通道方向上减去平均像素强度。 这意味着减法将使糖尿病性视网膜病变图像达到与在其上训练了预训练模型的处理过的 ImageNet 图像相同的强度范围。 提出每个图像后，它们将存储在`numpy`数组中。 图像预处理功能可以定义如下：
 
 ```py
 def get_im_cv2(path,dim=224):
@@ -285,7 +285,7 @@ InceptionV3 论文链接如下：
 
 [《重新思考计算机视觉的起始架构》](https://arxiv.org/abs/1512.00567)
 
-简而言之，`VGG16`是一个 16 层的 CNN，使用 3 x 3 滤波器和 2 x 2 接收场进行卷积。 整个网络使用的激活函数都是 ReLU。 由 Simonyan 和 Zisserman 开发的 VGG 架构是 2014 年 ILSVRC 竞赛的亚军。 `VGG16`网络由于其简单性而广受欢迎，它是从图像中提取特征的最受欢迎的网络。
+简而言之，`VGG16`是一个 16 层的 CNN，使用`3 x 3`滤波器和`2 x 2`接收场进行卷积。 整个网络使用的激活函数都是 ReLU。 由 Simonyan 和 Zisserman 开发的 VGG 架构是 2014 年 ILSVRC 竞赛的亚军。 `VGG16`网络由于其简单性而广受欢迎，它是从图像中提取特征的最受欢迎的网络。
 
 `ResNet50`是一种深层的 CNN，它实现了残余块的概念，与`VGG16`网络的概念完全不同。 经过一系列的卷积激活池操作之后，该块的输入再次被反馈到输出。 ResNet 架构是由 Kaiming He 等人开发的，尽管具有 152 层，但它不如 VGG 网络复杂。 该架构通过实现 3.57% 的前五位错误率赢得了 2015 年 ILSVRC 竞赛，这比该竞赛数据集上的人类水平性能要好。 通过检查目标是否在概率最高的五类预测中来计算前五个错误率。 原则上，ResNet 网络尝试学习残差映射，而不是直接从输出映射到输入，如下面的残差框图所示：
 
@@ -335,7 +335,7 @@ def VGG16_pseudo(dim=224,freeze_layers=10,full_freeze='N'):
 
 在以下代码块中定义了用于我们任务的`InceptionV3`网络。 需要注意的一件事是，由于`InceptionV3`是一个更深的网络，因此我们可以拥有更多的初始层。 在数据可用性方面，不训练每个模型中的所有层的想法还有另一个优势。 如果我们使用较少的数据训练，则整个网络的权重可能会导致过拟合。 冻结层会减少要训练的权重数，因此提供了一种形式的规则化。
 
-由于初始层学习通用特征，而与问题的范围无关，因此它们是冻结的最佳层。 我们还在全连接层中使用了 dropout，以防止过拟合：
+由于初始层学习通用特征，而与问题的范围无关，因此它们是冻结的最佳层。 我们还在全连接层中使用了丢弃，以防止过拟合：
 
 ```py
 def inception_pseudo(dim=224,freeze_layers=30,full_freeze='N'):
@@ -1002,7 +1002,7 @@ def inception_pseudo(dim=224,freeze_layers=30,full_freeze='N'):
 
 一旦我们预测了回归分数，就将其舍入到最接近的严重性类别（零到四）。
 
-# 使用 keras 顺序 utils 作为生成器
+# 使用 keras `utils.sequence`作为生成器
 
 Keras 具有一个名为`keras.utils.sequence()`的优秀批量生成器，可帮助您以极大的灵活性自定义批量创建。 实际上，使用`keras.utils.sequence()`可以设计整个周期流水线。 我们将在此回归问题中使用此实用程序以习惯该实用程序。 对于迁移学习问题，我们可以使用`keras.utils.sequence()`设计生成器类，如下所示：
 
@@ -1193,7 +1193,7 @@ python TransferLearning_reg.py --path '/media/santanu/9eb9b6dc-b380-486e-b4fd-c4
 Model saved to dest: {1: '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/InceptionV3___1', 2: '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/InceptionV3___2', 3: '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/InceptionV3___3', 4: '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/InceptionV3___4', 5: '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/InceptionV3___5'}
 ```
 
-如我们所见，对应于`5`折叠的`5`模型已保存在我们指定的 Regression 文件夹下。 接下来，我们可以对验证数据集进行推断，并查看回归模型的运行情况。 可以如下调用相同的 Python 脚本：
+如我们所见，对应于`5`折叠的`5`模型已保存在我们指定的`Regression`文件夹下。 接下来，我们可以对验证数据集进行推断，并查看回归模型的运行情况。 可以如下调用相同的 Python 脚本：
 
 ```py
  python TransferLearning_reg.py  --path '/media/santanu/9eb9b6dc-b380-486e-b4fd-c424a325b976/book AI/Diabetic Retinopathy/Extra/assignment2_train_dataset/' --class_folders '["class0","class1","class2","class3","class4"]' --dim 224  --lr 1e-4 --batch_size 32 --model InceptionV3  --outdir '/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/' --mode validation  --model_save_dest --'/home/santanu/ML_DS_Catalog-/Transfer_Learning_DR/Regression/model_dict.pkl' --folds 5 
diff --git a/new/intel-proj-py/03.md b/new/intel-proj-py/03.md
index d79915f0..3cfef8d1 100644
--- a/new/intel-proj-py/03.md
+++ b/new/intel-proj-py/03.md
@@ -102,7 +102,7 @@
 
 ![](img/b00765b5-99f5-4dc3-a9cd-32f3ae13a51f.png)
 
-对于 bigram 模型，给定当前单词`t[1]`的下一个单词的条件概率为`t[2]`计算训练语料库中偶对`(t[1], t[2])`的总数，并根据出现的次数归一化 语料库中`t[1]`的含义：
+对于二元模型，给定当前单词`t[1]`的下一个单词的条件概率为`t[2]`计算训练语料库中偶对`(t[1], t[2])`的总数，并根据出现的次数归一化 语料库中`t[1]`的含义：
 
 ![](img/4011e558-b4fc-468a-89cc-3ae457494668.png)
 
@@ -110,7 +110,7 @@
 
 ![](img/a4e37492-f2ae-4999-b8d1-53d9afac5fba.png)
 
-超出三字母组合模型通常会导致稀疏性。 即使对于双字母组模型，我们也可能会缺少几个双字母组的条件概率，因为它们没有出现在训练语料库中。 但是，那些缺失的二元组可能非常相关，并且估计其条件概率非常重要。 不用说，n-gram 模型倾向于估计出现在训练数据中的单词对的高条件概率，而忽略没有出现的单词。
+超出三字母组合模型通常会导致稀疏性。 即使对于双字母组模型，我们也可能会缺少几个双字母组的条件概率，因为它们没有出现在训练语料库中。 但是，那些缺失的二元组可能非常相关，并且估计其条件概率非常重要。 不用说，`n`元模型倾向于估计出现在训练数据中的单词对的高条件概率，而忽略没有出现的单词。
 
 # 语言模型的困惑
 
@@ -140,7 +140,7 @@
 
 如果语言模型的训练语料也是`I love Machine Learning`，则测试集的概率为 1，导致对数概率为`0`，且困惑为`1`。 这意味着该模型可以完全确定地生成下一个单词。
 
-另一方面，如果我们有一个更现实的训练语料库，其词汇量为`N`= 20,000，并且训练数据集在测试数据集上的困惑度为 100，那么平均而言， 为了预测序列中的下一个单词，我们将搜索范围从 20,000 个单词缩小到 100 个单词。
+另一方面，如果我们有一个更现实的训练语料库，其词汇量为`N = 20,000`，并且训练数据集在测试数据集上的困惑度为 100，那么平均而言， 为了预测序列中的下一个单词，我们将搜索范围从 20,000 个单词缩小到 100 个单词。
 
 让我们看一下最坏的情况，在这种情况下，我们设法建立一个模型，其中每个单词都与序列中的先前单词无关：
 
@@ -150,7 +150,7 @@
 
 ![](img/ba0cff31-c3c7-49ec-9967-d48fdcdb8ae4.png)
 
-如果我们像以前一样有`N`= 20,000，那么要预测序列中的任何单词，就需要考虑词汇表中的所有`N`个单词，因为它们都是一样的。 在这种情况下，我们无法减少单词的平均搜索空间来预测序列中的单词。
+如果我们像以前一样有`N = 20,000`，那么要预测序列中的任何单词，就需要考虑词汇表中的所有`N`个单词，因为它们都是一样的。 在这种情况下，我们无法减少单词的平均搜索空间来预测序列中的单词。
 
 # 翻译模型
 
@@ -697,7 +697,7 @@ python MachineTranslation.py --path '/home/santanu/ML_DS_Catalog/Machine Transla
 
 代替单热编码矢量，可以使用词矢量嵌入来表示维的密集空间中的单词，该空间比单热编码矢量低得多。 嵌入单词`w`的单词向量可以用`v[w] ∈ R^m`表示，其中`m`是词向量嵌入的维数。 如我们所见，虽然一个热编码矢量的每个分量只能占用{0,1}的二进制值，但词矢量嵌入的分量却可以占用任何实数，因此具有更密集的表示。 相似性和类比的概念也与词向量嵌入有关。
 
-通常通过诸如连续词袋法，skip-gram，GloVe 等技术来训练词向量嵌入。 我们将不对它们的实现进行过多的介绍，但中心思想是以这样的方式定义词向量嵌入：将类似的词紧密放置在 m 维欧几里得空间中：
+通常通过诸如连续词袋法，skip-gram，GloVe 等技术来训练词向量嵌入。 我们将不对它们的实现进行过多的介绍，但中心思想是以这样的方式定义词向量嵌入：将类似的词紧密放置在`m`维欧几里得空间中：
 
 ![](img/9f7522e1-949b-4004-b21d-4f95010db169.png)
 
diff --git a/new/intel-proj-py/04.md b/new/intel-proj-py/04.md
index 058b6b1c..38e60004 100644
--- a/new/intel-proj-py/04.md
+++ b/new/intel-proj-py/04.md
@@ -4,7 +4,7 @@
 
 生成对抗网络是通过在生成器网络和鉴别器网络之间进行零和游戏来学习的网络。 假设一位时装设计师想要设计一种特定结构的手袋，并且正在探索不同的印花。 设计人员可以绘制手提包的结构草图，然后将草图图像输入到生成的对抗网络中，以得出手提包的几种可能的最终印刷品。 这种样式迁移过程可以使客户自己绘制产品设计和图案，而无需征集大量设计师的意见，从而对时尚行业产生巨大影响。 通过推荐具有类似设计和风格的产品来补充客户已经拥有的产品，时装屋也可以从中受益。
 
-在这个项目中，我们将构建一个智能人工智能系统，该系统将生成与给定手提袋样式相似的鞋子，反之亦然。 我们之前讨论的香草 GAN 不足以实现这个项目。 我们需要的是 GAN 的定制版本，例如 DiscoGAN 和 CycleGAN。
+在这个项目中，我们将构建一个智能人工智能系统，该系统将生成与给定手提袋样式相似的鞋子，反之亦然。 我们之前讨论的原始 GAN 不足以实现这个项目。 我们需要的是 GAN 的定制版本，例如 DiscoGAN 和 CycleGAN。
 
 在本章中，我们将介绍以下主题：
 
@@ -23,13 +23,13 @@
 
 # DiscoGAN
 
-**DiscoGAN** 是一个生成的对抗网络，它在给定域 A 中的图像的情况下生成域 B 中产品的图像。下图说明了 DisoGAN 网络的架构图：
+**DiscoGAN** 是一个生成的对抗网络，它在给定域`A`中的图像的情况下生成域`B`中产品的图像。下图说明了 DisoGAN 网络的架构图：
 
 ![](img/ad2f3c06-0854-4f44-871f-d0916c1f0980.png)
 
 图 4.1：DiscoGAN 的架构图
 
-域 B 中生成的图像在样式和样式上都类似于域 A 中的图像。 无需在训练过程中显式配对来自两个域的图像就可以学习这种关系。 鉴于项目的配对是一项耗时的任务，因此这是一项非常强大的功能。 在较高的水平上，它尝试学习神经网络`G[AB]`和`G[BA]`形式的两个生成器函数。 图像`x[A]`，当通过发生器馈入时`G[AB]`，产生图像`x[AB]`，在域`B`中看起来很真实。此外，当此图像`x[AB]`通过其他生成器网络`G[BA]`馈送时，它应产生图像`x[ABA]`，理想情况下应与原始图像`x[A]`相同。 关于生成器功能，以下关系应成立：
+域`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)
 
@@ -37,7 +37,7 @@
 
 ![](img/09ada4ef-4d12-45db-a6b8-19064db767e9.png)
 
-仅使前面的损失最小化是不够的。 我们必须确保在域 B 中创建的图像`x[B]`看起来逼真。例如，如果我们将域`A`中的衣服映射到域`B`中的鞋子，我们将 确保`x[B]`类似于鞋子。 如果图像不够真实，则在域 B 侧的鉴别符`D[B]`将检测为`x[B]`为假。 鞋子，因此也要考虑与此有关的损失。 通常，在训练过程中，向鉴别器提供生成的域`B`图像`x[AB] = G[AB](X[A])`，我们选择在这里用`y[B]`表示，以便它学习从假图像中对真实图像进行分类。 您可能还记得，在 GAN 中，生成器和判别器相互进行*零和最小最大值游戏*，以便不断变得更好，直到达到平衡为止。 如果伪造的图像看起来不够逼真，则鉴别器将对其进行惩罚，这意味着生成器必须学习产生更好的图像`x[AB]`，如果输入图像`x[A]`。 考虑到所有这些因素，我们可以将我们希望最小化的生成器损耗公式化为重建损耗，以及鉴别器将`x[AB]`识别为假冒的损耗。 第二种损失将试图使生成器在域 B 中生成逼真的图像。将域 A 中的图像`x[A]`映射到域 B 中的图像的生成器损失可以表示为 如下：
+仅使前面的损失最小化是不够的。 我们必须确保在域`B`中创建的图像`x[B]`看起来逼真。例如，如果我们将域`A`中的衣服映射到域`B`中的鞋子，我们将 确保`x[B]`类似于鞋子。 如果图像不够真实，则在域`B`侧的鉴别符`D[B]`将检测为`x[B]`为假。 鞋子，因此也要考虑与此有关的损失。 通常，在训练过程中，向鉴别器提供生成的域`B`图像`x[AB] = G[AB](X[A])`，我们选择在这里用`y[B]`表示，以便它学习从假图像中对真实图像进行分类。 您可能还记得，在 GAN 中，生成器和判别器相互进行*零和最小最大值游戏*，以便不断变得更好，直到达到平衡为止。 如果伪造的图像看起来不够逼真，则鉴别器将对其进行惩罚，这意味着生成器必须学习产生更好的图像`x[AB]`，如果输入图像`x[A]`。 考虑到所有这些因素，我们可以将我们希望最小化的生成器损耗公式化为重建损耗，以及鉴别器将`x[AB]`识别为假冒的损耗。 第二种损失将试图使生成器在域`B`中生成逼真的图像。将域`A`中的图像`x[A]`映射到域`B`中的图像的生成器损失可以表示为 如下：
 
 ![](img/f2cdd9c3-d4d4-4c89-a533-e5044ea37592.png)
 
@@ -47,15 +47,15 @@ L2 范数下的重建损失可以表示为：
 
 由于我们正在处理图像，因此可以假设`x[A]`是所有像素的扁平向量，以符合 L2 规范术语。 如果我们假设`x[A]`是矩阵，则最好将![](img/6e698b45-8fde-420b-8ada-ee9b7b1f13c9.png)称为 **Frobenius 范数**。 但是，这些只是数学术语，实质上，我们只是将原始图像和重建图像之间的像素值差的平方和求和。
 
-让我们考虑一下生成器在使变换后的图像`x[AB]`追求时要尽量降低成本的做法。 鉴别者将尝试将图像标记为伪图像，因此生成器`G[AB]`应当在这种情况下产生`x[AB]`使其成为假图片的对数丢失的方式尽可能小。 如果域 B 中的鉴别符`D[B]`将真实图像标记为`1`，将伪图像标记为`0`，则图像真实的概率由`D[B](.)`，则发生器应使`x[AB]`在鉴别器网络下极有可能出现，从而使`D[B](x[B]) = D[B](G[AB](x[A]))`接近`1`）。 就对数损失而言，生成器应使先前概率的负对数最小化，这基本上使我们得到`C[D(AB)]`，如下所示：
+让我们考虑一下生成器在使变换后的图像`x[AB]`追求时要尽量降低成本的做法。 鉴别者将尝试将图像标记为伪图像，因此生成器`G[AB]`应当在这种情况下产生`x[AB]`使其成为假图片的对数丢失的方式尽可能小。 如果域`B`中的鉴别符`D[B]`将真实图像标记为`1`，将伪图像标记为`0`，则图像真实的概率由`D[B](.)`，则发生器应使`x[AB]`在鉴别器网络下极有可能出现，从而使`D[B](x[B]) = D[B](G[AB](x[A]))`接近`1`）。 就对数损失而言，生成器应使先前概率的负对数最小化，这基本上使我们得到`C[D(AB)]`，如下所示：
 
 ![](img/549bd16c-1bd7-4f76-b4c1-6179369f92c7.png)
 
-结合`(3)`和`(4)`，我们可以获得将映像从域 A 映射到域 A 的总生成器成本`C_G[AB]`域 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[BA]`将它们映射到域 A。 如果我们在域 B 中拍摄`x[B]`图像，并通过生成器`G[BA]`将其转换为图像`x[BA]`，而域 A 上的标识符由`D[A]`给出，则与这种转换相关的成本函数由以下给出：
+最大的问题是，我们可以在这里停下来吗？ 由于我们有来自两个域的图像，因此要获得更好的映射，我们也可以从域`B`拍摄图像，并通过生成器`G[BA]`将它们映射到域`A`。 如果我们在域`B`中拍摄`x[B]`图像，并通过生成器`G[BA]`将其转换为图像`x[BA]`，而域`A`上的标识符由`D[A]`给出，则与这种转换相关的成本函数由以下给出：
 
 ![](img/e8a983da-5a03-453d-8317-eff82e4164e6.png) ![](img/0812b062-6e92-4e91-b725-747ac4b61f31.png)
 
@@ -83,21 +83,21 @@ L2 范数下的重建损失可以表示为：
 
 对成本函数执行随机梯度下降（例如 Adam），以得出最优解。 请注意，如前所述，生成对抗网络的解决方案是优化成本函数的一个障碍。
 
-# 循环 GAN
+# CycleGAN
 
 **CycleGAN** 从根本上类似于 DiscoGAN，但有一个小的修改。 在 CycleGAN 中，我们可以灵活地确定相对于 GAN 损失或归因于鉴别器的损失，为重建损失分配多少权重。 该参数有助于根据眼前的问题按正确比例平衡损失，以帮助网络在训练时更快地收敛。 CycleGAN 的其余实现与 DiscoGAN 相同。
 
 # 学习从草绘的轮廓生成天然手袋
 
-在本章中，我们将使用草绘的轮廓生成手袋，而无需使用 DiscoGAN 进行显式配对。 我们将草图图像表示为属于域 A，而将自然手袋图像表示为属于域 B。将有两种生成器：一种生成器，用于获取域 A 的图像并将其映射到在域 B 下看起来逼真的图像，以及 另一个与此相反：将域 B 中的手袋图像映射到在域 A 下看起来很逼真的图像。鉴别者将尝试从每个域中真实图像的生成器中识别生成器生成的虚假图像。 生成器和判别器将相互进行 minimax 零和游戏。
+在本章中，我们将使用草绘的轮廓生成手袋，而无需使用 DiscoGAN 进行显式配对。 我们将草图图像表示为属于域`A`，而将自然手袋图像表示为属于域`B`。将有两种生成器：一种生成器，用于获取域`A`的图像并将其映射到在域`B`下看起来逼真的图像，以及 另一个与此相反：将域`B`中的手袋图像映射到在域`A`下看起来很逼真的图像。鉴别者将尝试从每个域中真实图像的生成器中识别生成器生成的虚假图像。 生成器和判别器将相互进行 minimax 零和游戏。
 
 要训​​练该网络，我们将需要两套图像，手袋的草图或轮廓以及手袋的自然图像。 [可以从以下链接下载图像](https://people.eecs.berkeley.edu/~tinghuiz/projects/pix2pix/datasets/edges2handbags.tar.gz)。
 
-在接下来的几节中，我们将完成在 TensorFlow 中定义 DiscoGAN 网络的过程，然后训练它使用充当图像边缘的手提包草图来生成逼真的手提包图像。 我们将从定义发电机网络的架构开始。
+在接下来的几节中，我们将完成在 TensorFlow 中定义 DiscoGAN 网络的过程，然后训练它使用充当图像边缘的手提包草图来生成逼真的手提包图像。 我们将从定义生成器网络的架构开始。
 
 # 预处理图像
 
-`edges2handbags`数据集文件夹中的每个图像在同一图像中包含`bag`的图片和`bag edges`的图片。 为了训练网络，我们需要将它们分离为属于我们在 DiscoGAN 架构中讨论过的两个域 A 和 B 的图像。 通过使用以下代码（`image_split.py`），可以将图像分为域 A 和域 B 图像：
+`edges2handbags`数据集文件夹中的每个图像在同一图像中包含`bag`的图片和`bag edges`的图片。 为了训练网络，我们需要将它们分离为属于我们在 DiscoGAN 架构中讨论过的两个域`A`和 B 的图像。 通过使用以下代码（`image_split.py`），可以将图像分为域`A`和域`B`图像：
 
 ```py
 # -*- coding: utf-8 -*-
@@ -187,7 +187,7 @@ the number of input images processed : 30000
 .....
 ```
 
-# DiscoGAN 的发电机
+# DiscoGAN 的生成器
 
 DiscoGAN 的生成器是前馈卷积神经网络，其中输入和输出是图像。 在网络的第一部分中，图像在空间维度上按比例缩小，而输出要素图的数量随图层的进展而增加。 在网络的第二部分中，图像沿空间维度按比例放大，而输出特征映射的数量则逐层减少。 在最终输出层中，将生成具有与输入相同的空间尺寸的图像。 如果生成器将图像`x[A]`转换为`x[AB]`从域`A`到域`B`表示为`G[AB]`，则我们有![](img/6c5507b6-7666-4601-8730-0b89c4a198fc.png)。
 
@@ -282,11 +282,11 @@ def build_generator(self,image,reuse=False,name='generator'):
         return out_img
 ```
 
-在生成器函数中，我们定义了泄漏的 ReLU 激活函数，并使用`0.2`的泄漏因子。 我们还定义了卷积层生成函数`common_conv2d`（用于对图像进行下采样）和`common_deconv2d`（用于将经降采样的图像上采样至其原始空间尺寸）。
+在生成器函数中，我们定义了LReLU 激活函数，并使用`0.2`的泄漏因子。 我们还定义了卷积层生成函数`common_conv2d`（用于对图像进行下采样）和`common_deconv2d`（用于将经降采样的图像上采样至其原始空间尺寸）。
 
 我们通过使用`tf.get_variable_scope().reuse_variables()`使用`reuse`选项定义生成器功能。 当多次调用同一个生成器函数时，重用选项可确保我们重用特定生成器使用的相同变量。 当我们删除重用选项时，我们为生成器创建了一组新的变量。
 
-例如，我们可能使用 generator 函数创建了两个生成器网络，因此在第一次创建这些网络时不会使用`reuse`选项。 如果再次引用该生成器功能，则使用`reuse`选项。 卷积（下采样）和解卷积（上采样）期间的激活函数是 LReLU，然后进行批量归一化，以实现稳定和快速的收敛。
+例如，我们可能使用生成器函数创建了两个生成器网络，因此在第一次创建这些网络时不会使用`reuse`选项。 如果再次引用该生成器功能，则使用`reuse`选项。 卷积（下采样）和解卷积（上采样）期间的激活函数是 LReLU，然后进行批量归一化，以实现稳定和快速的收敛。
 
 网络不同层中的输出要素图的数量可以是`self.gf` 或其倍数。 对于我们的 DiscoGAN 网络，我们选择了`self.gf`作为`64`。
 
@@ -300,7 +300,7 @@ def build_generator(self,image,reuse=False,name='generator'):
 
 # DiscoGAN 的区别
 
-DiscoGAN 的区分者将学会在特定域中将真实图像与假图像区分开。 我们将有两个鉴别符：一个用于域 A，一个用于域 B。这些鉴别器也是可以执行二进制分类的卷积网络。 与传统的基于分类的卷积网络不同，鉴别器没有任何全连接层。 使用步长为 2 的卷积对输入图像进行下采样，直到最终层（输出为 1 x 1）为止。同样，我们使用泄漏的 ReLU 作为激活函数并使用批量归一化以实现稳定和快速的收敛。 以下代码显示了 TensorFlow 中鉴别器构建函数的实现：
+DiscoGAN 的区分者将学会在特定域中将真实图像与假图像区分开。 我们将有两个鉴别符：一个用于域`A`，一个用于域`B`。这些鉴别器也是可以执行二进制分类的卷积网络。 与传统的基于分类的卷积网络不同，鉴别器没有任何全连接层。 使用步长为 2 的卷积对输入图像进行下采样，直到最终层（输出为`1 x 1`）为止。同样，我们使用LReLU 作为激活函数并使用批量归一化以实现稳定和快速的收敛。 以下代码显示了 TensorFlow 中鉴别器构建函数的实现：
 
 ```py
 def build_discriminator(self,image,reuse=False,name='discriminator'):
@@ -464,21 +464,21 @@ def build_network(self):
     self.saver = tf.train.Saver()
 ```
 
-在构建网络中，我们首先定义 L2 范数误差和二进制交叉熵误差的成本函数。 L2 范数误差将用作重建损失，而二元互熵将用作鉴别器损失。 然后，我们使用生成器函数为两个域中的图像定义占位符，并为每个域中的伪图像定义 TensorFlow ops。 我们还通过传递特定于域的伪造和真实图像来定义鉴别器输出的操作。 除此之外，我们为两个域中的每个域中的重建图像定义 TensorFlow op。
+在构建网络中，我们首先定义 L2 范数误差和二进制交叉熵误差的成本函数。 L2 范数误差将用作重建损失，而二元互熵将用作鉴别器损失。 然后，我们使用生成器函数为两个域中的图像定义占位符，并为每个域中的伪图像定义 TensorFlow 操作。 我们还通过传递特定于域的伪造和真实图像来定义鉴别器输出的操作。 除此之外，我们为两个域中的每个域中的重建图像定义 TensorFlow 操作。
 
-一旦定义了操作，我们就可以使用它们来计算损失函数，同时考虑图像的重建损失和归因于鉴别器的损失。 请注意，我们使用了相同的生成器函数来定义域 A 到 B 的生成器，也定义了从 B 到 A 的生成器。唯一不同的是为这两个网络提供了不同的名称：`generator_AB`和 `generator_BA`。 由于变量作用域定义为`name`，所以这两个生成器都将具有不同的权重集，并以提供的名称为前缀。
+一旦定义了操作，我们就可以使用它们来计算损失函数，同时考虑图像的重建损失和归因于鉴别器的损失。 请注意，我们使用了相同的生成器函数来定义域`A`到`B`的生成器，也定义了从`B`到`A`的生成器。唯一不同的是为这两个网络提供了不同的名称：`generator_AB`和 `generator_BA`。 由于变量作用域定义为`name`，所以这两个生成器都将具有不同的权重集，并以提供的名称为前缀。
 
 下表显示了我们需要跟踪的不同损耗变量。 就发生器或鉴别器的参数而言，所有这些损失都需要最小化：
 
 | **不同损失的变量** | **说明** |
-| `self.D_B_loss_real` | 在对域 B 中的真实图像进行分类时，鉴别符`D[B]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator `D[B]`) |
-| `self.D_B_loss_fake` | 在对域 B 中的伪造图像进行分类时，鉴别符`D[B]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator `D[B]`) |
-| `self.D_A_loss_real` | 在对域 A 中的真实图像进行分类时，鉴别符`D[A]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator `D[A]`) |
-| `self.D_A_loss_fake` | 在对域 A 中的伪造图像进行分类时，鉴别符`D[A]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator `D[A]`) |
-| `self.loss_GABA` | 通过两个生成器`G[AB]`和`G[BA]`将域 A 中的图像映射到 B，然后再映射回 A 的重建损失 ）加上假图片`G[AB](x[A])`的二进制交叉熵，并由域 B 中的鉴别器标记为真实图像。(This loss is to be minimized with respect to the parameters of the generators `G[AB]` and `G[BA]`) |
-| `self.loss_GBAB` | 通过两个生成器`G[BA]`和`G[AB]`将域 B 中的图像映射到 A，然后再映射回 B 的重建损失 加上伪图片`G[BA](x[B])`的二元交叉熵，由域 A 中的鉴别器标记为真实图像。(This loss is to be minimized with respect to the parameters of the generators `G[AB]` and `G[BA]`) |
+| `self.D_B_loss_real` | 在对域`B`中的真实图像进行分类时，鉴别符`D[B]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator `D[B]`) |
+| `self.D_B_loss_fake` | 在对域`B`中的伪造图像进行分类时，鉴别符`D[B]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator `D[B]`) |
+| `self.D_A_loss_real` | 在对域`A`中的真实图像进行分类时，鉴别符`D[A]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator `D[A]`) |
+| `self.D_A_loss_fake` | 在对域`A`中的伪造图像进行分类时，鉴别符`D[A]`的二进制交叉熵损失。(This loss is to be minimized with respect to the parameters of the discriminator `D[A]`) |
+| `self.loss_GABA` | 通过两个生成器`G[AB]`和`G[BA]`将域`A`中的图像映射到`B`，然后再映射回`A`的重建损失 ）加上假图片`G[AB](x[A])`的二进制交叉熵，并由域`B`中的鉴别器标记为真实图像。(This loss is to be minimized with respect to the parameters of the generators `G[AB]` and `G[BA]`) |
+| `self.loss_GBAB` | 通过两个生成器`G[BA]`和`G[AB]`将域`B`中的图像映射到`A`，然后再映射回`B`的重建损失 加上伪图片`G[BA](x[B])`的二元交叉熵，由域`A`中的鉴别器标记为真实图像。(This loss is to be minimized with respect to the parameters of the generators `G[AB]` and `G[BA]`) |
 
-前四个损耗组成了鉴别器损耗，需要根据鉴别器的参数将其最小化。 ]。 最后两个损耗组成了发电机损耗，需要根据发电机的参数将其最小化。 。
+前四个损耗组成了鉴别器损耗，需要根据鉴别器的参数将其最小化。 ]。 最后两个损耗组成了生成器损耗，需要根据生成器的参数将其最小化。 。
 
 损失变量通过`tf.summary.scaler` 与 TensorBoard 绑定，以便可以在训练过程中监控这些损失，以确保以期望的​​方式减少损失。 稍后，我们将在培训进行时在 TensorBoard 中看到这些损失痕迹。
 
@@ -578,9 +578,9 @@ def sample_model(self, sample_dir, epoch, id_):
                     './{}/B_{:02d}_{:04d}.jpg'.format(sample_dir, epoch, id_))
 ```
 
-在此`sample_model`函数中，从域 A 随机选择的图像被拍摄并馈送到生成器`G[AB]`，以在域 B 中生成图像。类似地，从域 B 随机选择的图像是 馈送到生成器`G[BA]`中，以在域 A 中生成图像。这些输出图像由两个生成器在不同时期生成，并将批次保存在样本文件夹中以查看是否 生成器在训练过程中随着时间的推移而不断改进，以产生更好的图像质量。
+在此`sample_model`函数中，从域`A`随机选择的图像被拍摄并馈送到生成器`G[AB]`，以在域`B`中生成图像。类似地，从域`B`随机选择的图像是 馈送到生成器`G[BA]`中，以在域`A`中生成图像。这些输出图像由两个生成器在不同时期生成，并将批次保存在样本文件夹中以查看是否 生成器在训练过程中随着时间的推移而不断改进，以产生更好的图像质量。
 
-使用 TensorFlow saver 功能保存模型的`save_model`函数如下所示：
+使用 TensorFlow 保存器功能保存模型的`save_model`函数如下所示：
 
 ```py
 def save_model(self,checkpoint_dir,step):
@@ -705,23 +705,23 @@ Epoch: [ 0] [ 19/ 156] time: 13.7525
 
 ![](img/8c1362f9-bf37-4c56-ac05-30bb6d00a579.png)
 
-图 4.2：Tensorboard Scalars 部分包含不同损耗的迹线
+图 4.2：Tensorboard `Scalars`部分包含不同损耗的迹线
 
-以下屏幕截图显示了随着训练的进行，域 A 中鉴别器的损耗成分：
+以下屏幕截图显示了随着训练的进行，域`A`中鉴别器的损耗成分：
 
 ![](img/a02c2ba3-678a-4f01-8f16-0addf12d379e.png)
 
-图 4.3：域 A 中的鉴别器丢失
+图 4.3：域`A`中的鉴别器丢失
 
-从前面的屏幕截图中，我们可以看到不同批次中域 A 中鉴别器的损失。 `da_loss`是`da_loss_real`和`da_loss_fake`损失的总和。 `da_loss_real`稳步下降，这是因为鉴别器易于学会识别域 A 中的真实图像，而虚假图像的损失则稳定在 0.69 左右，这是二进制分类器输出时您可以期望的`logloss` 具有 1/2 概率的类。 发生这种情况是因为生成器也在同时学习以使伪图像看起来逼真，因此使鉴别人员很难轻松地将生成器图像分类为伪图像。 域 B 上的鉴别器的损耗曲线看起来与域 A 的上一幅屏幕快照所示的相似。
+从前面的屏幕截图中，我们可以看到不同批次中域`A`中鉴别器的损失。 `da_loss`是`da_loss_real`和`da_loss_fake`损失的总和。 `da_loss_real`稳步下降，这是因为鉴别器易于学会识别域`A`中的真实图像，而虚假图像的损失则稳定在 0.69 左右，这是二进制分类器输出时您可以期望的`logloss` 具有`1/2`概率的类。 发生这种情况是因为生成器也在同时学习以使伪图像看起来逼真，因此使鉴别人员很难轻松地将生成器图像分类为伪图像。 域`B`上的鉴别器的损耗曲线看起来与域`A`的上一幅屏幕快照所示的相似。
 
-现在让我们看一下发电机的损耗曲线，如下所示：
+现在让我们看一下生成器的损耗曲线，如下所示：
 
 ![](img/70ea99da-3268-4b40-a8df-225aed87f8b3.png)
 
-图 4.4：DiscoGAN 发电机的损耗曲线
+图 4.4：DiscoGAN 生成器的损耗曲线
 
-`g_loss_a2b` 是从域 A 到域 B 以及从域 B 反向重构图像的组合生成器损耗，也是与使变换后的图像在 B 域中看起来逼真相关的二进制交叉熵损耗。 `g_loss_b2a`是从域 B 到域 A 以及从域 A 重建图像的组合生成器损耗，也是与使变换后的图像在 A 域中看起来逼真相关的二进制交叉熵损耗。这两种损耗曲线及其总和 （HTG2）随着批次的进行，损失不断减少，正如我们从上一个屏幕快照中的 TensorBoard 视觉图中看到的那样。
+`g_loss_a2b` 是从域`A`到域`B`以及从域`B`反向重构图像的组合生成器损耗，也是与使变换后的图像在`B`域中看起来逼真相关的二进制交叉熵损耗。 `g_loss_b2a`是从域`B`到域`A`以及从域`A`重建图像的组合生成器损耗，也是与使变换后的图像在`A`域中看起来逼真相关的二进制交叉熵损耗。这两种损耗曲线及其总和随着批次的进行不断减少，正如我们从上一个屏幕快照中的 TensorBoard 视觉图中看到的那样。
 
 由于训练生成对抗网络通常非常棘手，因此监视其损失概况的进度以了解训练是否按预期进行是有意义的。
 
@@ -733,7 +733,7 @@ Epoch: [ 0] [ 19/ 156] time: 13.7525
 
 图 4.5：根据草图生成的手提包图像
 
-以下屏幕截图包含**手提包草图的生成图像（域 A）**：
+以下屏幕截图包含**手提包草图的生成图像（域`A`）**：
 
 ![](img/b4acc286-1586-405f-b2a9-52123d6b7c5a.png)
 
diff --git a/new/intel-proj-py/05.md b/new/intel-proj-py/05.md
index 7d5360c6..161aa569 100644
--- a/new/intel-proj-py/05.md
+++ b/new/intel-proj-py/05.md
@@ -39,7 +39,7 @@
 
 从上图可以看出，从视频中顺序采样的图像经过预训练的卷积神经网络，并且最后一个全连接层中的`4,096`单元的激活为 输出。 如果将`t`时的视频图像表示为`x[t]`，并且最后一个全连接层的输出表示为`f[t] ∈ R^4096`，然后`f[t] = f[w](x[t])`。 此处，`W`表示直到最后一个全连接层的卷积神经网络的权重。
 
-这些系列的输出功能`f[1], f[2], ..., f[t], ..., f[n]`可以作为循环神经网络的输入，该神经网络学习根据输入特征生成文本标题，如下图所示（“图 5.2”]）：
+这些系列的输出功能`f[1], f[2], ..., f[t], ..., f[n]`可以作为循环神经网络的输入，该神经网络学习根据输入特征生成文本标题，如下图所示（“图 5.2”）：
 
 ![](img/c4301074-d0a6-499d-97fb-04b39f20d188.png)
 
@@ -233,7 +233,7 @@ def get_clean_caption_data(self,text_path,feat_path):
         return data
 ```
 
-在已定义的`get_data`函数中，我们从`video_corpus.csv`文件中删除了所有非英语的字幕。 完成后，我们首先通过构建视频名称（作为`VideoID`，`Start`和`End`功能的串联）并在功能目录名称前添加前缀来形成视频功能的链接。 然后，我们删除所有未指向 features 目录中任何实际视频特征向量或具有无效非文本描述的视频语料库文件记录。
+在已定义的`get_data`函数中，我们从`video_corpus.csv`文件中删除了所有非英语的字幕。 完成后，我们首先通过构建视频名称（作为`VideoID`，`Start`和`End`功能的串联）并在功能目录名称前添加前缀来形成视频功能的链接。 然后，我们删除所有未指向`features`目录中任何实际视频特征向量或具有无效非文本描述的视频语料库文件记录。
 
 数据如下图所示输出（“图 5.6”）：
 
@@ -783,7 +783,7 @@ Epoch 99 is done. Saving the model ...
 
 # 推理功能
 
-在推理过程中，我们调用`build_generator`定义模型以及推理所需的其他 TensorFlow op，然后使用`tf.train.Saver.restoreutility`从训练后的模型中保存已保存的权重，以加载定义的模型。 一旦加载了模型并准备对每个测试视频进行推理，我们就从 CNN 中提取其对应的视频帧图像预处理特征并将其传递给模型进行推理：
+在推理过程中，我们调用`build_generator`定义模型以及推理所需的其他 TensorFlow 操作，然后使用`tf.train.Saver.restoreutility`从训练后的模型中保存已保存的权重，以加载定义的模型。 一旦加载了模型并准备对每个测试视频进行推理，我们就从 CNN 中提取其对应的视频帧图像预处理特征并将其传递给模型进行推理：
 
 ```py
    def inference(self):
@@ -842,7 +842,7 @@ python Video_seq2seq.py process_main --path_prj '/media/santanu/9eb9b6dc-b380-48
 
 ![](img/654f2dd8-315e-4313-a3cd-5720be8ac811.png)
 
-使用经过训练的模型对视频 0lh_UWF9ZP4_82_87.avi 进行推断
+使用经过训练的模型对视频`0lh_UWF9ZP4_82_87.avi`进行推断
 
 在以下屏幕截图中，我们说明了对另一个`video8MVo7fje_oE_139_144.avi`的推断结果：
 
diff --git a/new/intel-proj-py/06.md b/new/intel-proj-py/06.md
index 58a0393d..6a846e39 100644
--- a/new/intel-proj-py/06.md
+++ b/new/intel-proj-py/06.md
@@ -70,7 +70,7 @@
 
 # 基于深度学习的潜在因素模型
 
-“潜在协同过滤的深度学习”部分中讨论的基于深度学习的潜在因素模型可以如图 HTG2 图 6.4 所示进行设计：
+“潜在协同过滤的深度学习”部分中讨论的基于深度学习的潜在因素模型可以如图 6.4 所示进行设计：
 
 ![](img/f686394a-db58-4ac8-937b-d66b473a96b7.png)
 
@@ -212,9 +212,9 @@ test_ratings_df[test_ratings_df['userID'] == 1].sort_values(['rating','predictio
 
 可以在[这个页面](https://github.com/PacktPublishing/Intelligent-Projects-using-Python/tree/master/Chapter06)上找到与深度学习方法潜在因子方法相关的代码。
 
-# SVD ++
+# SVD++ 
 
-通常，SVD 不会捕获用户和数据中可能存在的项目偏差。 一种名为 SVD ++的方法考虑了潜在分解因子方法中的用户和项目偏见，并且在诸如 *Netflix Challenge* 之类的比赛中非常流行。
+通常，SVD 不会捕获用户和数据中可能存在的项目偏差。 一种名为 SVD++ 的方法考虑了潜在分解因子方法中的用户和项目偏见，并且在诸如 *Netflix Challenge* 之类的比赛中非常流行。
 
 进行基于潜在因素推荐的最常见方法是将用户配置文件定义为`u[i] ∈ R^k`和`b[i] ∈ R`，项目轮廓和偏差为`v[i] ∈ R^k`和`b[j] ∈ R`。 然后，将用户`i`对项目`j`提供的评分![](img/0cdbff49-855e-4e8b-83d9-9e15fd915288.png)定义如下：
 
@@ -236,7 +236,7 @@ test_ratings_df[test_ratings_df['userID'] == 1].sort_values(['rating','predictio
 
 `surprise`软件包具有 SVD++ 的良好实现。 在下一部分中，我们将在`100K movie lens`数据集上使用 SVD++ 训练模型，并查看性能指标。
 
-# 电影镜头 100k 数据集上的 SVD ++训练模型
+# 电影镜头 100k 数据集上的 SVD++ 训练模型
 
 可以使用以下命令通过`conda`下载`surprise`软件包：
 
@@ -244,7 +244,7 @@ test_ratings_df[test_ratings_df['userID'] == 1].sort_values(['rating','predictio
 conda install -c conda-forge scikit-surprise 
 ```
 
-对应于 SVD ++的算法在`surprise`中被命名为`SVDpp`。 我们可以按以下方式加载所有必需的软件包：
+对应于 SVD++ 的算法在`surprise`中被命名为`SVDpp`。 我们可以按以下方式加载所有必需的软件包：
 
 ```py
 import numpy as np
@@ -303,7 +303,7 @@ SVD++ results on the test set
 RMSE: 0.9320
 ```
 
-从前面的结果可以看出，SVD ++模型在 RMSE 为`0.93`的测试数据集上确实表现良好。 结果与我们在此之前训练的基于深度学习的模型潜在因子模型（支持`0.95`的 RMSE）相当。
+从前面的结果可以看出，SVD++ 模型在 RMSE 为`0.93`的测试数据集上确实表现良好。 结果与我们在此之前训练的基于深度学习的模型潜在因子模型（支持`0.95`的 RMSE）相当。
 
 在“用于推荐的受限玻尔兹曼机”部分中，我们将介绍用于构建推荐系统的受限玻尔兹曼机。 由于该方法可以扩展到大型数据集，因此在协同过滤中获得了很大的普及。 协同过滤域中的大多数数据集都很稀疏，从而导致困难的非凸优化问题。 与其他分解方法（例如 SVD）相比，RBM 在数据集中更不容易遭受此稀疏问题的困扰。
 
@@ -347,7 +347,7 @@ RBM 的参数是可见层单位`i`与隐藏层单位之间的广义权重连接`
 
 # 对比分歧
 
-计算联合概率分布的期望值的一种方法是通过 Gibbs 采样从联合概率分布中生成很多样本，然后将样本的平均值作为期望值。 在吉布斯抽样中，可以以其余变量为条件对联合概率分布中的每个变量进行抽样。 由于可见单位是独立的，因此给定隐藏单位，反之亦然，因此您可以将隐藏单位采样为![](img/86849800-744f-4771-96a1-94246e7b9332.png)，然后将可见单位激活给定隐藏单位为![](img/0738e0a3-6a59-46f7-96a1-dea1b0bc29f8.png)。 然后我们可以将样本![](img/c9b254f1-f757-4479-8744-0fed6b0d930d.png)作为从联合概率分布中抽取的样本。 这样，我们可以生成大量样本，例如`M`，并取其平均值来计算期望的期望值。 但是，在梯度下降的每个步骤中进行如此大量的采样将使训练过程变得令人无法接受的缓慢，因此，与其在梯度下降的每个步骤中计算许多样本的平均值，不如从联合概率中生成一个样本 表示整个联合概率分布中期望期望的分布：
+计算联合概率分布的期望值的一种方法是通过吉布斯采样从联合概率分布中生成很多样本，然后将样本的平均值作为期望值。 在吉布斯抽样中，可以以其余变量为条件对联合概率分布中的每个变量进行抽样。 由于可见单位是独立的，因此给定隐藏单位，反之亦然，因此您可以将隐藏单位采样为![](img/86849800-744f-4771-96a1-94246e7b9332.png)，然后将可见单位激活给定隐藏单位为![](img/0738e0a3-6a59-46f7-96a1-dea1b0bc29f8.png)。 然后我们可以将样本![](img/c9b254f1-f757-4479-8744-0fed6b0d930d.png)作为从联合概率分布中抽取的样本。 这样，我们可以生成大量样本，例如`M`，并取其平均值来计算期望的期望值。 但是，在梯度下降的每个步骤中进行如此大量的采样将使训练过程变得令人无法接受的缓慢，因此，与其在梯度下降的每个步骤中计算许多样本的平均值，不如从联合概率中生成一个样本 表示整个联合概率分布中期望期望的分布：
 
 ![](img/e1fb8a28-45d4-4ebd-b17c-861618cfd639.png)
 
@@ -355,7 +355,7 @@ RBM 的参数是可见层单位`i`与隐藏层单位之间的广义权重连接`
 
 如上图所示（“图 6.7”），我们从可见的输入`v^(t)`开始，并对隐藏层进行采样 根据条件概率分布`P(h / v = v^(t))`激活![](img/f6ddc0c8-b917-44aa-a6c8-dadd737358ab.png)。 再次，使用条件概率分布`P(v / h = h')`，我们对`v'`进行采样。 根据条件概率分布`P(h / v = v')`对隐藏单元的下一次采样给出![](img/2f29e0d4-e0c2-4c48-aa9f-9f3b52890d1b.png)，然后使用![](img/af67a34a-3350-44c1-b5f8-9bb47f2c265a.png)对可见单元激活进行采样 给我们![](img/71ba3b2e-6fa9-482f-b01d-a3bd8bdac420.png)。 对于`v`和`h`，即![](img/a13d0854-7fa0-4a6f-a01b-d277a377c7eb.png)的整个联合概率分布，将样本![](img/bbe647d9-d45c-448f-8169-04ef6cc6a007.png)取为代表性样本。 相同的用于计算包含`v`和`h`的任何表达式的期望。 这种采样过程称为对比散度。
 
-从可见输入开始，然后从条件分布`P(v / h)`和`P(v / h)`连续采样构成吉布斯采样的一个步骤，并为我们提供了一个样本 联合分布中的`v / h`。 代替在 Gibbs 采样的每个步骤中选择样本`v / h`，我们可以选择从条件概率分布中进行几次连续的采样迭代后再选择样本。 如果在吉布斯采样的`k`个步骤之后，选择了代表元素，则将对比散度称为`CD-k`。 “图 6.7”中所示的对比散度可以称为`CD-2`，因为我们是在经过两步 Gibbs 采样后才选择样本的。
+从可见输入开始，然后从条件分布`P(v / h)`和`P(v / h)`连续采样构成吉布斯采样的一个步骤，并为我们提供了一个样本 联合分布中的`v / h`。 代替在吉布斯采样的每个步骤中选择样本`v / h`，我们可以选择从条件概率分布中进行几次连续的采样迭代后再选择样本。 如果在吉布斯采样的`k`个步骤之后，选择了代表元素，则将对比散度称为`CD-k`。 “图 6.7”中所示的对比散度可以称为`CD-2`，因为我们是在经过两步吉布斯采样后才选择样本的。
 
 # 使用 RBM 的协同过滤
 
@@ -389,7 +389,7 @@ RBM 的参数是可见层单位`i`与隐藏层单位之间的广义权重连接`
 
 ![](img/4486f0fa-b798-43eb-b87e-0522b99cba86.png)
 
-在定义隐藏单元和可见单元的输出时，还有一件重要的事情是需要概率抽样，而不是将输出默认为具有最大概率的抽样。 如果给定可见单位的隐藏单位激活的概率为`P`，则统一生成`[0, 1]`范围内的随机数`r`，并且如果`P > r`，则隐藏单元激活设置为`true`。 该方案将确保在很长的一段时间内以概率`P`将激活设置为 true。 类似地，电影的可见单位是根据跨国公司发行给定隐藏单位的概率从跨国发行机构中采样的。 因此，如果对于特定电影，给定的隐藏单位激活为`(p[1], p[2], p[3], p[4], p[5])`，然后可以从多项式分布中抽样选择五个评分中的评分值， 其概率质量函数如下：
+在定义隐藏单元和可见单元的输出时，还有一件重要的事情是需要概率抽样，而不是将输出默认为具有最大概率的抽样。 如果给定可见单位的隐藏单位激活的概率为`P`，则统一生成`[0, 1]`范围内的随机数`r`，并且如果`P > r`，则隐藏单元激活设置为`true`。 该方案将确保在很长的一段时间内以概率`P`将激活设置为`true`。 类似地，电影的可见单位是根据跨国公司发行给定隐藏单位的概率从跨国发行机构中采样的。 因此，如果对于特定电影，给定的隐藏单位激活为`(p[1], p[2], p[3], p[4], p[5])`，然后可以从多项式分布中抽样选择五个评分中的评分值， 其概率质量函数如下：
 
 ![](img/c23ff63c-d7c9-4531-b0b0-19c04bd9678e.png)
 
@@ -474,11 +474,11 @@ python preprocess_ratings.py --path '/home/santanu/ML_DS_Catalog-/Collaborating
 
 # 建立用于协同过滤的 RBM 网络
 
-以下函数`_network`为协同过滤创建所需的 RBM 结构。 首先，我们定义输入的权重，偏差和占位符。 然后定义`sample_hidden`和`sample_visible`函数，以根据概率分别对隐藏的激活和可见的激活进行采样。 隐藏的单位是从 Sigmoid 函数提供的概率从伯努利分布中采样的，而与每个电影有关的可见单元是根据 softmax 函数提供的概率从多项分布中采样的。 无需创建 softmax 概率，因为`tf.multinomial`函数可以直接从 logit 采样，而不是实际概率。
+以下函数`_network`为协同过滤创建所需的 RBM 结构。 首先，我们定义输入的权重，偏差和占位符。 然后定义`sample_hidden`和`sample_visible`函数，以根据概率分别对隐藏的激活和可见的激活进行采样。 隐藏的单位是从 Sigmoid 函数提供的概率从伯努利分布中采样的，而与每个电影有关的可见单元是根据 softmax 函数提供的概率从多项分布中采样的。 无需创建 softmax 概率，因为`tf.multinomial`函数可以直接从对率采样，而不是实际概率。
 
-接下来，我们根据 Gibbs 采样定义对比差异的逻辑。 `gibbs_step`函数执行 Gibbs 采样的一个步骤，然后利用它来实现`k`阶的对比散度。
+接下来，我们根据吉布斯采样定义对比差异的逻辑。 `gibbs_step`函数执行吉布斯采样的一个步骤，然后利用它来实现`k`阶的对比散度。
 
-现在我们拥有所有必需的功能，我们将创建 TensorFlow 操作，以在给定可见输入的情况下对隐藏状态`self.h`进行采样，并在给定采样状态下对可见单位`self.x`进行采样。 我们还使用对比散度从 v 和 h 的联合概率分布（即`P(v,h/model)`）中抽取`(self.x_s,self.h_s)`作为代表性样本，以计算梯度中的不同期望项。
+现在我们拥有所有必需的功能，我们将创建 TensorFlow 操作，以在给定可见输入的情况下对隐藏状态`self.h`进行采样，并在给定采样状态下对可见单位`self.x`进行采样。 我们还使用对比散度从`v`和`h`的联合概率分布（即`P(v,h/model)`）中抽取`(self.x_s,self.h_s)`作为代表性样本，以计算梯度中的不同期望项。
 
 `_network`函数的最后一步基于梯度更新 RBM 模型的权重和偏差。 如我们先前所见，梯度基于给定可见层输入的隐藏层激活`self.h`以及通过对比发散得出的联合概率分布`P(v,h/model)`的代表性样本`(self.x_s,self.h_s)`。
 
diff --git a/new/intel-proj-py/10.md b/new/intel-proj-py/10.md
index fd04602c..02ba1097 100644
--- a/new/intel-proj-py/10.md
+++ b/new/intel-proj-py/10.md
@@ -398,7 +398,7 @@ SVHN 是一个现实世界的数据集，由于它在对象识别算法中的使
 
 ![](img/ae36b54b-0a7c-4c94-8c4b-4e5209859d44.png)
 
-在前面的表达式中`D(.)`是鉴别函数，其输出表示将图像标记为实数的可能性。`P[z](z)`表示随机变量噪声`z`的分布，而`P[X](x)`表示真实门牌号图像的分布。`G(.)`和`D(.)`分别表示生成器网络功能和鉴别器网络功能。 这些参数可以通过网络的权重进行参数化，而网络的权重是我们为表示法的混乱而方便地跳过的。 如果我们用![](img/bf0dd083-8c73-4b7f-95bf-2dac7251d52d.png)表示发生器网络权重的参数，用![](img/5040a2b3-84b1-4d41-b866-77a741f6e3a4.png)表示鉴别器网络的权重，则鉴别器将学会使`(1)`相对于![](img/0aebd653-012b-4821-85d9-4cecc73c4091.png)的损失最小化，而 发电机将旨在使`(1)`与![](img/3803843a-e64f-4153-85e0-fea7a07d2755.png)的损失相同。 我们可以将`(1)`中优化的损耗称为效用函数，发生器和鉴别器都在参数方面进行了优化。 实用函数`U`可以根据生成器和鉴别器的参数来编写，如下所示：
+在前面的表达式中`D(.)`是鉴别函数，其输出表示将图像标记为实数的可能性。`P[z](z)`表示随机变量噪声`z`的分布，而`P[X](x)`表示真实门牌号图像的分布。`G(.)`和`D(.)`分别表示生成器网络功能和鉴别器网络功能。 这些参数可以通过网络的权重进行参数化，而网络的权重是我们为表示法的混乱而方便地跳过的。 如果我们用![](img/bf0dd083-8c73-4b7f-95bf-2dac7251d52d.png)表示发生器网络权重的参数，用![](img/5040a2b3-84b1-4d41-b866-77a741f6e3a4.png)表示鉴别器网络的权重，则鉴别器将学会使`(1)`相对于![](img/0aebd653-012b-4821-85d9-4cecc73c4091.png)的损失最小化，而 生成器将旨在使`(1)`与![](img/3803843a-e64f-4153-85e0-fea7a07d2755.png)的损失相同。 我们可以将`(1)`中优化的损耗称为效用函数，发生器和鉴别器都在参数方面进行了优化。 实用函数`U`可以根据生成器和鉴别器的参数来编写，如下所示：
 
 ![](img/e18dcc4f-da73-459c-ae45-a767f0e05be9.png)
 
@@ -432,7 +432,7 @@ SVHN 是一个现实世界的数据集，由于它在对象识别算法中的使
 
 我们已经将生成器和鉴别器优化目标都转换为最小化问题。 鉴别器和生成器的优化都是使用梯度下降进行的，直到我们达到目标函数的鞍点。
 
-# 发电机网络
+# 生成器网络
 
 生成器网络将吸收随机噪声，并尝试输出类似于 SVHN 图像的图像作为输出。 随机噪声是`100`维输入向量。 每个维度都是遵循标准正态分布的随机变量，平均值为`0`，标准偏差为`1`。
 
@@ -468,7 +468,7 @@ def generator(input_dim,alpha=0.2):
 
 ![](img/bcfebdf8-f4ff-46c4-aa47-050aea483200.png)
 
-图 10.5：发电机组网络图
+图 10.5：生成器组网络图
 
 # 鉴别器网络
 
@@ -511,9 +511,9 @@ def discriminator(img_dim,alpha=0.2):
 
 为生成对抗网络建立培训流程并非一帆风顺，因为这需要很多技术方面的考虑。 我们定义了以下三个培训网络：
 
-*   带有参数![](img/157d6e01-b76c-4084-a604-b1dfcf681cc4.png)的发电机网络`g`
+*   带有参数![](img/157d6e01-b76c-4084-a604-b1dfcf681cc4.png)的生成器网络`g`
 *   带有参数![](img/70de08ab-a253-4cc2-a37d-749c60e02794.png)的鉴别器网络`d`
-*   权重为![](img/5bdbe09a-9d95-42a6-9e3e-29e75ff75b52.png)和![](img/7e2796b1-735d-4c67-992b-4c7dbb5409f8.png)的以`g_d`表示的组合发电机鉴别器网络
+*   权重为![](img/5bdbe09a-9d95-42a6-9e3e-29e75ff75b52.png)和![](img/7e2796b1-735d-4c67-992b-4c7dbb5409f8.png)的以`g_d`表示的组合生成器鉴别器网络
 
 生成器`g`创建`d`鉴别器将评估的伪造图像，并尝试将其标记为伪造。
 
@@ -650,7 +650,7 @@ python captcha_gan.py train --dest_train '/home/santanu/Downloads/train_32x32.ma
 | **参数** | **值** | **注释** |
 | `batch_size` | `100` | 小型批次随机梯度下降的批次大小。 |
 | `gen_input_dim` | `100` | 输入随机噪声矢量维。 |
-| `gen_lr` | `0.0001` | 发电机学习率。 |
+| `gen_lr` | `0.0001` | 生成器学习率。 |
 | `gen_beta1` | `0.5` | `beta_1`是生成器的 Adam 优化器的参数。 |
 | `dis_input_dim` | `(32,32,3)` | 辨别真假房屋号码图像的形状。 |
 | `dis_lr` | `0.001` | 鉴别器网络的学习率。 |
-- 
GitLab