diff --git a/new/ai-py/04.md b/new/ai-py/04.md
index 12f8d76203a382fd4c54342ec1293caddd251ec6..1dd23d700a0d9f494adc9fae9444ae3292f1cb35 100644
--- a/new/ai-py/04.md
+++ b/new/ai-py/04.md
@@ -52,7 +52,7 @@ Zestimate 算法的确切细节是专有的，但是我们可以做一些假设
 在不影响模型精度的情况下可以删除的特征分为两类：
 
 *   **冗余**：此功能与其他输入功能高度相关，因此不会在信号中添加太多新信息。
-*   **不相关**：此功能与目标功能的相关性较低，因此提供的噪声大于信号。
+*   **不相关**：此功能与目标函数的相关性较低，因此提供的噪声大于信号。
 
 找出我们的假设是否正确的一种方法是在有或没有我们的假设的情况下训练模型，并查看产生更好结果的方法。 我们可以对每个单个功能使用此方法，但是如果我们具有大量功能，则可能会迅速增加组合的数量。
 
@@ -606,7 +606,7 @@ print(data)
 
 对于某些数据科学问题，时间特征可能至关重要。 在时间序列分析中，日期显然至关重要。 如果您没有在预测中附加日期，则预测 S&P 500 将达到 3,000 将毫无意义。
 
-没有进行任何处理的日期可能对大多数模型没有多大意义，并且这些值将太独特而无法提供任何预测能力。 为什么 10/21/2019 与 10/19/2019 不同？ 如果我们使用某些领域知识，则可能能够极大地增加功能的信息价值。 例如，将日期转换为分类变量可能会有所帮助。 如果目标功能是您试图确定何时支付租金，则将日期转换为二进制值，其中可能的值为：
+没有进行任何处理的日期可能对大多数模型没有多大意义，并且这些值将太独特而无法提供任何预测能力。 为什么 10/21/2019 与 10/19/2019 不同？ 如果我们使用某些领域知识，则可能能够极大地增加功能的信息价值。 例如，将日期转换为分类变量可能会有所帮助。 如果目标函数是您试图确定何时支付租金，则将日期转换为二进制值，其中可能的值为：
 
 *   该月的前 5 天`= 1`
 *   当月的前 5 天之后`= 0`
diff --git a/new/ai-py/23.md b/new/ai-py/23.md
index f2f8d03aa34bdb1519ba5b26f9ef705435b919db..b797a075dabfe356c20b1ef8af2d6797737fae33 100644
--- a/new/ai-py/23.md
+++ b/new/ai-py/23.md
@@ -1,6 +1,4 @@
-# 23
-
-# 人工智能和大数据
+# 23 人工智能和大数据
 
 在本章中，我们将学习什么是大数据以及如何在人工智能的背景下使用大数据技术。 我们将讨论大数据如何帮助加速机器学习流程。 我们还将讨论使用大数据技术什么时候是一个好主意，何时使用它们是过时的，并通过一些示例来加深我们的理解。 我们将学习使用大数据的机器学习管道的组成部分以及所涉及的各种挑战，并且将在 Python 中创建一个环境，以了解其在实践中的工作方式。 在本章的最后，我们将介绍：
 
diff --git a/new/gan-proj/0.md b/new/gan-proj/0.md
index 8629bad2f4a67670686733dfa948108420b29617..b93ae43c30b145149120f63cdbdeee75c4fdc6e1 100644
--- a/new/gan-proj/0.md
+++ b/new/gan-proj/0.md
@@ -30,7 +30,7 @@
 
 
 
-第 1 章，“生成对抗网络”的介绍始于 GAN 的概念。 读者将学习什么是判别器，什么是生成器以及什么是博弈论。 接下来的几个主题将涵盖生成器的结构，判别器的结构，生成器和判别器的目标函数，GAN 的训练算法，Kullback-Leibler 和 Jensen-Shannon 散度，GAN 的评估矩阵，GAN 的不同问题， GAN 中梯度消失和爆炸，纳什均衡，批量标准化和正则化的问题。
+第 1 章，“生成对抗网络”的介绍始于 GAN 的概念。 读者将学习什么是判别器，什么是生成器以及什么是博弈论。 接下来的几个主题将涵盖生成器的结构，判别器的结构，生成器和判别器的目标函数，GAN 的训练算法，Kullback-Leibler 和 Jensen-Shannon 散度，GAN 的评估矩阵，GAN 的不同问题， GAN 中梯度消失和爆炸，纳什均衡，批量规范化和正则化的问题。
 
 第 2 章，“3D-GAN – 使用 GAN 生成形状”首先简要介绍 3D-GAN 和各种架构细节。 在本章中，我们将训练 3D-GAN 生成真实世界的 3D 形状。 我们编写代码来收集 3D Shapenet 数据集，对其进行清理并使其经过训练。 然后，我们将使用 Keras 深度学习库为 3D-GAN 编写代码。
 
diff --git a/new/gan-proj/1.md b/new/gan-proj/1.md
index 970cd026abca76c20bf37e9df7085caf72509b6d..4285d9f0aa7c56df8eaaf483d5675ab84001f3e8 100644
--- a/new/gan-proj/1.md
+++ b/new/gan-proj/1.md
@@ -186,7 +186,7 @@ GAN 的架构具有两个基本元素：生成器网络和判别器网络。 每
 
 
 
-# 詹森-香农分歧
+# Jensen-Shannon 散度
 
 
 
@@ -222,11 +222,11 @@ GAN 的架构具有两个基本元素：生成器网络和判别器网络。 每
 
 
 
-# 目标功能
+# 目标函数
 
 
 
-为了创建一个生成器网络，该生成器网络生成与真实图像相似的图像，我们尝试提高生成器生成的数据与实际数据之间的相似性。 为了测量相似度，我们使用目标函数。 这两个网络都有自己的目标功能，并且在训练过程中，它们会尽量减少各自的目标功能。 以下方程式表示 GAN 的最终目标函数：
+为了创建一个生成器网络，该生成器网络生成与真实图像相似的图像，我们尝试提高生成器生成的数据与实际数据之间的相似性。 为了测量相似度，我们使用目标函数。 这两个网络都有自己的目标函数，并且在训练过程中，它们会尽量减少各自的目标函数。 以下方程式表示 GAN 的最终目标函数：
 
 ![](img/c682e8fd-bd22-4998-968f-227c26898f62.png)
 
@@ -238,11 +238,11 @@ GAN 的架构具有两个基本元素：生成器网络和判别器网络。 每
 
 
 
-# 计分算法
+# 评分算法
 
 
 
-计算 GAN 的准确性很简单。 GAN 的目标函数不是特定函数，例如均方误差或交叉熵。 GAN 在训练期间学习目标功能。 研究人员提出了许多计分算法来衡量模型的拟合程度。 让我们详细了解一些评分算法。
+计算 GAN 的准确性很简单。 GAN 的目标函数不是特定函数，例如均方误差或交叉熵。 GAN 在训练期间学习目标函数。 研究人员提出了许多计分算法来衡量模型的拟合程度。 让我们详细了解一些评分算法。
 
 
 
@@ -345,7 +345,7 @@ CycleGAN 由朱俊彦，Taesung Park，Phillip Isola 和 Alexei A. Efros 在题
 
 
 
-# 年龄
+# 面部老化
 
 
 
@@ -407,7 +407,7 @@ pix2pix 网络是由 Phillip Isola，朱俊彦，周廷辉和 Alexei A. Efros 
 
 
 
-# 消失的渐变
+# 梯度消失
 
 
 
@@ -423,11 +423,11 @@ pix2pix 网络是由 Phillip Isola，朱俊彦，周廷辉和 Alexei A. Efros 
 
 
 
-# 内部协变量移位
+# 内部协变量偏移
 
 
 
-当我们网络的输入分配发生变化时，就会发生内部协变量偏移。 当输入分布更改时，隐藏层将尝试学习以适应新的分布。 这减慢了训练过程。 如果进程变慢，则需要很长时间才能收敛到全局最小值。 当网络输入的统计分布与以前看到的输入完全不同时，就会出现此问题。 批量标准化和其他归一化技术可以解决此问题。 我们将在以下各节中进行探讨。
+当我们网络的输入分配发生变化时，就会发生内部协变量偏移。 当输入分布更改时，隐藏层将尝试学习以适应新的分布。 这减慢了训练过程。 如果进程变慢，则需要很长时间才能收敛到全局最小值。 当网络输入的统计分布与以前看到的输入完全不同时，就会出现此问题。 批量规范化和其他归一化技术可以解决此问题。 我们将在以下各节中进行探讨。
 
 
 
@@ -532,21 +532,21 @@ pix2pix 网络是由 Phillip Isola，朱俊彦，周廷辉和 Alexei A. Efros 
 
 
 
-# 批量标准化
+# 批量规范化
 
 
 
-批量标准化是一种对特征向量进行归一化以使其没有均值或单位方差的技术。 它用于稳定学习并处理较差的权重初始化问题。 这是预处理步骤，适用于网络的隐藏层，可帮助我们减少内部协变量偏移。
+批量规范化是一种对特征向量进行归一化以使其没有均值或单位方差的技术。 它用于稳定学习并处理较差的权重初始化问题。 这是预处理步骤，适用于网络的隐藏层，可帮助我们减少内部协变量偏移。
 
-批量标准化由 Ioffe 和 Szegedy 在其 2015 年论文《批量标准化：通过减少内部协变量偏移来加速深度网络训练》中引入。[可以在以下链接中找到](https://arxiv.org/pdf/1502.03167.pdf)。
+批量规范化由 Ioffe 和 Szegedy 在其 2015 年论文《批量规范化：通过减少内部协变量偏移来加速深度网络训练》中引入。[可以在以下链接中找到](https://arxiv.org/pdf/1502.03167.pdf)。
 
 The benefits of batch normalization are as follows:
 
-*   **减少内部协变量偏移**：批量标准化有助于我们通过归一化值来减少内部协变量偏移。
+*   **减少内部协变量偏移**：批量规范化有助于我们通过归一化值来减少内部协变量偏移。
 *   **更快的训练**：如果从正态/高斯分布中采样值 ，则网络将更快地训练。 批量规范化有助于将值白化到我们网络的内部层。 总体训练速度更快，但是由于涉及额外的计算，因此每次迭代都会变慢。
-*   **更高的准确性**：批量标准化提供了更好的准确性。
-*   **较高的学习率**：通常，当我们训练神经网络时，我们使用较低的学习率，这需要很长时间才能收敛网络。 通过批量标准化，我们可以使用更高的学习率，从而使我们的网络更快地达到全球最低水平。
-*   **减少了丢弃法的需求**：当我们使用丢弃时，我们会破坏网络内部层中的一些基本信息。 批量标准化充当一个正则化器，这意味着我们可以训练网络而无需退出层。
+*   **更高的准确性**：批量规范化提供了更好的准确性。
+*   **较高的学习率**：通常，当我们训练神经网络时，我们使用较低的学习率，这需要很长时间才能收敛网络。 通过批量规范化，我们可以使用更高的学习率，从而使我们的网络更快地达到全球最低水平。
+*   **减少了丢弃法的需求**：当我们使用丢弃时，我们会破坏网络内部层中的一些基本信息。 批量规范化充当一个正则化器，这意味着我们可以训练网络而无需退出层。
 
 在批量规范化中，我们将规范化应用于所有隐藏层，而不是仅将其应用于输入层。
 
@@ -558,7 +558,7 @@ The benefits of batch normalization are as follows:
 
 
 
-如上一节所述，批量标准化仅通过利用来自该批量的信息来对一批样本进行归一化。 实例规范化是一种略有不同的方法。 在实例归一化中，我们仅通过利用来自该特征图的信息来归一化每个特征图。 实例规范化由 Dmitry Ulyanov 和 Andrea Vedaldi 在标题为《实例规范化：用于快速风格化的缺失成分》的论文中介绍，[可通过以下链接获得](https://arxiv.org/pdf/1607.08022.pdf)。
+如上一节所述，批量规范化仅通过利用来自该批量的信息来对一批样本进行归一化。 实例规范化是一种略有不同的方法。 在实例归一化中，我们仅通过利用来自该特征图的信息来归一化每个特征图。 实例规范化由 Dmitry Ulyanov 和 Andrea Vedaldi 在标题为《实例规范化：用于快速风格化的缺失成分》的论文中介绍，[可通过以下链接获得](https://arxiv.org/pdf/1607.08022.pdf)。
 
 
 
diff --git a/new/gan-proj/2.md b/new/gan-proj/2.md
index 558fecb8608e5052d36bcb0382005db54684d278..bf2e57d30995f51864b36508bc8daa7d2471f101 100644
--- a/new/gan-proj/2.md
+++ b/new/gan-proj/2.md
@@ -1,6 +1,6 @@
 
 
-# 3D-GAN-使用 GAN 生成形状
+# 3D-GAN -- 使用 GAN 生成形状
 
 
 
@@ -68,7 +68,7 @@
 *   **过滤器**： 512，256，128 和 64，1
 *   **核大小**：`4 x 4 x 4`， `4 x 4 x 4`， `4 x 4 x 4`， `4 x 4 x 4`， `4 x 4 x 4`
 *   **步幅**：1、2、2、2、2 或`(1, 1), (2, 2), (2, 2), (2, 2), (2, 2)`
-*   **批量标准化**：是，是，是，是，否
+*   **批量规范化**：是，是，是，是，否
 *   **激活**：ReLU， ReLU， ReLU， ReLU，Sigmoid
 *   **池化层**：否，否，否，否，否
 *   **线性层**：否，否，否，否，否
@@ -101,7 +101,7 @@
 *   **核大小**：4、4、4、4、4、4
 *   **步幅**：2、2、2、2、1
 *   **激活**：LReLU，LReLU，LReLU，LReLU，Sigmoid
-*   **批量标准化**：是，是，是，是，无
+*   **批量规范化**：是，是，是，是，无
 *   **池化层**：否，否，否，否，否
 *   **线性层**：否，否，否，否，否
 
@@ -120,7 +120,7 @@
 
 
 
-# 目标功能
+# 目标函数
 
 
 
@@ -782,7 +782,7 @@ tensorboard --logdir=logs
 
 
 
-# 可视化图形
+# 可视化图
 
 
 
diff --git a/new/gan-proj/3.md b/new/gan-proj/3.md
index 7448d13029e6ead774edff0cd35393ba4213b071..7747ac94672cdb13ffb9ebfb915e948ad05935cb 100644
--- a/new/gan-proj/3.md
+++ b/new/gan-proj/3.md
@@ -134,7 +134,7 @@ Age-cGAN的各个阶段，资料来源：[使用条件生成对抗网络进行
 
 
 
-# 训练目标功能
+# 训练目标函数
 
 
 
@@ -378,7 +378,7 @@ input_layer = Input(shape=(64, 64, 3))
     *   **核大小**：`5`，`5`，`5`
     *   **步幅**：`2`，`2`，`2`
     *   **填充**：`same`，`same`，``same``
-    *   **批量标准化**：每个卷积层后面都有一个批量标准化层
+    *   **批量规范化**：每个卷积层后面都有一个批量规范化层
     *   **激活**：`LealyReLU`，`LeakyReLU`，`LeakyReLU`，其中`alpha`等于`0.2`：
 
 ```py
@@ -405,7 +405,7 @@ enc = LeakyReLU(alpha=0.2)(enc)
 
 5.  接下来，添加具有以下配置的密集（完全连接）层，批量规范化层和激活函数：
     *   **单元（节点）**：2,096
-    *   **批量标准化**：是
+    *   **批量规范化**：是
     *   **激活**：`LeakyReLU`，其中`alpha`等于`0.2`：
 
 ```py
@@ -517,7 +517,7 @@ x = Dropout(0.2)(x)
 
 4.  接下来，使用以下配置添加第二个密集（完全连接）块：
     *   **单元（节点）**：16,384
-    *   **批量标准化**：是
+    *   **批量规范化**：是
     *   **激活**：`alpha`等于`0.2`的`LeakyReLU`
     *   **退出**：`0.2`：
 
@@ -541,7 +541,7 @@ x = Reshape((8, 8, 256))(x)
     *   **过滤器**：`128`
     *   **核大小**：`5`
     *   **填充**：`same`
-    *   **批量标准化**：是，`momentum`等于`0.8`
+    *   **批量规范化**：是，`momentum`等于`0.8`
     *   **激活**：`LeakyReLU`，其中`alpha`等于`0.2`：
 
 ```py
@@ -687,7 +687,7 @@ x = concatenate([x, label_input1], axis=3)
     *   **核大小**：`3`
     *   **步幅**：`2`
     *   **填充**：`same`
-    *   **批量标准化**：是
+    *   **批量规范化**：是
     *   **激活**：`LeakyReLU`，其中`alpha`等于`0.2`：
 
 ```py
diff --git a/new/gan-proj/5.md b/new/gan-proj/5.md
index f19d2e1e95dea4266cb5eaf32595646ca51582b4..df55bd87cf72316e774ec1d631713a0c5accd824 100644
--- a/new/gan-proj/5.md
+++ b/new/gan-proj/5.md
@@ -71,9 +71,9 @@
 | **层名称** | **超参数** | **输入形状** | **输出形状** |
 | --- | --- | --- | --- |
 | 2D 卷积层 | `Filters=64, kernel_size=3, strides=1, padding='same', activation='relu'` | `(64, 64, 64)` | `(64, 64, 64)` |
-| 批量标准化层 | `Momentum=0.8` | `(64, 64, 64)` | `(64, 64, 64)` |
+| 批量规范化层 | `Momentum=0.8` | `(64, 64, 64)` | `(64, 64, 64)` |
 | 2D 卷积层 | `Filters=64, kernel_size=3, strides=1, padding='same'` | `(64, 64, 64)` | `(64, 64, 64)` |
-| 批量标准化层 | `Momentum=0.8` | `(64, 64, 64)` | `(64, 64, 64)` |
+| 批量规范化层 | `Momentum=0.8` | `(64, 64, 64)` | `(64, 64, 64)` |
 | 加法层 | `None` | `(64, 64, 64)` | `(64, 64, 64)` |
 
 加法层计算输入到块的张量和最后一批归一化层的输出之和。 生成器网络包含 16 个具有上述配置的残差块。
@@ -83,7 +83,7 @@
 | **层名称** | **超参数** | **输入形状** | **输出形状** |
 | --- | --- | --- | --- |
 | 2D 卷积层 | `Filters=64, kernel_size=3, strides=1, padding='same'` | `(64, 64, 64)` | `(64, 64, 64)` |
-| 批量标准化层 | `Momentum=0.8` | `(64, 64, 64)` | `(64, 64, 64)` |
+| 批量规范化层 | `Momentum=0.8` | `(64, 64, 64)` | `(64, 64, 64)` |
 
 *   **上采样块**：上采样块包含一个上采样层和一个 2D 卷积层，并使用 relu 作为激活函数。 生成器网络中有两个上采样模块。 第一个上采样模块的配置如下：
 
@@ -120,13 +120,13 @@
 | 输入层 | 没有 | `(256, 256, 3)` | `(256, 256, 3)` |
 | 2D 卷积层 | `filter= 64, kernel_size = 3, stride= 1, padding='same', activcation='leakyrelu'` | `(256, 256, 3)` | `(256, 256, 64)` |
 | 2D 卷积层 | `filter= 64, kernel_size = 3, stride= 2, padding='same', activcation='leakyrelu'` | `(256, 256, 64)` | `(128, 128, 64)` |
-| 批量标准化层 | `momentum= 0.8` | `(128, 128, 64)` | `(128, 128, 64)` |
+| 批量规范化层 | `momentum= 0.8` | `(128, 128, 64)` | `(128, 128, 64)` |
 | 2D 卷积层 | `filter= 128, kernel_size = 3, stride= 1, padding='same', activcation='leakyrelu'` | `(128, 128, 64)` | `(128, 128, 128)` |
-| 批量标准化层 | `momentum= 0.8` | `(128, 128, 128)` | `(128, 128, 128)` |
+| 批量规范化层 | `momentum= 0.8` | `(128, 128, 128)` | `(128, 128, 128)` |
 | 2D 卷积层 | `filter= 128, kernel_size = 3, stride= 2, padding='same', activcation='leakyrelu'` | `(128, 128, 128)` | `(64, 64, 128)` |
-| 批量标准化层 | `momentum= 0.8` | `(64, 64, 128)` | `(64, 64, 128)` |
+| 批量规范化层 | `momentum= 0.8` | `(64, 64, 128)` | `(64, 64, 128)` |
 | 2D 卷积层 | `filter= 256, kernel_size = 3, stride= 1, padding='same', activcation='leakyrelu'` | `(64, 64, 128)` | `(64, 64, 256)` |
-| 批量标准化层 | `momentum= 0.8` | `(64, 64, 256)` | `(64, 64, 256)` |
+| 批量规范化层 | `momentum= 0.8` | `(64, 64, 256)` | `(64, 64, 256)` |
 | 2D 卷积层 | `filter= 256, kernel_size = 3, stride= 2, padding='same', activcation='leakyrelu'` | `(64, 64, 256)` | `(32, 32, 256)` |
 
 现在，我们对这两个网络的架构有了清晰的了解。 在下一部分中，让我们看一下训练 SRGAN 所需的目标函数。
@@ -135,7 +135,7 @@
 
 
 
-# 训练目标功能
+# 训练目标函数
 
 
 
@@ -402,7 +402,7 @@ for i in range(residual_blocks - 1):
     *   **核大小**：`3`
     *   **步幅**：``1``
     *   **填充**：`same`
-    *   **批量标准化**：是（动量为 0.8）：
+    *   **批量规范化**：是（动量为 0.8）：
 
 ```py
 gen2 = Conv2D(filters=64, kernel_size=3, strides=1, padding='same')(res)
diff --git a/new/gan-proj/6.md b/new/gan-proj/6.md
index 75264e75429190a8c6a96bf2ffa92ecdbacde531..3ea601d6a439d56eab56429592cb3ce42c271a4d 100644
--- a/new/gan-proj/6.md
+++ b/new/gan-proj/6.md
@@ -544,7 +544,7 @@ x = Reshape((4, 4, 128 * 8), input_shape=(128 * 8 * 4 * 4,))(x)
 
 该操作将二维张量整形为二维张量。
 
-5.  接下来，创建一个二维向上采样卷积块。 该块包含一个上采样层，一个卷积层和一个批归一化层。 批量标准化后，使用`ReLU`作为此块的激活函数：
+5.  接下来，创建一个二维向上采样卷积块。 该块包含一个上采样层，一个卷积层和一个批归一化层。 批量规范化后，使用`ReLU`作为此块的激活函数：
 
 ```py
 x = UpSampling2D(size=(2, 2))(x)
@@ -730,7 +730,7 @@ merged_input = concatenate([x, input_layer2])
     *   **核大小**：`1`
     *   **步幅**：`1`
     *   **填充**：`'same'`
-    *   **批量标准化**：是
+    *   **批量规范化**：是
     *   **激活**：`LeakyReLU`，`alpha 0.2`
 
 ```py
@@ -901,7 +901,7 @@ x = ReLU()(x)
     *   **过滤器**：`256`
     *   **核大小**：`(4, 4)`
     *   **步幅**：`2`
-    *   **批量标准化**：是
+    *   **批量规范化**：是
     *   **激活**：`ReLU`
 
 ```py
@@ -916,7 +916,7 @@ x = ReLU()(x)
     *   **过滤器**：`512`
     *   **核大小**：`(4, 4)`
     *   **步幅**：`2`
-    *   **批量标准化**：是
+    *   **批量规范化**：是
     *   **激活**：`ReLU`
 
 ```py
@@ -980,7 +980,7 @@ def residual_block(input):
     *   **过滤器**：`512`
     *   **核大小**：`(3, 3)`
     *   **步幅**：`1`
-    *   **批量标准化**：`Yes`
+    *   **批量规范化**：`Yes`
     *   **激活**：`ReLU`
 
 ```py
@@ -1019,7 +1019,7 @@ x = residual_block(x)
     *   **核大小**：`3`
     *   **填充**：`"same"`
     *   **步幅**：`1`
-    *   **批量标准化**：`Yes`
+    *   **批量规范化**：`Yes`
     *   **激活**：`ReLU`
 
 ```py
diff --git a/new/gan-proj/7.md b/new/gan-proj/7.md
index b2712dc6dc6a5fd0e64e575b4435a9171378dcb5..70b98534fab15a5d7e2735c3eddf234c39f78e78 100644
--- a/new/gan-proj/7.md
+++ b/new/gan-proj/7.md
@@ -12,7 +12,7 @@ CycleGAN 是一种**生成对抗网络**（**GAN**），用于跨域传输任务
 *   CycleGAN 的架构
 *   数据收集与准备
 *   Keras 的 CycleGAN 实现
-*   目标功能
+*   目标函数
 *   训练 CycleGAN
 *   CycleGAN 的实际应用
 
@@ -96,9 +96,9 @@ 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)` |
+| 批量规范化层 | `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)` |
-| 批量标准化层 | `axis=3, momentum=0.9, epsilon=1e-5` | `(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)` |
 
 加法层计算输入到块的张量与最后一个批量归一化层的输出之和。
@@ -162,7 +162,7 @@ CycleGAN 总体上由两种架构组成：生成器和判别器。 生成器架
 
 
 
-# 训练目标功能
+# 训练目标函数
 
 
 
@@ -217,7 +217,7 @@ CycleGAN 总体上由两种架构组成：生成器和判别器。 生成器架
 
 
 
-# 完整目标功能
+# 完整目标函数
 
 
 
@@ -593,7 +593,7 @@ def build_discriminator():
 
 
 
-我们已经在“CycleGANs 简介”部分中介绍了训练目标功能。 我们还为两个网络分别创建了 Keras 模型。 训练 CycleGAN 是一个多步骤的过程。 我们将执行以下步骤来训练网络：
+我们已经在“CycleGANs 简介”部分中介绍了训练目标函数。 我们还为两个网络分别创建了 Keras 模型。 训练 CycleGAN 是一个多步骤的过程。 我们将执行以下步骤来训练网络：
 
 1.  加载数据集
 2.  创建生成器和判别器网络
diff --git a/new/gan-proj/8.md b/new/gan-proj/8.md
index d973fd39d07ef92505256f8795f159a18ab79950..41195b8fdd518ad106c0cc9c72e649a824c7a39b 100644
--- a/new/gan-proj/8.md
+++ b/new/gan-proj/8.md
@@ -12,7 +12,7 @@ Pix2pix 是一种**生成对抗网络**（**GAN**），用于图像到图像的
 *   Pix2pix 网络的架构
 *   数据收集与准备
 *   Pix2pix 的 Keras 实现
-*   目标功能
+*   目标函数
 *   训练 Pix2pix
 *   评估训练好的模型
 *   Pix2pix 网络的实际应用
@@ -66,25 +66,25 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章，“使用条件 GA
 | 第一个 2D 卷积层 | `filter= 64, kernel_size = 4, stride= 2, padding ='same'` | `(256, 256, 1)` | `(128, 128, 64)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(128, 128, 64)` | `(128, 128, 64)` |
 | 第二个 2D 卷积层 | `filter= 128, kernel_size = 4, stride= 2, padding ="same"` | `(128, 128, 64)` | `(64, 64, 128)` |
-| 批量标准化层 | 没有 | `(64, 64, 128)` | `(64, 64, 128)` |
+| 批量规范化层 | 没有 | `(64, 64, 128)` | `(64, 64, 128)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(64, 64, 128)` | `(64, 64, 128)` |
 | 第三个 2D 卷积层 | `filter= 256, kernel_size = 4, stride= 2, padding ='same'` | `(64, 64, 128)` | `(32, 32, 256)` |
-| 批量标准化层 | 没有 | `(32, 32, 256)` | `(32, 32, 256)` |
+| 批量规范化层 | 没有 | `(32, 32, 256)` | `(32, 32, 256)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(32, 32, 256)` | `(32, 32, 256)` |
 | 第四个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(32, 32, 256)` | `(16, 16, 512)` |
-| 批量标准化层 | 没有 | `(16, 16, 512)` | `(16, 16, 512)` |
+| 批量规范化层 | 没有 | `(16, 16, 512)` | `(16, 16, 512)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(16, 16, 512)` | `(16, 16, 512)` |
 | 第五个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(16, 16, 512)` | `(8, 8, 512)` |
-| 批量标准化层 | 没有 | `(8, 8, 512)` | `(8, 8, 512)` |
+| 批量规范化层 | 没有 | `(8, 8, 512)` | `(8, 8, 512)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(8, 8, 512)` | `(8, 8, 512)` |
 | 第六个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(8, 8, 512)` | `(4, 4, 512)` |
-| 批量标准化层 | 没有 | `(4, 4, 512)` | `(4, 4, 512)` |
+| 批量规范化层 | 没有 | `(4, 4, 512)` | `(4, 4, 512)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(4, 4, 512)` | `(4, 4, 512)` |
 | 第七个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(4, 4, 512)` | `(2, 2, 512)` |
-| 批量标准化层 | 没有 | `(2, 2, 512)` | `(2, 2, 512)` |
+| 批量规范化层 | 没有 | `(2, 2, 512)` | `(2, 2, 512)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(2, 2, 512)` | `(2, 2, 512)` |
 | 第八个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(2, 2, 512)` | `(1, 1, 512)` |
-| 批量标准化层 | 没有 | `(1, 1, 512)` | `(1, 1, 512)` |
+| 批量规范化层 | 没有 | `(1, 1, 512)` | `(1, 1, 512)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(1, 1, 512)` | `(1, 1, 512)` |
 
 编码器网络之后是解码器网络。 我们将在下一节中了解解码器网络的架构。
@@ -103,40 +103,40 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章，“使用条件 GA
 | --- | --- | --- | --- |
 | 第一个 2D 上采样层 | `size=(2, 2)` | `(1, 1, 512)` | `(2, 2, 512)` |
 | 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 1, padding="same"` | `(2, 2, 512)` | `(2, 2, 512)` |
-| 批量标准化层 | 没有 | `(2, 2, 512)` | `(2, 2, 512)` |
+| 批量规范化层 | 没有 | `(2, 2, 512)` | `(2, 2, 512)` |
 | 丢弃层 | 丢弃= 0.5 | `(2, 2, 512)` | `(2, 2, 512)` |
 | 级联层（编码器网络中的第 7 个卷积层） | `axis=3` | `(2, 2, 512)` | `(2, 2, 1024)` |
 | 激活层 | `activation="relu"` | `(2, 2, 1024)` | `(2, 2, 1024)` |
 | 第二个 2D 上采样层 | `size=(2, 2)` | `(2, 2, 1024)` | `(4, 4, 1024)` |
 | 2D 卷积层 | `filter= 1024, kernel_size = 4, stride= 1, padding="same"` | `(4, 4, 1024)` | `(4, 4, 1024)` |
-| 批量标准化层 | 没有 | `(4, 4, 1024)` | `(4, 4, 1024)` |
+| 批量规范化层 | 没有 | `(4, 4, 1024)` | `(4, 4, 1024)` |
 | 丢弃层 | 丢弃= 0.5 | `(4, 4, 1024)` | `(4, 4, 1024)` |
 | 级联层（编码器网络中的第 6 个卷积层） | `axis=3` | `(4, 4, 1024)` | `(4, 4, 1536)` |
 | 激活层 | `activation="relu"` | `(4, 4, 1536)` | `(4, 4, 1536)` |
 | 第三个 2D 上采样层 | `size=(2, 2)` | `(4, 4, 1536)` | `(8, 8, 1536)` |
 | 2D 卷积层 | `filter= 1024, kernel_size = 4, stride= 1, padding="same"` | `(8, 8, 1536)` | `(8, 8, 1024)` |
-| 批量标准化层 | 没有 | `(8, 8, 1024)` | `(8, 8, 1024)` |
+| 批量规范化层 | 没有 | `(8, 8, 1024)` | `(8, 8, 1024)` |
 | 丢弃层 | 丢弃= 0.5 | `(8, 8, 1024)` | `(8, 8, 1024)` |
 | 级联层（编码器网络中的第 5 个卷积层） | `axis=3` | `(8, 8, 1024)` | `(8, 8, 1536)` |
 | 激活层 | `activation="relu"` | `(8, 8, 1536)` | `(8, 8, 1536)` |
 | 第四个 2D 上采样层 | `size=(2, 2)` | `(8, 8, 1536)` | `(16, 16, 1536)` |
 | 2D 卷积层 | `filter= 1024, kernel_size = 4, stride= 1, padding="same"` | `(16, 16, 1536)` | `(16, 16, 1024)` |
-| 批量标准化层 | 没有 | `(16, 16, 1024)` | `(16, 16, 1024)` |
+| 批量规范化层 | 没有 | `(16, 16, 1024)` | `(16, 16, 1024)` |
 | 连接层（编码器网络的第 4 个卷积层） | `axis=3` | `(16, 16, 1024)` | `(16, 16, 1536)` |
 | 激活层 | `activation="relu"` | `(16, 16, 1536)` | `(16, 16, 1536)` |
 | 第五个 2D 上采样层 | `size=(2, 2)` | `(16, 16, 1536)` | `(32, 32, 1536)` |
 | 2D 卷积层 | `filter= 1024, kernel_size = 4, stride= 1, padding="same"` | `(32, 32, 1536)` | `(32, 32, 1024)` |
-| 批量标准化层 | 没有 | `(32, 32, 1024)` | `(32, 32, 1024)` |
+| 批量规范化层 | 没有 | `(32, 32, 1024)` | `(32, 32, 1024)` |
 | 连接层（编码器网络的第 3 个卷积层） | `axis=3` | `(32, 32, 1024)` | `(32, 32, 1280)` |
 | 激活层 | `activation="relu"` | `(32, 32, 1280)` | `(32, 32, 1280)` |
 | 第六个 2D 上采样层 | `size=(2, 2)` | `(64, 64, 1280)` | `(64, 64, 1280)` |
 | 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 1, padding="same"` | `(64, 64, 1280)` | `(64, 64, 512)` |
-| 批量标准化层 | 没有 | `(64, 64, 512)` | `(64, 64, 512)` |
+| 批量规范化层 | 没有 | `(64, 64, 512)` | `(64, 64, 512)` |
 | 连接层（编码器网络中的第二个卷积层） | `axis=3` | `(64, 64, 512)` | `(64, 64, 640)` |
 | 激活层 | `activation="relu"` | `(64, 64, 640)` | `(64, 64, 640)` |
 | 第七个 2D 上采样层 | `size=(2, 2)` | `(64, 64, 640)` | `(128, 128, 640)` |
 | 2D 卷积层 | `filter= 256, kernel_size = 4, stride= 1, padding="same"` | `(128, 128, 640)` | `(128, 128, 256)` |
-| 批量标准化层 | 没有 | `(128, 128, 256)` | `(128, 128, 256)` |
+| 批量规范化层 | 没有 | `(128, 128, 256)` | `(128, 128, 256)` |
 | 连接层（编码器网络中的第一个卷积层） | `axis=3` | `(128, 128, 256)` | `(128, 128, 320)` |
 | 激活层 | `activation="relu"` | `(128, 128, 320)` | `(128, 128, 320)` |
 | 第八个 2D 上采样层 | `size=(2, 2)` | `(128, 128, 320)` | `(256, 256, 320)` |
@@ -171,25 +171,25 @@ pix2pix 中判别器网络的架构受到 PatchGAN 网络架构的启发。 Patc
 | 第一个 2D 卷积层 | `filter= 64, kernel_size = 4, stride= 2, padding ='same'`  | `(256, 256, 1)` | `(256, 256, 64)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(128, 128, 64)` | `(128, 128, 64)` |
 | 第二个 2D 卷积层 | `filter= 128, kernel_size = 4, stride= 2, padding ="same"` | `(128, 128, 64)` | `(64, 64, 128)` |
-| 批量标准化层 | 没有 | `(64, 64, 128)` | `(64, 64, 128)` |
+| 批量规范化层 | 没有 | `(64, 64, 128)` | `(64, 64, 128)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(64, 64, 128)`[ | `(64, 64, 128)` |
 | 第三个 2D 卷积层 | `filter= 256, kernel_size = 4, stride= 2, padding ='same'`  | `(64, 64, 128)` | `(32, 32, 256)` |
-| 批量标准化层 | 没有 | `(32, 32, 256)` | `(32, 32, 256)` |
+| 批量规范化层 | 没有 | `(32, 32, 256)` | `(32, 32, 256)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(32, 32, 256)` | `(32, 32, 256)` |
 | 第四个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(32, 32, 256)` | `(16, 16, 512)` |
-| 批量标准化层 | 没有 | `(16, 16, 512)` | `(16, 16, 512)` |
+| 批量规范化层 | 没有 | `(16, 16, 512)` | `(16, 16, 512)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(16, 16, 512)` | `(16, 16, 512)` |
 | 第五个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(16, 16, 512)` | `(8, 8, 512)` |
-| 批量标准化层 | 没有 | `(8, 8, 512)` | `(8, 8, 512)` |
+| 批量规范化层 | 没有 | `(8, 8, 512)` | `(8, 8, 512)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(8, 8, 512)` | `(8, 8, 512)` |
 | 第六个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(8, 8, 512)` | `(4, 4, 512)` |
-| 批量标准化层 | 没有 | `(4, 4, 512)` | `(4, 4, 512)` |
+| 批量规范化层 | 没有 | `(4, 4, 512)` | `(4, 4, 512)` |
 | 激活层 |` Activation ='leakyrelu', alpha = 0.2` | `(4, 4, 512)` | `(4, 4, 512)` |
 | 第七个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(4, 4, 512)` | `(2, 2, 512)` |
-| 批量标准化层 | 没有 | `(2, 2, 512)` | `(2, 2, 512)` |
+| 批量规范化层 | 没有 | `(2, 2, 512)` | `(2, 2, 512)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(2, 2, 512)` | `(2, 2, 512)` |
 | 第八个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(4, 4, 512)` | `(1, 1, 512)` |
-| 批量标准化层 | 没有 | `(1, 1, 512)` | `(1, 1, 512)` |
+| 批量规范化层 | 没有 | `(1, 1, 512)` | `(1, 1, 512)` |
 | 激活层 | `Activation ='leakyrelu', alpha = 0.2 `| `(1, 1, 512)` | `(1, 1, 512)` |
 | 展开层 | 没有 | `(1, 1, 512)` | `(512, )` |
 | 密集层 | `unit= 2, activation='softmax'` | `(1, 1, 512)` | `(2, )` |
@@ -204,7 +204,7 @@ pix2pix 中判别器网络的架构受到 PatchGAN 网络架构的启发。 Patc
 
 
 
-# 训练目标功能
+# 训练目标函数
 
 
 
diff --git a/new/handson-unsup-learn-py/09.md b/new/handson-unsup-learn-py/09.md
index ee67e15607f48fd8c22c0b4a3ee3d5a4fd80b610..61efedef9a036a1573a2d25801765ba2bea8b1ee 100644
--- a/new/handson-unsup-learn-py/09.md
+++ b/new/handson-unsup-learn-py/09.md
@@ -192,13 +192,13 @@ nb_iterations = int(nb_samples / batch_size)
 现在，我们可以基于以下结构为生成器定义 DAG：
 
 *   具有 1,024 个`4×4`过滤器的 2D 卷积，步幅为`(1, 1)`，有效填充和线性输出
-*   批量标准化和 LReLU 激活（当输入值为负时，性能更高；实际上，当`x < 0`时，标准 ReLU 的梯度为零，而 LReLU 的常数较小） 允许稍微修改的渐变）
+*   批量规范化和 LReLU 激活（当输入值为负时，性能更高；实际上，当`x < 0`时，标准 ReLU 的梯度为零，而 LReLU 的常数较小） 允许稍微修改的渐变）
 *   带有`(2, 2)`步幅，相同填充和线性输出的 512 个`4×4`滤波器的 2D 卷积
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   256 个`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及线性输出
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   具有 128 个`4×4`过滤器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及线性输出
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   具有 1 个`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及双曲正切输出
 
 以下代码段显示了生成器的代码：
@@ -254,11 +254,11 @@ def generator(z, is_training=True):
 
 *   具有`(2, 2)`步幅的 128`4×4`个滤波器的 2D 卷积，相同填充，以及泄漏的 ReLU 输出
 *   256 个`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及线性输出
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   带有 512 个`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及线性输出
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   具有 1,024`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及线性输出
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   具有 1 个`4×4`过滤器的 2D 卷积，步幅为`(2, 2)`，有效填充，以及线性输出（预期输出为 sigmoid，可以表示一个概率，但是我们将直接在损失函数内部执行此变换）
 
 判别器的代码为，如下所示：
@@ -342,7 +342,7 @@ with graph.as_default():
         training_step_g = tf.train.AdamOptimizer(0.0005, beta1=0.5).minimize(loss=loss_g, var_list=variables_g)
 ```
 
-第一块包含占位符的声明。 为了清楚起见，虽然`input_x`和`input_z`的目的很容易理解，但`is_training`可能不太明显。 此布尔值标志的目的是允许在生产阶段禁用批量标准化（必须仅在训练阶段有效）。 下一步包括声明生成器和两个判别器（它们在形式上是相同的，因为变量是共享的，但是其中一个被提供了真实的样本，而另一个必须评估生成器的输出）。 然后，是时候定义损失函数了，它是基于一种可以加快计算速度并增加数值稳定性的技巧。
+第一块包含占位符的声明。 为了清楚起见，虽然`input_x`和`input_z`的目的很容易理解，但`is_training`可能不太明显。 此布尔值标志的目的是允许在生产阶段禁用批量规范化（必须仅在训练阶段有效）。 下一步包括声明生成器和两个判别器（它们在形式上是相同的，因为变量是共享的，但是其中一个被提供了真实的样本，而另一个必须评估生成器的输出）。 然后，是时候定义损失函数了，它是基于一种可以加快计算速度并增加数值稳定性的技巧。
 
 函数`tf.nn.sigmoid_cross_entropy_with_logits()`接受对率（这就是为什么我们没有将 Sigmoid 变换直接应用于判别器输出的原因），并允许我们执行以下向量计算：
 
@@ -356,7 +356,7 @@ with graph.as_default():
 
 ![](img/4bebedd1-9438-42e7-aae9-c18aa72d2a49.png)
 
-相同的概念适用于生成器损失函数。 下一步需要定义两个 Adam 优化器。 如前所述，我们需要隔离变量以进行隔行训练。 因此，`minimize()`函数现在被提供了损失和必须更新的变量集。 TensorFlow 官方文档中建议使用上下文声明`tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS))`，只要采用批量标准化，其目标是仅在计算均值和方差之后才允许执行训练步骤（有关此技术的更多详细信息，请检查原始论文：《批量标准化：通过减少内部协变量移位》。
+相同的概念适用于生成器损失函数。 下一步需要定义两个 Adam 优化器。 如前所述，我们需要隔离变量以进行隔行训练。 因此，`minimize()`函数现在被提供了损失和必须更新的变量集。 TensorFlow 官方文档中建议使用上下文声明`tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS))`，只要采用批量规范化，其目标是仅在计算均值和方差之后才允许执行训练步骤（有关此技术的更多详细信息，请检查原始论文：《批量规范化：通过减少内部协变量移位》。
 
 此时，我们可以创建一个会话并初始化所有变量，如下所示：
 
@@ -503,13 +503,13 @@ height = X_train.shape[2]
 现在，我们可以基于 DCGAN 的同一层定义生成器 DAG，如下所示：
 
 *   具有 1,024 个`4×4`滤波器的 2D 卷积，步幅为`(1, 1)`，有效填充，以及线性输出
-*   批量标准化和 LReLU 激活
+*   批量规范化和 LReLU 激活
 *   带有 512 个`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及线性输出
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   256 个`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及线性输出
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   具有 128 个`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及线性输出
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   具有 1 个`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及双曲正切输出
 
 该代码显示在以下代码片段中：
@@ -563,11 +563,11 @@ def generator(z, is_training=True):
 
 *   具有`(2, 2)`步幅的 128`4×4`个滤波器的 2D 卷积，相同填充，以及泄漏的 ReLU 输出
 *   256 个`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及线性输出
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   带有 512 个`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及线性输出
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   具有 1,024`4×4`滤波器的 2D 卷积，步幅为`(2, 2)`，相同填充，以及线性输出
-*   批量标准化和泄漏的 ReLU 激活
+*   批量规范化和泄漏的 ReLU 激活
 *   具有 1 个`4×4`过滤器的 2D 卷积，步幅为`(2, 2)`，有效填充和线性输出
 
 相应的代码块为，如下所示：