2020-12-07 22:03:02

new/ai-py/00.md

@@ -106,7 +106,7 @@
 
 第 21 章，“循环神经网络和其他深度学习模型”
 
-本章将继续涵盖其他类型的深度学习算法。 首先将介绍循环神经网络，然后将介绍较新的算法，例如注意力，自我注意和变压器模型。 本章将介绍使用这些网络的用例以及使用这些模型体系结构的优势及其局限性。 最后，讨论的技术将用于构建实际应用程序。
+本章将继续涵盖其他类型的深度学习算法。 首先将介绍循环神经网络，然后将介绍较新的算法，例如注意力，自我注意和变压器模型。 本章将介绍使用这些网络的用例以及使用这些模型架构的优势及其局限性。 最后，讨论的技术将用于构建实际应用程序。
 
 第 22 章，“通过强化学习创建智能体”
 

new/ai-py/02.md

@@ -349,7 +349,7 @@ DeepMind 的团队引入了一个名为 AlphaStar 的程序，该程序可以玩
 
 使《星际争霸 2》如此困难的一件事是需要平衡短期和长期目标并适应意外情况。 这通常对先前的系统提出了巨大的挑战。
 
-尽管 StarCraft 只是一个游戏，尽管很困难，但是 AlphaStar 提出的概念和技术对于解决其他现实世界中的挑战很有用。 例如，AlphaStar 的体系结构能够根据不完善的信息来对很长的可能动作序列进行建模-游戏通常持续数小时，并进行成千上万次动作。 在许多实际问题中，可以找到对长序列进行复杂预测的主要概念，例如：
+尽管 StarCraft 只是一个游戏，尽管很困难，但是 AlphaStar 提出的概念和技术对于解决其他现实世界中的挑战很有用。 例如，AlphaStar 的架构能够根据不完善的信息来对很长的可能动作序列进行建模-游戏通常持续数小时，并进行成千上万次动作。 在许多实际问题中，可以找到对长序列进行复杂预测的主要概念，例如：
 
 *   天气预报
 *   气候模拟

new/ai-py/03.md

@@ -19,7 +19,7 @@
 
 随着数据科学的发展，期望值越来越高。 数据源变得更加多样化，数量庞大（就大小而言）并且数量众多（就数量而言），并且管道和工作流变得更加复杂。 我们期望越来越多的数据本质上是实时的，这无济于事。 考虑一下网络日志，点击数据，电子商务交易和自动驾驶汽车输入。 这些系统中的数据来得太快了，我们必须拥有能够比接收到的信息更快处理信息的方法。
 
-存在许多机器学习解决方案来实现这些管道。 当然，仅使用 Python 或 R 语言就可以建立基本的机器学习管道。 我们将通过布局使用 Python 的管道示例来开始建立我们的理解。 在本章中，我们将详细探讨一些利用当今最流行工具的体系结构。 数据管道通常利用的一些工具是：
+存在许多机器学习解决方案来实现这些管道。 当然，仅使用 Python 或 R 语言就可以建立基本的机器学习管道。 我们将通过布局使用 Python 的管道示例来开始建立我们的理解。 在本章中，我们将详细探讨一些利用当今最流行工具的架构。 数据管道通常利用的一些工具是：
 
 *   Hadoop
 *   火花
@@ -280,19 +280,19 @@
 *   数据集的大小是多少？
 *   是否有需要遵循和遵守的法规，政策和其他约束条件？
 
-确认要求之后，我们现在可以考虑用于模型部署的高级体系结构。 以下是多种选择。 无论如何，这并不是一个详尽的清单，但它确实包含了一些较流行的体系结构：
+确认要求之后，我们现在可以考虑用于模型部署的高级架构。 以下是多种选择。 无论如何，这并不是一个详尽的清单，但它确实包含了一些较流行的架构：
 
 <colgroup><col> <col> <col> <col> <col></colgroup> 
-|  | **RESTful API 架构** | **共享数据库体系结构** | **流架构** | **移动应用架构** |
+|  | **RESTful API 架构** | **共享数据库架构** | **流架构** | **移动应用架构** |
 | **训练方法** | 批量 | 批量 | 流媒体 | 流媒体 |
 | **预测方法** | 即时的 | 批量 | 流媒体 | 即时的 |
 | **结果交付** | 通过 RESTful API | 通过共享数据库 | 通过消息队列流式传输 | 通过移动设备上的进程内 API |
 | **预测延迟** | 低 | 高 | 非常低 | 低 |
 | **系统可维护性** | 中 | 简单 | 难 | 中 |
 
-如表中所总结，这四个选项各有利弊。 当我们深入研究体系结构的细节时，还需要考虑更多的考虑因素。 作为示例，可以使用模块化微服务架构或以整体方式来实现这些架构中的每一个。 同样，选择应该由业务需求决定。 例如，可以选择整体方法，因为我们的用例非常有限，需要极低的延迟。
+如表中所总结，这四个选项各有利弊。 当我们深入研究架构的细节时，还需要考虑更多的考虑因素。 作为示例，可以使用模块化微服务架构或以整体方式来实现这些架构中的每一个。 同样，选择应该由业务需求决定。 例如，可以选择整体方法，因为我们的用例非常有限，需要极低的延迟。
 
-无论为模型部署选择哪种体系结构，使用以下原则都是一个好主意：
+无论为模型部署选择哪种架构，使用以下原则都是一个好主意：
 
 *   **可再现性**：存储所有模型输入和输出，以及所有相关元数据，例如配置，依赖项，地理位置和时区。 需要解释过去的预测。 确保每个部署捆绑包的最新版本均可用，其中还应包含训练数据。 例如，这对于受到严格监管的领域尤其重要。
 *   **自动化**：尽可能早地自动化训练和模型发布。

new/ai-py/12.md

@@ -514,7 +514,7 @@ AI Hub 是 Google Cloud Platform 中可用的服务之一。 AI Hub 是即插即
 
 除了 AI Hub 的（可以与 Amazon SageMaker 和 Azure 机器学习 Studio 相比）之外，Google Cloud 在完全托管服务方面还提供了与 AWS 和 Azure 类似的产品，这些服务简化了机器学习在文本中的应用， 语言，图像和视频。 Google 在 *Google Cloud AI 构件*框架下组织了许多此类托管服务。 对于许多此类托管服务，有两种与之交互的方式– AutoML 和 API。 AutoML 用于自定义模型，API 用于预训练模型。 AutoML 和 API 可以单独使用，也可以一起使用。
 
-**Google Cloud AutoML 自定义模型**：AutoML 服务使用 Google 的最新迁移学习和神经体系结构搜索技术，允许用户为各种用例创建特定于领域的自定义模型。
+**Google Cloud AutoML 自定义模型**：AutoML 服务使用 Google 的最新迁移学习和神经架构搜索技术，允许用户为各种用例创建特定于领域的自定义模型。
 
 **Google Cloud 预训练的 API**：在处理常见用例时，使用预先训练的 API 的 Google 服务用户可以立即变得富有成效，而无需事先训练模型。 预训练的 API 不断透明地升级，以提高这些模型的速度和准确性。
 

new/ai-py/19.md

@@ -276,7 +276,7 @@ for item in data_test:
 
 # 构建多层神经网络
 
-因此，我们将模型从几个节点增强到了一个单层，但距离 850 亿个节点还差得很远。 我们也不会在本节中谈到这一点，但让我们朝着正确的方向迈出又一步。 人脑不使用单层模型。 一些神经元的输出变成其他神经元的输入，依此类推。 具有这种特征的模型被称为多层神经网络。 这种类型的体系结构可产生更高的精度，并且使我们能够解决更复杂，更多样化的问题。 让我们看看如何使用 NeuroLab 构建多层神经网络。
+因此，我们将模型从几个节点增强到了一个单层，但距离 850 亿个节点还差得很远。 我们也不会在本节中谈到这一点，但让我们朝着正确的方向迈出又一步。 人脑不使用单层模型。 一些神经元的输出变成其他神经元的输入，依此类推。 具有这种特征的模型被称为多层神经网络。 这种类型的架构可产生更高的精度，并且使我们能够解决更复杂，更多样化的问题。 让我们看看如何使用 NeuroLab 构建多层神经网络。
 
 创建一个新的 Python 文件并导入以下软件包：
 

new/ai-py/20.md

@@ -2,7 +2,7 @@
 
 # 使用卷积神经网络进行深度学习
 
-在本章中，我们将学习深度学习和**卷积神经网络**（**CNN**）。 在过去的几年中，CNN 取得了很大的发展势头，尤其是在图像识别领域。 我们将讨论 CNN 的体系结构以及内部使用的层的类型。 我们将看到如何使用一个名为 TensorFlow 的软件包。 我们将构建一个基于感知器的线性回归器。 我们将学习如何使用单层神经网络构建图像分类器。
+在本章中，我们将学习深度学习和**卷积神经网络**（**CNN**）。 在过去的几年中，CNN 取得了很大的发展势头，尤其是在图像识别领域。 我们将讨论 CNN 的架构以及内部使用的层的类型。 我们将看到如何使用一个名为 TensorFlow 的软件包。 我们将构建一个基于感知器的线性回归器。 我们将学习如何使用单层神经网络构建图像分类器。
 
 然后，我们将使用 CNN 构建图像分类器。 图像分类器有许多应用。 这是一个奇特的名字，但这只是计算机辨别对象是什么的能力。 例如，您可以构建一个分类器来确定某物是热狗还是非热狗。 这是一个轻松的示例，但是图像分类器也可以使用生死攸关的应用程序。 为嵌入了图像分类软件的无人机拍照，它可以区分平民和敌方战斗人员。 在这种情况下不能犯任何错误。
 
@@ -55,19 +55,19 @@ GAN 可用于语音应用程序。 给定语音，可以训练 GAN 来重现著
 
 CNN 也由神经元组成，这些神经元由权重和偏差组成。 这些神经元接受输入数据，对其进行处理，然后输出某些数据。 网络的目标是从输入层中的原始图像数据转到输出层中的正确类别。 普通神经网络和 CNN 之间的区别在于我们使用的层类型以及我们如何处理输入数据。 CNN 假定输入是图像，这使它们可以提取特定于图像的属性。 这使 CNN 可以更有效地处理图像。 现在我们已经了解了 CNN 的基础知识，下面让我们看一下它们是如何成立的。
 
-# CNN 的体系结构
+# CNN 的架构
 
 当我们在普通神经网络中使用时，我们需要将输入数据转换为单个向量。 此向量充当神经网络的输入，然后通过神经网络的各层。 在这些层中，每个神经元都连接到上一层中的所有神经元。 还值得注意的是，每一层中的神经元彼此之间没有连接。 它们仅连接到相邻层中的神经元。 网络中的最后一层是输出层，它代表最终输出。
 
 如果我们将这种结构用于图像，它将很快变得难以管理。 例如，让我们考虑由`256×256` RGB 图像组成的图像数据集。 由于这些是 3 通道图像，因此权重为`256 * 256 * 3 = 196,608`。 请注意，这仅适用于单个神经元！ 每层将有多个神经元，因此权重数趋于迅速增加。 这意味着模型现在将具有在训练过程中要调整的大量参数。 因此，它很快变得非常复杂且耗时。 将每个神经元连接到上一层中的每个神经元（称为完全连通性）显然不会起作用。
 
-CNN 在处理数据时会明确考虑图像的结构。 CNN 中的神经元按 3 个维度排列-宽度，高度和深度。 当前层中的每个神经元都连接到前一层输出的一小块。 就像在输入图像上叠加`NxN`滤镜一样。 这与完全连接层形成对比，在完全连接层中，每个神经元都连接到上一层的所有神经元。
+CNN 在处理数据时会明确考虑图像的结构。 CNN 中的神经元按 3 个维度排列-宽度，高度和深度。 当前层中的每个神经元都连接到前一层输出的一小块。 就像在输入图像上叠加`NxN`过滤器一样。 这与完全连接层形成对比，在完全连接层中，每个神经元都连接到上一层的所有神经元。
 
-由于单个滤镜无法捕获图像的所有细微差别，因此我们多次执行`M`，以确保捕获所有细节。 这些`M`过滤器充当特征提取器。 如果查看这些过滤器的输出，我们可以看到它们提取了诸如边，角等特征。 对于 CNN 中的初始层来说，这是正确的。 随着我们在网络的层中的进展，我们将看到后面的层提取更高级别的功能。
+由于单个过滤器无法捕获图像的所有细微差别，因此我们多次执行`M`，以确保捕获所有细节。 这些`M`过滤器充当特征提取器。 如果查看这些过滤器的输出，我们可以看到它们提取了诸如边，角等特征。 对于 CNN 中的初始层来说，这是正确的。 随着我们在网络的层中的进展，我们将看到后面的层提取更高级别的功能。
 
 CNN 是深度学习网络。 它通常用于识别图像。 了解它如何识别图像将有助于您了解它们的工作原理。 像任何其他神经网络一样，它为图像中的元素分配权重和偏差，并能够将这些元素彼此区分开。 与其他分类模型相比，CNN 中使用的预处理较少。 当使用经过足够训练的原始方法过滤器时，可以训练 CNN 来区分这些过滤器和特征。
 
-CNN 体系结构的基本形式可以与人脑中的神经元和树突进行比较，并从视觉皮层中汲取灵感。 单个神经元对视野受限区域的刺激作出反应。 该区域称为接受场。 这些视场的一组彼此重叠，因此覆盖了整个视场。
+CNN 架构的基本形式可以与人脑中的神经元和树突进行比较，并从视觉皮层中汲取灵感。 单个神经元对视野受限区域的刺激作出反应。 该区域称为接受场。 这些视场的一组彼此重叠，因此覆盖了整个视场。
 
 ## CNN 与感知器神经网络
 
@@ -89,7 +89,7 @@ CNN 体系结构的基本形式可以与人脑中的神经元和树突进行比
 
 并非很容易识别，不是吗？ 尽管如此，它是相同的信息。 当使用传统的神经网络而不是 CNN 时，也会发生类似的情况。 现在，当像素连续时，我们拥有的信息将丢失。
 
-CNN 可以通过应用相关滤镜来捕获图像中的空间和时间相关性。 CNN 体系结构在数据集上表现更好，这是因为参数数量减少了，并且权重得到了重用。
+CNN 可以通过应用相关过滤器来捕获图像中的空间和时间相关性。 CNN 架构在数据集上表现更好，这是因为参数数量减少了，并且权重得到了重用。
 
 现在，我们对 CNN 架构和图像的处理方式有了更好的了解，让我们考虑一下包含 CNN 的层。
 
@@ -113,7 +113,7 @@ CNN 通常使用以下类型的层：
 
 图 4：CNN 层
 
-当我们从网络中的输入层到输出层时，输入图像就从像素值转换为最终的类别分数。 已经为 CNN 提出了许多不同的体系结构，这是一个活跃的研究领域。 模型的准确性和鲁棒性取决于许多因素-层的类型，网络的深度，网络内各种类型的层的排列，为每个层选择的功能离子，训练数据 ， 等等。
+当我们从网络中的输入层到输出层时，输入图像就从像素值转换为最终的类别分数。 已经为 CNN 提出了许多不同的架构，这是一个活跃的研究领域。 模型的准确性和鲁棒性取决于许多因素-层的类型，网络的深度，网络内各种类型的层的排列，为每个层选择的功能离子，训练数据 ， 等等。
 
 # 建立基于感知器的线性回归器
 
@@ -655,7 +655,7 @@ print('Test accuracy =', accuracy.eval(feed_dict = {
 
 # 总结
 
-在本章中，我们学习了深度学习和 CNN。 我们讨论了什么是 CNN，以及我们为什么需要它们。 我们讨论了 CNN 的体系结构。 我们了解了 CNN 中使用的各种类型的层。 我们讨论了如何使用 TensorFlow。 我们使用它来构建基于感知器的线性回归器。 我们学习了如何使用单层神经网络构建图像分类器。 然后，我们使用 CNN 构建了图像分类器。
+在本章中，我们学习了深度学习和 CNN。 我们讨论了什么是 CNN，以及我们为什么需要它们。 我们讨论了 CNN 的架构。 我们了解了 CNN 中使用的各种类型的层。 我们讨论了如何使用 TensorFlow。 我们使用它来构建基于感知器的线性回归器。 我们学习了如何使用单层神经网络构建图像分类器。 然后，我们使用 CNN 构建了图像分类器。
 
 在下一章中，我们将了解 CNN 的另一个受欢迎的兄弟– **循环神经网络**（**RNN**）。 像 CNN 一样，RNN 也已流行，并且现在非常流行。 与以前的模型相比，它们取得了令人印象深刻的结果。 在某些情况下，甚至在某些情况下甚至超过了人类的表现。
 

new/ai-py/21.md

@@ -4,7 +4,7 @@
 
 在本章中，我们将学习深度学习和**循环神经网络**（**RNN**）。 像前几章所介绍的 CNN 一样，RNN 在过去几年中也获得了很大发展。 就 RNN 而言，它们在语音识别领域被大量使用。 当今许多聊天机器人都基于 RNN 技术建立了基础。 使用 RNN 预测金融市场已经取得了一些成功。 例如，我们可能有一个带有单词序列的文本，并且我们有一个目标来预测序列中的下一个单词。
 
-我们将讨论 RNN 的体系结构及其组件。 我们将继续使用上一章开始学习的 TensorFlow。 我们将使用 TensorFlow 快速构建 RNN。 我们还将学习如何使用单层神经网络构建 RNN 分类器。 然后，我们将使用 CNN 构建图像分类器。
+我们将讨论 RNN 的架构及其组件。 我们将继续使用上一章开始学习的 TensorFlow。 我们将使用 TensorFlow 快速构建 RNN。 我们还将学习如何使用单层神经网络构建 RNN 分类器。 然后，我们将使用 CNN 构建图像分类器。
 
 到本章末，您将了解：
 
@@ -23,7 +23,7 @@ RNN 是另一种流行的模型，目前正在获得很大的关注。 正如我
 
 RNN 背后的数学有时可能会令人不知所措。 在深入研究 RNN 之前，请牢记以下思想：赛车手不需要完全了解其赛车的机械原理即可使其快速行驶并赢得比赛。 同样，我们不一定需要完全了解 RNN 在幕后的工作方式，以使其对我们有用，有时甚至是令人印象深刻的工作。 Keras 库的创建者 Francois Chollet 描述了**长短期记忆**（**LSTM**）网络，这是 RNN 的一种形式，如下所示：
 
-> “您不需要了解有关 LSTM 单元的特定体系结构的所有内容；作为人类，理解它不是您的工作。只需记住 LSTM 单元的含义：允许过去的信息 以后再注射。”
+> “您不需要了解有关 LSTM 单元的特定架构的所有内容；作为人类，理解它不是您的工作。只需记住 LSTM 单元的含义：允许过去的信息 以后再注射。”
 
 现在让我们进入神经网络的一些基础知识。 顾名思义，*神经*网络从大脑神经元的结构中获得灵感。 神经网络中的神经元大致模拟了人类神经元的结构和功能。 对于一般的大脑，尤其是神经元，我们有很多不了解的地方。 但在基本级别上，神经元接受输入，并且如果达到阈值，它将触发输出。 用数学术语来说，*人工*神经元是数学函数的容器，其唯一的任务是通过将给定的输入应用于函数来传递输出。
 
@@ -106,9 +106,9 @@ f(x) = max(0.3 * x, x)
 
 鉴于 ReLU 的特性和优势，它经常是深度学习从业人员和研究人员选择的激活函数。
 
-现在，我们已经介绍了 RNN 的一些基本功能，并讨论了它们的一些关键功能，下面让我们深入研究其实际的体系结构。
+现在，我们已经介绍了 RNN 的一些基本功能，并讨论了它们的一些关键功能，下面让我们深入研究其实际的架构。
 
-# RNN 的体系结构
+# RNN 的架构
 
 RNN 背后的主要概念是利用序列中的先前信息。 在传统的神经网络中，假定所有输入和输出彼此独立。 在某些领域和用例中，这种假设是不正确的，我们可以利用这种相互联系的优势。
 

new/ai-py/23.md

@@ -31,7 +31,7 @@ Google 提供这些答案的基本技术之一就是通常所说的大数据。
 
 这句话使人们明白，大数据对不同的人意味着不同的事物。 这种情况开始改变，但是传统数据库在我们可以存储多少信息以及可扩展的最大范围上有一个上限。 如果您正在使用 Hadoop，Spark，NoSQL 数据库和图形数据库等新技术，那么您正在使用大数据。 没有什么是无限的，但是这些技术可以横向扩展（而不是纵向扩展），因此可以更有效地扩展规模。 没有任何东西可以无限扩展，但是在传统技术（如传统数据库）与新技术（如 Hadoop 和 Spark）之间存在根本差异。 随着供应商和诸如 Snowflake 之类的工具的出现，也开始使用普通的 SQL 处理 PB 级数据库。
 
-随着业务的增长和对资源的需求的增加，如果他们使用的是传统体系结构，则他们将通过升级到更大，功能更强的计算机来扩展。 可以预见，这种增长方式将达到极限。 硬件制造商制造的机器只有这么大。
+随着业务的增长和对资源的需求的增加，如果他们使用的是传统架构，则他们将通过升级到更大，功能更强的计算机来扩展。 可以预见，这种增长方式将达到极限。 硬件制造商制造的机器只有这么大。
 
 相反，如果企业正在使用新技术并且遇到瓶颈，则可以通过*向外扩展*并向其中添加新机器而不是更换硬件来突破瓶颈。 由于我们正在增加火力，因此这个新增加的不必一定更大。 它通常与旧机器相同。 这种增长方法更具可扩展性。 我们可能有成千上万的机器协同工作来解决问题。
 
@@ -39,7 +39,7 @@ Google 提供这些答案的基本技术之一就是通常所说的大数据。
 
 这样的集群在低成本的商用计算机上运行 Hadoop 的开源分布式处理软件。 群集通常称为*，不共享*系统，因为节点之间唯一共享的资源是连接它们的网络。
 
-集群体系结构可以大大提高数据分析的处理速度。 该架构还具有高度可扩展性：当集群的处理能力因某个工作负载而无法承受时，可以轻松添加其他节点以提高吞吐量。 此外，集群体系结构本质上是容错的。
+集群架构可以大大提高数据分析的处理速度。 该架构还具有高度可扩展性：当集群的处理能力因某个工作负载而无法承受时，可以轻松添加其他节点以提高吞吐量。 此外，集群架构本质上是容错的。
 
 每个数据组件都冗余地复制到多个节点上，以确保不会因为单个节点故障而丢失数据。 数据丢失并非不可能，但极不可能。
 
@@ -205,7 +205,7 @@ Google 的工作方式与图书馆卡目录类似，不同之处在于 Google
 
 机器学习系统与大数据技术相结合，以多种方式帮助企业，包括比以往任何时候都更具战略性地管理，分析和使用捕获的数据。
 
-随着公司捕获并生成不断增长的数据量，这既是挑战，也是巨大的机遇。 幸运的是，这两种技术是共生的。 企业不断提出新的模型，这些模型增加了最终工作负载的计算需求。 大数据方面的新进展使这些新用例的处理变得容易并得到促进。 数据科学家发现，当前的体系结构可以处理增加的工作量。 因此，他们提出了分析此数据的新方法，并从可用的当前数据中获得了越来越深刻的见解。
+随着公司捕获并生成不断增长的数据量，这既是挑战，也是巨大的机遇。 幸运的是，这两种技术是共生的。 企业不断提出新的模型，这些模型增加了最终工作负载的计算需求。 大数据方面的新进展使这些新用例的处理变得容易并得到促进。 数据科学家发现，当前的架构可以处理增加的工作量。 因此，他们提出了分析此数据的新方法，并从可用的当前数据中获得了越来越深刻的见解。
 
 精心设计的算法可以在大型数据集上蓬勃发展，这意味着数据越多，学习越有效。 随着大数据的出现以及计算能力的提高，机器学习继续以加速的速度发展。 随着大数据分析在机器学习领域的稳定增长，机器和设备将变得越来越智能，并继续承担以前为人类保留的任务。
 
@@ -231,7 +231,7 @@ Hadoop 无疑是构建可伸缩大数据解决方案的最佳开源工具。 它
 
 Hadoop 核心高度依赖 MapReduce。 MapReduce 是一种编程设计模式，用于使用并行，分布式集群计算来处理，转换和生成大型数据集。 MapReduce 模型通过协调分布式资源，并行运行多个作业以及同步节点之间的通信和数据传输来完成大规模数据集的处理。 通过跨节点复制数据，它可以很好地处理各个节点何时出现故障。
 
-MapReduce 仅在多节点群集体系结构模型的上下文中才有意义。 MapReduce 背后的想法是，许多问题可以分为两个步骤。 映射和归约。
+MapReduce 仅在多节点群集架构模型的上下文中才有意义。 MapReduce 背后的想法是，许多问题可以分为两个步骤。 映射和归约。
 
 MapReduce 实现由一个映射组件和一个归约组件组成，映射组件执行映射，过滤和/或排序（例如，将不同家用物品的图像映射到队列中，每种类型的物品一个队列），归约组件完成摘要操作（继续示例，计算每个队列中的图像数量，为我们提供家用物品的频率）。
 
@@ -366,7 +366,7 @@ Impala 可以轻松与 Hadoop 集成，并支持 MapReduce，Apache Hive 和 Apa
 
 ## Apache Cassandra
 
-Apache Cassandra 是，一个开放源代码的分布式 NoSQL 数据库。 它可以处理大量数据。 我利用了可以使用许多商品服务器进行处理的水平架构。 它具有无单点故障的体系结构，因此可提供高可用性。 Cassandra 依赖可以跨越多个数据中心和区域的集群。 它使用异步无主复制，同时为用户提供低延迟的操作。
+Apache Cassandra 是，一个开放源代码的分布式 NoSQL 数据库。 它可以处理大量数据。 我利用了可以使用许多商品服务器进行处理的水平架构。 它具有无单点故障的架构，因此可提供高可用性。 Cassandra 依赖可以跨越多个数据中心和区域的集群。 它使用异步无主复制，同时为用户提供低延迟的操作。
 
 Avinash Lakshman（亚马逊 DynamoDB 的作者之一）和 Prashant Malik 最初在 Facebook 上开发了 Cassandra。 Facebook 将 Cassandra 作为开源项目发布，并在 2010 年成为 Apache 的顶级项目。
 

new/gan-proj/0.md

@@ -8,7 +8,7 @@
 
 *生成对抗网络项目*首先介绍了用于构建高效项目的概念，工具和库。 您还将在本书的不同项目中使用各种数据集。 在每一章中，复杂性和操作的水平都会提高，从而帮助您掌握 GAN 域。
 
-您将介绍 3D-GAN，DCGAN，StackGAN 和 CycleGAN 等流行的方法，并且您将通过它们的实际实现来理解生成模型的体系结构和功能。
+您将介绍 3D-GAN，DCGAN，StackGAN 和 CycleGAN 等流行的方法，并且您将通过它们的实际实现来理解生成模型的架构和功能。
 
 到本书结尾，您将准备在工作中或项目中建立，训练和优化自己的端到端 GAN 模型。
 

new/gan-proj/1.md

@@ -25,7 +25,7 @@
 
 
 
-GAN 是由两个网络（生成器网络和判别器网络）组成的深度神经网络体系结构。 通过生成和辨别的多个周期，两个网络互相训练，同时试图互相取胜。
+GAN 是由两个网络（生成器网络和判别器网络）组成的深度神经网络架构。 通过生成和辨别的多个周期，两个网络互相训练，同时试图互相取胜。
 
 
 
@@ -92,7 +92,7 @@ GAN 具有一些相当有用的实际应用，其中包括：
 
 
 
-GAN 的体系结构具有两个基本元素：生成器网络和判别器网络。 每个网络都可以是任何神经网络，例如**人工神经网络**（**ANN**），**卷积神经网络**（**CNN**）， **循环神经网络**（**RNN**），或**长短期记忆**（**LSTM**）。 判别器必须具有完全连接的层，最后是分类器。
+GAN 的架构具有两个基本元素：生成器网络和判别器网络。 每个网络都可以是任何神经网络，例如**人工神经网络**（**ANN**），**卷积神经网络**（**CNN**）， **循环神经网络**（**RNN**），或**长短期记忆**（**LSTM**）。 判别器必须具有完全连接的层，最后是分类器。
 
 让我们仔细看一下 GAN 架构的组件。 在此示例中，我们将想象正在创建一个虚拟 GAN。
 
@@ -161,7 +161,7 @@ The architecture of the discriminator network
 
 
 
-现在我们已经了解了 GAN 的体系结构，下面让我们看一下一些重要概念的简要概述。 我们首先来看 KL 散度。 理解 JS 差异非常重要，这是评估模型质量的重要措施。 然后，我们将研究纳什均衡，这是我们在训练中试图达到的状态。 最后，我们将仔细研究目标函数，了解这些目标函数对于很好地实现 GAN 至关重要。
+现在我们已经了解了 GAN 的架构，下面让我们看一下一些重要概念的简要概述。 我们首先来看 KL 散度。 理解 JS 差异非常重要，这是评估模型质量的重要措施。 然后，我们将研究纳什均衡，这是我们在训练中试图达到的状态。 最后，我们将仔细研究目标函数，了解这些目标函数对于很好地实现 GAN 至关重要。
 
 
 
@@ -564,7 +564,7 @@ The benefits of batch normalization are as follows:
 
 
 
-在本章中，我们了解了 GAN 是什么以及组成标准 GAN 体系结构的组件。 我们还探讨了可用的各种 GAN。 建立 GAN 的基本概念后，我们继续研究 GAN 的构建和功能中涉及的基本概念。 我们了解了 GAN 的优缺点，以及有助于克服这些缺点的解决方案。 最后，我们了解了 GAN 的各种实际应用。
+在本章中，我们了解了 GAN 是什么以及组成标准 GAN 架构的组件。 我们还探讨了可用的各种 GAN。 建立 GAN 的基本概念后，我们继续研究 GAN 的构建和功能中涉及的基本概念。 我们了解了 GAN 的优缺点，以及有助于克服这些缺点的解决方案。 最后，我们了解了 GAN 的各种实际应用。
 
 利用本章中 GAN 的基本知识，我们现在将进入下一章，在此我们将学习使用 GAN 生成各种形状。
 

new/gan-proj/2.md

@@ -4,7 +4,7 @@
 
 
 
-3D-GAN 是用于 3D 形状生成的 GAN 体系结构。 由于处理 3D 图像涉及复杂性，因此 3D 形状生成通常是一个复杂的问题。 3D-GAN 是一种可以生成逼真的，变化的 3D 形状的解决方案，由吴嘉俊，张成凯，薛天凡等人在题为《通过 3D 生成对抗建模学习对象形状的概率潜在空间》的论文中介绍，可以在[这个页面](http://3dgan.csail.mit.edu/papers/3dgan_nips.pdf)上找到该论文。 在本章中，我们将使用 Keras 框架实现 3D-GAN。
+3D-GAN 是用于 3D 形状生成的 GAN 架构。 由于处理 3D 图像涉及复杂性，因此 3D 形状生成通常是一个复杂的问题。 3D-GAN 是一种可以生成逼真的，变化的 3D 形状的解决方案，由吴嘉俊，张成凯，薛天凡等人在题为《通过 3D 生成对抗建模学习对象形状的概率潜在空间》的论文中介绍，可以在[这个页面](http://3dgan.csail.mit.edu/papers/3dgan_nips.pdf)上找到该论文。 在本章中，我们将使用 Keras 框架实现 3D-GAN。
 
 我们将涵盖以下主题：
 
@@ -40,7 +40,7 @@
 
 ![](img/9128ea2e-31f5-472a-8ebc-f3add1a716e0.png)
 
-现在，我们对 3D 卷积有了基本的了解，让我们继续看一下 3D-GAN 的体系结构。
+现在，我们对 3D 卷积有了基本的了解，让我们继续看一下 3D-GAN 的架构。
 
 
 
@@ -52,7 +52,7 @@
 
 3D-GAN 中的两个网络都是深度卷积神经网络。 生成器网络通常是一个上采样网络。 它对噪声向量（来自概率潜在空间的向量）进行上采样，以生成形状为的 3D 图像，该形状的长度，宽度，高度和通道与输入图像相似。 判别器网络是下采样网络。 使用一系列 3D 卷积运算和密集层，它可以识别提供给它的输入数据是真实的还是伪造的。
 
-在接下来的两节中，我们将介绍生成器和判别器网络的体系结构。
+在接下来的两节中，我们将介绍生成器和判别器网络的架构。
 
 
 
@@ -78,7 +78,7 @@
 *   **输入**：从概率潜在空间中采样的 200 维向量
 *   **输出**：形状为`64x64x64`的 3D 图像
 
-下图显示了生成器的体系结构：
+下图显示了生成器的架构：
 
 ![](img/adfe13fc-6e5c-4ffb-8230-ba4117391c77.png)
 

new/gan-proj/3.md

@@ -34,9 +34,9 @@
 
 
 
-cGAN 是 GAN 的一种，它取决于一些额外的信息。 我们将额外的`y`信息作为额外的输入层提供给生成器。 在朴素 GAN 中，无法控制所生成图像的类别。 当我们向生成器添加条件`y`时，我们可以使用`y`生成特定类别的图像，该图像可以是任何类型的数据，例如类标签或整数数据 。 Vanilla GAN 只能学习一个类别，而为多个类别构造 GAN 则非常困难。 但是，可以使用 cGAN 生成针对不同类别具有不同条件的多模式模型。
+cGAN 是 GAN 的一种，它取决于一些额外的信息。 我们将额外的`y`信息作为额外的输入层提供给生成器。 在朴素 GAN 中，无法控制所生成图像的类别。 当我们向生成器添加条件`y`时，我们可以使用`y`生成特定类别的图像，该图像可以是任何类型的数据，例如类标签或整数数据 。朴素 GAN 只能学习一个类别，而为多个类别构造 GAN 则非常困难。 但是，可以使用 cGAN 生成针对不同类别具有不同条件的多模式模型。
 
-下图显示了 cGAN 的体系结构：
+下图显示了 cGAN 的架构：
 
 ![](img/7b4b89cd-9b42-4609-84e2-94086b34ac3a.png)
 
@@ -1395,7 +1395,7 @@ Flow of tensors and different operations inside the graphs
 
 
 
-在本章中，我们介绍了年龄条件生成对抗网络（Age-cGAN）。 然后，我们研究了 Age-cGAN 的体系结构。 之后，我们学习了如何设置我们的项目，并研究了 Ages-cGAN 的 Keras 实现。 然后，我们在 Wiki 裁剪的数据集上训练了 Age-cGAN，并经历了 Age-cGAN 网络的所有三个阶段。 最后，我们讨论了 Age-cGAN 的实际应用。
+在本章中，我们介绍了年龄条件生成对抗网络（Age-cGAN）。 然后，我们研究了 Age-cGAN 的架构。 之后，我们学习了如何设置我们的项目，并研究了 Ages-cGAN 的 Keras 实现。 然后，我们在 Wiki 裁剪的数据集上训练了 Age-cGAN，并经历了 Age-cGAN 网络的所有三个阶段。 最后，我们讨论了 Age-cGAN 的实际应用。
 
 在下一章中，我们将使用 GAN 的另一个变体生成动画角色：DCGAN。
 

new/gan-proj/4.md

@@ -26,11 +26,11 @@
 
 
 
-CNN 在计算机视觉任务中非常出色，无论是用于分类图像还是检测图像中的对象。 CNN 善于理解图像，以至于激发研究人员在 GAN 网络中使用 CNN。 最初，GAN 官方论文的作者介绍了仅具有密集层的**深层神经网络**（**DNN**）。 在 GAN 网络的原始实现中未使用卷积层。 在以前的 GAN 中，生成器和判别器网络仅使用密集的隐藏层。 相反，作者建议在 GAN 设置中可以使用不同的神经网络体系结构。
+CNN 在计算机视觉任务中非常出色，无论是用于分类图像还是检测图像中的对象。 CNN 善于理解图像，以至于激发研究人员在 GAN 网络中使用 CNN。 最初，GAN 官方论文的作者介绍了仅具有密集层的**深层神经网络**（**DNN**）。 在 GAN 网络的原始实现中未使用卷积层。 在以前的 GAN 中，生成器和判别器网络仅使用密集的隐藏层。 相反，作者建议在 GAN 设置中可以使用不同的神经网络架构。
 
 DCGAN 扩展了在判别器和生成器网络中使用卷积层的思想。 DCGAN 的设置类似于朴素 GAN。 它由两个网络组成：生成器和判别器。 生成器是具有卷积层的 DNN，而判别器是具有卷积层的 DNN。 训练 DCGAN 类似于训练普通 GAN 网络。 在第一章中，我们了解到网络参与了非合作博弈，其中判别器网络将其错误反向传播到生成器网络，生成器网络使用此错误来提高其权重。
 
-在下一部分中，我们将探索两个网络的体系结构。
+在下一部分中，我们将探索两个网络的架构。
 
 
 
@@ -52,13 +52,13 @@ DCGAN 扩展了在判别器和生成器网络中使用卷积层的思想。 DCGA
 
 
 
-在继续之前，让我们看一下生成器网络的体系结构：
+在继续之前，让我们看一下生成器网络的架构：
 
 ![](img/7201db6b-98f4-473e-8ba3-615cd8d132f1.png)
 
 Source: arXiv:1511.06434 [cs.LG]
 
-上图包含了生成器网络体系结构中的不同层，并显示了它如何生成分辨率为`64 x 64 x 3`的图像。
+上图包含了生成器网络架构中的不同层，并显示了它如何生成分辨率为`64 x 64 x 3`的图像。
 
 DCGAN 的生成器网络包含 10 层。 它执行跨步卷积以增加张量的空间分辨率。 在 Keras 中，上采样和卷积层的组合等于跨步卷积层。 基本上，生成器网络会从均匀分布中获取采样的噪声向量，并不断对其进行转换，直到生成最终图像为止。 换句话说，它采取形状的张量（`batch_size, 100`），并输出形状的张量（`batch_size, 64, 64, 3`）。
 
@@ -349,7 +349,7 @@ total_num_faces = 0   for index, filename in enumerate(glob.glob('/path/to/direc
 print("Total number of faces:{}".format(total_num_faces))
 ```
 
-前面的脚本将从包含下载图像的文件夹中加载所有图像，使用`python-animeface`库检测脸部，然后**从初始图像中裁剪出**脸部。 然后，裁切后的图像将被调整为`64 x 64`的尺寸。如果要更改图像的尺寸，请相应地更改生成器和判别器的体系结构。 我们现在准备在我们的网络上工作。
+前面的脚本将从包含下载图像的文件夹中加载所有图像，使用`python-animeface`库检测脸部，然后**从初始图像中裁剪出**脸部。 然后，裁切后的图像将被调整为`64 x 64`的尺寸。如果要更改图像的尺寸，请相应地更改生成器和判别器的架构。 我们现在准备在我们的网络上工作。
 
 
 
@@ -369,7 +369,7 @@ print("Total number of faces:{}".format(total_num_faces))
 
 
 
-如 DCGAN 部分的*体系结构中所述，生成器网络由一些 2D 卷积层，上采样层，整形层和批归一化层组成 。 在 Keras 中，每个操作都可以指定为一个层。 甚至激活函数也是 Keras 中的层，可以像正常的密集层一样添加到模型中。*
+如 DCGAN 部分的“架构”中所述，生成器网络由一些 2D 卷积层，上采样层，整形层和批归一化层组成 。 在 Keras 中，每个操作都可以指定为一个层。 甚至激活函数也是 Keras 中的层，可以像正常的密集层一样添加到模型中。
 
 执行以下步骤来创建生成器网络：
 
@@ -394,7 +394,7 @@ gen_model.add(BatchNormalization())
 gen_model.add(Activation('tanh')) 
 ```
 
-第二密集层的输出是大小为[ **16384** ）的张量。 此处，[ **256、8、8** ）是密集层中神经元的数量。
+第二密集层的输出是大小为`16384`的张量。 此处，`(256, 8, 8)`是密集层中神经元的数量。
 
 4.  接下来，向网络中添加一个重塑层，以将张量从最后一层重塑为（`batch_size, 8, 8, 256`）**：**形状的张量
 
@@ -403,7 +403,7 @@ gen_model.add(Activation('tanh'))
 gen_model.add(Reshape((8, 8, 256), input_shape=(256`8`8,)))
 ```
 
-5.  接下来，添加 2D 上采样层以将形状从（8，8，256）更改为（16，16，256）。 上采样大小为（2，2），这将张量的大小增加到其原始大小的两倍。 在这里，我们有 256 个张量为 16 x 16：的张量。
+5.  接下来，添加 2D 上采样层以将形状从`(8, 8, 256)`更改为`(16, 16, 256)`。 上采样大小为`(2, 2)`，这将张量的大小增加到其原始大小的两倍。 在这里，我们有 256 个张量为`16 x 16`：的张量。
 
 ```py
 gen_model.add(UpSampling2D(size=(2, 2)))
@@ -437,14 +437,14 @@ gen_model.add(Activation('tanh'))
 gen_model.add(UpSampling2D(size=(2, 2))) 
 ```
 
-10.  最后，在第三个 2D 卷积层上添加三个 **滤镜** ， **内核大小`(5, 5)` ，然后是 ] `tanh` 作为激活函数：**
+10.  最后，在第三个 2D 卷积层上添加三个**过滤器**，**内核大小**`(5, 5)` ，然后是`tanh`作为激活函数：
 
 ```py
 gen_model.add(Conv2D(3, (5, 5), padding='same'))
 gen_model.add(Activation('tanh'))
 ```
 
-生成器网络将输出`(batch_size, 64, 64, 3)`形状的张量。 这批张量中的一个图像张量类似于具有三个通道的尺寸为 64 x 64 的图像： **红色，绿色** **和** **蓝色**（**RGB**）。
+生成器网络将输出`(batch_size, 64, 64, 3)`形状的张量。 这批张量中的一个图像张量类似于具有三个通道的尺寸为`64 x 64`的图像： **红色，绿色**和**蓝色**（**RGB**）。
 
 用 Python 方法包装的生成器网络的完整代码如下所示：
 
@@ -487,10 +487,10 @@ def get_generator():
 
 
 
-如 DCGAN 的*体系结构中所述，判别器网络具有三个 2D 卷积层，每个层均具有激活函数，后跟两个最大合并层。 网络的尾部包含两个完全连接的（密集）层，用作分类层。 首先，让我们看一下判别器网络中的不同层：*
+如 DCGAN 的架构中所述，判别器网络具有三个 2D 卷积层，每个层均具有激活函数，后跟两个最大合并层。 网络的尾部包含两个完全连接的（密集）层，用作分类层。 首先，让我们看一下判别器网络中的不同层：
 
-*   所有卷积层都具有`LeakyReLU`作为激活函数，其 alpha 值为 0.2
-*   卷积层分别具有 128、256 和 512 个滤波器。 它们的内核大小分别为（5、5），（3、3）和（3、3）。
+*   所有卷积层都具有`LeakyReLU`作为激活函数，其`alpha`值为 0.2
+*   卷积层分别具有 128、256 和 512 个滤波器。 它们的内核大小分别为`(5, 5)`，`(3, 3)`和`(3, 3)`。
 *   在卷积层之后，我们有一个平坦层，它将输入平坦化为一维张量。
 *   此后，网络具有两个密集层，分别具有 1,024 个神经元和一个神经元。
 *   第一密集层具有`LeakyReLU`作为激活函数，而第二层具有乙状结肠作为激活函数。 乙状结肠激活用于二进制分类。 我们正在训练辨别器网络，以区分真实图像还是伪图像。
@@ -503,9 +503,9 @@ def get_generator():
 dis_model = Sequential()
 ```
 
-2.  添加一个 2D 卷积层，该层采用形状为（64，64，3）的输入图像。 该层的超参数如下。 另外，添加具有`0.2`的 alpha 值的`LeakyReLU`作为激活函数：
+2.  添加一个 2D 卷积层，该层采用形状为`(64, 64, 3)`的输入图像。 该层的超参数如下。 另外，添加具有`0.2`的`alpha`值的`LeakyReLU`作为激活函数：
     *   **过滤器：** 128
-    *   **内核大小：** （5，5）
+    *   **内核大小：** `(5, 5)`
     *   **填充：** 相同：
 
 ```py
@@ -514,7 +514,7 @@ dis_model.add(Conv2D(filters=128, kernel_size=5, padding='same',
 dis_model.add(LeakyReLU(alpha=0.2))
 ```
 
-3.  接下来，添加池大小为`(2, 2)`的 2D 最大池化层。 最大池用于对图像表示进行下采样，并通过在表示的非重叠子区域上使用 max-filter 来应用它：
+3.  接下来，添加池大小为`(2, 2)`的 2D 最大池化层。 最大池用于对图像表示进行下采样，并通过在表示的非重叠子区域上使用最大过滤来应用它：
 
 ```py
 dis_model.add(MaxPooling2D(pool_size=(2, 2)))
@@ -524,9 +524,9 @@ dis_model.add(MaxPooling2D(pool_size=(2, 2)))
 
 4.  接下来，添加具有以下配置的另一个 2D 卷积层：
     *   **过滤器**：256
-    *   **内核大小** ：( 3，3）
-    *   **激活函数**： `LeakyReLU`，具有 alpha 0.2
-    *   **2D 最大池中的池大小**：（2、2）：
+    *   **内核大小** ：`(3, 3)`
+    *   **激活函数**： `LeakyReLU`，具有`alpha` 0.2
+    *   **2D 最大池中的池大小**：`(2, 2)`
 
 ```py
 dis_model.add(Conv2D(filters=256, kernel_size=3))
@@ -538,9 +538,9 @@ dis_model.add(MaxPooling2D(pool_size=(2, 2)))
 
 5.  接下来，添加具有以下配置的第三个 2D 卷积层：
     *   **过滤器**： 512
-    *   **内核大小** ：( 3 ，3）
-    *   **激活函数**：`LeakyReLU` ，带有 alpha 0.2
-    *   **2D 最大池中的池大小** ：( 2 ，2）：
+    *   **内核大小**：`(3, 3)`
+    *   **激活函数**：`LeakyReLU`，带有`alpha` 0.2
+    *   **2D 最大池中的池大小**：`(2, 2)`
 
 ```py
 dis_model.add(Conv2D(512, (3, 3)))
@@ -615,7 +615,7 @@ def get_discriminator():
 
 
 
-同样，训练 DCGAN 类似于训练 Vanilla GAN 网络。 这是一个四步过程：
+同样，训练 DCGAN 类似于训练朴素 GAN 网络。 这是一个四步过程：
 
 1.  加载数据集。
 2.  构建和编译网络。
@@ -740,7 +740,7 @@ for epoch in range(epcohs):
 *   最初，这两个网络都是幼稚的并且具有随机权重。
 *   训练 DCGAN 网络的标准过程是首先对一批样品进行判别器训练。
 *   为此，我们需要假样品和真实样品。 我们已经有了真实的样本，因此现在需要生成伪样本。
-*   要生成伪样本，请在均匀分布上创建形状为（100，）的潜向量。 将此潜向量馈入未经训练的生成器网络。 生成器网络将生成伪样本，我们将其用于训练判别器网络。
+*   要生成伪样本，请在均匀分布上创建形状为`(100, )`的潜向量。 将此潜向量馈入未经训练的生成器网络。 生成器网络将生成伪样本，我们将其用于训练判别器网络。
 *   合并真实图像和伪图像以创建一组新的样本图像。 我们还需要创建一个标签数组：真实图像使用标签 1，伪图像使用标签 0。
 
 
@@ -842,7 +842,7 @@ print("g_loss:", g_loss)
 
 这些 图像将帮助您决定是继续训练还是尽早停止训练。 如果生成的高分辨率图像的质量良好，请停止训练。 或者继续训练，直到您的模型变好为止。
 
-我们已经成功地在 ANIME 角色数据集上训练了 DCGAN 网络。 现在我们可以使用该模型生成动漫人物图像。
+我们已经成功地在动画角色数据集上训练了 DCGAN 网络。 现在我们可以使用该模型生成动漫人物图像。
 
 
 
@@ -944,7 +944,7 @@ tensorboard --logdir=logs
 
 
 
-Tensorboard 的 **GRAPHS** 部分包含两个网络的图形。 如果网络性能不佳，这些图可以帮助您调试网络。 它们还显示了每个图中的张量流和不同的操作：
+Tensorboard 的`GRAPHS`部分包含两个网络的图形。 如果网络性能不佳，这些图可以帮助您调试网络。 它们还显示了每个图中的张量流和不同的操作：
 
 ![](img/9bdd11ae-60a0-4d18-b9ba-9e9a46e9514f.png)
 
@@ -968,7 +968,7 @@ Tensorboard 的 **GRAPHS** 部分包含两个网络的图形。 如果网络性
 *   激活函数
 *   损失函数
 
-在*使用 Keras* 实现 DCGAN 的部分中，学习率是固定的：生成器模型为 0.0005，判别器模型为 0.0005。 批处理大小为 128。调整这些值可能会导致我们创建更好的模型。 如果您的模型没有生成合理的图像，请尝试更改这些值，然后再次运行模型。
+在“使用 Keras 实现 DCGAN”的部分中，学习率是固定的：生成器模型为 0.0005，判别器模型为 0.0005。 批处理大小为 128。调整这些值可能会导致我们创建更好的模型。 如果您的模型没有生成合理的图像，请尝试更改这些值，然后再次运行模型。
 
 
 
@@ -995,7 +995,7 @@ Tensorboard 的 **GRAPHS** 部分包含两个网络的图形。 如果网络性
 
 
 
-在本章中，我们介绍了深度卷积生成对抗网络。 我们从基本介绍 DCGAN 开始，然后深入探讨了 DCGAN 网络的体系结构。 之后，我们设置项目并安装必要的依赖项。 然后，我们研究了下载和准备数据集所需的不同步骤。 然后，我们准备了网络的 Keras 实现，并在我们的数据集中对其进行了训练。 经过训练后，我们将其用于生成新的动漫角色。 我们还探讨了 DCGAN 在实际用例中的不同应用。
+在本章中，我们介绍了深度卷积生成对抗网络。 我们从基本介绍 DCGAN 开始，然后深入探讨了 DCGAN 网络的架构。 之后，我们设置项目并安装必要的依赖项。 然后，我们研究了下载和准备数据集所需的不同步骤。 然后，我们准备了网络的 Keras 实现，并在我们的数据集中对其进行了训练。 经过训练后，我们将其用于生成新的动漫角色。 我们还探讨了 DCGAN 在实际用例中的不同应用。
 
 在下一章中，我们将研究用于高分辨率图像生成的 SRGAN。
 

new/gan-proj/5.md

@@ -32,15 +32,15 @@
 
 
 
-# SRGAN 的体系结构
+# SRGAN 的架构
 
 
 
-在 SRGAN 中，这两个网络都是深度卷积神经网络。 它们包含卷积层和上采样层。 每个卷积层之后是批处理归一化操作和一个激活层。 我们将在以下各节中详细探讨网络。 下图显示了 SRGAN 的体系结构：
+在 SRGAN 中，这两个网络都是深度卷积神经网络。 它们包含卷积层和上采样层。 每个卷积层之后是批处理归一化操作和一个激活层。 我们将在以下各节中详细探讨网络。 下图显示了 SRGAN 的架构：
 
 ![](img/fe3eced0-c452-4b7a-9f6d-dd8228048ab9.png)
 
-在以下各节中，让我们详细了解网络的体系结构。
+在以下各节中，让我们详细了解网络的架构。
 
 
 
@@ -402,7 +402,7 @@ gen2 = Conv2D(filters=64, kernel_size=3, strides=1, padding='same')(res)
 gen2 = BatchNormalization(momentum=momentum)(gen2)
 ```
 
-7.  现在，添加`Add`层，以获取残留前块的输出`gen1`和残留后块的输出`gen2`之和。 该层生成另一个类似形状的张量。 有关更多详细信息，请参考“ *生成器网络*的体系结构”部分。
+7.  现在，添加`Add`层，以获取残留前块的输出`gen1`和残留后块的输出`gen2`之和。 该层生成另一个类似形状的张量。 有关更多详细信息，请参考“ *生成器网络*的架构”部分。
 
 ```py
 gen3 = Add()([gen2, gen1])
@@ -520,7 +520,7 @@ def build_generator():
 
 
 
-我们已经在*中探讨了判别器网络的体系结构。 让我们 首先在 Keras 框架中编写区分网络的层，然后使用 Keras 框架的功能 API 创建 Keras 模型。*
+我们已经在*中探讨了判别器网络的架构。 让我们 首先在 Keras 框架中编写区分网络的层，然后使用 Keras 框架的功能 API 创建 Keras 模型。*
 
 执行以下步骤以在 Keras 中实现判别器网络：
 
@@ -1199,7 +1199,7 @@ TensorBoard 的 GRAPHS 部分包含两个网络的图形。 如果网络性能
 
 
 
-在本章中，我们首先介绍 SRGAN。 然后，我们研究了生成器和判别器网络的体系结构。 后来，我们执行了该项目所需的设置。 然后，我们收集并探索了数据集。 之后，我们在训练 SRGAN 之前先在 Keras 中实现了该项目，评估了训练后的 SRGAN 网络，并使用超参数优化技术对训练后的模型进行了优化。 最后，我们简要介绍了 SRGAN 的一些不同应用。
+在本章中，我们首先介绍 SRGAN。 然后，我们研究了生成器和判别器网络的架构。 后来，我们执行了该项目所需的设置。 然后，我们收集并探索了数据集。 之后，我们在训练 SRGAN 之前先在 Keras 中实现了该项目，评估了训练后的 SRGAN 网络，并使用超参数优化技术对训练后的模型进行了优化。 最后，我们简要介绍了 SRGAN 的一些不同应用。
 
 在下一章中，我们将介绍 StackGAN 及其不同的应用程序。
 

new/gan-proj/6.md

@@ -32,7 +32,7 @@
 
 
 
-# StackGAN 的体系结构
+# StackGAN 的架构
 
 
 
@@ -124,7 +124,7 @@ StackGAN 网络的主要组成部分是生成器网络和判别器网络。 在
 
 
 
-Stage-I 生成器网络是具有几个上采样层的深度卷积神经网络。 g 生成器网络是 CGAN ，其条件是处于![](img/10c2247d-25a3-41dc-9b01-e117a05f6b1d.png)  和随机变量  [ ![](img/f17e1ecf-417e-4b78-ad5c-6e5a25ae8e26.png)。   生成器网络采用高斯条件变量![](img/10c2247d-25a3-41dc-9b01-e117a05f6b1d.png)和随机噪声变量`z`，并生成尺寸为`64x64x3`  的图像。 生成的低分辨率图像可能具有原始形状和基本颜色，但会存在各种缺陷。 这里，`z`是从维数为![](img/79328706-d7f6-47a5-b93c-7c1c308af456.png)的高斯分布![](img/b3edb215-2b94-4a1a-92f6-c97f1c779948.png)采样的随机噪声变量。 生成器网络生成的图像可以表示为![](img/7846fcd5-c526-476d-bde4-e03e5d0980d0.png)。 让我们看一下生成器网络的体系结构，如以下屏幕截图所示：
+Stage-I 生成器网络是具有几个上采样层的深度卷积神经网络。 g 生成器网络是 CGAN ，其条件是处于![](img/10c2247d-25a3-41dc-9b01-e117a05f6b1d.png)  和随机变量  [ ![](img/f17e1ecf-417e-4b78-ad5c-6e5a25ae8e26.png)。   生成器网络采用高斯条件变量![](img/10c2247d-25a3-41dc-9b01-e117a05f6b1d.png)和随机噪声变量`z`，并生成尺寸为`64x64x3`  的图像。 生成的低分辨率图像可能具有原始形状和基本颜色，但会存在各种缺陷。 这里，`z`是从维数为![](img/79328706-d7f6-47a5-b93c-7c1c308af456.png)的高斯分布![](img/b3edb215-2b94-4a1a-92f6-c97f1c779948.png)采样的随机噪声变量。 生成器网络生成的图像可以表示为![](img/7846fcd5-c526-476d-bde4-e03e5d0980d0.png)。 让我们看一下生成器网络的架构，如以下屏幕截图所示：
 
 ![](img/04c840a1-a6ae-4b3d-a141-ed58f9dae21b.png)
 
@@ -199,7 +199,7 @@ Stack-I GAN 生成的图像存在的问题是，它们可能缺少生动的对
 
 
 
-生成器网络还是深层卷积神经网络。 第 I 阶段的结果是低分辨率图像，它经过几个下采样层以生成图像特征。 然后，将图像特征和文本条件变量沿通道尺寸连接在一起。 之后，将级联张量馈入一些残差块，这些残差块学习跨图像和文本特征的多峰表示。 最后，最后一个操作的输出被馈送到一组上采样层，这些上采样层生成尺寸为`256x256x3`的高分辨率图像。 让我们看一下生成器网络的体系结构，如下图所示：
+生成器网络还是深层卷积神经网络。 第 I 阶段的结果是低分辨率图像，它经过几个下采样层以生成图像特征。 然后，将图像特征和文本条件变量沿通道尺寸连接在一起。 之后，将级联张量馈入一些残差块，这些残差块学习跨图像和文本特征的多峰表示。 最后，最后一个操作的输出被馈送到一组上采样层，这些上采样层生成尺寸为`256x256x3`的高分辨率图像。 让我们看一下生成器网络的架构，如下图所示：
 
 ![](img/028e54b4-8184-45bd-8edf-abc7b7e8de97.png)
 
@@ -223,7 +223,7 @@ The architecture of the Stage-II generator
 
 
 
-类似于生成器网络，判别器网络是一个深度卷积神经网络，并且包含额外的下采样层，因为图像的大小比 Stage-I 中的判别器网络大。 判别器是一个可识别匹配的判别器（有关更多信息，[请参见以下链接](https://arxiv.org/pdf/1605.05396.pdf)，它使我们可以更好地实现 图片和条件文字。 在训练期间，判别器将真实图像及其对应的文本描述作为正样本对，而负样本对则由两组组成。 第一组是具有不匹配的文本嵌入的真实图像，而第二组是具有相应的文本嵌入的合成图像。 让我们看一下判别器网络的体系结构，如下图所示：
+类似于生成器网络，判别器网络是一个深度卷积神经网络，并且包含额外的下采样层，因为图像的大小比 Stage-I 中的判别器网络大。 判别器是一个可识别匹配的判别器（有关更多信息，[请参见以下链接](https://arxiv.org/pdf/1605.05396.pdf)，它使我们可以更好地实现 图片和条件文字。 在训练期间，判别器将真实图像及其对应的文本描述作为正样本对，而负样本对则由两组组成。 第一组是具有不匹配的文本嵌入的真实图像，而第二组是具有相应的文本嵌入的合成图像。 让我们看一下判别器网络的架构，如下图所示：
 
 ![](img/a8c04bff-bd5a-4350-8b08-bd2ef6ae193b.png)
 
@@ -393,7 +393,7 @@ StackGAN 的 Keras 实现分为两部分：第一阶段和第二阶段。 我们
 
 
 
-Stage-I StackGAN 包含生成器网络和判别器网络。 它还具有一个文本编码器网络和一个条件增强网络（CA 网络），下面将对此进行详细说明。 生成器网络获取文本条件变量（![](img/5636ece2-f10e-4485-bd3b-527ba2c14606.png)）以及噪声向量（`x`）。 经过一组上采样层后，它会生成尺寸为`64x64x3`的低分辨率图像。 判别器网络拍摄此低分辨率图像，并尝试识别图像是真实的还是伪造的。 生成器网络是具有一组下采样层的网络，其后是连接，然后是分类层。 在以下各节中，我们将详细探讨 StackGAN 的体系结构。
+Stage-I StackGAN 包含生成器网络和判别器网络。 它还具有一个文本编码器网络和一个条件增强网络（CA 网络），下面将对此进行详细说明。 生成器网络获取文本条件变量（![](img/5636ece2-f10e-4485-bd3b-527ba2c14606.png)）以及噪声向量（`x`）。 经过一组上采样层后，它会生成尺寸为`64x64x3`的低分辨率图像。 判别器网络拍摄此低分辨率图像，并尝试识别图像是真实的还是伪造的。 生成器网络是具有一组下采样层的网络，其后是连接，然后是分类层。 在以下各节中，我们将详细探讨 StackGAN 的架构。
 
 Stage-I StackGAN 网络中使用的网络如下：
 
@@ -466,7 +466,7 @@ log_sigma = x[:, 128:]
 
 此操作将创建两个张量的张量（`batch_size`，`128`）和（`batch_size`和`128`）。
 
-3.  接下来，使用以下代码计算文本条件变量。 有关如何生成文本条件变量的更多信息，请参见 StackGAN 小节的*体系结构中的*条件增强（CA）块*部分：*
+3.  接下来，使用以下代码计算文本条件变量。 有关如何生成文本条件变量的更多信息，请参见 StackGAN 小节的*架构中的*条件增强（CA）块*部分：*
 
 ```py
 stddev = K.exp(log_sigma)
@@ -2006,7 +2006,7 @@ StackGAN 的行业应用包括：
 
 
 
-在本章中，我们了解并实现了 StackGAN 网络，该网络可从文本描述生成高分辨率图像。 我们从对 StackGAN 的基本介绍开始，在其中我们探讨了 StackGAN 的体系结构细节，并发现了用于训练 StackGAN 的损失。 然后，我们下载并准备了数据集。 之后，我们开始在 Keras 框架中实现 StackGAN。 实现之后，我们依次训练了 Stage-I 和 Stage-II StackGANS。 成功训练网络后，我们评估了模型并将其保存以备将来使用。
+在本章中，我们了解并实现了 StackGAN 网络，该网络可从文本描述生成高分辨率图像。 我们从对 StackGAN 的基本介绍开始，在其中我们探讨了 StackGAN 的架构细节，并发现了用于训练 StackGAN 的损失。 然后，我们下载并准备了数据集。 之后，我们开始在 Keras 框架中实现 StackGAN。 实现之后，我们依次训练了 Stage-I 和 Stage-II StackGANS。 成功训练网络后，我们评估了模型并将其保存以备将来使用。
 
 在下一章中，我们将与 CycleGAN 合作，该网络可以将绘画转换为照片。
 

new/gan-proj/7.md

@@ -44,7 +44,7 @@ CycleGAN 中有两个判别器网络，如下所示：
 
 Illustration of a CycleGAN with two generator and two adversarial discriminator networks. Source: https://arxiv.org/pdf/1703.10593.pdf
 
-在下一节中，让我们详细了解 CycleGAN 的体系结构。
+在下一节中，让我们详细了解 CycleGAN 的架构。
 
 
 
@@ -54,7 +54,7 @@ Illustration of a CycleGAN with two generator and two adversarial discriminator
 
 
 
-CycleGAN 总体上由两种体系结构组成：生成器和判别器。 生成器体系结构用于创建两个模型，生成器 A 和生成器 B。判别器体系结构用于创建另外两个模型，判别器 A 和判别器 B。我们现在将在接下来的两节中介绍两个网络的体系结构。
+CycleGAN 总体上由两种架构组成：生成器和判别器。 生成器架构用于创建两个模型，生成器 A 和生成器 B。判别器架构用于创建另外两个模型，判别器 A 和判别器 B。我们现在将在接下来的两节中介绍两个网络的架构。
 
 
 
@@ -95,7 +95,7 @@ CycleGAN 总体上由两种体系结构组成：生成器和判别器。 生成
 | **层名称** | **超参数** | **输入形状** | **输出形状** |
 | 2D 卷积层 | `filters=128, kernel_size=3, strides=1, padding='same'` | (32, 32, 128) | （32、32、128） |
 | 批量归一化层 | `axis=3, momentum=0.9, epsilon=1e-5` | （32、32、128） | （32、32、128） |
-| 2D 卷积层 | `filters=138, kernel_size=3, strides=1, padding='same'` | （32、32、128） | （（32，32，128） |
+| 2D 卷积层 | `filters=138, kernel_size=3, strides=1, padding='same'` | （32、32、128） | （`(32, 32, 128)` |
 | 批量归一化层 | `axis=3, momentum=0.9, epsilon=1e-5` | （32、32、128） | （32、32、128） |
 | 加法层 | `None` | （32、32、128） | （32、32、128） |
 
@@ -128,29 +128,29 @@ These hyperparameters are best suited for the Keras framework. If you are using
 
 
 
-判别器网络的架构类似于 PatchGAN 网络中的判别器架构。 它是一个深度卷积神经网络，包含多个卷积块。 基本上，它会拍摄形状为（128、128、3）的图像，并预测该图像是真实的还是假的。 它包含几个 ZeroPadding2D 层，[可以在以下链接中找到其文档](https://keras.io/layers/convolutional/#zeropadding2d)。 下表详细显示了判别器网络的体系结构：
+判别器网络的架构类似于 PatchGAN 网络中的判别器架构。 它是一个深度卷积神经网络，包含多个卷积块。 基本上，它会拍摄形状为（128、128、3）的图像，并预测该图像是真实的还是假的。 它包含几个 ZeroPadding2D 层，[可以在以下链接中找到其文档](https://keras.io/layers/convolutional/#zeropadding2d)。 下表详细显示了判别器网络的架构：
 
 | **层名称** | **超参数** | **输入形状** | **输出形状** |
 | 输入层 | `none` | (128, 128, 3) | (128, 128, 3) |
 | ZeroPadding2D 层 | `padding(1, 1)` | (128, 128, 3) | (130, 130, 3) |
-| 2D 卷积层 | `filters=64, kernel_size=4, strides=2, padding='valid'` | (130, 130, 3) | （64，64，64） |
-| 激活层 | `activation='leakyrelu', alpha=0.2` | （64，64，64） | （64，64，64） |
+| 2D 卷积层 | `filters=64, kernel_size=4, strides=2, padding='valid'` | (130, 130, 3) | `(64, 64, 64)` |
+| 激活层 | `activation='leakyrelu', alpha=0.2` | `(64, 64, 64)` | `(64, 64, 64)` |
 | ZeroPadding2D 层 | `padding(1, 1)` | (64, 64, 64) | (66, 66, 64) |
 | 2D 卷积层 | `filters=128, kernel_size=4, strides=2, padding='valid'` | (66, 66, 64) | （32、32、128） |
 | 实例规范化层 | `axis=1` | (32, 32, 128) | (32, 32, 128) |
 | 激活层 | `activation='leakyrelu', alpha=0.2` | （32、32、128） | （32、32、128） |
 | ZeroPadding2D 层 | `padding(1, 1)` | (32, 32, 128) | (34, 34, 128) |
-| 2D 卷积层 | `filters=256, kernel_size=4, strides=2, padding='valid'` | (34, 34, 128) | （16，16，256） |
-| 实例规范化层 | `axis=1` | （16，16，256） | （16，16，256） |
-| 激活层 | `activation='leakyrelu', alpha=0.2` | （16，16，256） | （16，16，256） |
+| 2D 卷积层 | `filters=256, kernel_size=4, strides=2, padding='valid'` | (34, 34, 128) | `(16, 16, 256)` |
+| 实例规范化层 | `axis=1` | `(16, 16, 256)` | `(16, 16, 256)` |
+| 激活层 | `activation='leakyrelu', alpha=0.2` | `(16, 16, 256)` | `(16, 16, 256)` |
 | ZeroPadding2D 层 | `padding(1, 1)` | (16, 16, 256) | (18, 18, 256) |
-| 2D 卷积层 | `filters=512, kernel_size=4, strides=2, padding='valid'` | (18, 18, 256) | （8，8，512） |
-| 实例规范化层 | `axis=1` | （8，8，512） | （8，8，512） |
-| 激活层 | `activation='leakyrelu', alpha=0.2` | （8，8，512） | （8，8，512） |
-| ZeroPadding2D 层 | `padding(1, 1)` | （8，8，512） | (10, 10, 512) |
-| 2D 卷积层 | `filters=1, kernel_size=4, strides=1, padding='valid', activation='sigmoid'` | (10, 10, 512) | （7，7，1） |
+| 2D 卷积层 | `filters=512, kernel_size=4, strides=2, padding='valid'` | (18, 18, 256) | `(8, 8, 512)` |
+| 实例规范化层 | `axis=1` | `(8, 8, 512)` | `(8, 8, 512)` |
+| 激活层 | `activation='leakyrelu', alpha=0.2` | `(8, 8, 512)` | `(8, 8, 512)` |
+| ZeroPadding2D 层 | `padding(1, 1)` | `(8, 8, 512)` | (10, 10, 512) |
+| 2D 卷积层 | `filters=1, kernel_size=4, strides=1, padding='valid', activation='sigmoid'` | (10, 10, 512) | `(7, 7, 1)` |
 
-判别器网络返回形状为（7，7，1）的张量。 现在，我们已经介绍了这两个网络的详细架构。 在下一节中，我们将介绍训练 CycleGAN 所需的目标函数。
+判别器网络返回形状为`(7, 7, 1)`的张量。 现在，我们已经介绍了这两个网络的详细架构。 在下一节中，我们将介绍训练 CycleGAN 所需的目标函数。
 
 The ZeroPadding2D layer adds rows and columns of zeros at the top, bottom, left, and right of an image tensor.
 
@@ -308,7 +308,7 @@ The `monet2photo` dataset is available for educational purposes only. To use it
 
 
 
-如本章前面的 *CycleGAN 简介*部分中所述，CycleGAN 具有两种网络体系结构，即生成器网络和判别器网络。 在本节中，我们将编写所有网络的实现。
+如本章前面的 *CycleGAN 简介*部分中所述，CycleGAN 具有两种网络架构，即生成器网络和判别器网络。 在本节中，我们将编写所有网络的实现。
 
 但是，在开始编写实现之前，请创建一个 Python 文件`main.py`并导入基本模块，如下所示：
 
@@ -333,7 +333,7 @@ from scipy.misc import imread, imresize
 
 
 
-在本章前面的*生成器网络的体系结构*部分中，我们已经探讨了生成器网络的体系结构。 让我们首先在 Keras 框架中编写生成器网络的层，然后使用 Keras 框架的功能 API 创建 Keras 模型。
+在本章前面的*生成器网络的架构*部分中，我们已经探讨了生成器网络的架构。 让我们首先在 Keras 框架中编写生成器网络的层，然后使用 Keras 框架的功能 API 创建 Keras 模型。
 
 执行以下步骤以在 Keras 中实现生成器网络：
 
@@ -350,7 +350,7 @@ residual_blocks = 6
 input_layer = Input(shape=input_shape)
 ```
 
-3.  将第一个卷积块与先前在*生成器网络*部分的体系结构中指定的超参数相加，如下所示：
+3.  将第一个卷积块与先前在*生成器网络*部分的架构中指定的超参数相加，如下所示：
 
 ```py
 x = Conv2D(filters=32, kernel_size=7, strides=1, padding="same")(input_layer)
@@ -484,7 +484,7 @@ def build_generator():
 
 
 
-我们已经在 *中探索了判别器网络的体系结构。*部分 让我们 首先在 Keras 框架中编写区分网络的层，然后使用 Keras 框架的功能 API 创建 Keras 模型。
+我们已经在 *中探索了判别器网络的架构。*部分 让我们 首先在 Keras 框架中编写区分网络的层，然后使用 Keras 框架的功能 API 创建 Keras 模型。
 
 执行以下步骤以在 Keras 中实现判别器网络：
 
@@ -509,7 +509,7 @@ x = ZeroPadding2D(padding=(1, 1))(input_layer)
 
 该层将在`x`和`y`轴上为输入张量添加填充。
 
-4.  接下来，使用先前在*判别器网络*部分的体系结构中指定的超参数添加卷积块，如下所示：
+4.  接下来，使用先前在*判别器网络*部分的架构中指定的超参数添加卷积块，如下所示：
 
 ```py
 x = Conv2D(filters=64, kernel_size=4, strides=2, padding="valid")(x)
@@ -727,7 +727,7 @@ generatorAToB = build_generator()
 generatorBToA = build_generator()
 ```
 
-如 *CycleGAN 的体系结构*部分所述，CycleGAN 具有两个生成器网络。 `generatorAToB`会将图像从域 A 转换为域 B。`generatorBToA`会将图像从域 B 转换为域 A。
+如 *CycleGAN 的架构*部分所述，CycleGAN 具有两个生成器网络。 `generatorAToB`会将图像从域 A 转换为域 B。`generatorBToA`会将图像从域 B 转换为域 A。
 
 现在，我们已经创建了两个生成器网络和两个判别器网络。 在下一个小节中，我们将创建并编译一个对抗网络。
 

new/gan-proj/8.md

@@ -25,17 +25,17 @@ Pix2pix 是一种**生成对抗网络**（**GAN**），用于图像到图像的
 
 
 
-Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章，“使用条件 GAN（cGAN）进行面部老化处理”中介绍。 在继续之前，请确保您了解什么是 cGAN。 一旦熟悉了 cGAN，就可以继续本章。 Pix2pix 是一种 GAN，能够使用**机器学习**（**ML**）的无监督方法执行图像到图像的翻译。 经过训练后，pix2pix 可以将图像从域 A 转换为域 B。朴素 CNN 也可以用于图像到图像的转换，但是它们不会生成逼真的图像。 另一方面，pix2pix 显示出巨大的潜力，能够生成逼真的图像。 我们将训练 pix2pix 将立面的标签转换为立面的图像。 让我们从了解 pix2pix 的体系结构开始。
+Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章，“使用条件 GAN（cGAN）进行面部老化处理”中介绍。 在继续之前，请确保您了解什么是 cGAN。 一旦熟悉了 cGAN，就可以继续本章。 Pix2pix 是一种 GAN，能够使用**机器学习**（**ML**）的无监督方法执行图像到图像的翻译。 经过训练后，pix2pix 可以将图像从域 A 转换为域 B。朴素 CNN 也可以用于图像到图像的转换，但是它们不会生成逼真的图像。 另一方面，pix2pix 显示出巨大的潜力，能够生成逼真的图像。 我们将训练 pix2pix 将立面的标签转换为立面的图像。 让我们从了解 pix2pix 的架构开始。
 
 
 
 
 
-# pix2pix 的体系结构
+# pix2pix 的架构
 
 
 
-与其他 GAN 相似，pix2pix 由两个网络组成：生成器网络和判别器网络。 生成器网络的体系结构受 [U-Net](https://arxiv.org/pdf/1505.04597.pdf) 的体系结构的启发。 同样，判别器网络的架构也受到 [PatchGAN](https://arxiv.org/pdf/1604.04382.pdf) 架构的启发。 这两个网络都是深度卷积神经网络。 在本节中，我们将详细探讨 pix2pix。
+与其他 GAN 相似，pix2pix 由两个网络组成：生成器网络和判别器网络。 生成器网络的架构受 [U-Net](https://arxiv.org/pdf/1505.04597.pdf) 的架构的启发。 同样，判别器网络的架构也受到 [PatchGAN](https://arxiv.org/pdf/1604.04382.pdf) 架构的启发。 这两个网络都是深度卷积神经网络。 在本节中，我们将详细探讨 pix2pix。
 
 
 
@@ -45,11 +45,11 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章，“使用条件 GA
 
 
 
-正如我们在上一节中提到的，生成器网络在很大程度上受到 U-Net 架构的启发。 U-Net 的架构与自动编码器网络的架构几乎相同。 它们之间的主要区别在于，U-Net 网络在编码器中的各层之间具有跳过连接，并且生成器网络和自动编码器的解码器部分不具有跳过连接。 U-Net 网络由两个网络组成：编码器网络和解码器网络。 下图从基本层面说明了 U-Net 的体系结构：
+正如我们在上一节中提到的，生成器网络在很大程度上受到 U-Net 架构的启发。 U-Net 的架构与自动编码器网络的架构几乎相同。 它们之间的主要区别在于，U-Net 网络在编码器中的各层之间具有跳过连接，并且生成器网络和自动编码器的解码器部分不具有跳过连接。 U-Net 网络由两个网络组成：编码器网络和解码器网络。 下图从基本层面说明了 U-Net 的架构：
 
 ![](img/ba22d993-cf32-42a1-86b9-94c2b37311e8.png)
 
-上图应使您了解 U-Net 的体系结构。 如您所见，第一层的输出直接与最后一层合并。 第二层的输出与第二层的第二层合并，依此类推。 如果`n`是层的总数，则在编码器网络的第 i <sup>th</sup> 层与解码器的第[ *ni* ]层之间存在跳过连接 网络。 <sup>第</sup>层可以是这些层中的任何层。 让我们一个一个地仔细研究两个网络。
+上图应使您了解 U-Net 的架构。 如您所见，第一层的输出直接与最后一层合并。 第二层的输出与第二层的第二层合并，依此类推。 如果`n`是层的总数，则在编码器网络的第 i <sup>th</sup> 层与解码器的第[ *ni* ]层之间存在跳过连接 网络。 <sup>第</sup>层可以是这些层中的任何层。 让我们一个一个地仔细研究两个网络。
 
 
 
@@ -71,8 +71,8 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章，“使用条件 GA
 | 批次归一化层 | 没有 | （32、32、256） | （32、32、256） |
 | 激活层 | Activation ='leakyrelu'，alpha = 0.2 | （32、32、256） | (32, 32, 256) |
 | 第四层 2D 卷积层 | 过滤器= 512，kernel_size = 4，步幅= 2，padding =“相同”， | (32, 32, 256) | (16, 16, 512) |
-| 批次归一化层 | 没有 | （16，16，512） | （16，16，512） |
-| 激活层 | Activation ='leakyrelu'，alpha = 0.2 | （16，16，512） | （16，16，512） |
+| 批次归一化层 | 没有 | `(16, 16, 512)` | `(16, 16, 512)` |
+| 激活层 | Activation ='leakyrelu'，alpha = 0.2 | `(16, 16, 512)` | `(16, 16, 512)` |
 | 第五层 2D 卷积层 | 过滤器= 512，kernel_size = 4，步幅= 2，padding =“相同”， | (16, 16, 512) | (8, 8, 512) |
 | 批次归一化层 | 没有 | （ 8，8，512） | （ 8，8，512） |
 | 激活层 | Activation ='leakyrelu'，alpha = 0.2 | （ 8，8，512） | （ 8，8，512） |
@@ -86,7 +86,7 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章，“使用条件 GA
 | 批次归一化层 | 没有 | （ 1，1，512） | （ 1，1，512） |
 | 激活层 | Activation ='leakyrelu'，alpha = 0.2 | （ 1，1，512） | （ 1，1，512） |
 
-编码器网络之后是解码器网络。 我们将在下一节中了解解码器网络的体系结构。
+编码器网络之后是解码器网络。 我们将在下一节中了解解码器网络的架构。
 
 
 
@@ -99,45 +99,45 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章，“使用条件 GA
 生成器网络中的解码器网络还包括八个**上采样卷积块**。 八个上采样卷积块的配置如下：
 
 | **层名称** | **超参数** | **输入形状** | **输出形状** |
-| 第一 2D 上采样层 | 大小=（2，2） | （ 1，1，512） | （ 2，2，512） |
+| 第一 2D 上采样层 | 大小=`(2, 2)` | （ 1，1，512） | （ 2，2，512） |
 | 2D 卷积层 | 过滤器= 512，kernel_size = 4，步幅= 1，填充=“相同”， | (2, 2, 512) | (2, 2, 512) |
 | 批次归一化层 | 没有 | （ 2，2，512） | （ 2，2，512） |
 | 辍学层 | 辍学= 0.5 | (2, 2, 512) | （ 2，2，512） |
 | 级联层（编码器网络中的第 7 个 Conv 层） | 轴= 3 | (2, 2, 512) | (2, 2, 1024) |
-| 激活层 | 激活=“恢复” | （2，2，1024） | （ 2，2，1024） |
-| 第二 2D 上采样层 | 大小=（2，2） | （ 2，2，1024） | （4，4，1024 ） |
+| 激活层 | 激活=“恢复” | `(2, 2, 1024)` | （ 2，2，1024） |
+| 第二 2D 上采样层 | 大小=`(2, 2)` | （ 2，2，1024） | （4，4，1024 ） |
 | 2D 卷积层 | 过滤器= 1024，kernel_size = 4，步幅= 1，填充=“相同”， | （4，4，1024 ） | （ 4，4，1024 ） |
 | 批次归一化层 | 没有 | （ 4，4，1024 ） | （ 4，4，1024 ） |
 | 辍学层 | 辍学= 0.5 | （ 4，4，1024 ） | （ 4，4，1024 ） |
 | 级联层（编码器网络中的第 6 个 Conv 层） | 轴= 3 | （ 4，4，1024 ） | （ 4，4，1536 ） |
 | 激活层 | 激活=“恢复” | （ 4，4，1536） | （ 4，4，1536 ） |
-| 第三 2D 上采样层 | 大小=（2，2） | （ 4，4，1536） | （8 ，8、1536 ） |
+| 第三 2D 上采样层 | 大小=`(2, 2)` | （ 4，4，1536） | （8 ，8、1536 ） |
 | 2D 卷积层 | 过滤器= 1024，kernel_size = 4，步幅= 1，填充=“相同”， | (8, 8, 1536) | (8, 8, 1024) |
 | 批次归一化层 | 没有 | （ 8，8，1024） | （ 8，8，1024） |
 | 辍学层 | 辍学= 0.5 | （ 8，8，1024） | （ 8，8，1024） |
 | 级联层（编码器网络中的第 5 个 Conv 层） | 轴= 3 | （ 8，8，1024） | (8, 8, 1536) |
-| 激活层 | 激活=“恢复” | （8，8，1536） | （ 8，8，1536 ） |
-| 第四层 2D 上采样层 | 大小=（2，2） | （ 8，8，1536 ） | （ 16，16，1536） |
+| 激活层 | 激活=“恢复” | `(8, 8, 1536)` | （ 8，8，1536 ） |
+| 第四层 2D 上采样层 | 大小=`(2, 2)` | （ 8，8，1536 ） | （ 16，16，1536） |
 | 2D 卷积层 | 过滤器= 1024，kernel_size = 4，步幅= 1，填充=“相同”， | (16, 16, 1536) | (16, 16, 1024) |
 | 批次归一化层 | 没有 | （ 16，16，1024） | （ 16，16，1024） |
 | 串联层（编码器网络的第 4 个 Conv 层） | 轴= 3 | （ 16，16，1024） | (16, 16, 1536) |
 | 激活层 | 激活=“恢复” | （ 16，16，1536） | （ 16，16，1536） |
-| 第五层 2D 上采样层 | 大小=（2，2） | （ 16，16，1536 ） | （ 32、32、1536） |
+| 第五层 2D 上采样层 | 大小=`(2, 2)` | （ 16，16，1536 ） | （ 32、32、1536） |
 | 2D 卷积层 | 过滤器= 1024，kernel_size = 4，步幅= 1，填充=“相同”， | （ 32、32、1536） | (32, 32, 1024) |
 | 批次归一化层 | 没有 | （ 32、32、1024） | （ 32、32、1024） |
 | 串联层（编码器网络的第 3 个 Conv 层） | 轴= 3 | （ 32、32、1024） | （ 32、32、1280） |
 | 激活层 | 激活=“恢复” | （ 32、32、1280） | （ 32、32、1280） |
-| 第六层 2D 上采样层 | 大小=（2，2） | （ 64、64、1280） | （ 64、64、1280） |
+| 第六层 2D 上采样层 | 大小=`(2, 2)` | （ 64、64、1280） | （ 64、64、1280） |
 | 2D 卷积层 | 过滤器= 512，kernel_size = 4，步幅= 1，填充=“相同”， | （ 64、64、1280） | （ 64、64、512） |
 | 批次归一化层 | 没有 | （ 64、64、512） | （ 64、64、512） |
 | 串联层（编码器网络中的第二个 Conv 层） | 轴= 3 | （ 64、64、512） | （ 64、64、640） |
 | 激活层 | 激活=“恢复” | （ 64、64、640） | （ 64、64、640） |
-| 第七层 2D 上采样层 | 大小=（2，2） | （ 64、64、640） | （ 128、128、640） |
+| 第七层 2D 上采样层 | 大小=`(2, 2)` | （ 64、64、640） | （ 128、128、640） |
 | 2D 卷积层 | 过滤器= 256，kernel_size = 4，步幅= 1，填充=“相同”， | （ 128、128、640） | （ 128、128、256） |
 | 批次归一化层 | 没有 | （ 128、128、256） | （ 128、128、256） |
 | 串联层（编码器网络中的第一个转化层） | 轴= 3 | （ 128、128、256） | （ 128、128、320） |
 | 激活层 | 激活=“恢复” | （ 128、128、320） | （ 128、128、320） |
-| 第八层 2D 上采样层 | 大小=（2，2） | （ 128、128、320） | （ 256、256、320） |
+| 第八层 2D 上采样层 | 大小=`(2, 2)` | （ 128、128、320） | （ 256、256、320） |
 | 2D 卷积层 | 过滤器= 1，kernel_size = 4，步幅= 1，填充=“相同”， | （ 256、256、320） | （ 256，256，1） |
 | 激活层 | 激活='tanh' | （ 256、256、1） | （ 256，256，1） |
 
@@ -192,11 +192,11 @@ pix2pix 中判别器网络的架构受到 PatchGAN 网络架构的启发。 Patc
 | 展开层 | 没有 | （1、1、512） | (512, ) |
 | 密集层 | 单位= 2，激活='softmax' | （1、1、512） | (2, ) |
 
-下表突出显示了判别器网络的体系结构和配置。 fl1 tten 层将张量展开为一维数组。
+下表突出显示了判别器网络的架构和配置。 fl1 tten 层将张量展开为一维数组。
 
 The remaining layers in the discriminator network are covered in the *The Keras implementation of pix2pix* section of this chapter.
 
-现在，我们已经探索了这两个网络的体系结构和配置。 现在，我们将探讨训练 pix2pix 所需的训练目标函数。
+现在，我们已经探索了这两个网络的架构和配置。 现在，我们将探讨训练 pix2pix 所需的训练目标函数。
 
 
 
@@ -548,7 +548,7 @@ encoder8 = LeakyReLU(alpha=leakyrelu_alpha)(encoder8)
 
 这是生成器网络中编码器部分的末端。 生成器网络中的第二部分是解码器。 在接下来的几个步骤中，让我们为解码器编写代码。
 
-5.  将第一个上采样卷积块添加到先前在 *pix2pix* 部分的体系结构中指示的参数中：
+5.  将第一个上采样卷积块添加到先前在 *pix2pix* 部分的架构中指示的参数中：
 
 ```py
 # 1st Upsampling Convolutional Block in the decoder network decoder1 = UpSampling2D(size=upsampling_size)(encoder8)
@@ -607,7 +607,7 @@ decoder8 = Convolution2D(filters=output_channels, kernel_size=kernel_size, paddi
 decoder8 = Activation('tanh')(decoder8)
 ```
 
-最后一层的激活函数为`'tanh'`，因为我们打算让生成器生成介于-1 到 1 之间的值。`'concatenate'`层用于添加跳过连接。 最后一层将生成张量为（256，256，1）的张量。
+最后一层的激活函数为`'tanh'`，因为我们打算让生成器生成介于-1 到 1 之间的值。`'concatenate'`层用于添加跳过连接。 最后一层将生成张量为`(256, 256, 1)`的张量。
 
 The 'concatenate' layer concatenates tensors along the channel dimension. You can provide a value for the axis, along which you want your tensors to be concatenated.
 
@@ -784,7 +784,7 @@ number_patches = int((patchgan_output_dim[0] / patchgan_patch_dim[0]) * (patchga
 input_layer = Input(shape=patchgan_patch_dim)
 ```
 
-3.  接下来，如下所示将卷积层添加到网络。 *pix2pix 的体系结构*部分中提供了该块的配置：
+3.  接下来，如下所示将卷积层添加到网络。 *pix2pix 的架构*部分中提供了该块的配置：
 
 ```py
 des = Convolution2D(filters=64, kernel_size=kernel_size, padding=padding, strides=strides)(input_layer)
@@ -799,7 +799,7 @@ des = LeakyReLU(alpha=leakyrelu_alpha)(des)
 list_filters = [num_filters_start * min(total_conv_layers, (2 ** i)) for i in range(total_conv_layers)]
 ```
 
-5.  接下来，使用先前在 *pix2pix* 部分的体系结构中指示的超参数值添加另外七个卷积块：
+5.  接下来，使用先前在 *pix2pix* 部分的架构中指示的超参数值添加另外七个卷积块：
 
 ```py
 # Next 7 Convolutional blocks for filters in list_filters[1:]:
@@ -1415,7 +1415,7 @@ Source: Image-to-Image Translation with Conditional Adversarial Networks:Source:
 
 
 
-在本章中，我们了解了 pix2pix 网络是什么，并探讨了其体系结构。 我们从 d 自身加载开始，准备要训练的数据集，然后准备了项目，并研究了 pix2pix 网络的 K 时代实现。 之后，我们研究了训练 pix2pix 网络的目标函数。 然后，我们在立面数据集上训练了 pix2pix 网络，并探索了 pix2pix 网络的一些 p 实际应用。
+在本章中，我们了解了 pix2pix 网络是什么，并探讨了其架构。 我们从 d 自身加载开始，准备要训练的数据集，然后准备了项目，并研究了 pix2pix 网络的 K 时代实现。 之后，我们研究了训练 pix2pix 网络的目标函数。 然后，我们在立面数据集上训练了 pix2pix 网络，并探索了 pix2pix 网络的一些 p 实际应用。
 
 在下一章中，我们将预测 GAN 的未来。 我们将研究 GAN 领域在不久的将来会发生什么，以及它将如何改变我们的行业和我们的日常生活。
 

new/gan-proj/9.md

@@ -35,7 +35,7 @@
 我认为，GAN 的未来将具有以下特点：
 
 *   研究团体公开接受 GAN 及其应用。
-*   令人印象深刻的结果-到目前为止，GAN 在使用常规方法难以执行的任务上显示出非常令人印象深刻的结果。 例如，将低分辨率图像转换为高分辨率图像以前是一项艰巨的任务，通常是使用 CNN 进行的。 GAN 体系结构（例如 SRGAN 或 pix2pix）显示了 GAN 在此应用中的潜力，而 StackGAN 网络已被证明对文本到图像的合成任务很有用。 如今，任何人都可以创建 SRGAN 网络并将其训练在自己的图像上。
+*   令人印象深刻的结果-到目前为止，GAN 在使用常规方法难以执行的任务上显示出非常令人印象深刻的结果。 例如，将低分辨率图像转换为高分辨率图像以前是一项艰巨的任务，通常是使用 CNN 进行的。 GAN 架构（例如 SRGAN 或 pix2pix）显示了 GAN 在此应用中的潜力，而 StackGAN 网络已被证明对文本到图像的合成任务很有用。 如今，任何人都可以创建 SRGAN 网络并将其训练在自己的图像上。
 *   深度学习技术的进步。
 *   GAN 用于商业应用。
 *   GAN 训练过程的成熟。

new/handson-unsup-learn-py/01.md

@@ -208,7 +208,7 @@ Learned distribution
 
 ![](img/ca76916e-73c4-443f-9d41-78f2b0ff0ff7.png)
 
-因此，所得成本函数对应于`p`和 *p <sub class="calibre20">数据</sub>* 之间的交叉熵之间的差，直到一个恒定值（数据生成的熵 处理）。 因此，训练策略现在基于使用一键编码来表示标签（例如，如果有两个标签 *0→（0，1）*和`1`*→（1，0）*，因此所有元素的总和必须始终等于`1`），并使用内在的概率输出（例如在逻辑回归中）或 softmax 过滤器 ，将`M`值转换为概率分布。
+因此，所得成本函数对应于`p`和 *p <sub class="calibre20">数据</sub>* 之间的交叉熵之间的差，直到一个恒定值（数据生成的熵 处理）。 因此，训练策略现在基于使用一键编码来表示标签（例如，如果有两个标签 *0→`(0, 1)`*和`1`*→`(1, 0)`*，因此所有元素的总和必须始终等于`1`），并使用内在的概率输出（例如在逻辑回归中）或 softmax 过滤器 ，将`M`值转换为概率分布。
 
 在这两种情况下，很明显*隐藏的教师*的存在提供了对错误的一致度量，从而允许模型相应地校正参数。 特别地，第二种方法对我们的目的非常有帮助，因此，如果未知，我建议您进一步研究（所有主要定义也可以在 *Bonaccorso G.，《机器学习算法》第二版，Packt， 2018* ）。
 

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

@@ -85,7 +85,7 @@ Bidimensional clustering structure obeying the rule of maximum cohesion and maxi
 
 ![](img/db15a1eb-e8cb-40c2-bbcc-222fe193e9bf.png)
 
-对于 *p = 1* ，我们获得**曼哈顿**（或**城市街区**）的距离，而 *p = 2* 对应于标准欧几里得距离 。 我们想了解当 *p→∞*时 *d <sub class="calibre20">p</sub>* 的行为。 假设我们在二维空间中工作，并且有一个簇，其中心是 *x <sub class="calibre20">c</sub> =（0，0）*，并且采样点 *x =（5，3 ）*，相对于`p`不同值的距离 *d <sub class="calibre20">p</sub> （x <sub class="calibre20">c</sub> ，x）*为：
+对于 *p = 1* ，我们获得**曼哈顿**（或**城市街区**）的距离，而 *p = 2* 对应于标准欧几里得距离 。 我们想了解当 *p→∞*时 *d <sub class="calibre20">p</sub>* 的行为。 假设我们在二维空间中工作，并且有一个簇，其中心是 *x <sub class="calibre20">c</sub> =`(0, 0)`*，并且采样点 *x =（5，3 ）*，相对于`p`不同值的距离 *d <sub class="calibre20">p</sub> （x <sub class="calibre20">c</sub> ，x）*为：
 
 ![](img/a7e8b29a-189f-44d6-b5b1-1f03e08ebd2d.png)
 
@@ -112,11 +112,11 @@ Minkowski distances (log-scale) for different values of p and N
 
 第一个结果是，如果我们选择`N`的值，则当 *p→∞*时，距离收缩并饱和。 这是 Minkowski 距离结构的正常结果，但敏锐的读者可能会注意到另一个要素。 让我们想象一下将 *1N* -vector 的成分之一设置为等于 *0.0* 。 这等效于从`N`维超立方体的顶点移动到另一个顶点。 距离会怎样？ 好吧，用一个例子很容易证明，当 *p→∞*时，两个距离收敛到相同的值。 特别是 Aggarwal，Hinneburg 和 Keim （在 *中，关于高度量空间中距离度量的惊人行为，Aggarwal CC，Hinneburg A.，Keim DA，ICDT* 2001 ）被证明是重要的结果。
 
-假设我们有`M`个二元样本的分布 *p（x）* *x <sub class="calibre20">i</sub> ∈（0，1） <sup class="calibre27">d</sup>* 。 如果采用 Minkowski 度量，则可以计算最大值（ *D <sub class="calibre20">max</sub> <sup class="calibre27">p</sup>* ）和最小值（ *D <sub class="calibre20">min</sub> [ <sup class="calibre27">p</sup>* ）从 *p（x）*采样的两个点与原点之间的距离（通常，该距离可以通过解析来计算，但是也可以使用迭代程序 继续采样，直到 *D <sub class="calibre20">max</sub> <sup class="calibre27">p</sup>* 和 *D <sub class="calibre20">min</sub>* <sup class="calibre27">`p`</sup> 停止更改）。 作者证明以下不等式成立：
+假设我们有`M`个二元样本的分布 *p（x）* *x <sub class="calibre20">i</sub> ∈`(0, 1)` <sup class="calibre27">d</sup>* 。 如果采用 Minkowski 度量，则可以计算最大值（ *D <sub class="calibre20">max</sub> <sup class="calibre27">p</sup>* ）和最小值（ *D <sub class="calibre20">min</sub> [ <sup class="calibre27">p</sup>* ）从 *p（x）*采样的两个点与原点之间的距离（通常，该距离可以通过解析来计算，但是也可以使用迭代程序 继续采样，直到 *D <sub class="calibre20">max</sub> <sup class="calibre27">p</sup>* 和 *D <sub class="calibre20">min</sub>* <sup class="calibre27">`p`</sup> 停止更改）。 作者证明以下不等式成立：
 
 ![](img/251ae7ce-ea13-446d-a7ea-8c372fbc9cf0.png)
 
-在先前的公式中， *C <sub class="calibre20">p</sub>* 是取决于`p`的常数。 当 *p→∞*时，期望值 *E [D <sub class="calibre20">max</sub> <sup class="calibre27">p</sup> -D <sub class="calibre20">min</sub> <sup class="calibre27">p</sup> ]* i 在边界 *k <sub class="calibre20">1</sub> C <sub class="calibre20">p</sub> d <sup class="calibre27">1 / p- 1/2</sup>* 和*（M-1）C <sub class="calibre20">p</sub> d <sup class="calibre27">1 / p-1 / 2</sup>* 。 当 *p > 2* 和 *d→∞时，术语 *d <sup class="calibre27">1 / p-1 / 2</sup> →0** ，最大和最小距离之差的期望值收敛到`0`。 这意味着，独立于样本，当维数足够高且 *p > 2* 时，几乎不可能使用 Minkowski 距离来区分两个样本。 当我们发现距离函数的相似性时，该定理警告我们选择 *d > > 1* 时选择`p`较大的值。 当 *d > > 1* （即使 *p = 1* 是最佳选择）时，欧几里德度量标准的常用选择也相当可靠 组件的重量（可以假定它们具有相同的重量），并保证在高维空间中的可区分性。 相反，高维空间中的 *p > > 2* 对于所有最大分量保持固定而所有其他分量都被修改的样本，则产生无法区分的距离（例如，如果 *x =（5，0）→（5，a）*，其中 *|* *a | < 5* ），如以下示例所示 ：
+在先前的公式中， *C <sub class="calibre20">p</sub>* 是取决于`p`的常数。 当 *p→∞*时，期望值 *E [D <sub class="calibre20">max</sub> <sup class="calibre27">p</sup> -D <sub class="calibre20">min</sub> <sup class="calibre27">p</sup> ]* i 在边界 *k <sub class="calibre20">1</sub> C <sub class="calibre20">p</sub> d <sup class="calibre27">1 / p- 1/2</sup>* 和*（M-1）C <sub class="calibre20">p</sub> d <sup class="calibre27">1 / p-1 / 2</sup>* 。 当 *p > 2* 和 *d→∞时，术语 *d <sup class="calibre27">1 / p-1 / 2</sup> →0** ，最大和最小距离之差的期望值收敛到`0`。 这意味着，独立于样本，当维数足够高且 *p > 2* 时，几乎不可能使用 Minkowski 距离来区分两个样本。 当我们发现距离函数的相似性时，该定理警告我们选择 *d > > 1* 时选择`p`较大的值。 当 *d > > 1* （即使 *p = 1* 是最佳选择）时，欧几里德度量标准的常用选择也相当可靠 组件的重量（可以假定它们具有相同的重量），并保证在高维空间中的可区分性。 相反，高维空间中的 *p > > 2* 对于所有最大分量保持固定而所有其他分量都被修改的样本，则产生无法区分的距离（例如，如果 *x =`(5, 0)`→（5，a）*，其中 *|* *a | < 5* ），如以下示例所示 ：
 
 ```py
 import numpy as np

new/handson-unsup-learn-py/03.md

@@ -88,7 +88,7 @@ Example of a connected component extracted from a graph
 
 *   在对`L`进行特征分解之后（考虑非正规图 Laplacian *L <sub class="calibre20">u</sub> = D-W* 并求解方程 *L [，很容易计算特征值和特征向量 <sub class="calibre20">u</sub> v =λDv*），则空特征值始终以多重性出现`p`。
 *   如果`G`是无向图（因此 *w <sub class="calibre20">ij</sub> ≥0∀i，j* ），则连接的组件数等于`p`（空特征值的多重性）。
-*   如果 *A ![](img/055b1708-309e-409f-ab58-e4017eae690d.png)ℜ <sup class="calibre27">N</sup>* 和*Θ*是`A`的可数子集（即`X`是可计数的子集，因为样本数始终是有限的），向量 *v∈ℜ <sup class="calibre27">N</sup>* 被称为**指标向量**对于 *Θ* ，如果给定 *θ <sub class="calibre20"> i </sub> ∈ Θ， v <sup class="calibre27">（i）[ 如果 *θ <sub class="calibre20">i</sub> ∈* *A 和 v <sup class="calibre27">（i）</sup> = 0* </sup> = 1* HTG43]否则。 例如，如果我们有两个向量 *a =（1，0）*和 *b =（0，0）*（因此，*Θ= {a，b}* ），我们认为 *A = {（1，n）其中 n∈[1，10]}* ，向量 *v =（1，0）*是一个指标向量，因为 *a∈A* 和 *b∉A* 。
+*   如果 *A ![](img/055b1708-309e-409f-ab58-e4017eae690d.png)ℜ <sup class="calibre27">N</sup>* 和*Θ*是`A`的可数子集（即`X`是可计数的子集，因为样本数始终是有限的），向量 *v∈ℜ <sup class="calibre27">N</sup>* 被称为**指标向量**对于 *Θ* ，如果给定 *θ <sub class="calibre20"> i </sub> ∈ Θ， v <sup class="calibre27">（i）[ 如果 *θ <sub class="calibre20">i</sub> ∈* *A 和 v <sup class="calibre27">（i）</sup> = 0* </sup> = 1* HTG43]否则。 例如，如果我们有两个向量 *a =`(1, 0)`*和 *b =`(0, 0)`*（因此，*Θ= {a，b}* ），我们认为 *A = {（1，n）其中 n∈[1，10]}* ，向量 *v =`(1, 0)`*是一个指标向量，因为 *a∈A* 和 *b∉A* 。
 *  `L`的第一个`p`特征向量（对应于空特征值）是每个连接的分量 *C <sub class="calibre20">1</sub> ，C <sub class="calibre20">2</sub> ，...，C* <sub class="calibre20">`p`。</sub>
 
 因此，如果数据集由`M`个样本 *x <sub class="calibre20">i</sub> ∈ℜ <sup class="calibre27">N</sup>* 以及图`G`与亲和力矩阵 *W <sup class="calibre27">M ×M</sup>* 相关联，Shi 和 Malik 建议建立矩阵 *B∈ℜ <sup class="calibre27">M×p</sup>* 包含第一个`p`特征向量作为列，并使用诸如 K 均值的更简单方法对行进行聚类。 实际上，每一行代表样本在`p`维子空间上的投影，其中非凸性由可以封装在规则球中的子区域表示。
@@ -452,7 +452,7 @@ Statistical measures corresponding to the subdataset -20 < x < -20 and y < 20
 
 ![](img/f7d41112-b38c-4121-b764-1979a72dd4e4.png)
 
-因此，不稳定性是几对噪声变化的聚类结果之间的平均距离。 当然，该值不是绝对的，因此可以得出的规则是：选择产生最小不稳定的配置。 同样重要的是，这种方法不能与之前讨论的其他方法相提并论，因为它是基于其他超参数（噪声变化的数量，噪声均值和方差，二次采样率等），因此可以产生不同的结果。 当`A`和`X`固定时。 特别是噪声的大小会极大地改变不稳定性，因此在确定*μ*和*之前，有必要评估`X`的均值和协方差矩阵。 高斯噪声的Σ*。 在我们的示例中（基于“旷工”数据集中的 DBSCAN 聚类），我们从加性噪声项 *n <sub class="calibre20">i</sub> 〜N（E [X]* 开始创建了 20 个扰动版本。 ， *Cov（X）/ 4* ），然后应用从均匀分布 *U（0，1）*中采样的乘法掩码。 这样，一些噪声项将被随机抵消或减少，如以下代码所示：
+因此，不稳定性是几对噪声变化的聚类结果之间的平均距离。 当然，该值不是绝对的，因此可以得出的规则是：选择产生最小不稳定的配置。 同样重要的是，这种方法不能与之前讨论的其他方法相提并论，因为它是基于其他超参数（噪声变化的数量，噪声均值和方差，二次采样率等），因此可以产生不同的结果。 当`A`和`X`固定时。 特别是噪声的大小会极大地改变不稳定性，因此在确定*μ*和*之前，有必要评估`X`的均值和协方差矩阵。 高斯噪声的Σ*。 在我们的示例中（基于“旷工”数据集中的 DBSCAN 聚类），我们从加性噪声项 *n <sub class="calibre20">i</sub> 〜N（E [X]* 开始创建了 20 个扰动版本。 ， *Cov（X）/ 4* ），然后应用从均匀分布 *U`(0, 1)`*中采样的乘法掩码。 这样，一些噪声项将被随机抵消或减少，如以下代码所示：
 
 ```py
 import numpy as np
@@ -527,7 +527,7 @@ Example of centroid selection (left) and medoid selection (right)
 
 此外，K 质体趋向于*聚集*高度重叠的斑点，斑点的密度具有两个峰值，而 K 均值通常根据手段的位置将整个区域分为两部分。 如果凸几何的假设成立，则通常会接受此行为，但是在其他情况下这可能是一个限制（我们将在示例中展示这种效果）。
 
-最后一个基本差异是公制距离。 由于没有限制，所以 K 型药物或多或少具有攻击性。 正如我们在第 2 章，“聚类基本原理”中讨论的那样，最长的距离由 Manhattan 度量标准提供（以相同的方式评估每个组件），而当`p`增加（以通用的 Minkowski 度量），组件之间的最大差异成为主导。 K 均值基于最常见的折衷（欧几里德距离），但是在某些特殊情况下，较大的`p`可以带来更好的性能（比较 *p = 1* 与 *p > 1* ）。 例如，如果 *c <sub class="calibre20">1</sub> =（0，0）*， *c <sub class="calibre20">2</sub> =（2，1）*和 *x =（0.55，1.25）*，曼哈顿距离 *d <sub class="calibre20">1</sub> （x，c <sub class="calibre20">1</sub> ）*和 *d <sub class="calibre20">1</sub> （x，c <sub class="calibre20">2</sub> ）*分别为 1.8 和 1.7，而欧几里得距离为 1.37 和 1.47。 因此，在 *p = 1* 的情况下，该点被分配给第二个簇，而在 *p = 2* 的情况下，该点被分配给第一个簇。
+最后一个基本差异是公制距离。 由于没有限制，所以 K 型药物或多或少具有攻击性。 正如我们在第 2 章，“聚类基本原理”中讨论的那样，最长的距离由 Manhattan 度量标准提供（以相同的方式评估每个组件），而当`p`增加（以通用的 Minkowski 度量），组件之间的最大差异成为主导。 K 均值基于最常见的折衷（欧几里德距离），但是在某些特殊情况下，较大的`p`可以带来更好的性能（比较 *p = 1* 与 *p > 1* ）。 例如，如果 *c <sub class="calibre20">1</sub> =`(0, 0)`*， *c <sub class="calibre20">2</sub> =`(2, 1)`*和 *x =（0.55，1.25）*，曼哈顿距离 *d <sub class="calibre20">1</sub> （x，c <sub class="calibre20">1</sub> ）*和 *d <sub class="calibre20">1</sub> （x，c <sub class="calibre20">2</sub> ）*分别为 1.8 和 1.7，而欧几里得距离为 1.37 和 1.47。 因此，在 *p = 1* 的情况下，该点被分配给第二个簇，而在 *p = 2* 的情况下，该点被分配给第一个簇。
 
 通常，预测正确的`p`值并不容易，但始终可以使用轮廓和调整后的 Rand 得分等方法测试几种配置，并选择产生更好分割效果的方法（即 ，最大内聚力和分离度或更高的调整后的 Rand 得分）。 在我们的示例中，我们将生成一个也包含基本事实的数据集，因此我们可以使用后一个选项轻松评估性能。 因此，我们将使用函数`make_blobs`生成`1000`样本，这些样本在由`[-5.0, 5.0]` 界定的框中分成`8`个 blob，如下所示：
 

new/handson-unsup-learn-py/04.md

@@ -456,7 +456,7 @@ X, Y = make_blobs(n_samples=nb_samples, n_features=2, center_box=[-1, 1], center
 
 ![](img/2babcaa4-c3d5-4faf-8e30-a7371de35be1.png)Dataset for connectivity constraints example
 
-从图中可以看出，样本 18 和 31 （ *x <sub class="calibre20">0</sub> ∈（-2，-1）*和 *x <sub class="calibre20">1</sub> ∈（1，2）*）非常接近； 但是，我们不希望将它们合并，因为样本 18 在较大的中央斑点中有更多邻居，而点 31 被部分隔离，应视为一个自治簇。 我们还希望样本 33 形成单个簇。 这些要求将迫使算法合并不再考虑基础几何（根据高斯分布）的聚类，而是考虑现有知识。
+从图中可以看出，样本 18 和 31 （ *x <sub class="calibre20">0</sub> ∈（-2，-1）*和 *x <sub class="calibre20">1</sub> ∈`(1, 2)`*）非常接近； 但是，我们不希望将它们合并，因为样本 18 在较大的中央斑点中有更多邻居，而点 31 被部分隔离，应视为一个自治簇。 我们还希望样本 33 形成单个簇。 这些要求将迫使算法合并不再考虑基础几何（根据高斯分布）的聚类，而是考虑现有知识。
 
 为了检查聚类的工作原理，现在让我们使用欧几里德距离和平均链接计算树状图（截短为 20 片叶子）：
 
@@ -543,7 +543,7 @@ Y_pred = ag.fit_predict(X)
 
 
 1.  凝聚法和分裂法有什么区别？
-2.  给定两个簇 *a：[（-1，-1），（0，0）]* 和 *b：[[1，1），（1，0）]* ，什么 是否考虑欧几里得距离的单一和完整联系？
+2.  给定两个簇 *a：[（-1，-1），`(0, 0)`]* 和 *b：[[1，1），`(1, 0)`]* ，什么 是否考虑欧几里得距离的单一和完整联系？
 3.  树状图表示给定数据集的不同链接结果。 它是否正确？
 4.  在聚集聚类中，树状图的底部（初始部分）包含单个聚类。 它是否正确？
 5.  聚集聚类中树状图的`y`轴是什么意思？

new/handson-unsup-learn-py/05.md

@@ -74,7 +74,7 @@
 
 ![](img/022da733-107b-4523-a724-b2bdc04c1431.png)
 
-在上一个公式中，*μ <sub class="calibre20">j</sub>* 是簇 *C <sub class="calibre20">j</sub>* 的质心，而 *m（m > 1 ）*是重加权指数系数。 当 *m≈1* 时，权重不受影响。 对于较大的值，例如 *w <sub class="calibre20">ij</sub> ∈（0，1）*，它们的重要性将按比例降低。 可以选择这样的系数以比较不同值的结果和期望的模糊程度。 实际上，在每次迭代之后（完全等同于 K 均值），权重使用以下公式更新：
+在上一个公式中，*μ <sub class="calibre20">j</sub>* 是簇 *C <sub class="calibre20">j</sub>* 的质心，而 *m（m > 1 ）*是重加权指数系数。 当 *m≈1* 时，权重不受影响。 对于较大的值，例如 *w <sub class="calibre20">ij</sub> ∈`(0, 1)`*，它们的重要性将按比例降低。 可以选择这样的系数以比较不同值的结果和期望的模糊程度。 实际上，在每次迭代之后（完全等同于 K 均值），权重使用以下公式更新：
 
 ![](img/d1acd98b-e3aa-42e7-9bc8-4a9a58ecf622.png)
 

new/handson-unsup-learn-py/06.md

@@ -58,7 +58,7 @@
 
 ![](img/1eb5c69f-9568-4996-aae5-d3c8b80ba47a.png)
 
-即使连续空间（例如，高斯）中某个事件的绝对概率为零（因为积分具有相同的极值），概率密度函数还是一种非常有用的度量，可以用来了解一个样本比 另一个。 例如：考虑高斯分布 *N（0，1）*，密度 *p（1）= 0.4* ，而对于*密度降低到大约 *0.05* ] x ＝ 2* 。 这意味着`1`的可能性比`2`高 0.4 / 0.05 = 8 倍。 同样，我们可以设置可接受阈值*α*并定义所有 *x <sub class="calibre20">i</sub>* 样本，这些样本的 *p（x <sub class="calibre20">i</sub> ）<* *α*作为异常（例如，在我们的情况下，*α= 0.01* ）。 这种选择是异常检测过程中的关键步骤，正如我们将要讨论的那样，它还必须包括潜在的异常值，但是这些异常值仍然是常规样本。
+即使连续空间（例如，高斯）中某个事件的绝对概率为零（因为积分具有相同的极值），概率密度函数还是一种非常有用的度量，可以用来了解一个样本比 另一个。 例如：考虑高斯分布 *N`(0, 1)`*，密度 *p（1）= 0.4* ，而对于*密度降低到大约 *0.05* ] x ＝ 2* 。 这意味着`1`的可能性比`2`高 0.4 / 0.05 = 8 倍。 同样，我们可以设置可接受阈值*α*并定义所有 *x <sub class="calibre20">i</sub>* 样本，这些样本的 *p（x <sub class="calibre20">i</sub> ）<* *α*作为异常（例如，在我们的情况下，*α= 0.01* ）。 这种选择是异常检测过程中的关键步骤，正如我们将要讨论的那样，它还必须包括潜在的异常值，但是这些异常值仍然是常规样本。
 
 在许多情况下，特征向量是使用多维随机变量建模的。 例如：数据集 *X ![](img/6cce89ef-bec6-4be5-a2af-54e4704353b1.png)→ <sup class="calibre27">3</sup>* 可以用联合概率密度函数 *p（x，y，z）*表示。 在一般情况下，实际概率需要三重积分：
 
@@ -320,7 +320,7 @@ kd_05.fit(ages.reshape(-1, 1))
 kd_15.fit(ages.reshape(-1, 1))
 ```
 
-此时，可以调用`score_samples()`方法来获取一组数据点的对数密度估计值（在我们的示例中，我们正在考虑以 0.05 为增量的范围（10，70））。 由于值是 *log（p）*，因此有必要计算 *e <sup class="calibre27">log（p）</sup>* 以获得实际概率。
+此时，可以调用`score_samples()`方法来获取一组数据点的对数密度估计值（在我们的示例中，我们正在考虑以 0.05 为增量的范围`(10, 70)`）。 由于值是 *log（p）*，因此有必要计算 *e <sup class="calibre27">log（p）</sup>* 以获得实际概率。
 
 生成的图显示在以下屏幕截图中：
 
@@ -702,7 +702,7 @@ Decision process in SVM
 
 ![](img/5a35ab70-84af-4bd0-aec6-dc88a81ec8ad.png)
 
-这意味着必须将所有训练样本视为内部值，因此必须选择分隔的超平面，以便所有 *x <sub class="calibre20">i</sub>* 都在同一侧。 但是，松弛变量的使用通过定义软边界可以提供更大的灵活性。 每个训练样本都与变量 *ξ <sub class="calibre20">i</sub>* 相关联，当然，问题在于将其最小化。 但是，通过这种技巧，即使继续将其识别为离群值，也可以将一些边界样本放置在超平面的另一侧（足够靠近它）。 要考虑的最后一个元素是此上下文中最重要的元素，并且涉及超参数*ν∈（0，1）*。 在上述论文中，作者证明，每当 *ρ≠0 时，ν*都可以解释为训练样本分数的上限，实际上是离群值。 在本章开始时，我们已经指出，在新颖性检测问题中，数据集必须是干净的。 不幸的是，并非总是如此。 因此，`v`和松弛变量的联合使用使我们也能够处理包含一小部分离群值的数据集。 就概率而言，如果`X`是从部分被噪声破坏的数据生成过程中提取的，则*ν*是在`X`中发现异常值的概率 ]。
+这意味着必须将所有训练样本视为内部值，因此必须选择分隔的超平面，以便所有 *x <sub class="calibre20">i</sub>* 都在同一侧。 但是，松弛变量的使用通过定义软边界可以提供更大的灵活性。 每个训练样本都与变量 *ξ <sub class="calibre20">i</sub>* 相关联，当然，问题在于将其最小化。 但是，通过这种技巧，即使继续将其识别为离群值，也可以将一些边界样本放置在超平面的另一侧（足够靠近它）。 要考虑的最后一个元素是此上下文中最重要的元素，并且涉及超参数*ν∈`(0, 1)`*。 在上述论文中，作者证明，每当 *ρ≠0 时，ν*都可以解释为训练样本分数的上限，实际上是离群值。 在本章开始时，我们已经指出，在新颖性检测问题中，数据集必须是干净的。 不幸的是，并非总是如此。 因此，`v`和松弛变量的联合使用使我们也能够处理包含一小部分离群值的数据集。 就概率而言，如果`X`是从部分被噪声破坏的数据生成过程中提取的，则*ν*是在`X`中发现异常值的概率 ]。
 
 现在，基于一个用元组（年龄，身高）识别的学生数据集分析一个二维示例。 我们将从二元高斯分布中得出 2,000 个内点，并均匀采样 200 个测试点：
 
@@ -892,7 +892,7 @@ t-SNE plot for the novelty detection with the wine dataset
 1.  一个人身高 1.70 m 的概率为 *p（Tall）= 0.75* ，而明天要下雨的概率为 *P（Rain）= 0.2* 。 *P（高，雨）*的概率是多少？ （即一个人身高 1.70 m，明天要下雨的概率）。
 2.  给定数据集`X`，我们构建了一个具有 1,000 个 bin 的直方图，我们发现其中许多是空的。 为什么会这样？
 3.  直方图包含三个分别具有 20、30 和 25 个样本的 bin。 第一个容器的范围为 *0 < x < 2* ，第二 *2 < x < 4* ，第三 *4 < x < 6* 。 *P（x）> 2* 的大概概率是多少？
-4.  给定正态分布 *N（0，1）*，可以将 *p（x）= 0.35* 的样本`x`视为异常吗？
+4.  给定正态分布 *N`(0, 1)`*，可以将 *p（x）= 0.35* 的样本`x`视为异常吗？
 5.  具有 500 个样本的数据集`X`具有 *std（X）= 2.5* 和 *IQR（X）= 3.0* 。 最佳带宽是多少？
 6.  一位专家告诉我们，分布在两个值附近都达到了峰值，并且密度突然从峰均值下降了 0.2 个标准差。 哪种内核最合适？
 7.  给定样本`x`（从 10,000 个样本的流人口中收集），我们不确定这是异常还是新颖，因为 *p（x）= 0.0005* 。 再进行 10,000 次观察后，我们重新训练模型，`x`保持 *p（x）< 0.001* 。 我们可以得出结论`x`是异常吗？

new/handson-unsup-learn-py/07.md

@@ -660,7 +660,7 @@ lda = LatentDirichletAllocation(n_components=2, learning_method='online', max_it
 Xl = lda.fit_transform(Xc)
 ```
 
-在训练过程之后，`components_` 实例变量包含每对夫妇（单词和主题）的相对频率（以计数为单位）。 因此，在我们的情况下，其形状为（2，14，182），`components_[i, j]` 元素，且 *i∈（0，1）*和 *j∈ （0，14，181）*可以解释为单词`j`的重要性，以便定义主题`i`。 因此，我们将有兴趣检查两个主题的前 10 个词：
+在训练过程之后，`components_` 实例变量包含每对夫妇（单词和主题）的相对频率（以计数为单位）。 因此，在我们的情况下，其形状为`(2, 14, 182)`，`components_[i, j]` 元素，且 *i∈`(0, 1)`*和 *j∈ `(0, 14, 181)`*可以解释为单词`j`的重要性，以便定义主题`i`。 因此，我们将有兴趣检查两个主题的前 10 个词：
 
 ```py
 import numpy as np
@@ -777,8 +777,8 @@ Topic-mixtures for comp.sys.mac.hardware (left) and rec.autos (right)
 
 
 
-1.  数据集`X`具有协方差矩阵 *C = diag（2，1）*。 您对 PCA 有什么期望？
-2.  考虑到前面的问题，如果`X`居中于零，并且 *B <sub class="calibre20">0.5</sub> （0，0）*的球为空，我们可以假设一个阈值 *的 x = 0* （第一个主要成分）是否允许水平判别？
+1.  数据集`X`具有协方差矩阵 *C = diag`(2, 1)`*。 您对 PCA 有什么期望？
+2.  考虑到前面的问题，如果`X`居中于零，并且 *B <sub class="calibre20">0.5</sub> `(0, 0)`*的球为空，我们可以假设一个阈值 *的 x = 0* （第一个主要成分）是否允许水平判别？
 3.  PCA 提取的成分在统计上是独立的。 它是否正确？
 4.  *Kurt（X）= 5* 的分布适用于 ICA。 它是否正确？
 5.  包含样本（ *1，2* ）和（ *0，-3* ）的数据集`X`的 NNMF 是多少？

new/handson-unsup-learn-py/08.md

@@ -78,7 +78,7 @@ Structural schema of a generic autoencoder
 
 ![](img/889fb37b-214d-4bd3-9e6d-d74c5343ae91.png)
 
-由于 *p <sub class="calibre20">数据</sub>* 的熵是一个常数，因此可以通过优化过程将其排除； 因此，散度的最小化等于 *p <sub class="calibre20">数据</sub>* 和`q`之间的交叉熵最小化。 如果假设 *p <sub class="calibre20">数据</sub>* 和`q`为高斯，则 Kullback-Leibler 成本函数等效于均方误差。 在某些情况下，当数据在（0，1）范围内归一化时，可以对 *p <sub class="calibre20">数据</sub>* 和`q`采用伯努利分布。 形式上，这不是完全正确的，因为伯努利分布是二进制的，并且 *x <sub class="calibre20">i</sub> ∈{0，1} <sup class="calibre27">d</sup>* ； 但是，使用 S 型输出单元还可以保证连续样本的成功优化， *x <sub class="calibre20">i</sub> ∈（0， 1） <sup class="calibre27">d</sup>* 。 在这种情况下，成本函数变为：
+由于 *p <sub class="calibre20">数据</sub>* 的熵是一个常数，因此可以通过优化过程将其排除； 因此，散度的最小化等于 *p <sub class="calibre20">数据</sub>* 和`q`之间的交叉熵最小化。 如果假设 *p <sub class="calibre20">数据</sub>* 和`q`为高斯，则 Kullback-Leibler 成本函数等效于均方误差。 在某些情况下，当数据在`(0, 1)`范围内归一化时，可以对 *p <sub class="calibre20">数据</sub>* 和`q`采用伯努利分布。 形式上，这不是完全正确的，因为伯努利分布是二进制的，并且 *x <sub class="calibre20">i</sub> ∈{0，1} <sup class="calibre27">d</sup>* ； 但是，使用 S 型输出单元还可以保证连续样本的成功优化， *x <sub class="calibre20">i</sub> ∈（0， 1） <sup class="calibre27">d</sup>* 。 在这种情况下，成本函数变为：
 
 ![](img/72f5d9d6-18c3-4216-b4e1-af7a8143feab.png)
 
@@ -115,17 +115,17 @@ graph = tf.Graph()
 
 因此，我们将训练 600 个时期的模型，每批 50 个样本。 由于每个图像都是 *64×64 = 4,096* ，因此压缩率是 *4,096 / 256 = 16* 倍。 当然，这种选择不是规则，我邀请您始终检查不同的配置，以最大化收敛速度和最终精度。 在我们的案例中，我们正在对编码器进行以下建模：
 
-*   具有 16（3×3）滤镜，（2×2）步幅，ReLU 激活和相同填充的 2D 卷积
-*   具有 32 个（3×3）滤镜，（1×1）步幅，ReLU 激活和相同的填充的 2D 卷积
-*   具有 64 个（3×3）滤镜，（1×1）跨距，ReLU 激活和相同的填充的 2D 卷积
-*   2D 卷积，具有 128（3×3）个滤镜，（1×1）跨距，ReLU 激活和相同的填充
+*   具有 16（3×3）过滤器，（2×2）步幅，ReLU 激活和相同填充的 2D 卷积
+*   具有 32 个（3×3）过滤器，（1×1）步幅，ReLU 激活和相同的填充的 2D 卷积
+*   具有 64 个（3×3）过滤器，（1×1）跨距，ReLU 激活和相同的填充的 2D 卷积
+*   2D 卷积，具有 128（3×3）个过滤器，（1×1）跨距，ReLU 激活和相同的填充
 
 解码器利用一系列转置卷积（也称为**解卷积**）：
 
-*   2D 转置卷积，具有 128（3×3）个滤镜，（2×2）步幅，ReLU 激活和相同的填充
+*   2D 转置卷积，具有 128（3×3）个过滤器，（2×2）步幅，ReLU 激活和相同的填充
 *   具有 64 个（3×3）滤波器，（1×1）跨距，ReLU 激活和相同填充的 2D 转置卷积
 *   具有 32 个（3×3）滤波器，（1×1）跨距，ReLU 激活和相同填充的 2D 转置卷积
-*   2D 转置卷积，带有 1（3×3）滤镜，（1×1）跨步，Sigmoid 激活，以及相同的填充
+*   2D 转置卷积，带有 1（3×3）过滤器，（1×1）跨步，Sigmoid 激活，以及相同的填充
 
 损失函数基于重构图像和原始图像之间差异的 *L <sub class="calibre20">2</sub>* 范数。 优化器是 Adam，学习率为*η= 0.001* 。 TensorFlow DAG 的编码器部分如下：
 
@@ -276,7 +276,7 @@ Epoch 3) Average loss per sample: 9.917563934326171 (Code mean: 0.38105469942092
 Epoch 600) Average loss per sample: 0.4635812330245972 (Code mean: 0.42368677258491516)
 ```
 
-在训练过程结束时，每个样本的平均损失约为 0.46（考虑 32×32 图像），编码的平均值为 0.42。 该值表示编码相当密集，因为期望单个值在（0，1）范围内均匀分布； 因此，平均值为 0.5。 在这种情况下，我们对这个数据不感兴趣，但是在寻找稀疏度时我们也将比较结果。
+在训练过程结束时，每个样本的平均损失约为 0.46（考虑 32×32 图像），编码的平均值为 0.42。 该值表示编码相当密集，因为期望单个值在`(0, 1)`范围内均匀分布； 因此，平均值为 0.5。 在这种情况下，我们对这个数据不感兴趣，但是在寻找稀疏度时我们也将比较结果。
 
 下图显示了一些样本图像的自动编码器的输出：
 
@@ -494,17 +494,17 @@ ELBO 右侧的第二项是 *log p（x | z;* *θ）*的期望值。 不难看出
 
 在此示例中，我们要基于 Olivetti 人脸数据集构建和训练深度卷积变分自编码器。 该结构与我们第一个示例中使用的结构非常相似。 编码器具有以下几层：
 
-*   具有 16（3×3）滤镜，（2×2）步幅，ReLU 激活和相同填充的 2D 卷积
-*   具有 32 个（3×3）滤镜，（1×1）步幅，ReLU 激活和相同的填充的 2D 卷积
-*   具有 64 个（3×3）滤镜，（1×1）跨距，ReLU 激活和相同的填充的 2D 卷积
-*   2D 卷积，具有 128（3×3）个滤镜，（1×1）跨距，ReLU 激活和相同的填充
+*   具有 16（3×3）过滤器，（2×2）步幅，ReLU 激活和相同填充的 2D 卷积
+*   具有 32 个（3×3）过滤器，（1×1）步幅，ReLU 激活和相同的填充的 2D 卷积
+*   具有 64 个（3×3）过滤器，（1×1）跨距，ReLU 激活和相同的填充的 2D 卷积
+*   2D 卷积，具有 128（3×3）个过滤器，（1×1）跨距，ReLU 激活和相同的填充
 
 解码器具有以下转置卷积：
 
-*   2D 转置卷积，具有 128（3×3）个滤镜，（2×2）步幅，ReLU 激活和相同的填充
-*   2D 转置卷积，具有 128（3×3）个滤镜，（2×2）步幅，ReLU 激活和相同的填充
+*   2D 转置卷积，具有 128（3×3）个过滤器，（2×2）步幅，ReLU 激活和相同的填充
+*   2D 转置卷积，具有 128（3×3）个过滤器，（2×2）步幅，ReLU 激活和相同的填充
 *   具有 32 个（3×3）滤波器，（1×1）跨距，ReLU 激活和相同填充的 2D 转置卷积
-*   2D 转置卷积，带有 1（3×3）滤镜，（1×1）跨步，Sigmoid 激活，以及相同的填充
+*   2D 转置卷积，带有 1（3×3）过滤器，（1×1）跨步，Sigmoid 激活，以及相同的填充
 
 TensorFlow 完全控制了噪声的产生，并且基于理论部分中说明的技巧。 以下代码段显示了 DAG 的第一部分，其中包含图形定义和编码器：
 
@@ -1021,7 +1021,7 @@ Structure of a generic Restricted Boltzmann Machine
 
 ![](img/fec60140-16e2-454b-a5dd-61909bce0d08.png)
 
-该公式的主要假设是所有神经元都是伯努利分布的（即 *x <sub class="calibre20">i</sub> ，h <sub class="calibre20">j</sub> 〜B（0，1）*） 术语 *b <sub class="calibre20">i</sub>* 和 *c <sub class="calibre20">j</sub>* 是可观察和潜在单位的偏差。 给定数据生成过程 *p <sub class="calibre20">数据</sub>* ，必须优化 RBM，以便 *p（x;* *θ）的可能性* 最大化。 跳过所有中间步骤（可以在前面的文章中找到），可以证明以下几点：
+该公式的主要假设是所有神经元都是伯努利分布的（即 *x <sub class="calibre20">i</sub> ，h <sub class="calibre20">j</sub> 〜B`(0, 1)`*） 术语 *b <sub class="calibre20">i</sub>* 和 *c <sub class="calibre20">j</sub>* 是可观察和潜在单位的偏差。 给定数据生成过程 *p <sub class="calibre20">数据</sub>* ，必须优化 RBM，以便 *p（x;* *θ）的可能性* 最大化。 跳过所有中间步骤（可以在前面的文章中找到），可以证明以下几点：
 
 ![](img/e1cdc672-50a0-425c-8811-603832e1b5dd.png)
 
@@ -1143,7 +1143,7 @@ Sanger 和 Rubner-Tavan 的网络是神经模型，能够在不进行任何统
 
 1.  在自动编码器中，编码器和解码器都必须在结构上对称。 它是否正确？
 2.  给定数据集`X`及其转换`Y`，根据自动编码器产生的代码，可以在以下位置找到`X`中包含的所有信息 *是*。 它是否正确？
-3.  代码 *z <sub class="calibre20">i</sub> ∈（0，1） <sup class="calibre27">128</sup>* 的 *sum（z <sub class="calibre20">i</sub> ）= 36* 。 稀疏吗？
+3.  代码 *z <sub class="calibre20">i</sub> ∈`(0, 1)` <sup class="calibre27">128</sup>* 的 *sum（z <sub class="calibre20">i</sub> ）= 36* 。 稀疏吗？
 4.  如果 *std（z <sub class="calibre20">i</sub> ）= 0.03* ，代码是否稀疏？
 5.  Sanger 网络需要协方差矩阵列作为输入向量。 它是否正确？
 6.  我们如何确定 Rubner-Tavan 网络提取的每个成分的重要性？

new/handson-unsup-learn-py/09.md

@@ -191,13 +191,13 @@ nb_iterations = int(nb_samples / batch_size)
 
 现在，我们可以基于以下结构为生成器定义 DAG：
 
-*   具有 1,024（4×4）滤镜的 2D 卷积，步幅为[ *1，1* ），有效填充和线性输出
+*   具有 1,024（4×4）过滤器的 2D 卷积，步幅为[ *1，1* ），有效填充和线性输出
 *   批量归一化和 LReLU 激活（当输入值为负时，性能更高；实际上，当 *x < 0* 时，标准 ReLU 的梯度为零，而 LReLU 的常数较小） 允许稍微修改的渐变）
 *   带有（ *2、2* ）步幅，相同填充和线性输出的 512（4×4）滤波器的 2D 卷积
 *   批量标准化和泄漏的 ReLU 激活
 *   256 个（4×4）滤波器的 2D 卷积，步幅为[ *2，2* ），，相同  填充，以及线性输出
 *   批量标准化和泄漏的 ReLU 激活
-*   具有 128 个（4×4）滤镜的 2D 卷积，步幅为[ *2，2* ），  相同  填充，以及线性输出
+*   具有 128 个（4×4）过滤器的 2D 卷积，步幅为[ *2，2* ），  相同  填充，以及线性输出
 *   批量标准化和泄漏的 ReLU 激活
 *   具有 1 个（4×4）滤波器的 2D 卷积，步幅为[ *2，2* ），，相同的  填充，以及双曲正切输出
 
@@ -259,7 +259,7 @@ def generator(z, is_training=True):
 *   批量标准化和泄漏的 ReLU 激活
 *   具有 1,024（4×4）滤波器的 2D 卷积，步幅为[ *2，2* ），，相同的  填充，以及线性输出
 *   批量标准化和泄漏的 ReLU 激活
-*   具有 1 个（4×4）滤镜的 2D 卷积，步幅为[ *2，2* ），  有效  填充，以及线性输出（预期输出为 sigmoid，可以表示一个概率，但是我们将直接在损失函数内部执行此变换）
+*   具有 1 个（4×4）过滤器的 2D 卷积，步幅为[ *2，2* ），  有效  填充，以及线性输出（预期输出为 sigmoid，可以表示一个概率，但是我们将直接在损失函数内部执行此变换）
 
 鉴别符的代码为，如下所示：
 
@@ -568,7 +568,7 @@ def generator(z, is_training=True):
 *   批量标准化和泄漏的 ReLU 激活
 *   具有 1,024（4×4）滤波器的 2D 卷积，步幅为[ *2，2* ），，相同的  填充，以及线性输出
 *   批量标准化和泄漏的 ReLU 激活
-*   具有 1 个（4×4）滤镜的 2D 卷积，步幅为[ *2，2* ），  有效  填充和线性输出
+*   具有 1 个（4×4）过滤器的 2D 卷积，步幅为[ *2，2* ），  有效  填充和线性输出
 
 相应的代码块为，如下所示：
 
@@ -928,7 +928,7 @@ SOM 是基于大脑特定区域功能的结构，该结构迫使其特定单元
 3.  GAN 的问题之一是判别器过早收敛。 这个正确吗？
 4.  在 Wasserstein GAN 中，批评家（区分者）在训练阶段是否比生成器慢？
 5.  考虑到前面的问题，不同速度的原因是什么？
-6.  *U（-1，0）*和 *U（1，2）*之间的 Jensen-Shannon 散度值是多少？
+6.  *U（-1，0）*和 *U`(1, 2)`*之间的 Jensen-Shannon 散度值是多少？
 7.  赢家通吃战略的目标是什么？
 8.  SOM 训练过程的调整阶段的目的是什么？
 

new/handson-unsup-learn-py/10.md

@@ -66,7 +66,7 @@
 
 1.  在凝聚方法中，该算法从每个样本（被视为一个集群）开始，然后继续合并子集群，直到定义了一个集群。 在分裂方法中，该算法从包含所有样本的单个簇开始，然后通过拆分将其进行到每个样本组成一个簇为止。
 
-2.  最近的点是*（0，0）*和*（0，1）*，因此单键是 *L <sub class="calibre20">s</sub> （a，b）= 1* 。 最远的点是*（-1，-1）*和*（1、1）*，因此完整的链接是 *L <sub class="calibre20">c</sub> （a，b ）=2√2*。
+2.  最近的点是*`(0, 0)`*和*`(0, 1)`*，因此单键是 *L <sub class="calibre20">s</sub> （a，b）= 1* 。 最远的点是*（-1，-1）*和*（1、1）*，因此完整的链接是 *L <sub class="calibre20">c</sub> （a，b ）=2√2*。
 3.  没有; 树状图是给定度量和链接的分层聚类过程的树表示。
 4.  在聚集聚类中，树状图的初始部分包含所有样本作为自治聚类。
 5. `y`轴报告差异。
@@ -101,7 +101,7 @@
 1.  由于随机变量显然是独立的，因此 *P（高，雨）= P（高）P（雨）= 0.75•0.2 = 0.15。*
 2.  直方图的主要缺点之一是，当 bin 的数量太大时，它们中的许多都开始为空，因为在所有值范围内都没有样本。 在这种情况下，`X`的基数可以小于 1,000，或者即使具有超过 1,000 个样本，相对频率也可以集中在小于 1,000 的多个 bin 中。
 3.  样本总数为 75，并且各个条带的长度相等。 因此， *P（0 < x < 2）= 20/75≈0.27，P（2 < x < 4）= 30/75 = 0.4* 和 *P（4 < x < 6）= 25/75≈0.33* 。 由于我们没有任何样本，因此我们可以假设 *P（x > 6）= 0* ； 因此， *P（x > 2）=* *P（2 < x < 4）+ P（4 < x < 6）≈0.73* 。 考虑到 *0.73•75≈55* ，这是属于 *x > 2* 的 bin 的样本数，我们立即得到确认。
-4.  在正态分布 *N（0，1）*中，最大密度为 *p（0）≈0.4* 。 在大约三个标准差之后， *p（x）≈0* ； 因此，通常无法将样本 *p（x）= 0.35* 的样本`x`视为异常。
+4.  在正态分布 *N`(0, 1)`*中，最大密度为 *p（0）≈0.4* 。 在大约三个标准差之后， *p（x）≈0* ； 因此，通常无法将样本 *p（x）= 0.35* 的样本`x`视为异常。
 5.  当 *min* （ *std（X），IQR（X）/1.34）≈2.24* 时，最佳带宽为 *h = 0.9•2.24•500 <sup class="calibre27">-0.2 [</sup> = 0.58* 。
 6.  即使可以采用高斯核，在给出分布描述的情况下，我们也应首先选择指数核，这样可以使均值周围迅速下降。
 7.  这将是最合乎逻辑的结论。 实际上，就新颖性而言，我们也应该期望新样本会改变分布，以便为新颖性建模。 如果在重新训练模型后概率密度仍然很低，则样本很可能是异常的。
@@ -114,8 +114,8 @@
 
 
 
-1.  协方差矩阵已经是对角线； 因此，特征向量是标准`x`和`y`versors（1,0）和（0，1），特征值是 2 和 1。因此，`x`轴是主要成分，`y`轴是第二个成分。
-2.  由于球 *B <sub class="calibre20">0.5</sub> （0，0）*是空的，因此在该点（ *0，0* ）周围没有样品。 考虑到水平方差*σ <sub class="calibre20">x</sub> <sup class="calibre27">2</sup> = 2* ，我们可以想象`X`被分解为两个斑点，因此可以想象 *x = 0* 行是水平鉴别符。 但是，这只是一个假设，需要使用实际数据进行验证。
+1.  协方差矩阵已经是对角线； 因此，特征向量是标准`x`和`y`versors（1,0）和`(0, 1)`，特征值是 2 和 1。因此，`x`轴是主要成分，`y`轴是第二个成分。
+2.  由于球 *B <sub class="calibre20">0.5</sub> `(0, 0)`*是空的，因此在该点（ *0，0* ）周围没有样品。 考虑到水平方差*σ <sub class="calibre20">x</sub> <sup class="calibre27">2</sup> = 2* ，我们可以想象`X`被分解为两个斑点，因此可以想象 *x = 0* 行是水平鉴别符。 但是，这只是一个假设，需要使用实际数据进行验证。
 
 3.  不，他们不是。 PCA 之后的协方差矩阵不相关，但不能保证统计独立性。
 4.  是; Kurt（`X`）的分布是超高斯分布，因此达到峰值且尾巴很重。 这样可以保证找到独立的组件。
@@ -148,7 +148,7 @@
 
 
 1.  没有; 生成器和判别器在功能上是不同的。
-2.  不，不是这样，因为判别器的输出必须是一个概率（即 *p <sub class="calibre20">i</sub> ∈（0，1）*）。
+2.  不，不是这样，因为判别器的输出必须是一个概率（即 *p <sub class="calibre20">i</sub> ∈`(0, 1)`*）。
 3.  是; 这是正确的。 判别器可以学习非常快地输出不同的概率，，其损失函数的斜率可以变得接近于 0，从而减小了提供给生成器的校正反馈的幅度。
 4.  是; 通常会比较慢。
 5.  评论者比较慢，因为每次更新后都会对变量进行裁剪。

new/intel-mobi-proj-tf/07.md

@@ -34,7 +34,7 @@
 
 ![](img/ef475044-6568-4e50-bc98-8ff0a0d6efbf.png)Figure 7.1: The drawing classification mode
 
-与接受 2D 图像输入的 2D 卷积 API `tf.layers.conv2d` 不同，此处将 1D 卷积 API `tf.layers.conv1d`用于时间卷积（例如绘图）。 默认情况下，在图形分类模型中，使用三个 1D 卷积层，每个层具有 48、64 和 96 个滤镜，其长度分别为 5、5 和 3。 卷积层之后，将创建 3 个 LSTM 层，每层具有 128 个正向 BasicLSTMCell 节点和 128 个反向 BasicLSTMCell 节点，然后将其用于创建动态双向循环神经网络，该网络的输出将发送到最终的完全连接层以计算 logits（非标准化的日志概率）。
+与接受 2D 图像输入的 2D 卷积 API `tf.layers.conv2d` 不同，此处将 1D 卷积 API `tf.layers.conv1d`用于时间卷积（例如绘图）。 默认情况下，在图形分类模型中，使用三个 1D 卷积层，每个层具有 48、64 和 96 个过滤器，其长度分别为 5、5 和 3。 卷积层之后，将创建 3 个 LSTM 层，每层具有 128 个正向 BasicLSTMCell 节点和 128 个反向 BasicLSTMCell 节点，然后将其用于创建动态双向循环神经网络，该网络的输出将发送到最终的完全连接层以计算 logits（非标准化的日志概率）。
 
 If you don't have a good understanding of all these details, don't worry; to develop powerful mobile apps using a model built by others, you don't have to understand all the details, but in the next chapter we'll also discuss in greater detail how you can build a RNN model from scratch for stock prediction, and with that, you'll have a better understanding of all the RNN stuff.
 
@@ -281,7 +281,7 @@ bazel-bin/tensorflow/contrib/util/convert_graphdef_memmapped_format \
 
 
 
-从`tensorflow/contrib/makefile/Makefile`打开 Makefile，然后，如果您使用 TensorFlow 1.4，则搜索`IOS_ARCH`。 对于每种体系结构（总共 5 种：ARMV7，ARMV7S，ARM64，I386，X86_64），将`-D__ANDROID_TYPES_SLIM__` 更改为
+从`tensorflow/contrib/makefile/Makefile`打开 Makefile，然后，如果您使用 TensorFlow 1.4，则搜索`IOS_ARCH`。 对于每种架构（总共 5 种：ARMV7，ARMV7S，ARM64，I386，X86_64），将`-D__ANDROID_TYPES_SLIM__` 更改为
 `-D__ANDROID_TYPES_FULL__`。 TensorFlow 1.5（或 1.6 / 1.7）中的`Makefile`稍有不同，尽管它仍位于同一文件夹中。 对于 1.5 / 1.6 / 1.7，搜索`ANDROID_TYPES_SLIM`并将其更改为 `ANDROID_TYPES_FULL`。 现在，通过运行`tensorflow/contrib/makefile/build_all_ios.sh`重建 TensorFlow 库。 此后，在加载模型文件时，`RefSwitch`错误将消失。 使用 TensorFlow 库构建并具有完整数据类型支持的应用程序大小约为 70 MB，而使用默认的细长数据类型构建的应用程序大小为 37 MB。
 
 好像还不够，仍然发生另一个模型加载错误：

new/intel-mobi-proj-tf/10.md

@@ -105,7 +105,7 @@ pip install keras
 
 带有`.h5`扩展名的文件是 HDF5 格式的 Keras 模型文件，每个文件主要包含模型架构定义，训练后的权重和训练配置。 稍后，您将看到如何使用 Keras 模型文件生成 TensorFlow 检查点文件，然后将其冻结为可在移动设备上运行的模型文件。
 
-model.png 文件包含深度神经网络体系结构的详细视图。 卷积层的许多残差块之后是批处理归一化和 ReLU 层，以稳定训练，它的深度非常大。 该模型的顶部如下图所示（中间部分很大，因此我们将不显示其中间部分，建议您打开 model.png 文件以供参考）：
+model.png 文件包含深度神经网络架构的详细视图。 卷积层的许多残差块之后是批处理归一化和 ReLU 层，以稳定训练，它的深度非常大。 该模型的顶部如下图所示（中间部分很大，因此我们将不显示其中间部分，建议您打开 model.png 文件以供参考）：
 
 ![](img/99dc16a9-52c9-4adf-bd8f-1a244504de79.png)Figure 10.1 The first layers of the deep residual network
 

new/intel-mobi-proj-tf/12.md

@@ -920,7 +920,7 @@ training_op = optimizer.apply_gradients(gvs_feed)
  <tf.Variable 'dense_1/bias:0' shape=(1,) dtype=float32_ref>)]
 ```
 
-请注意，kernel 只是权重的另一个名称，（4，4），（4，），（4，1）和（1，）是权重的形状和对第一个（输入到隐藏）和 第二层（隐藏到输出）。 如果您从 iPython 多次运行脚本，则`tf`对象的默认图形将包含先前运行的可训练变量，因此，除非调用`tf.reset_default_graph()`，否则需要使用`gvs = [(g, v) for g, v in gvs if g != None]`删除那些过时的训练变量， 将返回 None 渐变（有关`computer_gradients`的更多信息，请参见[这里](https://www.tensorflow.org/api_docs/python/tf/train/AdamOptimizer#compute_gradients)）。
+请注意，kernel 只是权重的另一个名称，`(4, 4)`，（4，），`(4, 1)`和（1，）是权重的形状和对第一个（输入到隐藏）和 第二层（隐藏到输出）。 如果您从 iPython 多次运行脚本，则`tf`对象的默认图形将包含先前运行的可训练变量，因此，除非调用`tf.reset_default_graph()`，否则需要使用`gvs = [(g, v) for g, v in gvs if g != None]`删除那些过时的训练变量， 将返回 None 渐变（有关`computer_gradients`的更多信息，请参见[这里](https://www.tensorflow.org/api_docs/python/tf/train/AdamOptimizer#compute_gradients)）。
 
 现在，玩一些游戏并保存奖励和渐变值：