2020-12-11 22:45:31

new/ai-py/11.md

@@ -136,7 +136,7 @@ def create_toolbox(num_bits):
     toolbox.register("attr_bool", random.randint, 0, 1) 
 ```
 
-让我们注册`individual`功能。 方法`initRepeat`带有三个参数–个体的容器类，用于填充容器的函数以及我们希望函数重复自身的次数：
+让我们注册`individual`函数。 方法`initRepeat`带有三个参数–个体的容器类，用于填充容器的函数以及我们希望函数重复自身的次数：
 
 ```py
  # Initialize structures
@@ -144,7 +144,7 @@ def create_toolbox(num_bits):
         toolbox.attr_bool, num_bits) 
 ```
 
-我们需要注册`population`功能。 我们希望总体成为个体列表：
+我们需要注册`population`函数。 我们希望总体成为个体列表：
 
 ```py
  # Define the population to be a list of individuals 
@@ -185,7 +185,7 @@ def create_toolbox(num_bits):
 
 这是上一节中讨论的所有概念的实现。 `DEAP`中常见的是`toolbox`生成器功能，我们将在本章通篇使用它。 因此，花一些时间来了解`toolbox`是如何产生的，这一点很重要。
 
-从位模式的长度开始，通过定义`main`功能：
+从位模式的长度开始，通过定义`main`函数：
 
 ```py
 if __name__ == "__main__":
@@ -394,7 +394,7 @@ def create_toolbox(strategy):
  return toolbox 
 ```
 
-定义`main`功能。 首先定义个体数量和世代数量：
+定义`main`函数。 首先定义个体数量和世代数量：
 
 ```py
 if __name__ == "__main__":
@@ -671,7 +671,7 @@ def create_toolbox():
     creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) 
 ```
 
-创建`toolbox`和`register`功能。 注册过程的完成类似于前面的部分：
+创建`toolbox`和`register`函数。 注册过程的完成类似于前面的部分：
 
 ```py
  toolbox = base.Toolbox() 

new/ai-py/13.md

@@ -157,7 +157,7 @@ class LastCoinStanding(TwoPlayersGame):
         print(self.num_coins, 'coins left in the pile') 
 ```
 
-定义`main`功能并从定义转置表开始。 换位表用于游戏中以存储位置和运动，以加快算法的速度。
+定义`main`函数并从定义转置表开始。 换位表用于游戏中以存储位置和运动，以加快算法的速度。
 
 输入以下代码：
 
@@ -299,7 +299,7 @@ class GameController(TwoPlayersGame):
         return -100 if self.loss_condition() else 0 
 ```
 
-定义`main`功能并从定义算法开始。 Negamax 将用作此游戏的 AI 算法。 可以预先指定算法应预先考虑的步骤数。 在这种情况下，让我们选择`7`：
+定义`main`函数并从定义算法开始。 Negamax 将用作此游戏的 AI 算法。 可以预先指定算法应预先考虑的步骤数。 在这种情况下，让我们选择`7`：
 
 ```py
 if __name__ == "__main__":
@@ -444,7 +444,7 @@ class GameController(TwoPlayersGame):
         return -100 if self.loss_condition() else 0 
 ```
 
-定义`main`功能并从定义算法开始。 然后，这两种算法将相互竞争。 Negamax 将用于第一个计算机播放器，`SSS*`算法将用于第二个计算机播放器。 `SSS*`是一种搜索算法，它通过以最佳优先方式遍历树来进行状态空间搜索。 两种方法都将事先考虑的匝数作为输入参数。 在这种情况下，让我们同时使用`5`：
+定义`main`函数并从定义算法开始。 然后，这两种算法将相互竞争。 Negamax 将用于第一个计算机播放器，`SSS*`算法将用于第二个计算机播放器。 `SSS*`是一种搜索算法，它通过以最佳优先方式遍历树来进行状态空间搜索。 两种方法都将事先考虑的匝数作为输入参数。 在这种情况下，让我们同时使用`5`：
 
 ```py
 if __name__ == '__main__':

new/ai-py/14.md

@@ -340,7 +340,7 @@ def tone_synthesizer(freq, duration, amplitude=1.0, sampling_freq=44100):
     return signal.astype(np.int16) 
 ```
 
-定义`main`功能。 让我们定义输出音频文件名：
+定义`main`函数。 让我们定义输出音频文件名：
 
 ```py
 if __name__=='__main__':
@@ -428,7 +428,7 @@ if __name__=='__main__':
         duration = item[1] 
 ```
 
-使用`tone_synthesizer`功能合成音色：
+使用`tone_synthesizer`函数合成音色：
 
 ```py
  # Synthesize the tone

new/ai-py/15.md

@@ -582,7 +582,7 @@ def extract_features(word, N=2):
     return {'feature': last_n_letters.lower()} 
 ```
 
-定义`main`功能并从`scikit-learn`包中提取训练数据。 此数据包含带有标签的男性和女性姓名：
+定义`main`函数并从`scikit-learn`包中提取训练数据。 此数据包含带有标签的男性和女性姓名：
 
 ```py
 if __name__=='__main__':
@@ -689,7 +689,7 @@ def extract_features(words):
     return dict([(word, True) for word in words]) 
 ```
 
-定义`main`功能并加载带有标签的电影评论：
+定义`main`函数并加载带有标签的电影评论：
 
 ```py
 if __name__=='__main__':
@@ -886,7 +886,7 @@ tokens = tokenizer.tokenize(input_text.lower())
     return tokens_stemmed 
 ```
 
-定义`main`功能并从为您提供的文件`data.txt`中加载输入数据：
+定义`main`函数并从为您提供的文件`data.txt`中加载输入数据：
 
 ```py
 if __name__=='__main__':

new/ai-py/17.md

@@ -138,7 +138,7 @@ def read_data(input_file, index):
     return output 
 ```
 
-定义和`main`功能并指定输入文件：
+定义和`main`函数并指定输入文件：
 
 ```py
 if __name__=='__main__':

new/ai-py/18.md

@@ -225,7 +225,7 @@ def get_frame(cap, scaling_factor):
     return frame 
 ```
 
-定义`main`功能。 首先初始化视频捕获对象：
+定义`main`函数。 首先初始化视频捕获对象：
 
 ```py
 if __name__=='__main__':
@@ -758,7 +758,7 @@ class ObjectTracker(object):
         cv2.destroyAllWindows() 
 ```
 
-定义`main`功能并开始跟踪：
+定义`main`函数并开始跟踪：
 
 ```py
 if __name__ == '__main__':
@@ -1011,7 +1011,7 @@ def start_tracking():
             break 
 ```
 
-定义`main`功能并开始跟踪。 停止跟踪器后，请确保所有窗口均已正确关闭：
+定义`main`函数并开始跟踪。 停止跟踪器后，请确保所有窗口均已正确关闭：
 
 ```py
 if __name__ == '__main__':

new/ai-py/19.md

@@ -571,7 +571,7 @@ def visualize_output(nn, num_points_test):
     plt.plot(output.reshape(num_points_test * 4)) 
 ```
 
-定义`main`功能并创建一个波形：
+定义`main`函数并创建一个波形：
 
 ```py
 if __name__=='__main__':

new/ai-py/20.md

@@ -575,7 +575,7 @@ W_fc2, b_fc2 = create_layer([1024, 10])
 y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2 
 ```
 
-定义`loss`功能和`optimizer`功能：
+定义`loss`函数和`optimizer`函数：
 
 ```py
 # Define the entropy loss and the optimizer

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 编写代码。
 

new/gan-proj/1.md

@@ -427,7 +427,7 @@ pix2pix 网络是由 Phillip Isola，朱俊彦，周廷辉和 Alexei A. Efros
 
 
 
-当我们网络的输入分配发生变化时，就会发生内部协变量偏移。 当输入分布更改时，隐藏层将尝试学习以适应新的分布。 这减慢了训练过程。 如果进程变慢，则需要很长时间才能收敛到全局最小值。 当网络输入的统计分布与以前看到的输入完全不同时，就会出现此问题。 批量归一化和其他归一化技术可以解决此问题。 我们将在以下各节中进行探讨。
+当我们网络的输入分配发生变化时，就会发生内部协变量偏移。 当输入分布更改时，隐藏层将尝试学习以适应新的分布。 这减慢了训练过程。 如果进程变慢，则需要很长时间才能收敛到全局最小值。 当网络输入的统计分布与以前看到的输入完全不同时，就会出现此问题。 批量标准化和其他归一化技术可以解决此问题。 我们将在以下各节中进行探讨。
 
 
 
@@ -536,17 +536,17 @@ 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)。
 
 
 

new/gan-proj/2.md

@@ -99,7 +99,7 @@
 *   **3D 卷积层**：5
 *   **通道**：64、128、256、512、1
 *   **核大小**：4、4、4、4、4、4
-*   **大步前进**：2、2、2、2、1
+*   **步幅**：2、2、2、2、1
 *   **激活**：LReLU，LReLU，LReLU，LReLU，Sigmoid
 *   **批量标准化**：是，是，是，是，无
 *   **池化层**：否，否，否，否，否
@@ -264,7 +264,7 @@ unzip 3DShapeNetsCode.zip
 
 执行以下代码以从`.mat`文件加载 3D 图像：
 
-1.  使用`scipy`中的`loadmat()`功能检索`voxels`。 代码如下：
+1.  使用`scipy`中的`loadmat()`函数检索`voxels`。 代码如下：
 
 ```py
 import scipy.io as io
@@ -280,7 +280,7 @@ voxels = np.pad(voxels, (1, 1), 'constant', constant_values=(0, 0))
 
 `pad()`方法采用四个参数，它们是实际体素的 N 维数组，需要填充到每个轴边缘的值的数量，模式值（`constant`）和`constant_values` 被填充。
 
-3.  然后，使用`scipy.ndimage`模块中的`zoom()`功能将 3D 图像转换为尺寸为`64x64x64`的 3D 图像。
+3.  然后，使用`scipy.ndimage`模块中的`zoom()`函数将 3D 图像转换为尺寸为`64x64x64`的 3D 图像。
 
 ```py
 import scipy.ndimage as nd
@@ -801,7 +801,7 @@ TensorBoard 的 GRAPHS 部分包含两个网络的图形 。 如果网络性能
 我们训练的模型可能不是一个完美的模型，但是我们可以优化超参数来改进它。 3D-GAN 中有许多可以优化的超参数。 其中包括：
 
 *   **批量大小**：尝试使用 8、16、32、54 或 128 的批量大小值。
-*   **时期数**：尝试 100 个时期，并将其逐渐增加到 1,000-5,000。
+*   **周期数**：尝试 100 个时期，并将其逐渐增加到 1,000-5,000。
 *   **学习率**：这是最重要的超参数。 用 0.1、0.001、0.0001 和其他较小的学习率进行实验。
 *   **生成器和判别器网络**的不同层中的激活函数：使用 Sigmoid，tanh，ReLU，LeakyReLU，ELU，SeLU 和其他激活函数进行实验。
 *   **优化算法**：尝试使用 Adam，SGD，Adadelta，RMSProp 和 Keras 框架中可用的其他优化器。
@@ -836,6 +836,6 @@ TensorBoard 的 GRAPHS 部分包含两个网络的图形 。 如果网络性能
 
 在本章中，我们探讨了 3D-GAN。 我们首先介绍了 3D-GAN，并介绍了架构以及生成器和判别器的配置。 然后，我们经历了建立项目所需的不同步骤。 我们还研究了如何准备数据集。 最后，我们在 Keras 框架中实现了 3D-GAN，并在我们的数据集中对其进行了训练。 我们还探讨了不同的超参数选项。 我们通过探索 3D-GAN 的实际应用来结束本章。
 
-在下一章中，我们将学习如何使用**条件生成对抗网络（** cGAN **）执行面部老化。**
+在下一章中，我们将学习如何使用**条件生成对抗网络**（**cGAN**）执行面部老化。
 
 

new/gan-proj/3.md

@@ -66,7 +66,7 @@ cGAN 的问题在于它们无法学习将属性`y`的 输入图像`x`逆映射
 
 
 
-编码器网络的主要目标是生成所提供图像的潜向量。 基本上，它会拍摄尺寸为`(64, 64, 3)`的图像，并将其转换为 100 维向量。 编码器网络是一个深度卷积神经网络。 网络包含四个卷积块和两个密集层。 每个卷积块包含一个卷积层，一个批标准化层和一个激活函数。 在每个卷积块中，每个卷积层后面都有一个批处理归一化层，但第一个卷积层除外。 Age-cGAN 部分的 *Keras 实现将介绍编码器网络的配置。*
+编码器网络的主要目标是生成所提供图像的潜向量。 基本上，它会拍摄尺寸为`(64, 64, 3)`的图像，并将其转换为 100 维向量。 编码器网络是一个深度卷积神经网络。 网络包含四个卷积块和两个密集层。 每个卷积块包含一个卷积层，一个批标准化层和一个激活函数。 在每个卷积块中，每个卷积层后面都有一个批处理归一化层，但第一个卷积层除外。 Age-cGAN 部分的 “Keras 实现”将介绍编码器网络的配置。
 
 
 
@@ -108,9 +108,9 @@ cGAN 的问题在于它们无法学习将属性`y`的 输入图像`x`逆映射
 
 Age-cGAN 具有多个训练阶段。 如上一节所述，Age-cGAN 具有四个网络，并经过三个阶段的训练。 Age-cGAN 的训练包括三个阶段：
 
-1.  **有条件的 GAN 训练**：在此阶段，我们训练生成器网络和判别器网络。
+1.  **条件 GAN 训练**：在此阶段，我们训练生成器网络和判别器网络。
 2.  **初始潜在向量近似**：在此阶段，我们训练编码器网络。
-3.  **潜向量优化**：在此阶段，我们同时优化编码器和生成器网络。
+3.  **潜在向量优化**：在此阶段，我们同时优化编码器和生成器网络。
 
 以下屏幕截图显示了 Age-cGAN 的各个阶段：
 
@@ -166,7 +166,7 @@ Age-cGAN的各个阶段，资料来源：[使用条件生成对抗网络进行
 
 ![](img/98bda784-ced5-4608-8c1d-38477d40cb8f.png)
 
-*FR* 是面部识别网络。 该方程式表明，真实图像和重建图像之间的欧几里得距离应最小。 在此阶段，我们尝试最小化距离以最大程度地保留身份。
+`FR`是面部识别网络。 该方程式表明，真实图像和重建图像之间的欧几里得距离应最小。 在此阶段，我们尝试最小化距离以最大程度地保留身份。
 
 
 
@@ -365,7 +365,7 @@ input_layer = Input(shape=(64, 64, 3))
 2.  接下来，添加第一个卷积块，其中包含具有激活函数的 2D 卷积层，具有以下配置：
     *   **过滤器**：`32`
     *   **核大小**：`5`
-    *   **大步前进**：`2`
+    *   **步幅**：`2`
     *   **填充**：``same``
     *   **激活**：`LeakyReLU`，其中`alpha`等于`0.2`：
 
@@ -376,9 +376,9 @@ input_layer = Input(shape=(64, 64, 3))
 3.  接下来，再添加三个卷积块，其中每个都包含一个 2D 卷积层，然后是一个批处理归一化层和一个激活函数，具有以下配置：
     *   **过滤器**：`64`，`128`，`256`
     *   **核大小**：`5`，`5`，`5`
-    *   **跨越**：`2`，`2`，`2`
+    *   **步幅**：`2`，`2`，`2`
     *   **填充**：`same`，`same`，``same``
-    *   **批量归一化**：每个卷积层后面都有一个批量归一化层
+    *   **批量标准化**：每个卷积层后面都有一个批量标准化层
     *   **激活**：`LealyReLU`，`LeakyReLU`，`LeakyReLU`，其中`alpha`等于`0.2`：
 
 ```py
@@ -404,7 +404,7 @@ enc = LeakyReLU(alpha=0.2)(enc)
 将`n`维张量转换为一维张量（数组）称为“扁平化”。
 
 5.  接下来，添加具有以下配置的密集（完全连接）层，批处理规范化层和激活函数：
-    *   **单位（节点）**：2,096
+    *   **单元（节点）**：2,096
     *   **批量标准化**：是
     *   **激活**：`LeakyReLU`，其中`alpha`等于`0.2`：
 
@@ -415,7 +415,7 @@ enc = LeakyReLU(alpha=0.2)(enc)
 ```
 
 6.  接下来，使用以下配置添加第二个密集（完全连接）层：
-    *   **单位（节点）**：`100`
+    *   **单元（节点）**：`100`
     *   **激活**：无：
 
 ```py
@@ -504,7 +504,7 @@ x = concatenate([input_z_noise, input_label])
 上一步将生成级联张量。
 
 3.  接下来，添加具有以下配置的密集（完全连接）块：
-    *   **单位（节点）**：`2,048`
+    *   **单元（节点）**：`2,048`
     *   **输入尺寸**：106
     *   **激活**：`LeakyReLU`的`alpha`等于``0.2``
     *   **退出**：`0.2`：
@@ -516,7 +516,7 @@ x = Dropout(0.2)(x)
 ```
 
 4.  接下来，使用以下配置添加第二个密集（完全连接）块：
-    *   **单位（节点）**：16,384
+    *   **单元（节点）**：16,384
     *   **批量标准化**：是
     *   **激活**：`alpha`等于`0.2`的`LeakyReLU`
     *   **退出**：`0.2`：
@@ -536,12 +536,12 @@ x = Reshape((8, 8, 256))(x)
 
 该层将生成张量为（`batch_size`，`8, 8, 256`）的张量。
 
-6.  接下来，添加一个升采样模块，该模块包含一个升采样层，其后是一个具有以下配置的 2D 卷积层和一个批归一化层：
+6.  接下来，添加一个上采样模块，该模块包含一个上采样层，其后是一个具有以下配置的 2D 卷积层和一个批归一化层：
     *   **上采样大小**：`(2, 2)`
     *   **过滤器**：`128`
     *   **核大小**：`5`
     *   **填充**：`same`
-    *   **批量规范化**：是，`momentum`等于`0.8`
+    *   **批量标准化**：是，`momentum`等于`0.8`
     *   **激活**：`LeakyReLU`，其中`alpha`等于`0.2`：
 
 ```py
@@ -562,7 +562,7 @@ x = BatchNormalization(momentum=0.8)(x)
 x = LeakyReLU(alpha=0.2)(x)
 ```
 
-8.  接下来，添加最后一个升采样块。 该配置与上一层相似，除了在卷积层中使用了三个过滤器并且不使用批处理归一化的事实：
+8.  接下来，添加最后一个上采样块。 该配置与上一层相似，除了在卷积层中使用了三个过滤器并且不使用批处理归一化的事实：
 
 ```py
 x = UpSampling2D(size=(2, 2))(x)
@@ -646,9 +646,9 @@ label_input = Input(shape=label_shape)
 ```
 
 2.  接下来，添加具有以下配置的二维卷积块（Conv2D + 激活函数）：
-    *   **过滤器** = `64`
+    *   **过滤器**：`64`
     *   **核大小**：`3`
-    *   **大步前进**：`2`
+    *   **步幅**：`2`
     *   **填充**：`same`
     *   **激活**：`LeakyReLU`，其中`alpha`等于`0.2`：
 
@@ -663,7 +663,7 @@ x = LeakyReLU(alpha=0.2)(x)
 label_input1 = Lambda(expand_label_input)(label_input)
 ```
 
-`expand_label_input`功能如下：
+`expand_label_input`函数如下：
 
 ```py
 # The expand_label_input function
@@ -685,7 +685,7 @@ x = concatenate([x, label_input1], axis=3)
 5.  添加具有以下配置的卷积块（2D 卷积层 + 批处理归一化 + 激活函数）：
     *   **过滤器**：`128`
     *   **核大小**：`3`
-    *   **大步前进**：`2`
+    *   **步幅**：`2`
     *   **填充**：`same`
     *   **批量标准化**：是
     *   **激活**：`LeakyReLU`，其中`alpha`等于`0.2`：
@@ -847,7 +847,7 @@ tensorboard.set_model(generator)
 tensorboard.set_model(discriminator)
 ```
 
-6.  接下来，使用在*准备数据*部分中定义的`load_data`函数加载所有图像：
+6.  接下来，使用在“准备数据”部分中定义的`load_data`函数加载所有图像：
 
 ```py
 images, age_list = load_data(wiki_dir=wiki_dir, dataset="wiki")
@@ -1265,7 +1265,7 @@ image_resizer.compile(loss=loss, optimizer='adam')
 fr_model.compile(loss=loss, optimizer="adam")
 ```
 
-请参阅[这里](https://github.com/PacktPublishing/Generative-Adversarial-Networks-Projects/Age-cGAN/main.py)以获取`build_fr_model()`功能。
+请参阅[这里](https://github.com/PacktPublishing/Generative-Adversarial-Networks-Projects/Age-cGAN/main.py)以获取`build_fr_model()`函数。
 
 4.  接下来，创建另一个对抗模型。 在此对抗模型中，我们将具有三个网络：编码器，生成器和面部识别模型：
 

new/gan-proj/4.md

@@ -235,7 +235,7 @@ gallery-dl https://danbooru.donmai.us/posts?tags=face
 
 
 
-在本节中，我们将从图像中裁剪出面孔。 我们将使用 **python-animeface** 从图像中裁剪出面孔。 这是一个开源 GitHub 存储库，可从命令行的图像中自动裁剪面部。 [它可以通过以下链接公开获得](https://github.com/nya3jp/python-animeface)。
+在本节中，我们将从图像中裁剪出面孔。 我们将使用`python-animeface`从图像中裁剪出面孔。 这是一个开源 GitHub 存储库，可从命令行的图像中自动裁剪面部。 [它可以通过以下链接公开获得](https://github.com/nya3jp/python-animeface)。
 
 执行以下步骤来裁剪图像并调整其大小：
 
@@ -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`的尺寸。如果要更改图像的尺寸，请相应地更改生成器和判别器的架构。 我们现在准备在我们的网络上工作。
 
 
 
@@ -386,7 +386,7 @@ gen_model.add(Dense(units=2048))
 gen_model.add(Activation('tanh'))
 ```
 
-3.  接下来，添加第二层，它也是一个具有 16,384 个神经元的密集层。 接下来是 `batch normalization` 层，其中 `default hyperparameters` 和 `tanh` 作为 **激活函数**：
+3.  接下来，添加第二层，它也是一个具有 16,384 个神经元的密集层。 接下来是`batch normalization`层，其中`default hyperparameters`和`tanh`作为**激活函数**：
 
 ```py
 gen_model.add(Dense(256`8`8))
@@ -424,7 +424,7 @@ gen_model.add(UpSampling2D(size=(2, 2)))
 
 2D 上采样层 将张量 的行和列分别以[0]和[1]的大小重复 。
 
-8.  接下来，在第二个 2D 卷积层上添加 `64` 过滤器和，将`(5, 5)` 的**核大小** `tanh` 作为激活函数：
+8.  接下来，在第二个 2D 卷积层上添加 `64` 过滤器和，将`(5, 5)`的**核大小**`tanh`作为激活函数：
 
 ```py
 gen_model.add(Conv2D(64, (5, 5), padding='same'))
@@ -504,9 +504,9 @@ dis_model = Sequential()
 ```
 
 2.  添加一个 2D 卷积层，该层采用形状为`(64, 64, 3)`的输入图像。 该层的超参数如下。 另外，添加具有`0.2`的`alpha`值的`LeakyReLU`作为激活函数：
-    *   **过滤器：** 128
-    *   **核大小：** `(5, 5)`
-    *   **填充：** 相同：
+    *   **过滤器**：128
+    *   **核大小**：`(5, 5)`
+    *   **填充**：相同：
 
 ```py
 dis_model.add(Conv2D(filters=128, kernel_size=5, padding='same', 
@@ -524,7 +524,7 @@ dis_model.add(MaxPooling2D(pool_size=(2, 2)))
 
 4.  接下来，添加具有以下配置的另一个 2D 卷积层：
     *   **过滤器**：256
-    *   **核大小** ：`(3, 3)`
+    *   **核大小**：`(3, 3)`
     *   **激活函数**： `LeakyReLU`，具有`alpha` 0.2
     *   **2D 最大池中的池大小**：`(2, 2)`
 
@@ -605,7 +605,7 @@ def get_discriminator():
     return dis_model
 ```
 
-在本节中，我们已成功实现了判别器和生成器网络。 在下一部分中，我们将在*下载和准备动漫角色数据集*部分中准备的数据集上训练模型。
+在本节中，我们已成功实现了判别器和生成器网络。 在下一部分中，我们将在“下载和准备动漫角色数据集”部分中准备的数据集上训练模型。
 
 
 
@@ -685,7 +685,7 @@ gen_model = build_generator()
 gen_model.compile(loss='binary_crossentropy', optimizer=gen_optimizer)
 ```
 
-使用`binary_crossentropy`作为生成器网络的`loss`功能，并使用`gen_optimizer`作为优化器。
+使用`binary_crossentropy`作为生成器网络的`loss`函数，并使用`gen_optimizer`作为优化器。
 
 3.  接下来，创建判别模型的实例，并对其进行编译，如下所示：
 

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,9 +83,9 @@
 | **层名称** | **超参数** | **输入形状** | **输出形状** |
 | --- | --- | --- | --- |
 | 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 作为激活函数。 生成器网络中有两个上采样模块。 第一个升采样模块的配置如下：
+*   **上采样块**：上采样块包含一个上采样层和一个 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 所需的目标函数。
@@ -354,7 +354,7 @@ input_layer = Input(shape=input_shape)
     配置：
     *   **过滤器**：`64`
     *   **核大小**：`9`
-    *   **大步前进**：`1`
+    *   **步幅**：`1`
     *   **填充**：`same`
     *   **激活**：`relu:`
 
@@ -400,9 +400,9 @@ for i in range(residual_blocks - 1):
     配置：
     *   **过滤器**：`64`
     *   **核大小**：`3`
-    *   **大步前进**：``1``
+    *   **步幅**：``1``
     *   **填充**：`same`
-    *   **批量归一化**：是（动量为 0.8）：
+    *   **批量标准化**：是（动量为 0.8）：
 
 ```py
 gen2 = Conv2D(filters=64, kernel_size=3, strides=1, padding='same')(res)
@@ -415,12 +415,12 @@ gen2 = BatchNormalization(momentum=momentum)(gen2)
 gen3 = Add()([gen2, gen1])
 ```
 
-8.  接下来，添加一个升采样块，如下所示：
+8.  接下来，添加一个上采样块，如下所示：
     配置：
     *   **上采样大小**：`2`
-    *   **文件管理器**：`256`
+    *   **过滤器**：`256`
     *   **核大小**：`3`
-    *   **大步前进**：`1`
+    *   **步幅**：`1`
     *   **填充**：`same`
     *   **激活**：`PReLU:`
 
@@ -433,9 +433,9 @@ gen4 = Activation('relu')(gen4)
 9.  接下来，添加另一个上采样块，如下所示：
     配置：
     *   **上采样大小**：  `2`
-    *   **文件管理器**：  `256`
+    *   **过滤器**：  `256`
     *   **核大小**：  `3`
-    *   **大步前进**：  `1`
+    *   **步幅**：  `1`
     *   **填充**：  `same`
     *   **激活**：  `PReLU:`
 
@@ -449,7 +449,7 @@ gen5 = Activation('relu')(gen5)
     配置：
     *   **过滤器**：`3`（等于通道数）
     *   **核大小**：`9`
-    *   **大步前进**：`1`
+    *   **步幅**：`1`
     *   **填充**：`same`
     *   **激活**：`tanh:`
 
@@ -547,7 +547,7 @@ input_layer = Input(shape=input_shape)
     配置：
     *   **过滤器**：`64`
     *   **核大小**：`3`
-    *   **大步前进**：`1`
+    *   **步幅**：`1`
     *   **填充**：`same`
     *   **激活**：`LeakyReLU`，`alpha`等于 0.2：
 
@@ -560,8 +560,8 @@ dis1 = LeakyReLU(alpha=leakyrelu_alpha)(dis1)
     配置：
     *   **过滤器**：`64`，`128`，`128`，`256`，`256`，`512`，`512`
     *   **核大小**：`3`，`3`，`3`，`3`，`3`，`3`，`3`
-    *   **跨越**：`2`，`1`，`2`，`1`，`2`，`1`，`2`
-    *   每个卷积层的**填充**：`same`
+    *   **步幅**：`2`，`1`，`2`，`1`，`2`，`1`，`2`
+    *   **每个卷积层的填充**：`same`
     *   **激活**：`LealyReLU`，每个卷积层的`alpha`等于 0.2：
 
 ```py
@@ -818,7 +818,7 @@ def build_adversarial_model(generator, discriminator, vgg):
     return model
 ```
 
-我们现在已经成功地在 Keras 中实现了网络。 接下来，我们将在*数据准备*部分中下载的数据集上训练网络。
+我们现在已经成功地在 Keras 中实现了网络。 接下来，我们将在“数据准备”部分中下载的数据集上训练网络。
 
 
 

new/gan-proj/6.md

@@ -38,8 +38,8 @@
 
 StackGAN 是一个两阶段的网络。 每个阶段都有两个生成器和两个判别器。 StackGAN 由许多网络组成，这些网络如下：
 
-*   **Stack-I GAN** ：文本编码器，条件增强网络，生成器网络，判别器网络，嵌入压缩器网络
-*   **Stack-II GAN** ：文本编码器，条件增强网络，生成器网络，判别器网络，嵌入压缩器网络
+*   **阶段 1 GAN** ：文本编码器，条件增强网络，生成器网络，判别器网络，嵌入压缩器网络
+*   **阶段 2 GAN** ：文本编码器，条件增强网络，生成器网络，判别器网络，嵌入压缩器网络
 
 ![](img/6f2f1522-849c-4ee4-9c08-57884ea1b6b1.png)
 
@@ -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)
@@ -657,12 +657,12 @@ input_layer = Input(shape=(64, 64, 3))
 ```
 
 2.  接下来，添加具有以下参数的二维卷积层：
-    *   **过滤器** = `64`
-    *   **核大小** = `(4, 4)`
-    *   **大步前进** = `2`
-    *   **填充** = `'same'`
-    *   **使用偏差** = `False`
-    *   **用`alpha=0.2`激活** = `LeakyReLU`
+    *   **过滤器**：`64`
+    *   **核大小**：`(4, 4)`
+    *   **步幅**：`2`
+    *   **填充**：`'same'`
+    *   **使用偏差**：`False`
+    *   **激活**：`LeakyReLU`，`alpha=0.2`
 
 ```py
 stage1_dis = Conv2D(64, (4, 4),
@@ -672,12 +672,12 @@ stage1_dis = LeakyReLU(alpha=0.2)(stage1_dis)
 ```
 
 3.  之后，添加两个卷积层，每个卷积层之后是一个批处理归一化层和一个`LeakyReLU`激活函数，具有以下参数：
-    *   **过滤器：** `128`
-    *   **核大小：** `(4, 4)`
-    *   **大步前进** = `2`
-    *   **填充** = `'same'`
-    *   **使用偏差** = `False`
-    *   **用`alpha=0.2`激活** = `LeakyReLU`
+    *   **过滤器**：`128`
+    *   **核大小**：`(4, 4)`
+    *   **步幅**：`2`
+    *   **填充**：`'same'`
+    *   **使用偏差**：`False`
+    *   **激活**：`LeakyReLU`，`alpha=0.2`
 
 ```py
 x = Conv2D(128, (4, 4), padding='same', strides=2, use_bias=False)(x)
@@ -686,12 +686,12 @@ x = LeakyReLU(alpha=0.2)(x)
 ```
 
 4.  接下来，再添加一个 2D 卷积层，然后添加批处理规范化层和`LeakyReLU`激活函数，并具有以下参数：
-    *   **过滤器：** `256`
-    *   **核大小：** `(4, 4)`
-    *   **大步前进** = `2`
-    *   **填充** = `'same'`
-    *   **使用偏差** = `False`
-    *   **用`alpha=0.2`激活** = `LeakyReLU`
+    *   **过滤器**：`256`
+    *   **核大小**：`(4, 4)`
+    *   **步幅**：`2`
+    *   **填充**：`'same'`
+    *   **使用偏差**：`False`
+    *   **激活**：`LeakyReLU`，`alpha=0.2`
 
 ```py
 x = Conv2D(256, (4, 4), padding='same', strides=2, use_bias=False)(x)
@@ -700,12 +700,12 @@ x = LeakyReLU(alpha=0.2)(x)
 ```
 
 5.  之后，再添加一个 2D 卷积层，然后添加批处理规范化层和 LeakyReLU 激活函数，并具有以下参数：
-    *   **过滤器：** `512`
-    *   **核大小：** `(4, 4)`
-    *   **大步前进** = `2`
-    *   **填充** = `'same'`
-    *   **使用偏差** = `False`
-    *   **激活** = `LeakyReLU` 和  `alpha=0.2`
+    *   **过滤器**：`512`
+    *   **核大小**：`(4, 4)`
+    *   **步幅**：`2`
+    *   **填充**：`'same'`
+    *   **使用偏差**：`False`
+    *   **激活**：`LeakyReLU` 和  `alpha=0.2`
 
 ```py
 x = Conv2D(512, (4, 4), padding='same', strides=2, use_bias=False)(x)
@@ -726,12 +726,12 @@ merged_input = concatenate([x, input_layer2])
 ```
 
 8.  之后，添加另一个 2D 卷积层，然后添加批处理归一化层，并使用以下参数将`LeakyReLU`作为激活函数：
-    *   **过滤器** = `512`
-    *   **核大小** = `1`
-    *   **大步前进** = `1`
-    *   **填充** = `'same'`
-    *   **批量标准化** =是
-    *   **用`alpha 0.2`激活** = `LeakyReLU`
+    *   **过滤器**：`512`
+    *   **核大小**：`1`
+    *   **步幅**：`1`
+    *   **填充**：`'same'`
+    *   **批量标准化**：是
+    *   **激活**：`LeakyReLU`，`alpha 0.2`
 
 ```py
 x2 = Conv2D(64 * 8, kernel_size=1,
@@ -884,11 +884,11 @@ def build_adversarial_model(gen_model, dis_model):
 在本节中，我们将为降采样模块编写实现。
 
 1.  首先创建第一个下采样块。 该块包含一个以`ReLU`作为激活函数的 2D 卷积层。 在应用 2D 卷积之前，请在各侧用零填充输入。 该块中不同层的配置如下：
-    *   **填充大小：** `(1, 1)`
-    *   **过滤器：** `128`
-    *   **核大小：** `(3, 3)`
-    *   **大步走：** ``1``
-    *   **激活：** `ReLU`
+    *   **填充大小**：`(1, 1)`
+    *   **过滤器**：`128`
+    *   **核大小**：`(3, 3)`
+    *   **步幅**：``1``
+    *   **激活**：`ReLU`
 
 ```py
 x = ZeroPadding2D(padding=(1, 1))(input_lr_images)
@@ -897,12 +897,12 @@ x = ReLU()(x)
 ```
 
 2.  接下来，添加具有以下配置的第二个卷积块：
-    *   **填充大小：** `(1, 1)`
-    *   **过滤器：** `256`
-    *   **核大小：** `(4, 4)`
-    *   **大步走过：** `2`
-    *   **批量标准化：**是
-    *   **激活：** `ReLU`
+    *   **填充大小**：`(1, 1)`
+    *   **过滤器**：`256`
+    *   **核大小**：`(4, 4)`
+    *   **步幅**：`2`
+    *   **批量标准化**：是
+    *   **激活**：`ReLU`
 
 ```py
 x = ZeroPadding2D(padding=(1, 1))(x)
@@ -912,12 +912,12 @@ x = ReLU()(x)
 ```
 
 3.  之后，添加另一个具有以下配置的卷积块：
-    *   **填充大小：** `(1, 1)`
-    *   **过滤器：** `512`
-    *   **核大小：** `(4, 4)`
-    *   **大步走过：** `2`
-    *   **批量标准化：** 是
-    *   **激活：** `ReLU`
+    *   **填充大小**：`(1, 1)`
+    *   **过滤器**：`512`
+    *   **核大小**：`(4, 4)`
+    *   **步幅**：`2`
+    *   **批量标准化**：是
+    *   **激活**：`ReLU`
 
 ```py
 x = ZeroPadding2D(padding=(1, 1))(x)
@@ -976,12 +976,12 @@ def residual_block(input):
 初始输入被添加到第二个 2D 卷积层的输出中。 结果张量将是块的输出。
 
 2.  接下来，添加具有以下超参数的 2D 卷积块：
-    *   **填充大小：** `(1, 1)`
-    *   **过滤器：** `512`
-    *   **核大小：** `(3, 3)`
-    *   **大步走过：** `1`
-    *   **批量归一化：** `Yes`
-    *   **激活：** `ReLU`
+    *   **填充大小**：`(1, 1)`
+    *   **过滤器**：`512`
+    *   **核大小**：`(3, 3)`
+    *   **步幅**：`1`
+    *   **批量标准化**：`Yes`
+    *   **激活**：`ReLU`
 
 ```py
 x = ZeroPadding2D(padding=(1, 1))(c_code)
@@ -999,7 +999,7 @@ x = residual_block(x)
 x = residual_block(x)
 ```
 
-上采样块将从残差块接收该输出张量。 让我们为升采样块编写代码。
+上采样块将从残差块接收该输出张量。 让我们为上采样块编写代码。
 
 
 
@@ -1011,16 +1011,16 @@ x = residual_block(x)
 
 上采样块包含可提高图像空间分辨率并生成尺寸`256x256x3`的高分辨率图像的层。
 
-让我们为升采样块编写代码：
+让我们为上采样块编写代码：
 
 1.  首先，添加一个包含 2D 上采样层，2D 卷积层，批归一化和激活函数的上采样块。 块中使用的不同参数如下：
-    *   **上采样大小：** `(2, 2)`
-    *   **过滤器：** `512`
-    *   **核大小：** `3`
-    *   **填充：** `"same"`
-    *   **大步走：** `1`
-    *   **批量标准化：** `Yes`
-    *   **激活：** `ReLU`
+    *   **上采样大小**：`(2, 2)`
+    *   **过滤器**：`512`
+    *   **核大小**：`3`
+    *   **填充**：`"same"`
+    *   **步幅**：`1`
+    *   **批量标准化**：`Yes`
+    *   **激活**：`ReLU`
 
 ```py
 x = UpSampling2D(size=(2, 2))(x)

new/gan-proj/7.md

@@ -96,14 +96,14 @@ 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)` |
 
 加法层计算输入到块的  张量  与最后一批归一化层的输出之和。
 
-*   **上采样块**：上采样块包含 2D 转置卷积层，并使用`relu`作为激活函数。 生成器网络中有两个上采样模块。 第一个升采样模块的配置如下：
+*   **上采样块**：上采样块包含 2D 转置卷积层，并使用`relu`作为激活函数。 生成器网络中有两个上采样模块。 第一个上采样模块的配置如下：
 
 | **层名称** | **超参数** | **输入形状** | **输出形状** |
 | --- | --- | --- | --- |
@@ -356,7 +356,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)
@@ -402,7 +402,7 @@ for _ in range(residual_blocks):
     x = residual_block(x)
 ```
 
-7.  接下来，添加一个升采样块，如下所示：
+7.  接下来，添加一个上采样块，如下所示：
 
 ```py
 x = Conv2DTranspose(filters=64, kernel_size=3, strides=2, padding='same', use_bias=False)(x)
@@ -410,7 +410,7 @@ x = InstanceNormalization(axis=1)(x)
 x = Activation("relu")(x)
 ```
 
-8.  添加另一个升采样模块，如下所示：
+8.  添加另一个上采样模块，如下所示：
 
 ```py
 x = Conv2DTranspose(filters=32, kernel_size=3, strides=2, padding='same', use_bias=False)(x)
@@ -515,7 +515,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)
@@ -528,7 +528,7 @@ x = LeakyReLU(alpha=0.2)(x)
 x = ZeroPadding2D(padding=(1, 1))(x)
 ```
 
-6.  接下来，使用先前在*判别器网络* 部分中指定的超参数添加三个卷积块，如下所示：
+6.  接下来，使用先前在“判别器网络”部分中指定的超参数添加三个卷积块，如下所示：
 
 ```py
 for i in range(1, hidden_layers + 1):
@@ -854,7 +854,7 @@ fake_labels = np.zeros((batch_size, 7, 7, 1))
 imagesA, imagesB = load_images(data_dir=data_dir)
 ```
 
-我们已经在*中定义了`load_images`功能。*
+我们已经在定义了`load_images`函数。
 
 2.  接下来，创建一个`for`循环，该循环应运行由时期数指定的次数，如下所示：
 

new/gan-proj/8.md

@@ -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, )` |
@@ -1210,13 +1210,13 @@ print("Batch:{}".format(index))
         val_images_batch = validation_facade_photos[index * batch_size:(index + 1) * batch_size]
 ```
 
-12.  接下来，生成一批假图像并从中提取补丁。 如下使用`generate_and_extract_patches`功能：
+12.  接下来，生成一批假图像并从中提取补丁。 如下使用`generate_and_extract_patches`函数：
 
 ```py
 patches, labels = generate_and_extract_patches(train_images_batch, train_facades_batch, unet_generator,batch_counter, patch_dim)
 ```
 
-`generate_and_extract_patches`功能定义如下：
+`generate_and_extract_patches`函数定义如下：
 
 ```py
 def generate_and_extract_patches(images, facades, generator_model, batch_counter, patch_dim):

new/gan-proj/9.md

@@ -164,7 +164,7 @@ GAN 已被证明对图像生成任务很有用。 GAN 中的大部分研究目
 
 *   [**AdaGAN**：AdaGAN：增强生成模型](https://arxiv.org/abs/1701.02386v1)
 *   [**ArtGAN**：ArtGAN：带有条件分类 GAN 的艺术品合成](https://arxiv.org/abs/1702.03410)
-*   [**BAGAN**：BAGAN：平衡 GAN 的数据增强](https://arxiv.org/abs/1803.09655)
+*   [**BAGAN**：BAGAN：平衡 GAN 的数据扩充](https://arxiv.org/abs/1803.09655)
 *   [**BicycleGAN**：从多模态图像迈向图像翻译](https://arxiv.org/abs/1711.11586)
 *   [**CapsGAN**：CapsGAN：为生成对抗网络使用动态路由](https://arxiv.org/abs/1806.03968)
 *   [**E-GAN**：进化生成对抗网络](https://arxiv.org/abs/1803.00657)

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

@@ -125,7 +125,7 @@ graph = tf.Graph()
 *   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[2]`范数。 优化器是 Adam，学习率为*η= 0.001* 。 TensorFlow DAG 的编码器部分如下：
 
@@ -417,7 +417,7 @@ for e in range(nb_epochs):
 
 
 
-在此示例中，我们想通过使用`L[1]`罚分来提高代码的稀疏性。 DAG 和训练过程与主要示例完全相同，唯一的区别是`loss`功能，现在变为：
+在此示例中，我们想通过使用`L[1]`罚分来提高代码的稀疏性。 DAG 和训练过程与主要示例完全相同，唯一的区别是`loss`函数，现在变为：
 
 ```py
 ...
@@ -504,7 +504,7 @@ ELBO 右侧的第二项是 *log p（x | z;* *θ）*的期望值。 不难看出
 *   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 的第一部分，其中包含图形定义和编码器：
 

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

@@ -192,7 +192,7 @@ 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 激活
 *   256 个（4×4）滤波器的 2D 卷积，步幅为[ *2，2* ），，相同  填充，以及线性输出
@@ -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()`接受 *logit* （这就是为什么我们没有将 Sigmoid 变换直接应用于判别器输出的原因），并允许我们执行以下向量计算：
 

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

@@ -570,7 +570,7 @@ void RunInferenceOnImage(NSString *model)
 
 图 3.8：使用不同的模型运行应用程序并显示检测结果
 
-返回步骤 7 中的功能，`FilePathForResourceName`功能是用于返回资源文件路径的帮助程序功能：`mscoco_label_map.pbtxt`文件，该文件定义了要检测的 90 个对象类的 ID，内部名称和显示名称。 ，模型图文件和测试图像。 它的实现与我们在上一章的`HelloTensorFlow`应用中看到的实现相同。
+返回步骤 7 中的功能，`FilePathForResourceName`函数是用于返回资源文件路径的帮助程序功能：`mscoco_label_map.pbtxt`文件，该文件定义了要检测的 90 个对象类的 ID，内部名称和显示名称。 ，模型图文件和测试图像。 它的实现与我们在上一章的`HelloTensorFlow`应用中看到的实现相同。
 
 `LoadLablesFile`和`GetDisplayName`函数使用 Google Protobuf API 加载和解析`mscoco_label_map.pbtxt`文件，并返回显示名称以显示检测到的对象的 ID。
 

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

@@ -239,7 +239,7 @@ def _restore_fn(sess):
       saver.restore(sess, checkpoint_path)
 ```
 
-在启动`run_inference.py`之后到达`saver.restore`调用时，已进行了更新的图形定义，因此我们可以在此处保存新的检查点和图形文件，从而使`_restore_fn`功能如下：
+在启动`run_inference.py`之后到达`saver.restore`调用时，已进行了更新的图形定义，因此我们可以在此处保存新的检查点和图形文件，从而使`_restore_fn`函数如下：
 
 ```py
  def _restore_fn(sess):
@@ -350,7 +350,7 @@ x[:6]
  u'convert_image']
 ```
 
-解决您的 iOS 应用错误的第二种可能解决方案是，像在 中所做的那样，在 `tf_op_files`文件中添加未注册的操作实现，并重建 TensorFlow iOS 库。 就像第 5 章， “了解简单语音命令”一样。 坏消息是，由于 TensorFlow 中没有`DecodeJpeg`功能的实现，因此无法将`DecodeJpeg`的 TensorFlow 实现添加到`tf_op_files`中。
+解决您的 iOS 应用错误的第二种可能解决方案是，像在 中所做的那样，在 `tf_op_files`文件中添加未注册的操作实现，并重建 TensorFlow iOS 库。 就像第 5 章， “了解简单语音命令”一样。 坏消息是，由于 TensorFlow 中没有`DecodeJpeg`函数的实现，因此无法将`DecodeJpeg`的 TensorFlow 实现添加到`tf_op_files`中。
 
 实际上，在图 6.2 中也暗示了对此烦恼的解决方法，其中`convert_image`节点用作`image_feed`输入的解码版本。 为了更准确，单击 TensorBoard 图中的转换和**解码**节点，如图 6.4 所示，您将从右侧的 TensorBoard 信息卡中看到输入转换（名为`convert_image/Cast`）的输出为`decode/DecodeJpeg`和`convert_image`，解码的输入和输出为`image_feed`和`convert_image/Cast`：
 
@@ -555,7 +555,7 @@ while(t){
 t.close();
 ```
 
-6.  剩下的我们要做的就是实现`generateCaption`功能。 在其中，首先加载正确的模型：
+6.  剩下的我们要做的就是实现`generateCaption`函数。 在其中，首先加载正确的模型：
 
 ```py
 tensorflow::Status load_status;

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

@@ -164,7 +164,7 @@ def predict_input_fn():
   print(next(predictions)['argmax'])
 ```
 
-4.  在`model_fn`功能中，在`logits = _add_fc_layers(final_state)`之后，添加以下代码：
+4.  在`model_fn`函数中，在`logits = _add_fc_layers(final_state)`之后，添加以下代码：
 
 ```py
   argmax = tf.argmax(logits, axis=1)

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

@@ -581,7 +581,7 @@ bool getProbs(int *binary, float *probs) {
 }
 ```
 
-`getAllowedActions`功能定义如下：
+`getAllowedActions`函数定义如下：
 
 ```py
 void getAllowedActions(int bd[], vector<int> &actions) {