2020-12-17 22:44:27

new/ai-py/05.md

@@ -1126,7 +1126,7 @@ X_train, y_train = X[:num_training], y[:num_training]
 X_test, y_test = X[num_training:], y[num_training:] 
 ```
 
-使用线性核创建并训练支持向量回归器。 `C`参数代表训练错误的代价。 如果增加`C`的值，则模型将对其进行微调以适合训练数据。 但这可能会导致过拟合并使其失去通用性。 `epsilon`参数指定阈值； 如果预测值在与实际值的距离之内，则不会对训练错误造成任何损失：
+使用线性核创建并训练支持向量回归器。 `C`参数代表训练误差的代价。 如果增加`C`的值，则模型将对其进行微调以适合训练数据。 但这可能会导致过拟合并使其失去通用性。 `epsilon`参数指定阈值； 如果预测值在与实际值的距离之内，则不会对训练误差造成任何损失：
 
 ```py
 # Create Support Vector Regression model

new/ai-py/10.md

@@ -720,7 +720,7 @@ class MazeSolver(SearchProblem):
  super(MazeSolver, self).__init__(initial_state=self.initial) 
 ```
 
-覆盖`actions`方法。 在每个位置，我们需要检查前往相邻单元的成本，然后附加所有可能的操作。 如果相邻小区被阻止，则不考虑该操作：
+覆盖`actions`方法。 在每个位置，我们需要检查前往相邻单元的成本，然后附加所有可能的操作。 如果相邻单元被阻塞，则不考虑该操作：
 
 ```py
  # Define the method that takes actions 

new/ai-py/15.md

@@ -306,9 +306,9 @@ if __name__=='__main__':
 
 词袋模型的文本分析的主要目标之一是将文本转换为数字形式，以便我们可以在其上使用机器学习。 让我们考虑包含数百万个单词的文本文档。 为了分析这些文档，我们需要提取文本并将其转换为数字表示形式。
 
-机器学习算法需要使用数字数据，以便它们可以分析数据并提取有意义的信息。 这就是词袋模型的用处。该模型从文档中的所有单词中提取词汇，并使用文档术语矩阵构建模型。 这使我们可以将每个文档表示为*词袋*。 我们只是跟踪字数，而忽略语法细节和字序。
+机器学习算法需要使用数字数据，以便它们可以分析数据并提取有意义的信息。 这就是词袋模型的用处。该模型从文档中的所有单词中提取词汇，并使用文档项矩阵构建模型。 这使我们可以将每个文档表示为*词袋*。 我们只是跟踪字数，而忽略语法细节和字序。
 
-让我们看看文档术语矩阵的含义。 文档术语矩阵基本上是一个表，它为我们提供了文档中出现的各种单词的计数。 因此，文本文档可以表示为各个单词的加权组合。 我们可以设置阈值并选择更有意义的词。 在某种程度上，我们正在构建文档中所有单词的直方图，并将其用作特征向量。 该特征向量用于文本分类。
+让我们看看文档项矩阵的含义。 文档项矩阵基本上是一个表，它为我们提供了文档中出现的各种单词的计数。 因此，文本文档可以表示为各个单词的加权组合。 我们可以设置阈值并选择更有意义的词。 在某种程度上，我们正在构建文档中所有单词的直方图，并将其用作特征向量。 该特征向量用于文本分类。
 
 考虑以下句子：
 
@@ -380,7 +380,7 @@ for count, chunk in enumerate(text_chunks):
     chunks.append(d) 
 ```
 
-提取文档术语矩阵，从中获得每个单词的计数。 我们将使用`CountVectorizer`方法来实现这一点，该方法需要两个输入参数。 第一个参数是最小文档频率，第二个参数是最大文档频率。 频率是指单词在文本中出现的次数：
+提取文档项矩阵，从中获得每个单词的计数。 我们将使用`CountVectorizer`方法来实现这一点，该方法需要两个输入参数。 第一个参数是最小文档频率，第二个参数是最大文档频率。 频率是指单词在文本中出现的次数：
 
 ```py
 # Extract the document term matrix
@@ -405,7 +405,7 @@ for i in range(len(text_chunks)):
     chunk_names.append('Chunk-' + str(i+1)) 
 ```
 
-打印文档术语矩阵：
+打印文档项矩阵：
 
 ```py
 # Print the document term matrix
@@ -422,9 +422,9 @@ for word, item in zip(vocabulary, document_term_matrix.T):
 
 ![](img/B15441_15_05.png)
 
-图 5：文档术语矩阵输出
+图 5：文档项矩阵输出
 
-可以在词袋模型文档术语矩阵中看到所有单词以及每个块中相应的自发计数。
+可以在词袋模型文档项矩阵中看到所有单词以及每个块中相应的自发计数。
 
 现在我们已经对单词进行了计数，我们可以在此基础上开始基于单词的频率做出一些预测。
 
@@ -432,15 +432,15 @@ for word, item in zip(vocabulary, document_term_matrix.T):
 
 类别预测器用于预测给定文本所属的类别。 这在文本分类中经常用于对文本文档进行分类。 搜索引擎经常使用此工具按相关性对搜索结果进行排序。 例如，假设我们要预测给定的句子是属于体育，政治还是科学。 为此，我们建立了一个数据集并训练了一个算法。 然后可以将该算法用于推断未知数据。
 
-为了构建此预测变量，我们将使用一个称为**术语频率-文档反向频率**（**tf-idf**）的度量。 在文档集中，我们需要了解每个单词的重要性。 tf-idf 指标可帮助我们了解给定单词对文档集中的文档 t 的重要性。
+为了构建此预测变量，我们将使用一个称为**词频-文档反向频率**（**tf-idf**）的度量。 在文档集中，我们需要了解每个单词的重要性。 tf-idf 指标可帮助我们了解给定单词对文档集中的文档 t 的重要性。
 
-让我们考虑该指标的的第一部分。 **术语频率**（**tf**）基本上是，用于衡量每个单词在给定文档中出现的频率。 由于不同的文档具有不同的单词数，因此直方图中的确切数字将有所不同。 为了有一个公平的竞争环境，我们需要标准化直方图。 因此，我们将每个单词的计数除以给定文档中的单词总数，以获得词频。
+让我们考虑该指标的的第一部分。 **词频**（**tf**）基本上是，用于衡量每个单词在给定文档中出现的频率。 由于不同的文档具有不同的单词数，因此直方图中的确切数字将有所不同。 为了有一个公平的竞争环境，我们需要标准化直方图。 因此，我们将每个单词的计数除以给定文档中的单词总数，以获得词频。
 
 度量的第二部分是，**反向文档频率**（**idf**），它是一个单词在给定文档集中对文档的唯一性的度量。 当我们计算频率一词时，假设所有单词都同等重要。 但是我们不能仅仅依靠每个单词的频率，因为`and, or, the`以及等单词的出现很多。 为了平衡这些常见单词的频率，我们需要减少它们的权重并增加稀有单词的权重。 这也有助于我们识别每个文档唯一的单词，从而帮助我们制定独特的特征向量。
 
 要计算此统计信息，我们需要计算具有给定单词的文档数量的比率，并将其除以文档总数。 该比率实质上是包含给定单词的文档的一部分。 然后通过采用该比率的负算法来计算文档的逆向频率。
 
-然后，我们将术语频率和文档的逆频率结合起来，以制定特征向量来对文档进行分类。 这项工作是深入分析文本以获得更深层含义的基础，例如情感分析，文本上下文或主题分析。 让我们看看如何构建类别预测器。
+然后，我们将词频和文档的逆频率结合起来，以制定特征向量来对文档进行分类。 这项工作是深入分析文本以获得更深层含义的基础，例如情感分析，文本上下文或主题分析。 让我们看看如何构建类别预测器。
 
 创建一个新的 Python 文件并导入以下包：
 
@@ -468,7 +468,7 @@ training_data = fetch_20newsgroups(subset='train',
         categories=category_map.keys(), shuffle=True, random_state=5) 
 ```
 
-使用`CountVectorizer`对象提取术语计数：
+使用`CountVectorizer`对象提取单词计数：
 
 ```py
 # Build a count vectorizer and extract term counts
@@ -906,7 +906,7 @@ if __name__=='__main__':
     dict_tokens = corpora.Dictionary(tokens) 
 ```
 
-使用句子标记创建文档术语矩阵：
+使用句子标记创建文档项矩阵：
 
 ```py
  # Create a document-term matrix
@@ -956,6 +956,6 @@ if __name__=='__main__':
 
 在本章中，我们学习了自然语言处理中的各种基础概念。 我们讨论了标记化以及如何将输入文本分成多个标记。 我们学习了如何使用词干和词形还原将单词简化为基本形式。 我们实现了文本分块器，可根据预定义的条件将输入文本分为多个块。
 
-我们讨论了*词袋*模型，并为输入文本建立了文档术语矩阵。 然后，我们学习了如何使用机器学习对文本进行分类。 我们使用启发式方法构造了性别标识符。 我们还使用机器学习来分析电影评论的情感。 最后，我们讨论了主题建模并实现了一个用于识别给定文档中主题的系统。
+我们讨论了*词袋*模型，并为输入文本建立了文档项矩阵。 然后，我们学习了如何使用机器学习对文本进行分类。 我们使用启发式方法构造了性别标识符。 我们还使用机器学习来分析电影评论的情感。 最后，我们讨论了主题建模并实现了一个用于识别给定文档中主题的系统。
 
 在下一章中，我们将学习如何使用隐马尔可夫模型对序列数据进行建模，然后使用它们来分析股市数据。
\ No newline at end of file

new/ai-py/17.md

@@ -128,7 +128,7 @@ def read_data(input_file, index):
     date_indices = pd.date_range(start, end, freq='M') 
 ```
 
-使用时间戳创建一个 Pandas 数据系列：
+使用时间戳创建一个 Pandas 数据序列：
 
 ```py
  # Add timestamps to the input data to create time series data
@@ -302,7 +302,7 @@ data[(data['dim1'] < 45) & (data['dim2'] > 30)].plot()
 plt.title('dim1 < 45 and dim2 > 30') 
 ```
 
-我们也可以在 Pandas 中添加两个系列。 让我们在给定的开始日期和结束日期之间添加`dim1`和`dim2`：
+我们也可以在 Pandas 中添加两个序列。 让我们在给定的开始日期和结束日期之间添加`dim1`和`dim2`：
 
 ```py
 # Adding two dataframes 

new/ai-py/18.md

@@ -55,7 +55,7 @@ OpenCV 可以与 TensorFlow，PyTorch 和 Caffe 结合使用。
 
 帧差分是可用于识别视频中运动部分的最简单技术之一。 直观地，在大多数应用中，这是有趣的部分所在。 如果我们有一个跑步者的视频，我们可能想分析跑步者的跑步情况，而不是背景图像。 当我们看电影时，我们主要关注最前沿的人物在说话和做事时。 我们不会倾向于关注背景中无聊的相框。
 
-有时候，您会发现一个一次性的极客，会在隐藏在这种背景下的电影中发现问题，正如我们在《权力的游戏》的最新情节中几次看到，有人在背景中发现一杯星巴克，但这是例外而不是规则。
+有时候，您会发现一个一次性的极客，会在隐藏在这种背景下的电影中发现问题，正如我们在《权力的游戏》的最新剧情中几次看到，有人在背景中发现一杯星巴克，但这是例外而不是规则。
 
 当我们观看实时视频流时，从该流捕获的连续帧之间的差异为我们提供了很多信息。 让我们看看如何获​​取连续帧之间的差异并显示差异。 本节中的代码需要连接的摄像头，因此请确保您的计算机上装有摄像头。
 

new/ai-py/19.md

@@ -152,13 +152,13 @@ plt.show()
 
 图 2：训练进度图
 
-第二张屏幕截图使用错误指标表示训练进度：
+第二张屏幕截图使用误差指标表示训练进度：
 
 ![](img/B15441_19_03.png)
 
 图 3：训练误差图
 
-我们可以从前面的屏幕截图中观察到，在第四个时期结束时，错误降至`0`，这正是我们想要发生的情况。 如果错误为`0`，则无法进一步改善。 在下一部分中，我们将增强模型并创建单层神经网络。
+我们可以从前面的屏幕截图中观察到，在第四个时期结束时，误差降至`0`，这正是我们想要发生的情况。 如果误差为`0`，则无法进一步改善。 在下一部分中，我们将增强模型并创建单层神经网络。
 
 # 构建单层神经网络
 
@@ -270,7 +270,7 @@ for item in data_test:
 
 图 6：训练周期
 
-正如我们在“图 5”中看到的那样，错误迅速开始减少，这表明我们的训练有效地创造了越来越好的预测。 在这种情况下，错误不会降为零。 但是如果我们让模型再运行几个周期，我们预计误差将继续减少。 如果将这些测试数据点定位在 2D 图形上，则可以直观地验证预测输出的正确性。
+正如我们在“图 5”中看到的那样，误差迅速开始减少，这表明我们的训练有效地创造了越来越好的预测。 在这种情况下，误差不会降为零。 但是如果我们让模型再运行几个周期，我们预计误差将继续减少。 如果将这些测试数据点定位在 2D 图形上，则可以直观地验证预测输出的正确性。
 
 # 构建多层神经网络
 
@@ -388,7 +388,7 @@ plt.show()
 
 图 9：覆盖输入数据的输出图
 
-预测的输出似乎在一定程度上接近实际输入。 如果继续训练网络并减少错误，您将看到预测输出将与输入曲线相匹配，即使重新仍很准确。
+预测的输出似乎在一定程度上接近实际输入。 如果继续训练网络并减少误差，您将看到预测输出将与输入曲线相匹配，即使重新仍很准确。
 
 您还应该看到打印出以下内容：
 
@@ -654,7 +654,7 @@ if __name__=='__main__':
 
 图 15：训练周期
 
-如您所见，错误持续减小，直到达到训练次数的最大值。 到此结束了本节，我们展示了如何使用 RNN 来分析时间序列数据。 在下一部分中，我们将通过研究光学字符识别来演示神经网络的实际应用。
+如您所见，误差持续减小，直到达到训练次数的最大值。 到此结束了本节，我们展示了如何使用 RNN 来分析时间序列数据。 在下一部分中，我们将通过研究光学字符识别来演示神经网络的实际应用。
 
 # 可视化光学字符识别数据库中的字符
 

new/ai-py/22.md

@@ -313,7 +313,7 @@ $ python3 balancer.py --input-env cartpole
 
 图 12：绘图输出
 
-不同的情节需要完成不同的步骤。 如果您滚动查看打印出来的信息，您将能够看到。 希望，当您运行本示例时，您至少在大多数情况下都会看到棘突。 凭借在本章中获得的知识，我认为我们还没有准备好在 Go 的游戏中击败 AlphaZero。 但是我们了解了如何构建此类系统的基础知识。
+不同的剧集需要完成不同的步骤。 如果您滚动查看打印出来的信息，您将能够看到。 希望，当您运行本示例时，您至少在大多数情况下都会看到棘突。 凭借在本章中获得的知识，我认为我们还没有准备好在 Go 的游戏中击败 AlphaZero。 但是我们了解了如何构建此类系统的基础知识。
 
 # 总结
 

new/gan-proj/4.md

@@ -28,7 +28,7 @@
 
 CNN 在计算机视觉任务中非常出色，无论是用于分类图像还是检测图像中的对象。 CNN 善于理解图像，以至于激发研究人员在 GAN 网络中使用 CNN。 最初，GAN 官方论文的作者介绍了仅具有密集层的**深层神经网络**（**DNN**）。 在 GAN 网络的原始实现中未使用卷积层。 在以前的 GAN 中，生成器和判别器网络仅使用密集的隐藏层。 相反，作者建议在 GAN 设置中可以使用不同的神经网络架构。
 
-DCGAN 扩展了在判别器和生成器网络中使用卷积层的思想。 DCGAN 的设置类似于朴素 GAN。 它由两个网络组成：生成器和判别器。 生成器是具有卷积层的 DNN，而判别器是具有卷积层的 DNN。 训练 DCGAN 类似于训练普通 GAN 网络。 在第一章中，我们了解到网络参与了非合作博弈，其中判别器网络将其错误反向传播到生成器网络，生成器网络使用此错误来提高其权重。
+DCGAN 扩展了在判别器和生成器网络中使用卷积层的思想。 DCGAN 的设置类似于朴素 GAN。 它由两个网络组成：生成器和判别器。 生成器是具有卷积层的 DNN，而判别器是具有卷积层的 DNN。 训练 DCGAN 类似于训练普通 GAN 网络。 在第一章中，我们了解到网络参与了非合作博弈，其中判别器网络将其误差反向传播到生成器网络，生成器网络使用此误差来提高其权重。
 
 在下一部分中，我们将探索两个网络的架构。
 

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

@@ -491,9 +491,9 @@ syn = poisson.rvs(mu, size=2000)
 
 强化学习方案可以看作是一种有监督的方案，其中隐藏的老师在模型的每个决定之后仅提供近似的反馈。 更正式地讲，强化学习的特征在于主体与环境之间的持续交互。 前者负责制定决策（行动），并最终确定其结果以增加回报，而后者则负责为每项行动提供反馈。 反馈通常被认为是一种奖励，其值可以是积极的（行动已经成功）或消极的（行动不应重复）。 当智能体分析环境（状态）的不同配置时，必须将每个奖励都视为绑定到元组（动作，状态）。 因此，最终目标是找到一个最大化预期总回报的策略（一种建议在每个州采取最佳行动的策略）。
 
-强化学习的一个非常经典的例子是学习如何玩游戏的智能体。 在情节期间，智能体会在所有遇到的状态下测试动作并收集奖励。 一种算法会纠正该策略，以减少非积极行为（即那些奖励为正的行为）的可能性，并增加在情节结束时可获得的预期总奖励。
+强化学习的一个非常经典的例子是学习如何玩游戏的智能体。 在剧集期间，智能体会在所有遇到的状态下测试动作并收集奖励。 一种算法会纠正该策略，以减少非积极行为（即那些奖励为正的行为）的可能性，并增加在剧集结束时可获得的预期总奖励。
 
-强化学习有许多有趣的应用，而不仅限于游戏。 例如，推荐系统可以根据用户提供的二进制反馈（例如，拇指向上或向下）来校正建议。 强化学习和监督学习之间的主要区别是环境提供的信息。 实际上，在有监督的情况下，校正通常与校正成比例，而在强化学习中，必须考虑一系列操作和将来的奖励来进行分析。 因此，校正通常基于预期奖励的估计，并且其效果受后续操作的值影响。 例如，一个受监督的模型没有记忆，因此它的修正是即时的，而强化学习智能体必须考虑情节的部分推出，以便确定一个动作是否实际上是负面的。
+强化学习有许多有趣的应用，而不仅限于游戏。 例如，推荐系统可以根据用户提供的二进制反馈（例如，拇指向上或向下）来校正建议。 强化学习和监督学习之间的主要区别是环境提供的信息。 实际上，在有监督的情况下，校正通常与校正成比例，而在强化学习中，必须考虑一系列操作和将来的奖励来进行分析。 因此，校正通常基于预期奖励的估计，并且其效果受后续操作的值影响。 例如，一个受监督的模型没有记忆，因此它的修正是即时的，而强化学习智能体必须考虑剧集的部分推出，以便确定一个动作是否实际上是负面的。
 
 强化学习是机器学习的一个有趣的分支。 不幸的是，该主题超出了本文的讨论范围，因此我们不对其进行详细讨论（您可以在《Python 强化学习实用指南》中找到更多详细信息）。
 

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

@@ -91,7 +91,7 @@
 
 ![](img/a7e8b29a-189f-44d6-b5b1-1f03e08ebd2d.png)
 
-很明显（并且很容易证明），如果`|x[1]^j - x[2]^j|`是最大的组件绝对差，`p → ∞`，`d[p](x[c] , x) → |x[1]^j - x[2]^j|`。 这意味着，如果考虑由于所有组件的差异而导致的相似性（或相异性），则需要为`p`选择一个较小的值（例如`p = 1`或`2`）。 另一方面，如果必须仅根据组件之间的最大绝对差将两个样本视为不同，则`p`的较高值是合适的。 通常，此选择非常依赖于上下文，并且不能轻易概括。 为了我们的目的，我们通常只考虑欧几里得距离，这在大多数情况下是合理的。 另一方面，当`N → ∞`时，为`p`选择更大的值具有重要的意义。 让我们从一个例子开始。 对于不同的`p`和`N`值，我们要测量`1N`向量 （属于`ℜ^N`且所有分量均等于 1 的向量）到原点的距离 （使用对数标度压缩`y`轴）。 如下：
+很明显（并且很容易证明），如果`|x[1]^j - x[2]^j|`是最大的组件绝对差，`p → ∞`，`d[p](x[c] , x) → |x[1]^j - x[2]^j|`。 这意味着，如果考虑由于所有组件的差异而导致的相似性（或相异性），则需要为`p`选择一个较小的值（例如`p = 1`或`2`）。 另一方面，如果必须仅根据组件之间的最大绝对差将两个样本视为不同，则`p`的较高值是合适的。 通常，此选择非常依赖于上下文，并且不能轻易概括。 为了我们的目的，我们通常只考虑欧几里得距离，这在大多数情况下是合理的。 另一方面，当`N → ∞`时，为`p`选择更大的值具有重要的意义。 让我们从一个例子开始。 对于不同的`p`和`N`值，我们要测量`1N`向量 （属于`ℜ^N`且所有分量均等于 1 的向量）到原点的距离 （使用对数刻度压缩`y`轴）。 如下：
 
 ```py
 import numpy as np

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

@@ -329,7 +329,7 @@ CPC Average linkage: 0.794
 
 现在，让我们考虑一个更大的数据集上的更详细的问题（在本章开头的“技术要求”部分中提供了下载说明），其中包含 527 个样本，其中有 38 个化学和物理变量描述了水处理厂的状态。 正如同一作者（ Bejar，Cortes 和 Poch）所述，该域的结构较差，需要仔细分析。 同时，我们的目标是使用不可知论的方法找到最佳的聚类。 换句话说，我们将不考虑语义标记过程（需要领域专家），而仅考虑数据集的几何结构以及通过聚集算法发现的关系。
 
-下载后，可以使用 Pandas 加载 CSV 文件（称为`water-treatment.data`）（当然，必须更改术语`<DATA_PATH>`才能指向文件的确切位置）。 第一列是与特定工厂相关的索引，而所有其他值都是数字，可以转换为`float64`。 缺少的值用`'?'` 字符表示，并且由于我们没有其他信息，因此将每个属性的均值设置为：
+下载后，可以使用 Pandas 加载 CSV 文件（称为`water-treatment.data`）（当然，必须更改项目`<DATA_PATH>`才能指向文件的确切位置）。 第一列是与特定工厂相关的索引，而所有其他值都是数字，可以转换为`float64`。 缺少的值用`'?'` 字符表示，并且由于我们没有其他信息，因此将每个属性的均值设置为：
 
 ```py
 import pandas as pd

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

@@ -703,7 +703,7 @@ Gaussian 2:
 
 最终配置，经过 10 次迭代
 
-可以看到，两个高斯函数均已成功优化，并且它们能够从充当**受信任指南**的几个标记样本开始生成整个数据集。 这种方法非常强大，因为它允许我们在不做任何修改的情况下将一些先验知识包括在模型中。 但是，由于标记的样本具有等于 1 的固定概率，因此该方法在异常值方面不是非常可靠。 如果样本尚未通过数据生成过程生成或受噪声影响，则可能导致模型放错高斯分布。 但是，通常不应该考虑这种情况，因为任何先验知识（包括在估计中）都必须进行预评估，以检查其是否可靠。 这样的步骤是必要的，以避免强迫模型仅学习原始数据生成过程的一部分的风险。 相反，当标记的样本真正代表了潜在的过程时，它们的包含减少了错误并加快了收敛速度。 我邀请读者在引入一些噪声点（例如（-20，-10））之后重复该示例，并比较一些未标记的测试样本的概率。
+可以看到，两个高斯函数均已成功优化，并且它们能够从充当**受信任指南**的几个标记样本开始生成整个数据集。 这种方法非常强大，因为它允许我们在不做任何修改的情况下将一些先验知识包括在模型中。 但是，由于标记的样本具有等于 1 的固定概率，因此该方法在异常值方面不是非常可靠。 如果样本尚未通过数据生成过程生成或受噪声影响，则可能导致模型放错高斯分布。 但是，通常不应该考虑这种情况，因为任何先验知识（包括在估计中）都必须进行预评估，以检查其是否可靠。 这样的步骤是必要的，以避免强迫模型仅学习原始数据生成过程的一部分的风险。 相反，当标记的样本真正代表了潜在的过程时，它们的包含减少了误差并加快了收敛速度。 我邀请读者在引入一些噪声点（例如（-20，-10））之后重复该示例，并比较一些未标记的测试样本的概率。
 
 
 

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

@@ -698,7 +698,7 @@ p = 0.00000 - High risk
 
 支持向量机中的决策过程
 
-权向量正交于分离超平面。 样本`x[i]`被确定为一个正常值，因为点积为正且大于阈值`ρ`。 相反，`x[j]`被标记为异常值，因为决策函数的符号为负。 术语`ξ[i] ≥ 0`被称为松弛变量，它们的引入是为了产生异常值和正常值间的更灵活的边界。实际上，如果这些变量都等于零（并且为简单起见，`ρ = 1`），则优化问题的条件变为：
+权向量正交于分离超平面。 样本`x[i]`被确定为一个正常值，因为点积为正且大于阈值`ρ`。 相反，`x[j]`被标记为异常值，因为决策函数的符号为负。 项`ξ[i] ≥ 0`被称为松弛变量，它们的引入是为了产生异常值和正常值间的更灵活的边界。实际上，如果这些变量都等于零（并且为简单起见，`ρ = 1`），则优化问题的条件变为：
 
 ![](img/5a35ab70-84af-4bd0-aec6-dc88a81ec8ad.png)
 

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

@@ -427,7 +427,7 @@ Factor Analysis log-likelihood(Xnz): 1459.2912218162423
 
 ![](img/6d321ec9-2ff5-4b21-8c88-e47d435bf51a.png)
 
-在前面的表达式中，系数`$1[$2]`几乎总是不为零，因此所有组件都参与重建过程。 出于降维的目的，这不是问题，因为为了限制它们，我们对每个组件解释的方差更感兴趣。 但是，在某些任务下，分析每个较大的**构建原子**很有帮助，并假设每个向量都可以表示为它们的稀疏组合。 最经典的例子是文本语料库，其中词典包含的术语比每个文档中涉及的术语更多。 这些类型的模型通常称为**字典学习**算法，因为原子集定义了一种字典，其中包含可用于创建新样本的所有单词。 当原子数`k`大于样本的维数`n`时，该字典被称为**过度完成**，其表示通常是稀疏的。 相反，当`k < n`时，字典被称为**尚未完成**，并且向量需要更密集。
+在前面的表达式中，系数`$1[$2]`几乎总是不为零，因此所有组件都参与重建过程。 出于降维的目的，这不是问题，因为为了限制它们，我们对每个组件解释的方差更感兴趣。 但是，在某些任务下，分析每个较大的**构建原子**很有帮助，并假设每个向量都可以表示为它们的稀疏组合。 最经典的例子是文本语料库，其中词典包含的项目比每个文档中涉及的项目更多。 这些类型的模型通常称为**字典学习**算法，因为原子集定义了一种字典，其中包含可用于创建新样本的所有单词。 当原子数`k`大于样本的维数`n`时，该字典被称为**过度完成**，其表示通常是稀疏的。 相反，当`k < n`时，字典被称为**尚未完成**，并且向量需要更密集。
 
 通过对函数的最小化，对解决方案的`L[1]`范数施加惩罚，可以轻松解决此类学习问题。 这种限制导致稀疏性的原因不在本书的讨论范围之内，但是有兴趣的人可以在《Mastering Machine Learning Algorithms》中找到更长的讨论范围。 
 
@@ -625,7 +625,7 @@ ica.fit(faces['data'])
 
 ![](img/4e47e13c-2fba-4f37-9b1b-7105ac0113fe.png)
 
-这意味着主题之间的单词分布也很少。 因此，我们具有完整的联合概率（单词，主题），并且我们想要确定条件概率`p(w[i] | t[k])`和`p(t[k] | w[i])`。 换句话说，给定一个文档，它是术语的集合（每个术语都有边际概率`p(w[i])`计算此类文档属于特定主题的概率。 由于一个文档被轻柔地分配给所有主题（也就是说，它可以在不同程度上属于一个以上的主题），因此我们需要考虑一个稀疏的主题文档分布，其中的主题组合（`$1[$2]`）被绘制为：
+这意味着主题之间的单词分布也很少。 因此，我们具有完整的联合概率（单词，主题），并且我们想要确定条件概率`p(w[i] | t[k])`和`p(t[k] | w[i])`。 换句话说，给定一个文档，它是项目的集合（每个项目都有边际概率`p(w[i])`计算此类文档属于特定主题的概率。 由于一个文档被轻柔地分配给所有主题（也就是说，它可以在不同程度上属于一个以上的主题），因此我们需要考虑一个稀疏的主题文档分布，其中的主题组合（`$1[$2]`）被绘制为：
 
 ![](img/e168ebe0-4213-45f5-aa01-83a00d2af0b0.png)
 
@@ -717,7 +717,7 @@ eventual
 agressive
 ```
 
-易于理解（考虑一些非常特殊的术语），已将`Topic 0`分配给`comp.sys.mac.hardware` ，将另一个分配给`rec.autos`（不幸的是，此过程不能基于自动检测，因为语义必须由人解释）。 为了评估模型，让我们考虑两个示例消息，如下所示：
+易于理解（考虑一些非常特殊的项目），已将`Topic 0`分配给`comp.sys.mac.hardware` ，将另一个分配给`rec.autos`（不幸的是，此过程不能基于自动检测，因为语义必须由人解释）。 为了评估模型，让我们考虑两个示例消息，如下所示：
 
 ```py
 print(corpus[100])

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

@@ -78,7 +78,7 @@
 
 ![](img/889fb37b-214d-4bd3-9e6d-d74c5343ae91.png)
 
-由于`p_data`的熵是一个常数，因此可以通过优化过程将其排除； 因此，散度的最小化等于`p_data`和`q`之间的交叉熵最小化。 如果假设`p_data`和`q`为高斯，则 Kullback-Leibler 成本函数等效于均方误差。 在某些情况下，当数据在`(0, 1)`范围内归一化时，可以对`p_data`和`q`采用伯努利分布。 形式上，这不是完全正确的，因为伯努利分布是二进制的，并且`x[i] ∈ {0, 1}^d`； 但是，使用 S 型输出单元还可以保证连续样本的成功优化， `x[i] ∈ (0, 1)^d`。 在这种情况下，成本函数变为：
+由于`p_data`的熵是一个常数，因此可以通过优化过程将其排除； 因此，散度的最小化等于`p_data`和`q`之间的交叉熵最小化。 如果假设`p_data`和`q`为高斯，则 Kullback-Leibler 成本函数等效于均方误差。 在某些情况下，当数据在`(0, 1)`范围内归一化时，可以对`p_data`和`q`采用伯努利分布。 形式上，这不是完全正确的，因为伯努利分布是二进制的，并且`x[i] ∈ {0, 1}^d`； 但是，使用 Sigmoid 输出单元还可以保证连续样本的成功优化， `x[i] ∈ (0, 1)^d`。 在这种情况下，成本函数变为：
 
 ![](img/72f5d9d6-18c3-4216-b4e1-af7a8143feab.png)
 
@@ -1021,7 +1021,7 @@ Final covariance matrix: [[28.9963492 0.31487817]
 
 ![](img/fec60140-16e2-454b-a5dd-61909bce0d08.png)
 
-该公式的主要假设是所有神经元都是伯努利分布的（即`x[i], h[j] ~ B(0, 1)`） 术语`b[i]`和`c[j]`是可观察和潜在单位的偏差。 给定数据生成过程`p_data`，必须优化 RBM，以便`p(x; θ)`的可能性最大化。 跳过所有中间步骤（可以在前面的文章中找到），可以证明以下几点：
+该公式的主要假设是所有神经元都是伯努利分布的（即`x[i], h[j] ~ B(0, 1)`） 项`b[i]`和`c[j]`是可观察和潜在单位的偏差。 给定数据生成过程`p_data`，必须优化 RBM，以便`p(x; θ)`的可能性最大化。 跳过所有中间步骤（可以在前面的文章中找到），可以证明以下几点：
 
 ![](img/e1cdc672-50a0-425c-8811-603832e1b5dd.png)
 

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

@@ -352,7 +352,7 @@ with graph.as_default():
 
 ![](img/cc9c07fc-72da-4fae-b60c-9c17149f81cc.png)
 
-相反，`loss_d_2`恰好需要 S 型交叉熵的第二项。 因此，我们将所有标签设置为零，以获得损失函数：
+相反，`loss_d_2`恰好需要 Sigmoid 交叉熵的第二项。 因此，我们将所有标签设置为零，以获得损失函数：
 
 ![](img/4bebedd1-9438-42e7-aae9-c18aa72d2a49.png)
 

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

@@ -120,7 +120,7 @@
 3.  不，他们不是。 PCA 之后的协方差矩阵不相关，但不能保证统计独立性。
 4.  是; `Kurt(X)`的分布是超高斯分布，因此达到峰值且尾巴很重。 这样可以保证找到独立的组件。
 5.  由于`X`包含负数，因此无法使用 NNMF 算法。
-6.  否; 由于字典有 10 个元素，因此意味着文档由许多重复出现的术语组成，因此字典不够完整（ `10 < 30`）。
+6.  否; 由于字典有 10 个元素，因此意味着文档由许多重复出现的项目组成，因此字典不够完整（ `10 < 30`）。
 7.  样本`(x, y) ∈ R^2`通过二次多项式变换为`(ax, by, cx^2, dy^2, exy, f) ∈ R^6`。
 
 

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

@@ -54,7 +54,7 @@
 
 图 2.1：由文件夹或狗的品种分开的狗集图像
 
-您可以下载数据集，然后在 Mac 上运行`retrain.py`脚本，因为该脚本在相对位置上运行不会花费太长时间（少于一小时） 小型数据集（总共约 20,000 张图像），但是，如上一章所述，如果您在 GPU 驱动的 Ubuntu 上执行此操作，则该脚本仅需几分钟即可完成。 此外，当使用大型图像数据集进行再培训时，在 Mac 上运行可能需要花费数小时或数天，因此在 GPU 驱动的计算机上运行它是有意义的。
+您可以下载数据集，然后在 Mac 上运行`retrain.py`脚本，因为该脚本在相对位置上运行不会花费太长时间（少于一小时） 小型数据集（总共约 20,000 张图像），但是，如上一章所述，如果您在 GPU 驱动的 Ubuntu 上执行此操作，则该脚本仅需几分钟即可完成。 此外，当使用大型图像数据集进行再训练时，在 Mac 上运行可能需要花费数小时或数天，因此在 GPU 驱动的计算机上运行它是有意义的。
 
 假设您已经创建了`/tf_file`目录和`/tf_file/dogs_bottleneck`目录，那么重新训练模型的命令如下：
 
@@ -98,9 +98,9 @@ INFO:tensorflow:Final test accuracy = 91.0% (N=2109)
 
 训练精度是神经网络用于训练的图像上的分类精度，而验证精度是神经网络未用于训练的图像上的验证精度。 因此，验证准确度是衡量模型准确度的一种更可靠的度量，并且通常应该比训练准确度小一点，但是如果训练收敛并进行得很好，也就是说，训练的模型是否既不欠拟合也不过拟合。
 
-如果火车精度很高，但验证精度仍然很低，则意味着模型过拟合。 如果火车精度仍然很低，则表明模型不适合。 同样，交叉熵是损失函数值，如果再训练顺利进行，则总体上应该越来越小。 最后，测试准确性取决于尚未用于训练或验证的图像。 通常，这是我们可以说出的关于重新训练模型的最准确的值。
+如果训练精度很高，但验证精度仍然很低，则意味着模型过拟合。 如果训练精度仍然很低，则表明模型不适合。 同样，交叉熵是损失函数值，如果再训练顺利进行，则总体上应该越来越小。 最后，测试准确性取决于尚未用于训练或验证的图像。 通常，这是我们可以说出的关于重新训练模型的最准确的值。
 
-如前面的输出所示，在再训练结束时，我们看到验证精度与火车精度相似（90% 和 93%，相比之初为 3% 和 21%），最终测试精度为 91%  。 交叉熵也从开始时的 4.767 下降到最后的 0.379。 因此，我们现在有了一个很好的再训练狗品种识别模型。
+如前面的输出所示，在再训练结束时，我们看到验证精度与训练精度相似（90% 和 93%，相比之初为 3% 和 21%），最终测试精度为 91%  。 交叉熵也从开始时的 4.767 下降到最后的 0.379。 因此，我们现在有了一个很好的再训练狗品种识别模型。
 
 为了进一步提高准确性，您可以使用`retrain.py`的其他参数（例如训练步骤） (`--how_many_training_steps`)，学习率(`--learning_rate`)，和数据扩充(`--flip_left_right`, `--random_crop`, `--random_scale`, `--random_brightness`). 通常，这是一个乏味的过程，涉及到许多“肮脏的工作”，这是最著名的深度学习专家之一 Andrew Ng 在他的“应用深度学习的基本原理”演讲中提到的（[视频可在以下位置找到](https://www.youtube.com/watch?v=F1ka6a13S9I)）。
 

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

@@ -666,7 +666,7 @@ for (int i=0; i<CAPTION_LEN; i++) {
 }
 ```
 
-我们可能从未详细解释过如何在 C++ 中获取和设置 TensorFlow 张量值。 但是，如果您到目前为止已经阅读了本书中的代码，那么您应该已经学会了。 这就像 RNN 学习：如果您接受了足够的代码示例培训，就可以编写有意义的代码。 总而言之，首先使用`Tensor`类型定义变量，并使用该变量的数据类型和形状指定，然后调用`Tensor`类的`tensor`方法，传入数据类型的 C++ 版本和形状，以创建张量的贴图变量。 之后，您可以简单地使用映射来获取或设置张量的值。
+我们可能从未详细解释过如何在 C++ 中获取和设置 TensorFlow 张量值。 但是，如果您到目前为止已经阅读了本书中的代码，那么您应该已经学会了。 这就像 RNN 学习：如果您接受了足够的代码示例训练，就可以编写有意义的代码。 总而言之，首先使用`Tensor`类型定义变量，并使用该变量的数据类型和形状指定，然后调用`Tensor`类的`tensor`方法，传入数据类型的 C++ 版本和形状，以创建张量的贴图变量。 之后，您可以简单地使用映射来获取或设置张量的值。
 
 12.  最后，只需遍历`captions`向量并将向量中存储的每个词 ID 转换为一个词，然后将该词添加到`sentence`字符串中，而忽略起始 ID 和结束 ID，然后返回该句子，希望是可读的自然语言：
 

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

@@ -28,7 +28,7 @@ GAN 是学习生成类似于真实数据或训练集中数据的神经网络。
 *   当以生成器的输出作为输入时，使其输出的可能性为实，尽可能接近 0.0，这恰好是生成器的相反目标
 *   当输入真实数据作为输入时，使其输出的可能性为实数，尽可能接近 1.0
 
-在下一节中，您将看到与生成器和鉴别器网络及其训练过程的给定描述相匹配的详细代码片段。 如果您想了解更多关于 GAN 的知识，除了这里的摘要概述之外，您还可以在 YouTube 上搜索“GAN 简介”，并观看 2016 年 NIPS（神经信息处理系统）和 ICCV（国际计算机视觉会议）2017 大会上的 Ian Goodfellow 的 GAN 入门和教程视频。 事实上，YouTube 上有 7 个 NIPS 2016 对抗训练培训班视频和 12 个 ICCV 2017 GAN 指导视频，您可以自己投入其中。
+在下一节中，您将看到与生成器和鉴别器网络及其训练过程的给定描述相匹配的详细代码片段。 如果您想了解更多关于 GAN 的知识，除了这里的摘要概述之外，您还可以在 YouTube 上搜索“GAN 简介”，并观看 2016 年 NIPS（神经信息处理系统）和 ICCV（国际计算机视觉会议）2017 大会上的 Ian Goodfellow 的 GAN 入门和教程视频。 事实上，YouTube 上有 7 个 NIPS 2016 对抗训练训练班视频和 12 个 ICCV 2017 GAN 指导视频，您可以自己投入其中。
 
 在生成者和区分者两个参与者的竞争目标下，GAN 是一个寻求两个对手之间保持平衡的系统。 如果两个玩家都具有无限的能力并且可以进行最佳训练，那么纳什均衡（继 1994 年诺贝尔经济学奖得主约翰·纳什和电影主题《美丽心灵》之后） 一种状态，在这种状态下，任何玩家都无法通过仅更改其自己的策略来获利，这对应于生成器生成数据的状态，该数据看起来像真实数据，而判别器无法从假数据中分辨真实数据。
 

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

@@ -111,7 +111,7 @@ pip install keras
 
 图 10.1：深度残差网络的第一层
 
-值得注意的是，神经网络称为残差网络（ResNet），由 Microsoft 于 2015 年在 ImageNet 和 COCO 2015 竞赛的获奖作品中引入。 在 ResNet 中，使用身份映射（图 10.1 右侧的箭头）可避免在网络越深时出现更高的训练错误。 有关 ResNet 的更多信息，您可以查看原始论文[《用于图像识别的深度残差学习》](https://arxiv.org/pdf/1512.03385v1.pdf)， 以及博客[《了解深度残差网络》](https://blog.waya.ai/deep-residual-learning-9610bb62c355) - 一个简单的模块化学习框架，它重新定义了构成最新技术的内容。
+值得注意的是，神经网络称为残差网络（ResNet），由 Microsoft 于 2015 年在 ImageNet 和 COCO 2015 竞赛的获奖作品中引入。 在 ResNet 中，使用身份映射（图 10.1 右侧的箭头）可避免在网络越深时出现更高的训练误差。 有关 ResNet 的更多信息，您可以查看原始论文[《用于图像识别的深度残差学习》](https://arxiv.org/pdf/1512.03385v1.pdf)， 以及博客[《了解深度残差网络》](https://blog.waya.ai/deep-residual-learning-9610bb62c355) - 一个简单的模块化学习框架，它重新定义了构成最新技术的内容。
 
 深度网络的最后一层如图 10.2 所示，您可以看到，在最后的残差块和具有批量归一化和 ReLU 层的卷积层之后，将应用密集的全连接层以输出`value_head and policy_head`值：
 

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

@@ -534,7 +534,7 @@ Out[4]: '0.10.4'
 
 CartPole 是一种可用于训练机器人以保持平衡的环境-如果它携带某些东西并希望在移动时保持其放置状态。 由于本章的范围，我们将仅构建在模拟 CartPole 环境中工作的模型，但是可以肯定地将模型以及模型的构建和训练方式应用于类似于 CartPole 的实际物理环境。
 
-在 CartPole 环境中，将杆连接到推车，该推车沿轨道水平移动。 您可以对购物车执行 1（向右加速）或 0（向左加速）操作。 杆子开始直立，目的是防止其跌落。 杆保持直立的每个时间步长都奖励 1。 当极点与垂直方向的夹角超过 15 度，或者手推车从中心移出 2.4 个单位以上时，情节就会结束。
+在 CartPole 环境中，将杆连接到推车，该推车沿轨道水平移动。 您可以对购物车执行 1（向右加速）或 0（向左加速）操作。 杆子开始直立，目的是防止其跌落。 杆保持直立的每个时间步长都奖励 1。 当极点与垂直方向的夹角超过 15 度，或者手推车从中心移出 2.4 个单位以上时，剧集就会结束。
 
 现在让我们使用 CartPole 环境。 首先，创建一个新环境并找出智能体可以在该环境中采取的措施：
 
@@ -554,7 +554,7 @@ obs
 # array([ 0.04052535, 0.00829587, -0.03525301, -0.00400378])
 ```
 
-环境中的每个步骤（动作）将导致新的观察，动作的奖励，情节是否完成（如果是，则您无法采取任何进一步的步骤）以及一些其他信息：
+环境中的每个步骤（动作）将导致新的观察，动作的奖励，剧集是否完成（如果是，则您无法采取任何进一步的步骤）以及一些其他信息：
 
 ```py
 obs, reward, done, info = env.step(1)
@@ -563,7 +563,7 @@ obs
 # array([ 0.04069127, 0.2039052 , -0.03533309, -0.30759772])
 ```
 
-记住动作（或步骤）1 表示向右移动，0 表示向左移动。 要查看当您继续向右移动购物车时情节可以持续多长时间，请运行：
+记住动作（或步骤）1 表示向右移动，0 表示向左移动。 要查看当您继续向右移动购物车时剧集可以持续多长时间，请运行：
 
 ```py
 while not done:
@@ -577,7 +577,7 @@ while not done:
 #[ 0.18298552 1.77178219 -0.25898254 -2.87789912]
 ```
 
-现在，让我们手动执行从头到尾的一系列操作，并打印出观测值的第一个值（水平位置）和第三个值（极点与垂直方向的度数），因为这两个值确定一个情节是否为完成。
+现在，让我们手动执行从头到尾的一系列操作，并打印出观测值的第一个值（水平位置）和第三个值（极点与垂直方向的度数），因为这两个值确定一个剧集是否为完成。
 
 首先，重置环境并正确加速购物车几次：
 
@@ -649,7 +649,7 @@ obs[0], obs[2]*360/np.pi
 # (-0.02739315127299434, 10.619948631208114)
 ```
 
-如我们前面所述，定义 CartPole 环境的方式是情节“当极距与垂直方向成 15 度以上时结束”，因此让我们再做一些动作并打印出`done`值， 时间：
+如我们前面所述，定义 CartPole 环境的方式是剧集“当极距与垂直方向成 15 度以上时结束”，因此让我们再做一些动作并打印出`done`值， 时间：
 
 ```py
 obs, reward, done, info = env.step(0)
@@ -668,7 +668,7 @@ obs, reward, done, info = env.step(0)
 # WARN: You are calling 'step()' even though this environment has already returned done = True. You should always call 'reset()' once you receive 'done = True' -- any further steps are undefined behavior.
 ```
 
-环境决定何时将`done`返回`True`时会有一些延迟-尽管前两个步骤已经返回了大于 15 度的度数（当极点与垂直线成 15 度以上时，情节结束了） ，您仍然可以对环境执行 0 操作。 第三步将`done`返回为`True`，并且环境中的另一步骤（最后一步）将导致警告，因为环境已经完成了该情节。
+环境决定何时将`done`返回`True`时会有一些延迟-尽管前两个步骤已经返回了大于 15 度的度数（当极点与垂直线成 15 度以上时，剧集结束了） ，您仍然可以对环境执行 0 操作。 第三步将`done`返回为`True`，并且环境中的另一步骤（最后一步）将导致警告，因为环境已经完成了该剧集。
 
 对于 CartPole 环境，每个`step`调用返回的`reward`值始终为 1，信息始终为{}。 这就是关于 CartPole 模拟环境的全部知识。 现在我们了解了 CartPole 的工作原理，让我们看看可以在每种状态（观察）下制定什么样的策略，我们可以让该策略告诉我们要采取的操作（步骤），以便我们可以保持杆直立。换句话说，就是尽可能长的时间，这样我们才能最大化我们的回报。 请记住，强化学习中的一项策略只是一个函数，该函数以智能体所处的状态为输入，并输出智能体接下来应采取的行动，以实现值最大化或长期回报。
 
@@ -680,7 +680,7 @@ obs, reward, done, info = env.step(0)
 
 
 
-显然，每次都执行相同的动作（全 0 或 1s）不会使杆保持太直的状态。 为了进行基线比较，请运行以下代码，以查看在每个情节中应用相同操作时在 1,000 个情节中获得的平均奖励：
+显然，每次都执行相同的动作（全 0 或 1s）不会使杆保持太直的状态。 为了进行基线比较，请运行以下代码，以查看在每个剧集中应用相同操作时在 1,000 个剧集中获得的平均奖励：
 
 ```py
 # single_minded_policy.py
@@ -847,7 +847,7 @@ with tf.Session() as sess:
 
 策略梯度的基本思想是，为了训练神经工作以生成更好的策略，当所有智能体从环境中知道的都是从任何给定状态采取行动时所能获得的奖励（这意味着我们不能使用监督学习进行训练），我们可以采用两种新机制：
 
-*   折扣奖励：每个动作的值都需要考虑其未来动作的奖励。 例如，一个动作获得立即奖励 1，但是在两个动作（步骤）之后结束情节的长期奖励应该比获得立即奖励 1 但在 10 个步骤之后结束情节的动作具有较少的长期奖励。 动作的折现奖励的典型公式是其立即奖励加上其每个未来奖励的倍数和由未来步骤提供动力的折现率的总和。 因此，如果一个动作序列在剧集结束前有 1、1、1、1、1 个奖励，则第一个动作的折扣奖励为`1+(1*discount_rate)+(1*discount_rate**2)+(1*discount_rate**3)+(1*discount_rate**4)`。
+*   折扣奖励：每个动作的值都需要考虑其未来动作的奖励。 例如，一个动作获得立即奖励 1，但是在两个动作（步骤）之后结束剧集的长期奖励应该比获得立即奖励 1 但在 10 个步骤之后结束剧集的动作具有较少的长期奖励。 动作的折现奖励的典型公式是其立即奖励加上其每个未来奖励的倍数和由未来步骤提供动力的折现率的总和。 因此，如果一个动作序列在剧集结束前有 1、1、1、1、1 个奖励，则第一个动作的折扣奖励为`1+(1*discount_rate)+(1*discount_rate**2)+(1*discount_rate**3)+(1*discount_rate**4)`。
 
 *   测试运行当前策略，查看哪些操作导致较高的折扣奖励，然后使用折扣奖励更新当前策略的梯度（权重损失），以使具有较高折扣奖励的操作在网络更新后， 下次被选中的可能性更高。 重复这样的测试运行并多次更新该过程，以训练神经网络以获得更好的策略。
 
@@ -868,7 +868,7 @@ def normalized_discounted_rewards(rewards):
     return (dr - dr.mean()) / dr.std()
 ```
 
-例如，如果`discount_rate`为 0.95，则奖励列表`[1,1,1]`中第一个动作的折扣奖励为`1 + 1 * 0.95 + 1 * 0.95 ** 2 = 2.8525`，并且第二和最后一个折扣奖励是 1.95 和 1； 奖励列表`[1,1,1,1,1]`中第一个动作的折扣奖励为`1 + 1 * 0.95 + 1 * 0.95 ** 2 + 1 * 0.95 ** 3 + 1 * 0.95 ** 4 = 4.5244`，其余动作为 3.7099、2.8525、1.95 和 1 。` [1,1,1]`和`[1,1,1,1,1]`的归一化折扣奖励为`[1.2141, 0.0209, -1.2350]`和`[1.3777, 0.7242,  0.0362, -0.6879, -1.4502]`。 每个规范化的折扣清单按降序排列，这意味着动作持续的时间越长（在情节结束之前），其奖励就越大。
+例如，如果`discount_rate`为 0.95，则奖励列表`[1,1,1]`中第一个动作的折扣奖励为`1 + 1 * 0.95 + 1 * 0.95 ** 2 = 2.8525`，并且第二和最后一个折扣奖励是 1.95 和 1； 奖励列表`[1,1,1,1,1]`中第一个动作的折扣奖励为`1 + 1 * 0.95 + 1 * 0.95 ** 2 + 1 * 0.95 ** 3 + 1 * 0.95 ** 4 = 4.5244`，其余动作为 3.7099、2.8525、1.95 和 1 。` [1,1,1]`和`[1,1,1,1,1]`的归一化折扣奖励为`[1.2141, 0.0209, -1.2350]`和`[1.3777, 0.7242,  0.0362, -0.6879, -1.4502]`。 每个规范化的折扣清单按降序排列，这意味着动作持续的时间越长（在剧集结束之前），其奖励就越大。
 
 接下来，创建 CartPole 体育馆环境，定义`learning_rate`和`discount_rate`超参数，并像以前一样使用四个输入神经元，四个隐藏神经元和一个输出神经元构建网络：