2020-09-07 11:06:18

docs/dl-quick-ref/10.md

@@ -60,11 +60,11 @@ NLP 领域广阔而复杂。 从技术上讲，人类语言与计算机科学之
 *   **文档**：文档是句子的集合。 它可能是一个句子，或更可能是多个句子。
 *   **语料库**：文档的集合。
 
-# Word 模型袋
+# 词袋模型
 
 **词袋**（**BoW**）模型是 NLP 模型，实际上忽略了句子结构和单词放置。 在“单词袋”模型中，我们将每个文档视为单词袋。 很容易想到这一点。 每个文档都是一个包含大量单词的容器。 我们忽略句子，结构以及哪个词排在前或后。 我们对文档中包含“非常”，“很好”和“不好”这两个词的事实感到关注，但是我们并不真正在意“好”而不是“坏”。
 
-Word 袋模型很简单，需要相对较少的数据，并且考虑到该模型的天真性，其运行效果非常好。
+词袋模型很简单，需要相对较少的数据，并且考虑到该模型的天真性，其运行效果非常好。
 
 注意，这里使用模型表示表示。 我并不是在特定意义上指深度学习模型或机器学习模型。 相反，在这种情况下，模型是表示文本的一种方式。
 
@@ -86,7 +86,7 @@ cat, cats, cat's, cats' -> cat
 
 大部分 BoW 模型都受益于词干，词根化和删除停用词。 有时，我们很快将要讨论的词嵌入模型也可以从词干提取或词义化中受益。 词嵌入模型很少会受益于停用词的删除。
 
-# 计数和 TF-IDF 矢量化
+# 计数和 TF-IDF 向量化
 
 计数向量化和**词频逆文档频率**（**TF-IDF**）是两种策略，将词袋转换成适合机器学习算法输入的特征向量。
 
@@ -128,7 +128,7 @@ docB = "the dog sat on my bed"
 
 ![](img/b1ca6787-9563-418b-aaa1-60a25fdc68c7.png)
 
-n 这个公式：
+这个公式：
 
 ![](img/cd6249c7-e42a-484b-90b3-4bf2de2f1300.png) 
 
@@ -143,9 +143,9 @@ n 这个公式：
 
 # 词嵌入
 
-Word 袋模型具有一些不理想的属性，值得注意的是。
+词袋模型具有一些不理想的属性，值得注意的是。
 
-我们之前研究过的 Bag of Word 模型的第一个问题是它们没有考虑单词的上下文。 他们并没有真正考虑文档中单词之间存在的关系。
+我们之前研究过的词袋模型的第一个问题是它们没有考虑单词的上下文。 他们并没有真正考虑文档中单词之间存在的关系。
 
 第二个相关问题是向量空间中单词的分配有些随意。 可能无法捕获有关语料库词汇中两个单词之间的关系的信息。 例如，虽然鳄鱼和鳄鱼都是相似的具有许多特征的生物，但已经学会处理鳄鱼的单词的模型几乎无法利用鳄鱼学到的知识（爬行动物学家讨厌邮件） 。
 
@@ -153,13 +153,13 @@ Word 袋模型具有一些不理想的属性，值得注意的是。
 
 单词嵌入模型通过为每个单词学习一个向量来解决这些问题，其中每个语义相似的单词都映射到（嵌入）附近的点。 另外，与 BoW 模型相比，我们将在更小的向量空间中表示整个词汇表。 这提供了降维效果，并为我们提供了一个更小，更密集的矢量，该矢量可以捕获单词的语义值。
 
-词嵌入模型在现实文档分类问题和语义分析问题中通常比 Word of Bag 模型具有很大的提升，因为这种能力可以保留词相对于语料库中其他词的语义值。
+词嵌入模型在现实文档分类问题和语义分析问题中通常比词袋模型具有很大的提升，因为这种能力可以保留词相对于语料库中其他词的语义值。
 
 # 一个简单的例子
 
 如果您不熟悉单词嵌入，那么您现在可能会感到有些迷茫。 挂在那儿，它很快就会变得清晰起来。 让我们尝试一个具体的例子。
 
-使用流行的单词嵌入模型`word2vec`，我们可以从单词 cat 开始，找到它的 384 元素矢量，如以下输出代码所示：
+使用流行的单词嵌入模型`word2vec`，我们可以从单词`cat`开始，找到它的 384 元素矢量，如以下输出代码所示：
 
 ```py
 array([ 5.81600726e-01, 3.07168198e+00, 3.73339128e+00,
@@ -192,7 +192,7 @@ array([ 5.81600726e-01, 3.07168198e+00, 3.73339128e+00,
 
 ![](img/ec71e9df-b735-4432-ab12-d31905f6d2c6.png)
 
-该网络导致隐藏层的形状为权重矩阵`[词汇 x 神经元]`。 例如，如果我们的语料库中有 20,000 个唯一单词，而隐藏层中有 300 个神经元，那么我们的隐藏层权重矩阵将为 20,000 x300。将这些权重保存到磁盘后，我们将拥有一个 300 元素向量，可用于代表每个词。 然后，在训练其他模型时，可以使用这些向量表示单词。
+该网络导致隐藏层的形状为权重矩阵`[词汇 x 神经元]`。 例如，如果我们的语料库中有 20,000 个唯一单词，而隐藏层中有 300 个神经元，那么我们的隐藏层权重矩阵将为`20,000 x 300`。将这些权重保存到磁盘后，我们将拥有一个 300 元素向量，可用于代表每个词。 然后，在训练其他模型时，可以使用这些向量表示单词。
 
 当然，除此以外，还有更多的培训词嵌入网络的方法，而我故意过分简化了快速参考样式。
 
@@ -234,7 +234,7 @@ Le 和 Mikolov 在[《句子和文档的分布式表示》](https://arxiv.org/ab
 Embedding(input_dim=10000, output_dim=128, input_length=10)
 ```
 
-在这种情况下，该层的输出将是形状为 10 x 128 的 2D 矩阵，其中每个文档的 10 个单词将具有与之关联的 128 元素矢量。
+在这种情况下，该层的输出将是形状为`10 x 128`的 2D 矩阵，其中每个文档的 10 个单词将具有与之关联的 128 元素矢量。
 
 这样的单词序列可以作为 LSTM 的出色输入。 LSTM 层可以紧随嵌入层。 就像上一章一样，我们可以将嵌入层中的这 10 行视为 LSTM 的顺序输入。 在本章的第一个示例中，我将使用 LSTM，因此，如果您在未阅读第 9 章“从头开始训练 RNN”的情况下，则请花一点时间重新了解 LSTM 的操作，可以在此处找到。
 
@@ -246,9 +246,9 @@ Embedding(input_dim=10000, output_dim=128, input_length=10)
 
 事实证明，我们可以对一系列单词使用相同的策略。 在这里，我们的 2D 矩阵是嵌入层的输出。 每行代表一个单词，并且该行中的所有元素都是其单词向量。 继续前面的示例，我们将有一个 10 x 128 的向量，其中连续有 10 个单词，每个单词都由 128 个元素的向量空间表示。 我们当然可以在这些单词上滑动过滤器。
 
-卷积过滤器的大小针对 NLP 问题而改变。 当我们构建网络来解决 NLP 问题时，我们的过滤器将与单词 vector 一样宽。 过滤器的高度可以变化，通常在 2 到 5 之间。高度为 5 表示我们一次要在五个字上滑动过滤器。
+卷积过滤器的大小针对 NLP 问题而改变。 当我们构建网络来解决 NLP 问题时，我们的过滤器将与单词向量一样宽。 过滤器的高度可以变化，通常在 2 到 5 之间。高度为 5 表示我们一次要在五个字上滑动过滤器。
 
-事实证明，对于许多 NLP 问题，CNN 可以很好地运行，并且比 LSTM 快得多。 很难就何时使用 RNN / LSTM 和何时使用 CNN 给出确切的规则。 通常，如果您的问题需要状态，或者从很远的序列中学习到一些东西，那么使用 LSTM 可能会更好。 如果您的问题需要检测描述文本的特定单词集或文档的语义感觉，那么 CNN 可能会更快甚至更好地解决您的问题。
+事实证明，对于许多 NLP 问题，CNN 可以很好地运行，并且比 LSTM 快得多。 很难就何时使用 RNN/LSTM 和何时使用 CNN 给出确切的规则。 通常，如果您的问题需要状态，或者从很远的序列中学习到一些东西，那么使用 LSTM 可能会更好。 如果您的问题需要检测描述文本的特定单词集或文档的语义感觉，那么 CNN 可能会更快甚至更好地解决您的问题。
 
 # 文件分类的案例研究
 
@@ -323,7 +323,7 @@ embedding = Embedding(input_dim=vocab_size, output_dim=embedding_dim,
 
 我们定义的词汇量为 20,000 个单词，数据的序列长度为 2,494，并且指定的嵌入维数为 100。
 
-将所有这些放在一起，嵌入层将从每个文件的 20,000 个输入热向量到每个文档的 2,494 x 100 2D 矩阵，从而为序列中的每个单词嵌入向量空间。 随着模型的学习，嵌入层将不断学习。 很酷吧？
+将所有这些放在一起，嵌入层将从每个文件的 20,000 个输入热向量到每个文档的`2,494 x 100` 2D 矩阵，从而为序列中的每个单词嵌入向量空间。 随着模型的学习，嵌入层将不断学习。 很酷吧？
 
 # LSTM 层
 
@@ -565,7 +565,7 @@ embedding_layer = Embedding(input_dim=vocab_size,
                             name="embedding")(sequence_input)
 ```
 
-# 与 GloVe 向量
+# 带有 GloVe 向量
 
 现在，将其与包含以 2D 矩阵编码的预先训练的 GloVe 向量的代码进行比较：
 
@@ -601,7 +601,7 @@ x = GlobalMaxPooling1D()(x)
 
 我正在使用的`MaxPooling1D`层也将使用 5 的窗口大小。相同的规则适用于一维实现中的池化层。
 
-在最后一个卷积层之后，我们应用`GlobalMaxPooling1D`层。 该层是最大池化的特殊实现，它将获取最后一个`Conv1D`层（一个[batch x 35 x 128]张量）的输出，并跨时间步长将其合并到[batch x 128]。 这通常是在 NLP 网络中完成的，其目的类似于在基于图像的卷积网络中使用`Flatten()`层。 该层充当卷积层和密集层之间的桥梁。
+在最后一个卷积层之后，我们应用`GlobalMaxPooling1D`层。 该层是最大池化的特殊实现，它将获取最后一个`Conv1D`层（一个`[batch x 35 x 128]`张量）的输出，并跨时间步长将其合并到`[batch x 128]`。 这通常是在 NLP 网络中完成的，其目的类似于在基于图像的卷积网络中使用`Flatten()`层。 该层充当卷积层和密集层之间的桥梁。
 
 # 输出层
 

docs/dl-quick-ref/11.md

@@ -124,7 +124,7 @@ Go now.    Vas-y maintenant.
 
 加载此数据涉及很多工作。 阅读本文时，您可能想参考代码块。
 
-以下代码中的第一个 for 循环将遍历整个输入文件或调用`load_data()`时指定的一些样本。 我这样做是因为您可能没有 RAM 来加载整个数据集。 多达 10,000 个示例，您可能会获得良好的结果； 但是，多多益善。
+以下代码中的第一个`for`循环将遍历整个输入文件或调用`load_data()`时指定的一些样本。 我这样做是因为您可能没有 RAM 来加载整个数据集。 多达 10,000 个示例，您可能会获得良好的结果； 但是，多多益善。
 
 当我们逐行浏览输入文件时，我们一次要执行几项操作：
 
@@ -231,7 +231,7 @@ def one_hot_vectorize(data):
 *   `decoder_input_data`是形状（`number_of_pairs`，`max_french_sequence_length`，`number_of_french_characters`）的 3d 矩阵。
 *   `decoder_output_data`与`decoder_input_data`相同，仅向前移了一个时间步。 这意味着`decoder_input_data[:, t+1, :]`等于`decoder_output_data[:, t, :]`。
 
-前面的每个向量都是字符层上整个短语的一个热编码表示。 这意味着，如果我们输入的短语是 Go！ 向量的第一步是为文本中每个可能的英文字符包含一个元素。 除 g 设置为 1 以外，其他每个元素都将设置为`0`。
+前面的每个向量都是字符层上整个短语的一个热编码表示。 这意味着，如果我们输入的短语是 Go！ 向量的第一步是为文本中每个可能的英文字符包含一个元素。 除`g`设置为 1 以外，其他每个元素都将设置为`0`。
 
 我们的目标是使用`encoder_input_data`和`decoder_input`数据作为输入特征，训练序列至序列模型来预测`decoder_output_data`。
 
@@ -591,6 +591,6 @@ while not stop_condition:
 
 如果您已经做到了，那就好。 您已经看到了很多深度学习的应用程序，并且发现自己正处于深层神经网络应用程序的最先进的钟形曲线的右边。
 
-在下一章中，我将向您展示另一个高级主题的示例，即深度强化学习或 Deep-Q 学习，并向您展示如何实现自己的 Deep-Q 网络。
+在下一章中，我将向您展示另一个高级主题的示例，即深度强化学习或深度 Q 学习，并向您展示如何实现自己的深度 Q 网络。
 
 在此之前，请放松！
\ No newline at end of file

docs/dl-quick-ref/12.md

@@ -123,7 +123,7 @@
 
 # 安装 Keras-RL
 
-Keras-RL 可以通过 pip 安装。 但是，我建议从项目 GitHub 存储库中安装它，因为代码可能会更新一些。 为此，只需克隆存储库并按以下方式运行`python setup.py install`：
+Keras-RL 可以通过 PIP 安装。 但是，我建议从项目 GitHub 存储库中安装它，因为代码可能会更新一些。 为此，只需克隆存储库并按以下方式运行`python setup.py install`：
 
 ```py
 git clone https://github.com/matthiasplappert/keras-rl.git
@@ -133,7 +133,7 @@ python setup.py install
 
 # 安装 OpenAI Gym
 
-OpenAI 健身房可作为点子安装。 我将使用他们的`Box2D`和`atari`环境中的示例。 您可以使用以下代码安装它们：
+OpenAI 体育场可作为点子安装。 我将使用他们的`Box2D`和`atari`环境中的示例。 您可以使用以下代码安装它们：
 
 ```py
 pip install gym
@@ -143,9 +143,9 @@ pip install gym[Box2D]
 
 # 使用 OpenAI 体育馆
 
-使用 OpenAI 健身房确实使深度强化学习变得容易。 Keras-RL 将完成大部分艰苦的工作，但是我认为值得单独走遍体育馆，这样您才能了解代理如何与环境互动。
+使用 OpenAI 体育场确实使深度强化学习变得容易。 Keras-RL 将完成大部分艰苦的工作，但是我认为值得单独走遍体育馆，这样您才能了解代理如何与环境互动。
 
-环境是可以实例化的对象。 例如，要创建`CartPole-v0`环境，我们只需要导入健身房并创建环境，如以下代码所示：
+环境是可以实例化的对象。 例如，要创建`CartPole-v0`环境，我们只需要导入体育场并创建环境，如以下代码所示：
 
 ```py
 import gym
@@ -188,7 +188,7 @@ def build_model(state_size, num_actions):
     return model
 ```
 
-输入将是一个 1 x 状态空间向量，每个可能的动作都有一个输出神经元，它将预测每个步骤该动作的`Q`值。 通过获取输出的`argmax`，我们可以选择`Q`值最高的动作，但是我们不必自己做，因为 Keras-RL 会为我们做。
+输入将是一个`1 x 状态空间`向量，每个可能的动作都有一个输出神经元，它将预测每个步骤该动作的`Q`值。 通过获取输出的`argmax`，我们可以选择`Q`值最高的动作，但是我们不必自己做，因为 Keras-RL 会为我们做。
 
 # 记忆
 
@@ -208,7 +208,7 @@ Keras-RL 提供了一个称为`rl.policy.EpsGreedyQPolicy`的 ε-贪婪 Q 策略
 policy = LinearAnnealedPolicy(EpsGreedyQPolicy(), attr='eps', value_max=1., value_min=.1, value_test=.05, nb_steps=10000)
 ```
 
-在这里我们要说的是，我们要从`ε`的值 1 开始，并且不小于 0.1，同时测试我们的随机数是否小于 0.05。 我们将步数设置为 1 到.1 到 10,000 之间，Keras-RL 为我们处理衰减数学。
+在这里我们要说的是，我们要从`ε`的值 1 开始，并且不小于 0.1，同时测试我们的随机数是否小于 0.05。 我们将步数设置为 .1 到 10,000 之间，Keras-RL 为我们处理衰减数学。
 
 # 代理商
 
@@ -224,11 +224,11 @@ dqn.compile(Adam(lr=1e-3), metrics=['mae'])
 此时，其中两个参数`target_model_update`和`nb_steps_warmup`可能还不熟悉：
 
 *   `nb_steps_warmup`：确定我们开始进行体验重播之前需要等待的时间，如果您还记得的话，这是我们实际上开始培训网络的时间。 这使我们积累了足够的经验来构建适当的小批量生产。 如果您为此参数选择的值小于批量大小，则 Keras RL 将抽样替换。
-*   `target_model_update`：Q 函数是递归的，当代理更新它的网络以获取 Q（s，a）时，更新也影响其对 Q（s'，a）所​​做的预测。 这会导致网络非常不稳定。 大多数深度 Q 网络实现解决此限制的方法是使用目标网络，该目标网络是未经训练的深度 Q 网络的副本，而经常被新副本替换。 `target_model_update`参数控制这种情况发生的频率。
+*   `target_model_update`：`Q`函数是递归的，当代理更新它的网络以获取` Q(s, a)`时，更新也影响其对`Q(s', a)`所​​做的预测。 这会导致网络非常不稳定。 大多数深度 Q 网络实现解决此限制的方法是使用目标网络，该目标网络是未经训练的深度 Q 网络的副本，而经常被新副本替换。 `target_model_update`参数控制这种情况发生的频率。
 
 # 训练
 
-Keras RL 提供了多个类似 Keras 的回调，可以方便地进行模型检查指向和记录。 我将在下面使用这两个回调。 如果您想查看 Keras-RL 提供的更多回调，[可以在以下位置找到它们](https://github.com/matthiasplappert/keras-rl/blob/master/rl/callbacks.py)。 您还可以找到可用于创建自己的 Keras-RL 回调的 Callback 类。
+Keras RL 提供了多个类似 Keras 的回调，可以方便地进行模型检查指向和记录。 我将在下面使用这两个回调。 如果您想查看 Keras-RL 提供的更多回调，[可以在以下位置找到它们](https://github.com/matthiasplappert/keras-rl/blob/master/rl/callbacks.py)。 您还可以找到可用于创建自己的 Keras-RL 回调的回调类。
 
 我们将使用以下代码来训练我们的模型：
 
@@ -306,7 +306,7 @@ dqn.compile(Adam(lr=0.00025), metrics=['mae'])
 
 # 训练
 
-在训练该特工时，您会注意到它学会做的第一件事是将着陆器悬停，并避免着陆。 当着陆器最终着陆时，它会收到非常高的奖励，成功着陆时为+100，坠毁时为-100。 这种-100 的奖励是如此之强，以至于代理商一开始宁愿因悬停而受到小额罚款。 我们的探员要花很多时间才能得出这样的提示：良好的着陆总比没有良好着陆好，因为坠机着陆非常糟糕。
+在训练该特工时，您会注意到它学会做的第一件事是将着陆器悬停，并避免着陆。 当着陆器最终着陆时，它会收到非常高的奖励，成功着陆时为 +100，坠毁时为 -100。 这种 -100 的奖励是如此之强，以至于代理商一开始宁愿因悬停而受到小额罚款。 我们的探员要花很多时间才能得出这样的提示：良好的着陆总比没有良好着陆好，因为坠机着陆非常糟糕。
 
 可以塑造奖励信号来帮助座席更快地学习，但这超出了本书的范围。 有关更多信息，请查看奖励塑造。
 
@@ -321,7 +321,7 @@ dqn.fit(env, nb_steps=1000000,
         callbacks=callbacks)
 ```
 
-您可以通过调整参数 gamma（默认值为 0.99）来进一步改进此示例。 如果您从`Q`函数中调用，此参数会减少或增加`Q`函数中将来奖励的影响。
+您可以通过调整参数`gamma`（默认值为 0.99）来进一步改进此示例。 如果您从`Q`函数中调用，此参数会减少或增加`Q`函数中将来奖励的影响。
 
 # 结果
 

docs/dl-quick-ref/13.md

@@ -51,13 +51,13 @@ GAN 的整体体系结构如下图所示。 生成器和判别器分别是单独
 
 ![](img/6e7de048-2461-4be3-a702-f4d0a87d3c43.png)
 
-生成器的输入只是 100 x 1 的随机向量，我们将其称为噪声向量。 当此噪声矢量是从正态分布生成时，GAN 往往工作得最好。
+生成器的输入只是`100 x 1`的随机向量，我们将其称为噪声向量。 当此噪声矢量是从正态分布生成时，GAN 往往工作得最好。
 
 网络的第一层是密集的并且完全连接。 它为我们提供了一种建立线性代数的方法，以便最终得到正确的输出形状。 对于每个卷积块，我们最终将第一轴和第二轴（最终将成为图像的高度和宽度的行和列）加倍，而通道数逐渐缩小到 1。我们最终需要输出的高度和宽度为 28。因此，我们将需要从`7 x 7 x 128`张量开始，以便它可以移动到`14 x 14`，然后最终是`28 x 28`。 为此，我们将密集层的大小设置为`128 x 7 x 7`神经元或 6,272 单位。 这使我们可以将密集层的输出重塑为`7 x 7 x 128`。 如果现在看来这还不算什么，请不用担心，在编写代码后，这才有意义。
 
 在完全连接的层之后，事情变得更加简单。 就像我们一直一样，我们正在使用卷积层。 但是，这次我们反向使用它们。 我们不再使用最大池来缩减样本量。 取而代之的是，我们进行上采样，在学习视觉特征时使用卷积来构建我们的网络，并最终输出适当形状的张量。
 
-通常，生成器中最后一层的激活是双曲正切，并且训练图像矩阵中的元素被归一化为-1 和 1 之间。这是我将在整章中提到的众多 GAN hack 之一。 研究人员已经发现了一些经验证明可以帮助构建稳定的 GAN 的 hack，Soumith Chintala 可以在此 Git 上找到大多数黑客，[而 Soumith Chintala 也是 DCGAN 原始论文的作者之一](https://github.com/soumith/ganhacks)。 深度学习研究的世界无疑是一个很小的领域。
+通常，生成器中最后一层的激活是双曲正切，并且训练图像矩阵中的元素被归一化为 -1 和 1 之间。这是我将在整章中提到的众多 GAN 黑魔法之一。 研究人员已经发现了一些经验证明可以帮助构建稳定的 GAN 的黑魔法，Soumith Chintala 可以在此 Git 上找到大多数黑客，[而 Soumith Chintala 也是 DCGAN 原始论文的作者之一](https://github.com/soumith/ganhacks)。 深度学习研究的世界无疑是一个很小的领域。
 
 # 鉴别器架构
 
@@ -107,7 +107,7 @@ DCGAN 框架是使用迷你批量来进行训练的，这与我之前在本书
 
 # GAN 的安全选择
 
-我之前已经提到过 Soumith Chintala 的 [GAN hacks Git](https://github.com/soumith/ganhacks)，当您试图使 GAN 稳定时，这是一个很好的起点。 既然我们已经讨论了训练稳定的 GAN 会有多么困难，让我们来谈谈一些安全的选择，这些选择可能会帮助您成功找到自己的地方。 尽管有很多技巧，但以下是本章中尚未涵盖的我的主要建议：
+我之前已经提到过 Soumith Chintala 的 [GAN 黑魔法 Git](https://github.com/soumith/ganhacks)，当您试图使 GAN 稳定时，这是一个很好的起点。 既然我们已经讨论了训练稳定的 GAN 会有多么困难，让我们来谈谈一些安全的选择，这些选择可能会帮助您成功找到自己的地方。 尽管有很多技巧，但以下是本章中尚未涵盖的我的主要建议：
 
 *   **批量规范**：使用批量规范化时，请为真实数据和伪数据构造不同的微型批量，并分别进行更新。
 *   **泄漏的 ReLU**：泄漏的 ReLU 是 ReLU 激活功能的变异。 回想一下 ReLU 函数是`f(x) = max(0, x)`。
@@ -121,7 +121,7 @@ DCGAN 框架是使用迷你批量来进行训练的，这与我之前在本书
 *   **在生成器中使用丢弃**：这将产生噪声并防止模式崩溃。
 *   **使用软标签**：对于真实示例，请使用介于 0.7 和 1 之间的标签，对于伪示例，请使用介于 0 和 0.3 之间的标签。 这种噪声有助于保持信息从鉴别器流向生成器。
 
-在本章的其他地方，我们还将介绍许多其他的 GAN 黑客。 但是，我认为在成功实施 GAN 时，这几项技巧是最重要的。
+在本章的其他地方，我们还将介绍许多其他的 GAN 黑魔法。 但是，我认为在成功实施 GAN 时，这几项技巧是最重要的。
 
 # 使用 Keras GAN 生成 MNIST 图像
 
@@ -319,7 +319,7 @@ d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
 
 请注意，这里我使用的是鉴别符的`train_on_batch()`方法。 这是我第一次在本书中使用此方法。 `train_on_batch()`方法正好执行一轮正向和反向传播。 每次我们调用它时，它都会从模型的先前状态更新一次模型。
 
-另请注意，我正在分别对真实图像和伪图像进行更新。 这是我先前在“生成器体系结构”部分中引用的 GAN hack Git 上给出的建议。 尤其是在训练的早期阶段，当真实图像和伪图像来自完全不同的分布时，如果我们将两组数据放在同一更新中，则批量归一化将导致训练问题。
+另请注意，我正在分别对真实图像和伪图像进行更新。 这是我先前在“生成器体系结构”部分中引用的 GAN 黑魔法 Git 上给出的建议。 尤其是在训练的早期阶段，当真实图像和伪图像来自完全不同的分布时，如果我们将两组数据放在同一更新中，则批量归一化将导致训练问题。
 
 现在，鉴别器已经更新，是时候更新生成器了。 这是通过更新组合堆栈间接完成的，如以下代码所示：
 
@@ -330,7 +330,7 @@ g_loss = combined.train_on_batch(noise, np.ones((batch_size, 1)))
 
 为了更新组合模型，我们创建了一个新的噪声矩阵，这次它将与整个批次一样大。 我们将其用作堆栈的输入，这将使生成器生成图像，并使用鉴别器评估该图像。 最后，我们将使用`1`标签，因为我们想在实际图像和生成的图像之间反向传播错误。
 
-最后，训练循环报告`epoch` / `batch`处的鉴别器和生成器损失，然后每`epoch`中的每 50 批，我们将使用`save_imgs`生成示例图像并将其保存到磁盘，如以下代码所示：
+最后，训练循环报告`epoch`/`batch`处的鉴别器和生成器损失，然后每`epoch`中的每 50 批，我们将使用`save_imgs`生成示例图像并将其保存到磁盘，如以下代码所示：
 
 ```py
 print("Epoch %d Batch %d/%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" %
@@ -364,7 +364,7 @@ for j in range(c):
 
 # 模型评估
 
-当您构建深层神经网络来创建图像时，Good 有点主观。 让我们看一下训练过程的一些示例，以便您可以亲自了解 GAN 如何开始学习如何生成 MNIST。
+当您构建深层神经网络来创建图像时，好坏有点主观。 让我们看一下训练过程的一些示例，以便您可以亲自了解 GAN 如何开始学习如何生成 MNIST。
 
 这是第一个时代的第一批网络。 显然，此时生成器对生成 MNIST 并不了解。 只是噪音，如下图所示：