2020-12-29 21:47:10

new/begin-app-dev-tf-keras/1.md

@@ -149,11 +149,11 @@
 
 节点是网络中表示数据的地方。 有两个与节点关联的值：偏差和权重。 这两个值都影响数据如何由节点表示并传递到其他节点。 当网络*学习*时，它会有效地调整这些值以满足优化函数。
 
-神经网络中的大部分工作都发生在隐藏层中。 不幸的是，没有明确的规则来确定网络应具有多少层或节点。 在实现神经网络时，人们可能会花费时间来尝试不同的层和节点组合。 建议始终从单个层开始，并且总是以反映输入数据具有的要素数量（即，数据集中有多少*列*可用）的数量的节点开始。 然后，将继续添加层和节点，直到获得令人满意的性能-或每当网络开始过度适应训练数据时。
+神经网络中的大部分工作都发生在隐藏层中。 不幸的是，没有明确的规则来确定网络应具有多少层或节点。 在实现神经网络时，人们可能会花费时间来尝试不同的层和节点组合。 建议始终从单个层开始，并且总是以反映输入数据具有的特征数量（即，数据集中有多少*列*可用）的数量的节点开始。 然后，将继续添加层和节点，直到获得令人满意的性能-或每当网络开始过度适应训练数据时。
 
 当前的神经网络实践通常仅限于实验，该实验涉及节点和层的数量（例如，网络的深度）以及在每一层执行的操作的种类。 在许多成功的实例中，仅通过调整这些参数，神经网络的性能就优于其他算法。
 
-作为一种直觉，考虑一下数据通过输入层进入神经网络系统，然后在网络中从一个节点移动到另一个节点。 数据采用的路径将取决于节点的互连程度，每个节点的权重和偏差，在每个层中执行的操作的类型以及此类操作结束时的数据状态。 神经网络通常需要许多“运行”（或历元），以便不断调整节点的权重和偏差，这意味着数据多次流经图形的不同层。
+作为一种直觉，考虑一下数据通过输入层进入神经网络系统，然后在网络中从一个节点移动到另一个节点。 数据采用的路径将取决于节点的互连程度，每个节点的权重和偏差，在每个层中执行的操作的类型以及此类操作结束时的数据状态。 神经网络通常需要许多“运行”（或历元），以便不断调整节点的权重和偏差，这意味着数据多次流经图的不同层。
 
 本节为您提供了神经网络和深度学习的概述。 此外，我们讨论了入门者的直觉，以了解以下关键概念：
 
@@ -177,7 +177,7 @@
 
 ### TensorFlow
 
-TensorFlow 是一个库，用于以图形形式执行数学运算。 TensorFlow 最初由 Google 开发，如今已是一个由许多贡献者参与的开源项目。 它在设计时就考虑了神经网络，是创建深度学习算法时最受欢迎的选择之一。
+TensorFlow 是一个库，用于以图形式执行数学运算。 TensorFlow 最初由 Google 开发，如今已是一个由许多贡献者参与的开源项目。 它在设计时就考虑了神经网络，是创建深度学习算法时最受欢迎的选择之一。
 
 TensorFlow 也以其生产组件而闻名。 它随附 [TensorFlow 服务](https://github.com/tensorflow/serving)，这是一种用于深度学习模型的高性能系统。 此外，可以在其他高性能编程语言（例如 Java，Go 和 C）中使用经过训练的 TensorFlow 模型。这意味着人们可以在从微型计算机（即 RaspberryPi）到 Android 设备的任何内容中部署这些模型。 。
 

new/begin-app-dev-tf-keras/2.md

@@ -27,7 +27,7 @@
 
 卷积神经网络因处理具有网格状结构的问题而臭名昭著。 它们最初是为了对图像进行分类而创建的，但已用于许多其他领域，从语音识别到自动驾驶车辆。
 
-CNN 的基本见解是将紧密相关的数据用作训练过程的要素，而不仅仅是单个数据输入。 这个想法在图像的上下文中特别有效，因为位于另一个像素右边的一个像素也与该像素有关，因为它们构成了较大合成的部分。 在这种情况下，网络正在训练预测该组成。 因此，将几个像素组合在一起比单独使用单个像素更好。
+CNN 的基本见解是将紧密相关的数据用作训练过程的特征，而不仅仅是单个数据输入。 这个想法在图像的上下文中特别有效，因为位于另一个像素右边的一个像素也与该像素有关，因为它们构成了较大合成的部分。 在这种情况下，网络正在训练预测该组成。 因此，将几个像素组合在一起比单独使用单个像素更好。
 
 **卷积**的名称是，以表示此过程的数学表达式：
 
@@ -301,7 +301,7 @@ bitcoin_recent.to_csv('data/bitcoin_recent.csv', index=False)
 
 # 使用 Keras 作为 TensorFlow 接口
 
-本节重点介绍 Keras。 我们之所以使用 Keras，是因为它将 TensorFlow 接口简化为通用抽象。 在后端，计算仍然在 TensorFlow 中执行，并且仍然使用 TensorFlow 组件构建图形，但是接口要简单得多。 我们花费较少的时间来担心诸如变量和运算之类的各个组件，而花费更多的时间将网络构建为计算单元。 Keras 使您可以轻松地尝试不同的架构和超参数，从而更快地向高性能解决方案迈进。
+本节重点介绍 Keras。 我们之所以使用 Keras，是因为它将 TensorFlow 接口简化为通用抽象。 在后端，计算仍然在 TensorFlow 中执行，并且仍然使用 TensorFlow 组件构建图，但是接口要简单得多。 我们花费较少的时间来担心诸如变量和运算之类的各个组件，而花费更多的时间将网络构建为计算单元。 Keras 使您可以轻松地尝试不同的架构和超参数，从而更快地向高性能解决方案迈进。
 
 从 TensorFlow 1.4.0（2017 年 11 月）开始，Keras 现在以 TensorFlow 作为`tf.keras`正式发行。 这表明 Keras 现在已经与 TensorFlow 紧密集成，并且很可能会在很长一段时间内继续作为开源工具进行开发。
 
@@ -502,7 +502,7 @@ data = np.array(samples)
 
 > “代码段 3”：创建不同星期组的 Python 代码段
 
-结果变量`data`是包含所有正确大小的变量。 Keras LSTM 层期望这些维度以特定的顺序进行组织：要素数量，观测数量和周期长度。 让我们重塑数据集以匹配该格式：
+结果变量`data`是包含所有正确大小的变量。 Keras LSTM 层期望这些维度以特定的顺序进行组织：特征数量，观测数量和周期长度。 让我们重塑数据集以匹配该格式：
 
 ```py
 X_train = data[:-1,:].reshape(1, 76, 7)
@@ -559,7 +559,7 @@ LSTM 是计算上昂贵的模型。 在现代计算机上，我们最多可能
 
 ## 活动 5 – 组装深度学习系统
 
-在本活动中，我们将构建基本的深度学习系统的所有基本要素汇总在一起：数据，模型和预测。
+在本活动中，我们将构建基本的深度学习系统的所有基本特征汇总在一起：数据，模型和预测。
 
 我们将继续使用 Jupyter 笔记本，并将使用之前练习中准备的数据（`data/train_dataset.csv`）和我们本地存储的模型（`bitcoin_lstm_v0.h5`）。
 

new/begin-app-dev-tf-keras/3.md

@@ -114,7 +114,7 @@ TensorBoard 擅长评估神经网络。 正如“第 1 课”，“神经网络
 
 有关更多信息，请参阅 [Keras 回调文档](https://keras.io/callbacks/)。
 
-实现 TensorBoard 回调后，`loss`函数指标现在可在 TensorBoard 接口中使用。 现在，您可以运行 TensorBoard 进程（使用`tensorboard --logdir=./logs`），并在使用`fit()`训练网络时保持运行状态。 要评估的主要图形通常称为*损失*。 通过将已知指标传递给`fit()`函数中的`metrics`参数，可以添加更多指标； 这些将可以在 TensorBoard 中用于可视化，但不会用于调整网络权重。 交互式图形将继续实时更新，这使您可以了解每个时期发生的情况。
+实现 TensorBoard 回调后，`loss`函数指标现在可在 TensorBoard 接口中使用。 现在，您可以运行 TensorBoard 进程（使用`tensorboard --logdir=./logs`），并在使用`fit()`训练网络时保持运行状态。 要评估的主要图通常称为*损失*。 通过将已知指标传递给`fit()`函数中的`metrics`参数，可以添加更多指标； 这些将可以在 TensorBoard 中用于可视化，但不会用于调整网络权重。 交互式图形将继续实时更新，这使您可以了解每个时期发生的情况。
 
 ![Using TensorBoard](img/image03_05.jpg)
 

new/handson-dl-img-tf/3.md

@@ -163,7 +163,7 @@ Keras 函数式模型
 
 在我们的“模型摘要输出”的屏幕截图中，请注意屏幕截图底部代码中突出显示的部分中可训练参数的数量。 这就是我们的模型`adam`优化器与我们的分类交叉熵`loss`函数一起将在模型内部包含的单个浮点数的数目，以便找到可能的最佳参数值。 因此，此可训练的参数编号是我们的`optimizer`函数学习的唯一编号集合。 但是，此代码和前面的屏幕快照中还有许多其他数字。 这些不可训练的参数呢？ 在我们当前的模型中，有零个不可训练参数。 但是，Keras 中不同种类的层可能具有恒定值，因此它们将显示为不可训练的。 再次，这只是意味着不需要对其进行训练，并且我们的`optimizer`函数将不会尝试更改其值。
 
-那么，什么是超参数？ 好吧，非常简单，超参数是模型本身之外的值（参数）。 因此，认为超参数最简单的是实际的模型结构。 在这种情况下，我们创建层的次数是一个超参数，层的大小是一个超参数，我们在密集层中选择的`32`单位是一个超参数，`0.1`的丢弃设置是超参数，甚至激活函数本身（例如，选择`relu`而不是`sigmoid`）都是超参数。 现在您可能在想，“请稍等，我不得不在这里选择很多参数；我以为机器应该在学习”。 它是！ 但是，诀窍在于`optimizer`无法学习我们需要了解的所有知识，以组成一个最佳模型。
+那么，什么是超参数？ 好吧，非常简单，超参数是模型本身之外的值（参数）。 因此，认为超参数最简单的是实际的模型结构。 在这种情况下，我们创建层的次数是一个超参数，层的大小是一个超参数，我们在密集层中选择的`32`单元是一个超参数，`0.1`的丢弃设置是超参数，甚至激活函数本身（例如，选择`relu`而不是`sigmoid`）都是超参数。 现在您可能在想，“请稍等，我不得不在这里选择很多参数；我以为机器应该在学习”。 它是！ 但是，诀窍在于`optimizer`无法学习我们需要了解的所有知识，以组成一个最佳模型。
 
 # 网格搜索
 
@@ -183,7 +183,7 @@ Keras 函数式模型
 
 我们将使用 scikit-learn，这是经常与 Keras 和其他机器学习软件一起使用的工具包，以便进行网格搜索和分类报告，从而告诉我们最佳模型。 然后，我们还将导入 Keras 的`KerasClassifier`包装器，使其与`scikit_learn`兼容。
 
-现在，让我们集中讨论一个模型生成函数并设想两个超参数。 其中一个将是`dropout`，另一个将是每个密集隐藏层中的单位数。 因此，我们在此处构建一个名为`dense_model`的函数，该函数接受`units`和`dropout`，然后像以前一样计算网络。 但是，而不是使用硬编码的`32`或`0.1`（例如），实际的参数将被传入，这将为我们编译模型，然后将该模型作为输出返回。 这次，我们使用顺序模型。 以前，当我们使用 Keras 函数式模型时，我们一层又一层地链接在一起。 对于顺序模型，它更像一个列表：从顺序模型开始，然后逐层添加，直到顺序模型本身为您形成链。 现在是超参数网格。 这是我们指出网格搜索与优化器相比的缺点。 您可以在前面的屏幕截图中看到我们选择的值。 为了使运行更快，我们将做一个时期，并保持`64`图像的恒定`batch_size`，该图像将在`32`，`64`和`128`隐藏单位以及退出之间变化 `0.1`，`0.2`和`0.4`的特征。 这是网格搜索的最大缺点：您将在此处看到的超参数是唯一可以完成的操作-网格搜索不会在两者之间探索超参数值。
+现在，让我们集中讨论一个模型生成函数并设想两个超参数。 其中一个将是`dropout`，另一个将是每个密集隐藏层中的单元数。 因此，我们在此处构建一个名为`dense_model`的函数，该函数接受`units`和`dropout`，然后像以前一样计算网络。 但是，而不是使用硬编码的`32`或`0.1`（例如），实际的参数将被传入，这将为我们编译模型，然后将该模型作为输出返回。 这次，我们使用顺序模型。 以前，当我们使用 Keras 函数式模型时，我们一层又一层地链接在一起。 对于顺序模型，它更像一个列表：从顺序模型开始，然后逐层添加，直到顺序模型本身为您形成链。 现在是超参数网格。 这是我们指出网格搜索与优化器相比的缺点。 您可以在前面的屏幕截图中看到我们选择的值。 为了使运行更快，我们将做一个时期，并保持`64`图像的恒定`batch_size`，该图像将在`32`，`64`和`128`隐藏单元以及退出之间变化 `0.1`，`0.2`和`0.4`的特征。 这是网格搜索的最大缺点：您将在此处看到的超参数是唯一可以完成的操作-网格搜索不会在两者之间探索超参数值。
 
 现在，我们设置`KerasClassifier`，将其交给我们刚刚创建的模型构建函数，并将`verbose`设置为`0`以隐藏每次 Keras 运行的进度条。 然后，我们设置一个计时器； 我想知道这需要多长时间。 现在，我们设置了带有交叉验证的网格搜索。 对于其估计量，我们给我们提供我们的模型，即我们的`KerasClassifier`包装器和我们的`grid`参数（请参阅前面的超参数），然后说`cv=6`，这意味着将数据（训练数据）分为六个不同部分，然后交叉验证。 在`5`上进行训练，并使用六分之一进行验证并反复重复此步骤，以搜索最佳的超参数值。 另外，将`verbose`设置为`4`，这样我们就可以看到很多输出。 现在仅 Keras 就运行了很多东西，我们将`fit`函数从我们的`x`训练数据（同样是我们的输入图像）转到我们的`y`训练数据（这些是从零到数字的标签） 九），然后打印出我们最好的结果。 请注意，我们实际上尚未触及我们的测试数据。 我们将在稍后使用它来对网格搜索报告的最佳模型的值进行评分。
 

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

@@ -56,7 +56,7 @@
 
 在发表连体网络的[第一篇论文](https://papers.nips.cc/paper/769-signature-verification-using-a-siamese-time-delay-neural-network.pdf)中，作者描述了网络对于签名验证任务的重要性。 签名验证任务的目的是识别签名的真实性。 因此，作者用真正的和不正确的签名对训练了连体网络，并使用了卷积网络从签名中提取特征。 提取特征后，他们测量了两个特征向量之间的距离以识别相似性。 因此，当出现新的签名时，我们提取特征并将其与签名者存储的特征向量进行比较。 如果距离小于某个阈值，则我们接受签名为真实签名，否则我们拒绝签名。
 
-连体网络也广泛用于 NLP 任务。 [有一篇有趣的论文](http://www.aclweb.org/anthology/W16-1617)，作者使用连体网络来计算文本相似度。 他们使用连体网络作为双向单位，并使用余弦相似度作为能量函数来计算文本之间的相似度。
+连体网络也广泛用于 NLP 任务。 [有一篇有趣的论文](http://www.aclweb.org/anthology/W16-1617)，作者使用连体网络来计算文本相似度。 他们使用连体网络作为双向单元，并使用余弦相似度作为能量函数来计算文本之间的相似度。
 
 连体网络的应用是无止境的。 它们已经堆叠了用于执行各种任务的各种架构，例如人类动作识别，场景更改检测和机器翻译。
 

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

@@ -531,7 +531,7 @@ elif inverse_transform_type == "other":
 
 考虑一下我们的数据集包含一些未标记数据点的情况：我们如何计算这些未标记数据点的类原型？
 
-假设我们有一个支持集`S = (x1, y1), (x2, y2), ..., (xk, yk)`，其中`x`是要素，`y`是标签，还有一个查询集`Q = (x1', y1'), (x2', y2'), ..., (xk', yk')`。 伴随着这些，我们还有另外一个称为未标记集`R`的集合，在这里，我们只有未标记的例子`R = (x_tilde1, y_tilde1), (x_tilde2, y_tilde2), ..., (x_tildek, y_tildek)`。
+假设我们有一个支持集`S = (x1, y1), (x2, y2), ..., (xk, yk)`，其中`x`是特征，`y`是标签，还有一个查询集`Q = (x1', y1'), (x2', y2'), ..., (xk', yk')`。 伴随着这些，我们还有另外一个称为未标记集`R`的集合，在这里，我们只有未标记的例子`R = (x_tilde1, y_tilde1), (x_tilde2, y_tilde2), ..., (x_tildek, y_tildek)`。
 
 那么，我们该如何处理这个未标记的集呢？
 

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

@@ -25,7 +25,7 @@
 *   学习率`α`
 *   更新方向
 
-我们通常将参数`θ`设置为某个随机值，并在训练过程中尝试找到最佳值，然后将学习率`α`的值设置为一个小数值，或者将其随时间衰减，以及跟随梯度的更新方向。 我们是否可以通过元学习来学习梯度下降的所有这些关键要素，以便可以从几个数据点快速学习？ 在上一章中，我们已经看到 MAML 如何找到可在各个任务之间推广的最佳初始参数`θ`。 有了最佳的初始参数，我们就可以减少梯度步骤，并快速学习新任务。
+我们通常将参数`θ`设置为某个随机值，并在训练过程中尝试找到最佳值，然后将学习率`α`的值设置为一个小数值，或者将其随时间衰减，以及跟随梯度的更新方向。 我们是否可以通过元学习来学习梯度下降的所有这些关键特征，以便可以从几个数据点快速学习？ 在上一章中，我们已经看到 MAML 如何找到可在各个任务之间推广的最佳初始参数`θ`。 有了最佳的初始参数，我们就可以减少梯度步骤，并快速学习新任务。
 
 因此，现在我们是否可以学习最佳的学习率和更新方向，从而可以跨任务进行概括，从而实现更快的收敛和训练？ 让我们看看如何通过将其与 MAML 进行比较在元 SGD 中学习。 如果您还记得，请在 MAML 内循环中，通过最小化梯度下降带来的损失，找到每个任务`T[i]`的最佳参数`θ'[i]`：
 

new/handson-rl-py/00.md

@@ -8,7 +8,7 @@
 
 # 本书涵盖的内容
 
-第 1 章，“强化学习简介”帮助我们了解强化学习是什么以及它如何工作。 我们将学习强化学习的各种要素，例如智能体，环境，策略和模型，并且还将看到用于强化学习的不同类型的环境，平台和库。 在本章的后面，我们将看到强化学习的一些应用。
+第 1 章，“强化学习简介”帮助我们了解强化学习是什么以及它如何工作。 我们将学习强化学习的各种特征，例如智能体，环境，策略和模型，并且还将看到用于强化学习的不同类型的环境，平台和库。 在本章的后面，我们将看到强化学习的一些应用。
 
 第 2 章和 “OpenAI 和 TensorFlow 入门”可帮助我们为各种强化学习任务设置机器。 我们将学习如何通过安装 Anaconda，Docker，OpenAI Gym，Universe 和 TensorFlow 来设置机器。 然后，我们将学习如何在 OpenAI Gym 中模拟智能体，并且将了解如何构建视频游戏机器人。 我们还将学习 TensorFlow 的基础知识，并了解如何使用 TensorBoard 进行可视化。
 

new/handson-rl-py/02.md

@@ -616,7 +616,7 @@ B = tf.multiply(4,3)
 sess = tf.Session()
 ```
 
-我们可以使用`tf.Session()`方法为我们的计算图创建会话，该方法将分配用于存储变量当前值的内存。 创建会话后，我们可以使用`sess.run()`方法执行图形。
+我们可以使用`tf.Session()`方法为我们的计算图创建会话，该方法将分配用于存储变量当前值的内存。 创建会话后，我们可以使用`sess.run()`方法执行图。
 
 为了在 TensorFlow 中运行任何内容，我们需要为实例启动 TensorFlow 会话； 请参考代码：
 
@@ -667,7 +667,7 @@ f = tf.multiply(d,e)
 g = tf.add(c,f)
 ```
 
-现在，我们将创建一个 TensorFlow 会话。 我们将使用`tf.summary.FileWriter()`将图形的结果写入名为`event`的文件中：
+现在，我们将创建一个 TensorFlow 会话。 我们将使用`tf.summary.FileWriter()`将图的结果写入名为`event`的文件中：
 
 ```py
 with tf.Session() as sess:
@@ -748,7 +748,7 @@ with tf.Session() as sess:
 
 # 总结
 
-在本章中，我们学习了如何通过安装 Anaconda，Docker，OpenAI Gym，Universe 和 TensorFlow 来设置机器。 我们还学习了如何使用 OpenAI 创建模拟，以及如何训练智能体在 OpenAI 环境中学习。 然后，我们了解了 TensorFlow 的基础知识，然后在 TensorBoard 中可视化了图形。
+在本章中，我们学习了如何通过安装 Anaconda，Docker，OpenAI Gym，Universe 和 TensorFlow 来设置机器。 我们还学习了如何使用 OpenAI 创建模拟，以及如何训练智能体在 OpenAI 环境中学习。 然后，我们了解了 TensorFlow 的基础知识，然后在 TensorBoard 中可视化了图。
 
 在下一章第 3 章，“马尔可夫决策过程和动态规划”中，我们将学习马尔可夫决策过程和动态规划以及如何使用值和策略迭代来解决冻湖问题。
 

new/handson-rl-py/07.md

@@ -15,7 +15,7 @@
 
 # 人工神经元
 
-在了解 ANN 之前，首先让我们了解什么是神经元以及大脑中神经元的实际工作方式。 神经元可以定义为人脑的基本计算单位。 我们的大脑包含大约 1000 亿个神经元。 每个神经元通过突触连接。 神经元通过称为树突的分支状结构从外部环境，感觉器官或其他神经元接收输入，如下图所示。 这些输入被增强或减弱，也就是说，根据它们的重要性对其进行加权，然后将它们加在一起在体（细胞体）中。 然后，这些合计的输入从细胞体中被处理并穿过轴突，然后被发送到其他神经元。 下图显示了基本的单个生物神经元：
+在了解 ANN 之前，首先让我们了解什么是神经元以及大脑中神经元的实际工作方式。 神经元可以定义为人脑的基本计算单元。 我们的大脑包含大约 1000 亿个神经元。 每个神经元通过突触连接。 神经元通过称为树突的分支状结构从外部环境，感觉器官或其他神经元接收输入，如下图所示。 这些输入被增强或减弱，也就是说，根据它们的重要性对其进行加权，然后将它们加在一起在体（细胞体）中。 然后，这些合计的输入从细胞体中被处理并穿过轴突，然后被发送到其他神经元。 下图显示了基本的单个生物神经元：
 
 ![](img/00159.gif)
 
@@ -795,15 +795,15 @@ CNN 通常包含三个主要层：
 
 # 池化层
 
-在卷积层之后，我们有了池化层。 池化层用于减少特征映射的维数，并且仅保留必要的细节，因此可以减少计算量。 例如，要确定图像中是否有一只狗，我们不想了解狗在图像中的哪个位置，我们只需要狗的特征。 因此，池化层通过仅保留重要特征来减小空间大小。 有多种类型的池化操作。 最大池化是最常用的池化操作之一，我们仅从窗口内的要素图中获取最大值。
+在卷积层之后，我们有了池化层。 池化层用于减少特征映射的维数，并且仅保留必要的细节，因此可以减少计算量。 例如，要确定图像中是否有一只狗，我们不想了解狗在图像中的哪个位置，我们只需要狗的特征。 因此，池化层通过仅保留重要特征来减小空间大小。 有多种类型的池化操作。 最大池化是最常用的池化操作之一，我们仅从窗口内的特征图中获取最大值。
 
 带有`2 x 2`过滤器且步幅为 2 的最大池如下所示：
 
 ![](img/00236.gif)
 
-在平均池中，我们只取窗口内要素图中元素的平均值，而在汇总池中，我们取窗口中要素图中元素的总和。
+在平均池中，我们只取窗口内特征图中元素的平均值，而在汇总池中，我们取窗口中特征图中元素的总和。
 
-合并操作不会更改要素图的深度，只会影响高度和宽度。
+合并操作不会更改特征图的深度，只会影响高度和宽度。
 
 # 全连接层
 

new/handson-rl-py/08.md

@@ -42,7 +42,7 @@ DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧
 
 当执行诸如对象检测或分类之类的任务时，池层非常有用，其中我们不考虑对象在图像中的位置，而只想知道所需对象是否在图像中。 例如，如果我们要对图像中是否有狗进行分类，我们只查看图像中是否有狗，而不检查狗在哪里。 在那种情况下，使用池化层对图像进行分类，而与狗的位置无关。 但是对于我们来说，要了解游戏屏幕，位置很重要，因为它描述了游戏状态。 例如，在乒乓游戏中，我们不仅要分类游戏屏幕上是否有球。 我们想知道球的位置，以便我们下一步行动。 这就是为什么我们在架构中不使用池化层的原因。
 
-好的，我们如何计算 Q 值？ 如果我们传递一个游戏画面和一个动作作为 DQN 的输入，它将给我们 Q 值。 但这将需要一个完整的前向通过，因为一个状态中将有许多动作。 而且，游戏中将有许多状态，每个动作都有一个前移，这在计算上将是昂贵的。 因此，我们只需将游戏屏幕单独作为输入，并通过将输出层中的单位数设置为游戏状态下的动作数，即可获得该状态下所有可能动作的 Q 值。
+好的，我们如何计算 Q 值？ 如果我们传递一个游戏画面和一个动作作为 DQN 的输入，它将给我们 Q 值。 但这将需要一个完整的前向通过，因为一个状态中将有许多动作。 而且，游戏中将有许多状态，每个动作都有一个前移，这在计算上将是昂贵的。 因此，我们只需将游戏屏幕单独作为输入，并通过将输出层中的单元数设置为游戏状态下的动作数，即可获得该状态下所有可能动作的 Q 值。
 
 下图显示了 DQN 的架构，我们在其中馈送了一个游戏屏幕，它提供了该游戏状态下所有动作的 Q 值：
 

new/handson-rl-py/09.md

@@ -572,7 +572,7 @@ DARQN 的架构如下所示：
 
 ![](img/00291.gif)
 
-它由三层组成； 卷积层，注意力层和 LSTM 循环层。 游戏屏幕作为图像被馈送到卷积网络。 卷积网络处理图像并生成特征映射。 然后，要素贴图会进入关注层。 注意层将它们转换为向量，并产生它们的线性组合，称为上下文向量。 然后将上下文向量以及先前的隐藏状态传递到 LSTM 层。 LSTM 层提供两个输出； 一方面，它提供 Q 值来决定在某种状态下要执行的动作；另一方面，它可以帮助注意力网络确定在下一个时间步中要关注的图像区域，从而可以生成更好的上下文向量。 。
+它由三层组成； 卷积层，注意力层和 LSTM 循环层。 游戏屏幕作为图像被馈送到卷积网络。 卷积网络处理图像并生成特征映射。 然后，特征贴图会进入关注层。 注意层将它们转换为向量，并产生它们的线性组合，称为上下文向量。 然后将上下文向量以及先前的隐藏状态传递到 LSTM 层。 LSTM 层提供两个输出； 一方面，它提供 Q 值来决定在某种状态下要执行的动作；另一方面，它可以帮助注意力网络确定在下一个时间步中要关注的图像区域，从而可以生成更好的上下文向量。 。
 
 注意有两种类型：
 

new/handson-rl-py/11.md

@@ -226,7 +226,7 @@ class PolicyGradient:
 
 与 DQN 相似，这里我们使用经验缓冲区，通过采样少量的经验来训练演员和评论家网络。 我们还使用单独的目标演员和评论家网络来计算损失。
 
-例如，在乒乓游戏中，我们将具有不同比例的不同特征，例如位置，速度等。 因此，我们以所有要素都处于相同比例的方式来缩放要素。 我们使用一种称为批归一化的方法来缩放要素。 它将所有特征归一化以具有单位均值和方差。 我们如何探索新的行动？ 在连续环境中，将有`n`个动作。 为了探索新动作，我们在演员网络产生的动作中添加了一些噪声`N`。 我们使用称为 Ornstein-Uhlenbeck 随机过程的过程来生成此噪声。
+例如，在乒乓游戏中，我们将具有不同比例的不同特征，例如位置，速度等。 因此，我们以所有特征都处于相同比例的方式来缩放特征。 我们使用一种称为批归一化的方法来缩放特征。 它将所有特征归一化以具有单位均值和方差。 我们如何探索新的行动？ 在连续环境中，将有`n`个动作。 为了探索新动作，我们在演员网络产生的动作中添加了一些噪声`N`。 我们使用称为 Ornstein-Uhlenbeck 随机过程的过程来生成此噪声。
 
 现在，我们将详细介绍 DDPG 算法。
 

new/handson-rl-py/13.md

@@ -78,7 +78,7 @@ DQfd 中的损失函数将是各种损失的总和。 为了防止我们的智
 
 我们已经了解了如何在 DQN 中使用经验回放来避免相关经验。 此外，我们了解到，优先经验回放是对原始经验回放的一种改进，因为它优先考虑 TD 误差的每个经验。 现在，我们将研究由 OpenAI 研究人员提出的一种用于处理稀疏奖励的名为**事后经验回放**（**HER**）的新技术。 您还记得如何学习骑自行车吗？ 第一次尝试时，您将无法正确平衡自行车。 您可能多次无法正确平衡。 但是，所有这些失败并不意味着您没有学到任何东西。 失败会教你如何不平衡自行车。 即使您没有学会骑自行车（目标），您也学习了一个不同的目标，即，您学会了如何不平衡自行车。 这是我们人类学习的方式，对吗？ 我们从失败中学习，这就是事后回顾经验的想法。
 
-让我们考虑本文中给出的相同示例。 如图所示，查看 FetchSlide 环境。 在这种环境下的目标是移动机械臂并在桌子上滑动冰球以击中目标，这是一个红色的小圆圈（来自[的图表 https://blog.openai.com/ingredients-for-robotics-research /](https://blog.openai.com/ingredients-for-robotics-research/) ）：
+让我们考虑本文中给出的相同示例。 如图所示，查看 FetchSlide 环境。 在这种环境下的目标是移动机械臂并在桌子上滑动冰球以击中目标，这是一个红色的小圆圈（图表来自[这里](https://blog.openai.com/ingredients-for-robotics-research/)）：
 
 ![](img/00434.jpeg)
 
@@ -157,7 +157,7 @@ MAXQ 值函数分解是 HRL 中最常用的算法之一。 让我们看看 MAXQ
 
 ![](img/00458.gif)
 
-我们重新设计的图形包含两种特殊类型的节点：最大节点和 Q 节点。 最大节点定义任务分解中的子任务，而 Q 节点定义可用于每个子任务的动作。
+我们重新设计的图包含两种特殊类型的节点：最大节点和 Q 节点。 最大节点定义任务分解中的子任务，而 Q 节点定义可用于每个子任务的动作。
 
 # 逆强化学习
 

new/intel-proj-py/01.md

@@ -54,7 +54,7 @@
 
 图 1.4：人工神经网络
 
-输入`x ∈ R^N`穿过神经单位的连续层，这些层以分层方式排列。 特定层中的每个神经元都接收来自先前层的神经元的输入，这些输入被它们之间的连接权重所衰减或放大。 权重`w[ij]^(l)`对应于`l`层第`i`个神经元与`l + 1`层第`j`个神经元。 同样，每个神经元单元`i`在特定层`1`中都有一个偏见`b[i]^(l)`。 神经网络为输入向量`x ∈ R^N`预测输出`y_hat`。 如果数据的实际标签是`y`，其中`y`取连续值，则神经元网络将预测误差最小化`(y - y_hat)^2`来学习权重和偏差。 当然，对于所有标记的数据点，必须将误差最小化：`(xi, yi), i ∈ 1, 2, ..., m`。
+输入`x ∈ R^N`穿过神经单元的连续层，这些层以分层方式排列。 特定层中的每个神经元都接收来自先前层的神经元的输入，这些输入被它们之间的连接权重所衰减或放大。 权重`w[ij]^(l)`对应于`l`层第`i`个神经元与`l + 1`层第`j`个神经元。 同样，每个神经元单元`i`在特定层`1`中都有一个偏见`b[i]^(l)`。 神经网络为输入向量`x ∈ R^N`预测输出`y_hat`。 如果数据的实际标签是`y`，其中`y`取连续值，则神经元网络将预测误差最小化`(y - y_hat)^2`来学习权重和偏差。 当然，对于所有标记的数据点，必须将误差最小化：`(xi, yi), i ∈ 1, 2, ..., m`。
 
 如果我们用一个公共向量`W`表示一组权重和偏差，并且预测中的总误差由`C`表示，则在训练过程中，估计的`W`可以表示为：
 
@@ -186,7 +186,7 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 图 1.10：说明反向传播的网络
 
-令网络输入为二维向量， `x = [x1, x2]^T`， 输出标签和预测分别为 ![](img/df5f56eb-23da-40f8-900d-1da3eecfb2d3.png) 和 ![](img/b3cffb09-935e-4bc2-a6d1-330919797695.png) 。 另外，我们假设神经网络中的所有激活单元都是 Sigmoid。 让广义权重将层`l-1`中的任何单元`i`连接到层`l`中的单元`j`表示为 ![](img/29efb244-a597-41d7-baee-9826abbacd0b.png) ，而`l`层中任何单位`i`的偏置应表示为 ![](img/99d2725a-1b33-4aea-a0b1-7631b21edbc1.png) 。 让我们得出一个数据点的梯度； 总梯度可以计算为训练（或小批量）中使用的所有数据点的总和。 如果输出是连续的，则可以选择损失函数`C`作为预测误差的平方：
+令网络输入为二维向量， `x = [x1, x2]^T`， 输出标签和预测分别为 ![](img/df5f56eb-23da-40f8-900d-1da3eecfb2d3.png) 和 ![](img/b3cffb09-935e-4bc2-a6d1-330919797695.png) 。 另外，我们假设神经网络中的所有激活单元都是 Sigmoid。 让广义权重将层`l-1`中的任何单元`i`连接到层`l`中的单元`j`表示为 ![](img/29efb244-a597-41d7-baee-9826abbacd0b.png) ，而`l`层中任何单元`i`的偏置应表示为 ![](img/99d2725a-1b33-4aea-a0b1-7631b21edbc1.png) 。 让我们得出一个数据点的梯度； 总梯度可以计算为训练（或小批量）中使用的所有数据点的总和。 如果输出是连续的，则可以选择损失函数`C`作为预测误差的平方：
 
 ![](img/bb6a924b-9414-4008-b7a8-ee6cc0d11649.png)
 
@@ -248,7 +248,7 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 # 卷积神经网络
 
-**卷积神经网络**（**CNN**）利用卷积运算从具有关联拓扑的数据中提取有用信息。 这最适合图像和音频数据。 输入图像在通过卷积层时会生成多个输出图像，称为**输出特征映射**。 输出要素图将检测要素。 初始卷积层中的输出特征映射可以学习检测基本特征，例如边缘和颜色成分变化。
+**卷积神经网络**（**CNN**）利用卷积运算从具有关联拓扑的数据中提取有用信息。 这最适合图像和音频数据。 输入图像在通过卷积层时会生成多个输出图像，称为**输出特征映射**。 输出特征图将检测特征。 初始卷积层中的输出特征映射可以学习检测基本特征，例如边缘和颜色成分变化。
 
 第二卷积层可以检测到稍微复杂的特征，例如正方形，圆形和其他几何结构。 随着神经网络的发展，卷积层学会了检测越来越复杂的特征。 例如，如果我们有一个 CNN 可以对图像是猫还是狗进行分类，则神经网络底部的卷积层可能会学会检测诸如头部，腿部等特征。
 
@@ -268,9 +268,9 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 要注意的一件事是，卷积运算减少了每层要学习的权重数。 例如，如果我们有一个空间大小为`224 x 224`的输入图像，而下一层的期望输出为大小为` 224 x 224 `的大小，那么对于具有完整连接的传统神经网络来说，要学习的权重数是`224 x 224 x 224 x 224`。对于具有相同输入和输出大小的卷积层，我们需要学习的只是滤波器内核的权重。 因此，如果我们使用`3 x 3`过滤器内核，我们只需要学习 9 个权重即可，而不是`224 x 224 x 224 x 224`权重。 这种简化是有效的，因为局部空间邻域中的图像和音频之类的结构之间具有高度相关性。
 
-输入图像经过多层卷积和池化操作。 随着网络的发展，特征映射的数量增加，而图像的空间分辨率降低。 在卷积池层的末端，要素图的输出被馈送到全连接层，然后是输出层。
+输入图像经过多层卷积和池化操作。 随着网络的发展，特征映射的数量增加，而图像的空间分辨率降低。 在卷积池层的末端，特征图的输出被馈送到全连接层，然后是输出层。
 
-输出单位取决于手头的任务。 如果执行回归，则输出激活单位是线性的，而如果是二进制分类问题，则输出单位是 Sigmoid 的。 对于多类别分类，输出层是 softmax 单位。
+输出单元取决于手头的任务。 如果执行回归，则输出激活单元是线性的，而如果是二进制分类问题，则输出单元是 Sigmoid 的。 对于多类别分类，输出层是 softmax 单元。
 
 在本书的所有图像处理项目中，我们都将使用一种或另一种形式的卷积神经网络。
 
@@ -504,7 +504,7 @@ Figure 1.14: GAN architecture
 
 图 1.19：受限玻尔兹曼机
 
-权重`w[ij] ∈ W`将可见单位`i`连接到隐藏单位`j`，其中`W ∈ R^(mxn)`是所有这些权重的集合，从可见单位到隐藏单位。 可见单位的偏差由`b[i] ∈ b`表示，而隐藏单位的偏差由`c[j] ∈ c`表示。
+权重`w[ij] ∈ W`将可见单元`i`连接到隐藏单元`j`，其中`W ∈ R^(mxn)`是所有这些权重的集合，从可见单元到隐藏单元。 可见单元的偏差由`b[i] ∈ b`表示，而隐藏单元的偏差由`c[j] ∈ c`表示。
 
 受统计物理学中玻耳兹曼分布的思想启发，可见层向量`v`和隐藏层向量`h`的联合分布正比于配置的负能量的指数：
 
@@ -514,11 +514,11 @@ Figure 1.14: GAN architecture
 
 ![](img/e92fb4ee-090a-4067-b628-b1f0dcf9eac0.png)（2）
 
-给定可见输入向量`v`的隐藏单位`j`的概率可以表示为：
+给定可见输入向量`v`的隐藏单元`j`的概率可以表示为：
 
 ![](img/7e50218c-8aa9-4d4b-8d38-761ba1efb7ff.png)（2）
 
-类似地，给出隐藏输入向量`h`的可见单位`i`的概率由以下公式给出：
+类似地，给出隐藏输入向量`h`的可见单元`i`的概率由以下公式给出：
 
 ![](img/7bab8697-ec6f-46d1-8e2f-9ec1cf2bf5cc.png)（3）
 

new/intel-proj-py/02.md

@@ -978,7 +978,7 @@ if __name__ == '__main__':
 
 # 执行回归而不是分类
 
-我们在“损失函数公式”部分中讨论的一件事是，类别标签不是独立的分类类别，但随着糖尿病性视网膜病变情况的严重性增加，它们确实具有序数意义。 因此，值得通过定义的迁移学习网络进行回归，而不是进行分类，并观察结果如何。 我们唯一需要更改的是输出单位，从 softmax 到线性单元。 实际上，我们将其更改为 ReLU，因为我们希望避免出现负分数。 以下代码块显示了回归网络的`InceptionV3`版本：
+我们在“损失函数公式”部分中讨论的一件事是，类别标签不是独立的分类类别，但随着糖尿病性视网膜病变情况的严重性增加，它们确实具有序数意义。 因此，值得通过定义的迁移学习网络进行回归，而不是进行分类，并观察结果如何。 我们唯一需要更改的是输出单元，从 softmax 到线性单元。 实际上，我们将其更改为 ReLU，因为我们希望避免出现负分数。 以下代码块显示了回归网络的`InceptionV3`版本：
 
 ```py
 def inception_pseudo(dim=224,freeze_layers=30,full_freeze='N'):

new/intel-proj-py/04.md

@@ -189,7 +189,7 @@ the number of input images processed : 30000
 
 # DiscoGAN 的生成器
 
-DiscoGAN 的生成器是前馈卷积神经网络，其中输入和输出是图像。 在网络的第一部分中，图像在空间维度上按比例缩小，而输出要素图的数量随层的进展而增加。 在网络的第二部分中，图像沿空间维度按比例放大，而输出特征映射的数量则逐层减少。 在最终输出层中，将生成具有与输入相同的空间大小的图像。 如果生成器将图像`x[A]`转换为`x[AB]`从域`A`到域`B`表示为`G[AB]`，则我们有`x[AB] = G[AB](x[A])`。
+DiscoGAN 的生成器是前馈卷积神经网络，其中输入和输出是图像。 在网络的第一部分中，图像在空间维度上按比例缩小，而输出特征图的数量随层的进展而增加。 在网络的第二部分中，图像沿空间维度按比例放大，而输出特征映射的数量则逐层减少。 在最终输出层中，将生成具有与输入相同的空间大小的图像。 如果生成器将图像`x[A]`转换为`x[AB]`从域`A`到域`B`表示为`G[AB]`，则我们有`x[AB] = G[AB](x[A])`。
 
 此处显示的是`build_generator`函数，我们可以使用它来构建 DiscoGAN 网络的生成器：
 
@@ -288,7 +288,7 @@ def build_generator(self,image,reuse=False,name='generator'):
 
 例如，我们可能使用生成器函数创建了两个生成器网络，因此在第一次创建这些网络时不会使用`reuse`选项。 如果再次引用该生成器函数，则使用`reuse`选项。 卷积（下采样）和解卷积（上采样）期间的激活函数是 LReLU，然后进行批量归一化，以实现稳定和快速的收敛。
 
-网络不同层中的输出要素图的数量可以是`self.gf` 或其倍数。 对于我们的 DiscoGAN 网络，我们选择了`self.gf`作为`64`。
+网络不同层中的输出特征图的数量可以是`self.gf` 或其倍数。 对于我们的 DiscoGAN 网络，我们选择了`self.gf`作为`64`。
 
 生成器中要注意的一件事是输出层的`tanh`激活函数。 这样可以确保生成器生成的图像的像素值在`[-1, +1]`的范围内。 这对于输入图像具有`[-1, +1]`范围内的像素强度非常重要，这可以通过对像素强度进行简单的逐元素变换来实现，如下所示：
 

new/intel-proj-py/05.md

@@ -91,7 +91,7 @@ o1, o2, . . . . . ot . . . oN = { "A ","man" "in" "a" "yellow" "helmet" "is" "wo
 
 # 处理视频图像来创建 CNN 特征
 
-从指定位置下载数据后，下一个任务是处理视频图像帧，以从预训练的卷积神经网络的最后全连接层中提取特征。 我们使用在 ImageNet 上预训练的`VGG16`卷积神经网络。 我们将激活从`VGG16`的最后一个全连接层中取出。 由于`VGG16`的最后一个全连接层具有`4096`单位，因此每个时间步`t`的特征向量`f[t]`为`4096`维向量，`f[t] ∈ R^4096`。
+从指定位置下载数据后，下一个任务是处理视频图像帧，以从预训练的卷积神经网络的最后全连接层中提取特征。 我们使用在 ImageNet 上预训练的`VGG16`卷积神经网络。 我们将激活从`VGG16`的最后一个全连接层中取出。 由于`VGG16`的最后一个全连接层具有`4096`单元，因此每个时间步`t`的特征向量`f[t]`为`4096`维向量，`f[t] ∈ R^4096`。
 
 在通过`VGG16`处理视频中的图像之前，需要从视频中对其进行采样。 我们从视频中采样图像，使每个视频具有`80`帧。 处理来自`VGG16`的`80`图像帧后，每个视频将具有`80`特征向量`f[1], f[2], ..., f[80]`。 这些特征将被馈送到 LSTM 以生成文本序列。 我们在 Keras 中使用了预训练的`VGG16`模型。 我们创建一个`VideoCaptioningPreProcessing`类，该类首先通过函数`video_to_frames`从每个视频中提取`80`视频帧作为图像，然后通过函数`extract_feats_pretrained_cnn`中的预训练`VGG16`卷积神经网络处理这些视频帧。 。
 

new/intel-proj-py/06.md

@@ -317,7 +317,7 @@ RMSE: 0.9320
 
 图 6.6：用于二进制数据的受限玻尔兹曼机
 
-只是为了刷新我们的记忆，上图（“图 6.6”）是一个 RBM，具有`m`输入或可见单位。 这被投影到具有`n`个单位的隐藏层。 给定可见层输入`v[i]`，则隐藏单元彼此独立，因此可以如下进行采样，其中`σ(·)`表示 Sigmoid 函数：
+只是为了刷新我们的记忆，上图（“图 6.6”）是一个 RBM，具有`m`输入或可见单元。 这被投影到具有`n`个单元的隐藏层。 给定可见层输入`v[i]`，则隐藏单元彼此独立，因此可以如下进行采样，其中`σ(·)`表示 Sigmoid 函数：
 
 ![](img/e4c4d443-0ad5-4a56-a6ac-73c05bcca858.png)
 
@@ -325,7 +325,7 @@ RMSE: 0.9320
 
 ![](img/8b9a6a5c-dafb-4b91-b89d-676a37ce40ce.png)
 
-RBM 的参数是可见层单位`i`与隐藏层单位之间的广义权重连接`w[ij] ∈ w[mxn]`，在可见单位`i`处的偏差`c[i] ∈ b`和隐藏层单位`j`处的偏差`c[j] ∈ c`。
+RBM 的参数是可见层单元`i`与隐藏层单元之间的广义权重连接`w[ij] ∈ w[mxn]`，在可见单元`i`处的偏差`c[i] ∈ b`和隐藏层单元`j`处的偏差`c[j] ∈ c`。
 
 通过最大化可见输入数据的可能性来学习 RBM 的这些参数。 如果我们用`θ = [W; b; c]`表示组合的参数集，并且有一组`T`训练输入数据点，则在 RBM 中，我们尝试使似然函数最大化：
 
@@ -343,11 +343,11 @@ RBM 的参数是可见层单位`i`与隐藏层单位之间的广义权重连接`
 
 ![](img/2f08b2c0-b2cf-4e04-abda-de583497996c.png)
 
-项`E[.]`表示对隐藏和可见单位的联合概率分布的任何给定数量的期望。 另外，`h_hat`表示给定可见单位`v`的采样的隐藏层输出。 在梯度下降的每次迭代中计算联合概率分布的期望在计算上是棘手的。 我们将采用下一节中讨论的称为**对比发散**的智能方法来计算期望值。
+项`E[.]`表示对隐藏和可见单元的联合概率分布的任何给定数量的期望。 另外，`h_hat`表示给定可见单元`v`的采样的隐藏层输出。 在梯度下降的每次迭代中计算联合概率分布的期望在计算上是棘手的。 我们将采用下一节中讨论的称为**对比发散**的智能方法来计算期望值。
 
 # 对比散度
 
-计算联合概率分布的期望值的一种方法是通过吉布斯采样从联合概率分布中生成很多样本，然后将样本的平均值作为期望值。 在吉布斯抽样中，可以以其余变量为条件对联合概率分布中的每个变量进行抽样。 由于可见单位是独立的，因此给定隐藏单位，反之亦然，因此您可以将隐藏单位采样为`h_bar <- P(h/v)`，然后将可见单位激活给定隐藏单位为`v_bar = P(v/h = h_bar)`。 然后我们可以将样本`(v_bar, h_bar)`作为从联合概率分布中抽取的样本。 这样，我们可以生成大量样本，例如`M`，并取其平均值来计算期望的期望值。 但是，在梯度下降的每个步骤中进行如此大量的采样将使训练过程变得令人无法接受的缓慢，因此，与其在梯度下降的每个步骤中计算许多样本的平均值，不如从联合概率中生成一个样本，它应当表示整个联合概率分布上的所需期望：
+计算联合概率分布的期望值的一种方法是通过吉布斯采样从联合概率分布中生成很多样本，然后将样本的平均值作为期望值。 在吉布斯抽样中，可以以其余变量为条件对联合概率分布中的每个变量进行抽样。 由于可见单元是独立的，因此给定隐藏单元，反之亦然，因此您可以将隐藏单元采样为`h_bar <- P(h/v)`，然后将可见单元激活给定隐藏单元为`v_bar = P(v/h = h_bar)`。 然后我们可以将样本`(v_bar, h_bar)`作为从联合概率分布中抽取的样本。 这样，我们可以生成大量样本，例如`M`，并取其平均值来计算期望的期望值。 但是，在梯度下降的每个步骤中进行如此大量的采样将使训练过程变得令人无法接受的缓慢，因此，与其在梯度下降的每个步骤中计算许多样本的平均值，不如从联合概率中生成一个样本，它应当表示整个联合概率分布上的所需期望：
 
 ![](img/e1fb8a28-45d4-4ebd-b17c-861618cfd639.png)
 
@@ -361,7 +361,7 @@ RBM 的参数是可见层单位`i`与隐藏层单位之间的广义权重连接`
 
 提出建议时，可以使用受限玻尔兹曼机进行协同过滤。 我们将使用这些 RBM 向用户推荐电影。 使用不同用户为不同电影提供的分级来训练他们。 用户不会观看或评价所有电影，因此可以使用此训练模型来向用户推荐未看过的电影。
 
-我们应该首先遇到的一个问题是如何处理 RBM 中的评分，因为评分本质上是有序的，而 RBM 则针对二进制数据。 可以将评分视为二进制数据，表示评分的单位数量等于每个评分的唯一值的数量。 例如：在评级系统中，评分从 1 到 5 不等，并且将有 5 个二进制单位，其中与评分相对应的 1 个单位设置为 1，其余单位设置为 0。 RBM 可见的单位将是为用户提供给不同电影的评分。 如所讨论的，每个评分将以二进制表示，并且对于每个可见单元，来自所有二进制可见单元的权重连接都与电影评分相对应。 由于每个用户将为一组不同的电影评分，因此每个用户的输入将不同。 但是，从电影分级单位到隐藏单位的重量连接对于所有用户而言都是通用的。
+我们应该首先遇到的一个问题是如何处理 RBM 中的评分，因为评分本质上是有序的，而 RBM 则针对二进制数据。 可以将评分视为二进制数据，表示评分的单元数量等于每个评分的唯一值的数量。 例如：在评级系统中，评分从 1 到 5 不等，并且将有 5 个二进制单元，其中与评分相对应的 1 个单元设置为 1，其余单元设置为 0。 RBM 可见的单元将是为用户提供给不同电影的评分。 如所讨论的，每个评分将以二进制表示，并且对于每个可见单元，来自所有二进制可见单元的权重连接都与电影评分相对应。 由于每个用户将为一组不同的电影评分，因此每个用户的输入将不同。 但是，从电影分级单元到隐藏单元的重量连接对于所有用户而言都是通用的。
 
 下图所示（“图 6.8a”和“图 6.8b”）是用户`A`和用户`B`的 RBM 视图。 **用户**`A`和用户`B`为一组不同的电影评分。 但是，正如我们所看到的，每个用户到每部电影中隐藏单元的权重连接都相同。 关于用户`A`的 RBM 评分如下：
 
@@ -375,21 +375,21 @@ RBM 的参数是可见层单位`i`与隐藏层单位之间的广义权重连接`
 
 图 6.8b：用于协同过滤的 RBM 用户 B 视图
 
-还有一点要注意的是，如果有`M`个电影，并且每个电影都有`k`评分，那么 RBM 的可见单位数是`M * k`。 此外，如果二进制隐藏单元的数量为`n`，则`W`中的权重连接数等于`M * k * n`。 给定可见层输入，每个隐藏单元`h[j]`可以独立于其他隐藏单元进行采样，如下所示：
+还有一点要注意的是，如果有`M`个电影，并且每个电影都有`k`评分，那么 RBM 的可见单元数是`M * k`。 此外，如果二进制隐藏单元的数量为`n`，则`W`中的权重连接数等于`M * k * n`。 给定可见层输入，每个隐藏单元`h[j]`可以独立于其他隐藏单元进行采样，如下所示：
 
 ![](img/e65a7129-a15e-4668-9318-a0679190ba63.png)
 
 此处，`m = M * k`。
 
-与传统的 RBM 不同，在给定隐藏层激活的情况下，无法独立采样该网络可见层中的二进制单元。 相对于电影的评分，每个`k`个二进制单位通过 k 路 softmax 激活函数进行绑定。 如果给定隐藏单元的特定电影的可见单元的输入为`s[i1], s[i2], ..., s[il], ..., s[ik]`，则电影`i`的评分`l`的一般输入计算如下：
+与传统的 RBM 不同，在给定隐藏层激活的情况下，无法独立采样该网络可见层中的二进制单元。 相对于电影的评分，每个`k`个二进制单元通过 k 路 softmax 激活函数进行绑定。 如果给定隐藏单元的特定电影的可见单元的输入为`s[i1], s[i2], ..., s[il], ..., s[ik]`，则电影`i`的评分`l`的一般输入计算如下：
 
 ![](img/ebac218a-2831-48b7-ad7b-c718d8fcc48e.png)
 
-在这里，`(i - 1) * k + 1`是电影`i`的可见单位对评分`l`的索引。 同样，可以根据 soft-max 函数给出的概率对任何特定电影的可见单位进行采样，如下所示：
+在这里，`(i - 1) * k + 1`是电影`i`的可见单元对评分`l`的索引。 同样，可以根据 soft-max 函数给出的概率对任何特定电影的可见单元进行采样，如下所示：
 
 ![](img/4486f0fa-b798-43eb-b87e-0522b99cba86.png)
 
-在定义隐藏单元和可见单元的输出时，还有一件重要的事情是需要概率抽样，而不是将输出默认为具有最大概率的抽样。 如果给定可见单位的隐藏单位激活的概率为`P`，则统一生成`[0, 1]`范围内的随机数`r`，并且如果`P > r`，则隐藏单元激活设置为`true`。 该方案将确保在很长的一段时间内以概率`P`将激活设置为`true`。 类似地，电影的可见单位是根据跨国公司发行给定隐藏单位的概率从跨国发行机构中采样的。 因此，如果对于特定电影，给定的隐藏单位激活为`(p[1], p[2], p[3], p[4], p[5])`，然后可以从多项式分布中抽样选择五个评分中的评分值， 其概率质量函数如下：
+在定义隐藏单元和可见单元的输出时，还有一件重要的事情是需要概率抽样，而不是将输出默认为具有最大概率的抽样。 如果给定可见单元的隐藏单元激活的概率为`P`，则统一生成`[0, 1]`范围内的随机数`r`，并且如果`P > r`，则隐藏单元激活设置为`true`。 该方案将确保在很长的一段时间内以概率`P`将激活设置为`true`。 类似地，电影的可见单元是根据跨国公司发行给定隐藏单元的概率从跨国发行机构中采样的。 因此，如果对于特定电影，给定的隐藏单元激活为`(p[1], p[2], p[3], p[4], p[5])`，然后可以从多项式分布中抽样选择五个评分中的评分值， 其概率质量函数如下：
 
 ![](img/c23ff63c-d7c9-4531-b0b0-19c04bd9678e.png)
 
@@ -474,11 +474,11 @@ python preprocess_ratings.py --path '/home/santanu/ML_DS_Catalog-/Collaborating
 
 # 建立用于协同过滤的 RBM 网络
 
-以下函数`_network`为协同过滤创建所需的 RBM 结构。 首先，我们定义输入的权重，偏差和占位符。 然后定义`sample_hidden`和`sample_visible`函数，以根据概率分别对隐藏的激活和可见的激活进行采样。 隐藏的单位是从 Sigmoid 函数提供的概率从伯努利分布中采样的，而与每个电影有关的可见单元是根据 softmax 函数提供的概率从多项分布中采样的。 无需创建 softmax 概率，因为`tf.multinomial`函数可以直接从对率采样，而不是实际概率。
+以下函数`_network`为协同过滤创建所需的 RBM 结构。 首先，我们定义输入的权重，偏差和占位符。 然后定义`sample_hidden`和`sample_visible`函数，以根据概率分别对隐藏的激活和可见的激活进行采样。 隐藏的单元是从 Sigmoid 函数提供的概率从伯努利分布中采样的，而与每个电影有关的可见单元是根据 softmax 函数提供的概率从多项分布中采样的。 无需创建 softmax 概率，因为`tf.multinomial`函数可以直接从对率采样，而不是实际概率。
 
 接下来，我们根据吉布斯采样定义对比差异的逻辑。 `gibbs_step`函数执行吉布斯采样的一个步骤，然后利用它来实现`k`阶的对比散度。
 
-现在我们拥有所有必需的函数，我们将创建 TensorFlow 操作，以在给定可见输入的情况下对隐藏状态`self.h`进行采样，并在给定采样状态下对可见单位`self.x`进行采样。 我们还使用对比散度从`v`和`h`的联合概率分布（即`P(v,h/model)`）中抽取`(self.x_s,self.h_s)`作为代表性样本，以计算梯度中的不同期望项。
+现在我们拥有所有必需的函数，我们将创建 TensorFlow 操作，以在给定可见输入的情况下对隐藏状态`self.h`进行采样，并在给定采样状态下对可见单元`self.x`进行采样。 我们还使用对比散度从`v`和`h`的联合概率分布（即`P(v,h/model)`）中抽取`(self.x_s,self.h_s)`作为代表性样本，以计算梯度中的不同期望项。
 
 `_network`函数的最后一步基于梯度更新 RBM 模型的权重和偏差。 如我们先前所见，梯度基于给定可见层输入的隐藏层激活`self.h`以及通过对比发散得出的联合概率分布`P(v,h/model)`的代表性样本`(self.x_s,self.h_s)`。
 

new/intel-proj-py/09.md

@@ -34,7 +34,7 @@
 
 ![](img/fd483030-7af9-4f3f-90ca-321cbcf08493.png)
 
-现在，我们拥有定义马尔可夫决策过程所需的一切。 马尔可夫决策过程是一个系统，其特征在于以下四个要素：
+现在，我们拥有定义马尔可夫决策过程所需的一切。 马尔可夫决策过程是一个系统，其特征在于以下四个特征：
 
 *   一组状态`S`
 *   一组动作`A`
@@ -140,7 +140,7 @@ Q 值表也通过迭代`t`进行索引，因为智能体只能查看到目前为
 
 # 离散化深度 Q 学习的动作
 
-离散化动作对于深度 Q 学习非常重要，因为三维连续动作空间可以具有无限的 Q 值，并且在深度 Q 网络的输出层中不可能为每个动作单独设置单位。 动作空间的三个维度如下：
+离散化动作对于深度 Q 学习非常重要，因为三维连续动作空间可以具有无限的 Q 值，并且在深度 Q 网络的输出层中不可能为每个动作单独设置单元。 动作空间的三个维度如下：
 
 **Steering**：`[-1, 1]`
 

new/master-pred-anal-sklearn-tf/0.md

@@ -16,7 +16,7 @@ Python 是一种编程语言，可提供数据科学领域的各种功能。 在
 
 第 2 章，“交叉验证和参数调整”探索了各种技术来组合和构建更好的模型。 我们将学习不同的交叉验证方法，包括保留交叉验证和 k 折交叉验证。 我们还将讨论什么是超参数调优。
 
-第 3 章，“处理特征”，探讨了特征选择方法，降维，PCA 和要素工程。 我们还将研究通过特征工程改进模型的方法。
+第 3 章，“处理特征”，探讨了特征选择方法，降维，PCA 和特征工程。 我们还将研究通过特征工程改进模型的方法。
 
 第 4 章，“人工神经网络和 TensorFlow 简介”是 ANN 和 TensorFlow 的简介。 我们将探索网络中的各种元素及其功能。 我们还将在其中学习 TensorFlow 的基本概念。
 

new/master-pred-anal-sklearn-tf/1.md

@@ -60,7 +60,7 @@
 
 # 随机森林
 
-该集成方法是专门为回归树或分类树创建的。 它与装袋非常相似，因为在这里，每棵树都是在训练数据集的引导样本上训练的。 装袋的不同之处在于，它使模型非常强大，并且在从树中拆分节点时，选择的拆分在要素的随机子集中是最好的。 因此，每个预测变量都会考虑特征的随机子集。 这具有使每个单独的预测变量稍微更差，更偏颇的效果，但是由于各个预测变量的相关性，总体上总体上要比单个预测变量更好。
+该集成方法是专门为回归树或分类树创建的。 它与装袋非常相似，因为在这里，每棵树都是在训练数据集的引导样本上训练的。 装袋的不同之处在于，它使模型非常强大，并且在从树中拆分节点时，选择的拆分在特征的随机子集中是最好的。 因此，每个预测变量都会考虑特征的随机子集。 这具有使每个单独的预测变量稍微更差，更偏颇的效果，但是由于各个预测变量的相关性，总体上总体上要比单个预测变量更好。
 
 # 提升
 

new/master-pred-anal-sklearn-tf/2.md

@@ -300,7 +300,7 @@ X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_
 我们将使用以下参数调整`RandomForestRegressor`模型：
 
 *   `n_estimators`：此参数表示森林中的树木数量。
-*   `max_features`：此参数表示寻找最佳分割时要考虑的特征数量。 可能的选择是`n_features`，它对应于自动超参数，或者是要素数量的`log2`的平方根。
+*   `max_features`：此参数表示寻找最佳分割时要考虑的特征数量。 可能的选择是`n_features`，它对应于自动超参数，或者是特征数量的`log2`的平方根。
 *   `max_depth`：此参数表示树的最大深度。
 
 这些参数将使用带有网格搜索的不同值。 对于`n_estimators`和`max_depth`，我们将使用四个不同的值。 对于`n_estimators`，我们将使用`[25,50,75,100]`作为值，对于`max_depth`，我们将使用`[10,15,20,30]`作为值。 对于`max_features`，我们将使用自动和平方根。

new/master-pred-anal-sklearn-tf/3.md

 # 使用特征
 
-在本章中，我们将仔细研究要素如何在要素工程技术中发挥重要作用。 我们将学习一些技术，这些技术将使我们能够通过两种方式改进预测分析模型：就模型的性能指标而言，以及了解特征与我们试图预测的目标变量之间的关系。
+在本章中，我们将仔细研究特征如何在特征工程技术中发挥重要作用。 我们将学习一些技术，这些技术将使我们能够通过两种方式改进预测分析模型：就模型的性能指标而言，以及了解特征与我们试图预测的目标变量之间的关系。
 
 在本章中，我们将涵盖以下主题：
 
@@ -147,7 +147,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 # 降维和 PCA
 
-降维方法是通过获取一组主变量来减少所考虑要素数量的过程。 **主成分分析**（**PCA**）技术是用于降维的最重要技术。 在这里，我们将讨论为什么需要降维，并且还将在`scikit-learn`中看到如何执行 PCA 技术。
+降维方法是通过获取一组主变量来减少所考虑特征数量的过程。 **主成分分析**（**PCA**）技术是用于降维的最重要技术。 在这里，我们将讨论为什么需要降维，并且还将在`scikit-learn`中看到如何执行 PCA 技术。
 
 这些是在进行预测分析时拥有大量特征的原因：
 
@@ -157,7 +157,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 在本章前面看到的特征选择可以认为是降维的一种形式。 当您具有一组紧密相关甚至冗余的特征时，PCA 将是使用较少特征对相同信息进行编码的首选技术。 那么，什么是 PCA？ 这是一种统计过程，将一组可能相关的变量的观测值转换为一组线性无关的变量，称为**主成分**。 我们不要讨论有关 PCA 发生了什么的数学细节。
 
-假设我们有一个二维数据集。 PCA 确定数据集变化最大的方向，并将关于这两个要素的最大信息量编码为一个要素，以将维数从二维减少为一个。 此方法将每个点投影到这些轴或新大小上。
+假设我们有一个二维数据集。 PCA 确定数据集变化最大的方向，并将关于这两个特征的最大信息量编码为一个特征，以将维数从二维减少为一个。 此方法将每个点投影到这些轴或新大小上。
 
 如下面的屏幕截图所示，这两个特征的第一个主要组成部分是点到红线上的投影，这是 PCA 中发生的事情的主要数学直觉：
 
@@ -187,7 +187,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 ![](img/14f1e55c-9574-4e3f-a89e-902ba51eb556.png)
 
-之后，我们实例化此`PCA`对象。 然后，我们将要应用 PCA 分解的列或要素传递给：
+之后，我们实例化此`PCA`对象。 然后，我们将要应用 PCA 分解的列或特征传递给：
 
 ![](img/f4998794-1b14-4646-83ca-ab9e871a4de8.png)
 
@@ -209,8 +209,8 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 # 特征工程
 
-特征工程在使机器学习算法正常工作中起着至关重要的作用，如果正确执行，它会增强机器学习算法的预测能力。 换句话说，特征工程是使用领域知识，问题的上下文或产生更准确的预测模型的专门技术，从原始数据中提取现有特征或创建新特征的过程。 这是一项领域知识和创造力起着非常重要作用的活动。 这是一个重要的过程，可以显着提高我们的预测模型的性能。 您对问题的了解越多，创建新的有用特征的能力就越强。 基本上，要素工程过程会将要素转换为算法可以理解的输入值。
-有多种实现要素工程的方法。 您可能会发现所有技术都不可行，并且最终可能会排除其中的一些技术。 这样做的目的不是要就此主题进行学术讨论，而是要向您展示在使用要素和尝试创建新要素时我们所做的一些常见操作。 第一个是缩放特征，用于将其范围转换为更合适的特征。 另一个是以更好的方式对信息进行编码，我们将在本章后面看到一个示例。 特征工程涉及从现有特征创建新特征，以便您可以通过对现有特征执行一些数学运算来组合它们。
+特征工程在使机器学习算法正常工作中起着至关重要的作用，如果正确执行，它会增强机器学习算法的预测能力。 换句话说，特征工程是使用领域知识，问题的上下文或产生更准确的预测模型的专门技术，从原始数据中提取现有特征或创建新特征的过程。 这是一项领域知识和创造力起着非常重要作用的活动。 这是一个重要的过程，可以显着提高我们的预测模型的性能。 您对问题的了解越多，创建新的有用特征的能力就越强。 基本上，特征工程过程会将特征转换为算法可以理解的输入值。
+有多种实现特征工程的方法。 您可能会发现所有技术都不可行，并且最终可能会排除其中的一些技术。 这样做的目的不是要就此主题进行学术讨论，而是要向您展示在使用特征和尝试创建新特征时我们所做的一些常见操作。 第一个是缩放特征，用于将其范围转换为更合适的特征。 另一个是以更好的方式对信息进行编码，我们将在本章后面看到一个示例。 特征工程涉及从现有特征创建新特征，以便您可以通过对现有特征执行一些数学运算来组合它们。
 创建新特征的另一种方法是使用降维技术，例如我们之前看到的 PCA。 只要您使它具有创造力，使用哪种技术都没有关系。 如前所述，您对问题的了解越多越好。
 
 # 创建新特征
@@ -352,7 +352,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 ![](img/6062dd52-525e-48e5-90ed-caa3e760dbe1.png)
 
-您可以将此特征的重要性与之前的特征进行比较。 应用要素工程后，您可以做很多事情。 我们可能会提高性能并从模型中获得见识。 已经观察到，通过使用此技术，我们对模型进行了一些改进。 现在，您可以提出不同的方法来组合现有特征，以进一步改善模型。 这只是一个简单的小例子，向您展示您可以实际使用有意义的特征来玩这些特征。
+您可以将此特征的重要性与之前的特征进行比较。 应用特征工程后，您可以做很多事情。 我们可能会提高性能并从模型中获得见识。 已经观察到，通过使用此技术，我们对模型进行了一些改进。 现在，您可以提出不同的方法来组合现有特征，以进一步改善模型。 这只是一个简单的小例子，向您展示您可以实际使用有意义的特征来玩这些特征。
 
 # 可减少和不可减少的误差
 

new/master-pred-anal-sklearn-tf/4.md

 # 人工神经网络和 TensorFlow 简介
 
-在本章中，我们将介绍**人工神经网络**（**ANN**），它们基本上是受活脑和感知器启发的计算模型，而感知器是 ANN 的基础。 我们还将讨论构建深度神经网络模型时要考虑的所有要素。 然后，我们将讨论 TensorFlow，这是我们将用来创建这些深度神经网络模型的库。 最后，我们将讨论我们需要了解的有关 TensorFlow 的核心概念，以便使用这些库概念，例如变量，占位符，会话，图形以及其他对于使用此库必不可少的概念。
+在本章中，我们将介绍**人工神经网络**（**ANN**），它们基本上是受活脑和感知器启发的计算模型，而感知器是 ANN 的基础。 我们还将讨论构建深度神经网络模型时要考虑的所有特征。 然后，我们将讨论 TensorFlow，这是我们将用来创建这些深度神经网络模型的库。 最后，我们将讨论我们需要了解的有关 TensorFlow 的核心概念，以便使用这些库概念，例如变量，占位符，会话，图以及其他对于使用此库必不可少的概念。
 
 以下是随着我们的前进将涉及的主题：
 
@@ -99,7 +99,7 @@
 
 在多层感知器中构建深度学习模型时，需要考虑很多因素。 您必须考虑架构，激活函数，优化算法，`loss`函数，权重初始化策略，正则化策略和训练策略。 我们将在以下列表中讨论有关它们的更多信息：
 
-*   **架构**：构建深度学习模型时，您需要考虑的第一个元素是 MLP 的架构。 当我们说架构时，我们在谈论的是层数和每层神经元数。 输入层中神经元的数量由数据集中的要素数量决定。 输出值的数量也是如此。 因此，它们基本上由您在分类设置中的问题确定。 输出值的数量通常是分类问题中的类数，而在回归问题中，输出层中将只有一个输出。 您必须做出的选择是要使用多少个隐藏层以及每个隐藏层的神经元数量。 设置这些数字并不容易。 实际上，我们要做的是首先使用几层。 如果有几层不起作用，也许我们增加更多层，每层的神经元数量就是输入值数量和输出数量`[n_inputs, n_outputs]`之间的数字。
+*   **架构**：构建深度学习模型时，您需要考虑的第一个元素是 MLP 的架构。 当我们说架构时，我们在谈论的是层数和每层神经元数。 输入层中神经元的数量由数据集中的特征数量决定。 输出值的数量也是如此。 因此，它们基本上由您在分类设置中的问题确定。 输出值的数量通常是分类问题中的类数，而在回归问题中，输出层中将只有一个输出。 您必须做出的选择是要使用多少个隐藏层以及每个隐藏层的神经元数量。 设置这些数字并不容易。 实际上，我们要做的是首先使用几层。 如果有几层不起作用，也许我们增加更多层，每层的神经元数量就是输入值数量和输出数量`[n_inputs, n_outputs]`之间的数字。
 
 这只是一个经验法则。 但是，有更多正式的方法可以选择隐藏层的数量和神经元的数量，研究人员一直在努力寻找更好的方法来选择这些值。
 
@@ -195,12 +195,12 @@ pip install --ignore-installed --upgrade tensorflow
 
 # 张量
 
-**张量**是 TensorFlow 中数据的中央单位。 张量由一组原始值组成，这些原始值成形为任意数量的维数组。 它基本上是类似于 NumPy 数组的多维数组。 维数定义张量的等级。 让我们看下面的一些例子：
+**张量**是 TensorFlow 中数据的中央单元。 张量由一组原始值组成，这些原始值成形为任意数量的维数组。 它基本上是类似于 NumPy 数组的多维数组。 维数定义张量的等级。 让我们看下面的一些例子：
 
 *   `3`：如果我们只有一个数字，则将张量视为等级`0`张量。 这可以是`shape[]`的标量。
 *   `[2., 2., 1.]`：如果我们有一个向量，它将被认为是等级`1`张量，因此我们将其称为形状`3`的向量，因为它具有三个元素。
 *   `[[9., 5., 3.], [4., 5., 7]]`：形状为`[2, 3]`的矩阵将是等级`2`张量。
-*   `[[[8., 3.]], [[7., 9.,]]]`：形状为`[2, 1, 2]`的矩阵将是等级`3`张量，如您在最外层看到的，我们有两个元素，在下一层，我们只有一个元素，在最后一维， 我们有两个要素。 这就是为什么我们将`2`，`1`和`2`用作值并且它们都是张量的原因。
+*   `[[[8., 3.]], [[7., 9.,]]]`：形状为`[2, 1, 2]`的矩阵将是等级`3`张量，如您在最外层看到的，我们有两个元素，在下一层，我们只有一个元素，在最后一维， 我们有两个特征。 这就是为什么我们将`2`，`1`和`2`用作值并且它们都是张量的原因。
 
 # 计算图
 
@@ -227,7 +227,7 @@ pip install --ignore-installed --upgrade tensorflow
 
 *   **会话**：会话是封装执行操作对象的环境的对象。 因此，会话是将操作放置在 CPU 或 GPU 等设备上的对象。
 *   **占位符**：占位符是对稍后提供值的承诺。 这些对象通常用于在机器学习模型中提供训练和测试值。
-*   **变量**：这些是用值初始化的对象，该值可以在图形执行期间更改。 通常，它们在机器学习模型中用作可训练变量。
+*   **变量**：这些是用值初始化的对象，该值可以在图执行期间更改。 通常，它们在机器学习模型中用作可训练变量。
 *   **常量**：常量是其值永不变的对象。
 
 为了更好地理解这些对象概念，让我们看一个例子。 首先，我们将通过执行以下代码片段导入所需的库：
@@ -309,6 +309,6 @@ adder_node = mult_node + quadruple_node
 
 # 总结
 
-在本章中，我们讨论了人工神经网络，深度学习以及深度学习模型的要素。 然后，我们安装了 TensorFlow，并了解了我们在 TensorFlow 中使用的核心概念。
+在本章中，我们讨论了人工神经网络，深度学习以及深度学习模型的特征。 然后，我们安装了 TensorFlow，并了解了我们在 TensorFlow 中使用的核心概念。
 
 在下一章中，我们将使用 TensorFlow 和深度学习执行预测分析。
\ No newline at end of file

new/master-pred-anal-sklearn-tf/5.md

@@ -98,7 +98,7 @@ X = tf.placeholder(tf.float32, shape=[None, n_inputs])
 y = tf.placeholder(tf.int64)
 ```
 
-因此，对于要素（即输入层），我们有一个占位符`X`；对于目标值，我们有一个占位符`y`。 因此，此对象将包含数字的实际真标签。
+因此，对于特征（即输入层），我们有一个占位符`X`；对于目标值，我们有一个占位符`y`。 因此，此对象将包含数字的实际真标签。
 
 # 建立神经网络
 
@@ -136,7 +136,7 @@ y = tf.placeholder(tf.int64)
 
 ![](img/dfff9daa-7bfb-4207-bb88-7419a4c8654a.png)
 
-在第 3 行中，我们初始化程序中的所有变量。 现在，在这里，我们没有任何明确的变量。 但是，内部的变量是全连接。 `fully_connected`函数是我们包含权重的所有隐藏层的地方。 这些就是变量，这就是为什么我们必须使用`global_ variables_initializer`对象初始化变量并运行此节点的原因。 对于每个时期，我们运行此循环 20 次。 现在，对于批量数量超过 80 的示例数量中的每次迭代，我们将获得要素和目标的值。 因此，每次迭代将有 80 个数据点。 然后，我们运行训练操作，并将通过`x`； 我们将传递特征值，在这里我们将传递目标值。 请记住，`x`和`y`是我们的占位符。 然后，我们评估训练的准确性，然后评估测试数据集中的准确性，从而获得测试数据集。 我们来自`mnist.test.images`，因此现在这些都是特征，`test.labels`是目标。 然后，在这两个循环完成之后，我们将打印两个精度。
+在第 3 行中，我们初始化程序中的所有变量。 现在，在这里，我们没有任何明确的变量。 但是，内部的变量是全连接。 `fully_connected`函数是我们包含权重的所有隐藏层的地方。 这些就是变量，这就是为什么我们必须使用`global_ variables_initializer`对象初始化变量并运行此节点的原因。 对于每个时期，我们运行此循环 20 次。 现在，对于批量数量超过 80 的示例数量中的每次迭代，我们将获得特征和目标的值。 因此，每次迭代将有 80 个数据点。 然后，我们运行训练操作，并将通过`x`； 我们将传递特征值，在这里我们将传递目标值。 请记住，`x`和`y`是我们的占位符。 然后，我们评估训练的准确性，然后评估测试数据集中的准确性，从而获得测试数据集。 我们来自`mnist.test.images`，因此现在这些都是特征，`test.labels`是目标。 然后，在这两个循环完成之后，我们将打印两个精度。
 
 然后，我们为测试数据集中的前 15 张图像生成一些单独的预测。 运行此步骤后，我们获得了第一个周期，其训练准确度为 86%，测试准确度为 88-89%。 以下屏幕截图显示了训练的结果以及不同时期的测试结果：
 
@@ -160,7 +160,7 @@ y = tf.placeholder(tf.int64)
 
 在运行模型之前，我们首先必须确定用于构建多层感知器模型的元素，如下所示：
 
-*   **架构**：该模型在输入层中包含 23 个元素，因此在此数据集中有 25 个要素。 尽管可以使用任意数量的隐藏层，但在输出层中只有一个元素，并且将使用三个隐藏层。 我们将在第一层使用 256 个神经元，第二层使用 128 个神经元，第三层使用 64 个神经元。 这是两个的力量。
+*   **架构**：该模型在输入层中包含 23 个元素，因此在此数据集中有 25 个特征。 尽管可以使用任意数量的隐藏层，但在输出层中只有一个元素，并且将使用三个隐藏层。 我们将在第一层使用 256 个神经元，第二层使用 128 个神经元，第三层使用 64 个神经元。 这是两个的力量。
 *   **激活函数**：我们将选择 ReLu 激活函数。
 *   **优化算法**：这里使用的优化算法是 Adam 优化器。 Adam 优化器是最受欢迎的优化器之一，因为它是解决许多问题的最佳选择。
 *   **损失函数**：我们将使用均方误差，因为我们在这里进行回归问题，这是`loss`函数的最佳选择之一。
@@ -294,7 +294,7 @@ y = tf.placeholder(y_train.dtype)
 中将使用的元素，如下所示：
 
 *   **架构**：该模型在输入层中包含 25 个元素，因为我们在数据集中具有
-    25 个要素。 在输出层中我们有两个元素，尽管我们可以使用任意数量的隐藏
+    25 个特征。 在输出层中我们有两个元素，尽管我们可以使用任意数量的隐藏
     层，但
     也将使用三个隐藏层。 我们将在每层中使用相同数量的神经元，即 200。在这里，我们使用
     的 2 的幂进行选择。

new/whats-new-tf2/1.md

@@ -33,7 +33,7 @@ TF 1.x 和 TF 2.0 之间的第一个主要区别是 API 的组织。 TF 2.0 减
 
 `tf.contrib`库现在也已从主要 TensorFlow 存储库中删除。 该库中实现的代码已移至其他位置或已移至 TensorFlow 附加库。 这样做的原因是`contrib`模块已经超出了单个存储库中可以维护的范围。
 
-其他更改包括删除`QueueRunner`模块以支持使用`tf.data`，删除图形集合以及更改如何处理变量。 `QueueRunner`模块是一种向模型提供数据以进行训练的方法，但是它比`tf.data`复杂且难于使用，后者现在是将数据提供给模型的默认方法。 在第 3 章“设计和构造输入数据管道”中，说明了将`tf.data`用于数据管道的其他好处。
+其他更改包括删除`QueueRunner`模块以支持使用`tf.data`，删除图集合以及更改如何处理变量。 `QueueRunner`模块是一种向模型提供数据以进行训练的方法，但是它比`tf.data`复杂且难于使用，后者现在是将数据提供给模型的默认方法。 在第 3 章“设计和构造输入数据管道”中，说明了将`tf.data`用于数据管道的其他好处。
 
 TF 2.0 的另一个主要变化是没有更多的全局变量。 在 TF 1.x 中，使用`tf.Variable`创建的变量将被放在默认图中，并且仍可以通过其名称恢复。 TF 1.x 具有各种机制，旨在帮助用户恢复变量，例如变量作用域，全局集合以及诸如`tf.get_global_step`和`tf.global_variables_initializer`之类的辅助方法。 对于 TF 中的默认变量行为，所有这些都已在 TF 2.0 中删除。
 
@@ -142,7 +142,7 @@ python3 -c "import tensorflow as tf; a = tf.constant(1); print(tf.math.add(a, a)
 
 TF 2.0 可以通过两种主要方式使用-使用低级 API 和使用高级 API。 为了在 TF 2.0 中使用低级 API，需要实现诸如`tf.GradientTape`和`tf.function`之类的 API。
 
-编写低级代码的代码流程是定义函数内部的前向传递，该函数将输入数据作为参数。 然后使用`tf.function`装饰器对该函数进行注解，以便在图形模式下运行它及其所有优点。 为了记录和获得前向通过的梯度，装饰器函数和损失函数都在`tf.GradientTape`上下文管理器中运行，可以从中计算梯度并将其应用于模型变量。
+编写低级代码的代码流程是定义函数内部的前向传递，该函数将输入数据作为参数。 然后使用`tf.function`装饰器对该函数进行注解，以便在图模式下运行它及其所有优点。 为了记录和获得前向通过的梯度，装饰器函数和损失函数都在`tf.GradientTape`上下文管理器中运行，可以从中计算梯度并将其应用于模型变量。
 
 训练代码也可以使用低级 API 编写，用于...
 

new/whats-new-tf2/2.md

@@ -206,7 +206,7 @@ my_model_architecture = my_model.get_config()
 
 # 加载和保存权重
 
-在 Python API 中，`tensorflow.keras`使用 NumPy 数组作为权重交换的单位。 这与用于加载和保存架构的 API 非常相似。 这些 NumPy 数组也可以使用原生 Python 技术保存到磁盘中。 `get_weights()`和`set_weights()`方法大致类似于`get_config()`和`from_config()`。 前者返回对应于模型中不同层的 NumPy 数组列表。 后者接受 NumPy 数组列表并更新内存中的模型。
+在 Python API 中，`tensorflow.keras`使用 NumPy 数组作为权重交换的单元。 这与用于加载和保存架构的 API 非常相似。 这些 NumPy 数组也可以使用原生 Python 技术保存到磁盘中。 `get_weights()`和`set_weights()`方法大致类似于`get_config()`和`from_config()`。 前者返回对应于模型中不同层的 NumPy 数组列表。 后者接受 NumPy 数组列表并更新内存中的模型。
 
 以下代码段说明了如何获取现有模型的权重：
 
@@ -303,7 +303,7 @@ loaded_model = tf.keras.models.load_model(
 
 *   一个包含模型权重的 TensorFlow 检查点
 *   包含底层 TensorFlow 图的`SavedModel`原型：
-    *   默认情况下，为预测阶段保存了单独的图表（训练和评估阶段也分别在适用时存储）
+    *   默认情况下，为预测阶段保存了单独的图（训练和评估阶段也分别在适用时存储）
 *   模型的架构配置（如果有）
 
 在 Python API 中，与`SavedModel ...`进行交互
@@ -396,7 +396,7 @@ TensorFlow 团队尝试通过引入 Estimators 来解决此问题，Estimators
 
 # 求值 TensorFlow 图
 
-TensorFlow 的中心思想是，要求程序员创建计算图以指定需要执行的操作才能获得所需的结果。 然后，程序员指定了硬件和其他环境参数，以针对给定的一组输入来计算此计算图的输出。 这意味着在程序员明确计算图形之前，值和变量没有任何值。 当程序员真正想要的只是数量的值时，这增加了程序员创建和管理会话的开销。
+TensorFlow 的中心思想是，要求程序员创建计算图以指定需要执行的操作才能获得所需的结果。 然后，程序员指定了硬件和其他环境参数，以针对给定的一组输入来计算此计算图的输出。 这意味着在程序员明确计算图之前，值和变量没有任何值。 当程序员真正想要的只是数量的值时，这增加了程序员创建和管理会话的开销。
 
 TF 2.0 旨在通过更改求值和计算基础计算图的方式来解决此问题。 用一个句子，TF ...
 

new/whats-new-tf2/4.md

@@ -338,9 +338,9 @@ print("Final loss: {:.3f}".format(loss(model, input_x, input_y)))
 print("W = {}, B = {}".format(*model.trainable_variables))
 ```
 
-TF 2.0 中添加的另一个功能是`tf.function`装饰器。 用`tf.function`注解函数时，它仍然像任何其他 Python 函数一样工作，但是将被编译成图形，这提供了诸如执行速度更快，GPU 和 TPU 加速之类的好处，并且可以轻松导出到`SavedModel`。
+TF 2.0 中添加的另一个功能是`tf.function`装饰器。 用`tf.function`注解函数时，它仍然像任何其他 Python 函数一样工作，但是将被编译成图，这提供了诸如执行速度更快，GPU 和 TPU 加速之类的好处，并且可以轻松导出到`SavedModel`。
 
-并非所有函数都需要使用`tf.function`进行注解，因为在带注解的函数内部调用的任何函数也将在图形模式下运行。 对于具有多个较小操作的图形，此类函数速度更快，但对于其他具有较昂贵操作（例如卷积）的图形，改进效果会较小。
+并非所有函数都需要使用`tf.function`进行注解，因为在带注解的函数内部调用的任何函数也将在图模式下运行。 对于具有多个较小操作的图，此类函数速度更快，但对于其他具有较昂贵操作（例如卷积）的图，改进效果会较小。
 
 `tf.function`装饰器还可以绘制 Python 控制流图，例如`if`，`while`，`for`，`break`，`continue`和`return`。 运行这些功能可实现更快的求值和硬件加速。
 
@@ -422,7 +422,7 @@ TensorBoard 是 TensorFlow 平台最重要的优势之一，而有了 TF 2.0，T
 
 TensorBoard 可以在 TF 2.0 中以两种主要方式使用。 一种方法是在使用`tf.keras.Model.fit()`训练模型时将其用作回调，另一种方法是将`tf.summary`用于使用`tf.GradientTape`的较低级模型。
 
-要在 Keras 模型训练中使用 TensorBoard，我们需要指定一个 TensorBoard 回调，该回调以`logdir`作为参数。 TensorBoard 回调的其他参数包括`histogram_freq`，`write_graph`，`write_images`和`update_freq`。 `histogram_freq`允许用户指定应该多久计算一次激活和权重直方图，并需要指定验证数据。 `write_graph`指定是否要在 TensorBoard 中可视化模型的图形，...
+要在 Keras 模型训练中使用 TensorBoard，我们需要指定一个 TensorBoard 回调，该回调以`logdir`作为参数。 TensorBoard 回调的其他参数包括`histogram_freq`，`write_graph`，`write_images`和`update_freq`。 `histogram_freq`允许用户指定应该多久计算一次激活和权重直方图，并需要指定验证数据。 `write_graph`指定是否要在 TensorBoard 中可视化模型的图，...
 
 # 可视化标量，度量，张量和图像数据
 
@@ -502,8 +502,8 @@ TensorBoard 的图形仪表板提供可视化和检查 TensorFlow 模型的功
 
 在 TF 2.0 中，按照以下步骤查看操作级图非常简单：
 
-1.  将 TensorBoard 回调添加到`Model.fit`以确保图形数据记录在 TensorBoard 中。
-2.  运行后，打开 TensorBoard 并导航到顶部栏上的“图形”选项卡以查看图形。 默认情况下，TensorBoard 显示操作级别图，该图显示...
+1.  将 TensorBoard 回调添加到`Model.fit`以确保图数据记录在 TensorBoard 中。
+2.  运行后，打开 TensorBoard 并导航到顶部栏上的“图”选项卡以查看图。 默认情况下，TensorBoard 显示操作级别图，该图显示...
 
 # 超参数调优
 

new/whats-new-tf2/5.md

@@ -62,7 +62,7 @@ import tensorflow as tf
 
 # `tf.autograph`函数
 
-到目前为止，我们已经看到了如何从 Python 函数创建 TensorFlow 图形代码。 TF 2.0 将 Python-TensorFlow 耦合提升到了一个全新的水平。 新引入的 AutoGraph（`tf.autograph`）函数使用户可以使用本机 Python 语法编写图形代码。
+到目前为止，我们已经看到了如何从 Python 函数创建 TensorFlow 图的代码。 TF 2.0 将 Python-TensorFlow 耦合提升到了一个全新的水平。 新引入的 AutoGraph（`tf.autograph`）函数使用户可以使用本机 Python 语法编写图的代码。
 
 当前，此功能仅支持 Python 语法的有限子集。 [这个页面](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/autograph/LIMITATIONS.md)中提供了当前支持的语法元素的详细列表。
 
@@ -100,7 +100,7 @@ print(result)
 tf.Tensor(225, shape=(), dtype=int32)
 ```
 
-正如我们在提取的输出中看到的那样，我们已经编写的纯 Python 函数现在被转换为 TensorFlow 图。 函数现在返回张量而不是单个数字的事实证明了这一点。 输出值与预期值相同。 有效地，我们已经证明了特定于 Python 的语法结构（例如`for`循环和幂运算符）已成功转换为 TensorFlow 图形代码。 这是`tf.function`和 AutoGraph 的真正功能。 由于我们现在已经有效地将本机 Python 代码转换为 TensorFlow 计算图，因此可以使用`SavedModel`格式在环境之间共享此图。
+正如我们在提取的输出中看到的那样，我们已经编写的纯 Python 函数现在被转换为 TensorFlow 图。 函数现在返回张量而不是单个数字的事实证明了这一点。 输出值与预期值相同。 有效地，我们已经证明了特定于 Python 的语法结构（例如`for`循环和幂运算符）已成功转换为 TensorFlow 图的代码。 这是`tf.function`和 AutoGraph 的真正功能。 由于我们现在已经有效地将本机 Python 代码转换为 TensorFlow 计算图，因此可以使用`SavedModel`格式在环境之间共享此图。
 
 # 导出自己的 SavedModel 模型
 
@@ -127,7 +127,7 @@ def compute_square(number):
 
 ```
 
-到目前为止，我们已经成功实现了一个 TensorFlow 计算图，该图可以计算给定一维张量的平方。 现在唯一要做的就是以`SavedModel`格式将此图形导出到磁盘。 您可能还记得，`tf.saved_model`模块中提供了用于`SavedModel`的 API。 [在阅读该模块的文档](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/saved_model)时，我们发现`save`方法可能会对我们有所帮助。 一个粗糙的边缘是`tf.saved_model.save`方法仅适用于`Trackable`类型的对象，而我们所拥有的是`tf.function()`对象（属于`Trackable`类型或其子类）。 为了克服这个问题，我们只需将代码包装在实现`Trackable`接口的类中：
+到目前为止，我们已经成功实现了一个 TensorFlow 计算图，该图可以计算给定一维张量的平方。 现在唯一要做的就是以`SavedModel`格式将此图导出到磁盘。 您可能还记得，`tf.saved_model`模块中提供了用于`SavedModel`的 API。 [在阅读该模块的文档](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/saved_model)时，我们发现`save`方法可能会对我们有所帮助。 一个粗糙的边缘是`tf.saved_model.save`方法仅适用于`Trackable`类型的对象，而我们所拥有的是`tf.function()`对象（属于`Trackable`类型或其子类）。 为了克服这个问题，我们只需将代码包装在实现`Trackable`接口的类中：
 
 ```py
 class Square(tf.Module):

new/whats-new-tf2/7.md

@@ -22,9 +22,9 @@ TF 1.x 中的`session.run()`调用与...非常相似。
 
 # 适用于 TF 2.0 的推荐技术
 
-第一条建议涉及在 TF 2.0 中处理常规代码工作流。 TF 1.x 中常见的工作流程是使用瀑布策略，其中所有计算都布置在默认图形上。 然后，使用`session.run()`运行选定的张量。 在 TF 2.0 中，应将代码重构为较小的函数，这些函数将在需要时调用。 这些函数可以是普通的 Python 函数，但如果在另一个以`tf.function`注解的函数中调用它们，则仍可以在图形模式下运行。 这意味着`tf.function`仅应用于注解高级计算，例如模型的前向传递或单个训练步骤。
+第一条建议涉及在 TF 2.0 中处理常规代码工作流。 TF 1.x 中常见的工作流程是使用瀑布策略，其中所有计算都布置在默认图上。 然后，使用`session.run()`运行选定的张量。 在 TF 2.0 中，应将代码重构为较小的函数，这些函数将在需要时调用。 这些函数可以是普通的 Python 函数，但如果在另一个以`tf.function`注解的函数中调用它们，则仍可以在图模式下运行。 这意味着`tf.function`仅应用于注解高级计算，例如模型的前向传递或单个训练步骤。
 
-以前，模型和训练循环所需的所有计算都将预先确定并编写，并使用`session.run()`执行。 这使得 TF 1.x 代码对于大多数编码人员来说很难遵循，因为模型的流程可能与图形的编码方式完全不同，因为该图是在最后运行的。 急切执行和`tf.function`专门用于简化 TensorFlow 代码动态过程，并使其他开发人员更容易理解预编写的代码。
+以前，模型和训练循环所需的所有计算都将预先确定并编写，并使用`session.run()`执行。 这使得 TF 1.x 代码对于大多数编码人员来说很难遵循，因为模型的流程可能与图的编码方式完全不同，因为该图是在最后运行的。 急切执行和`tf.function`专门用于简化 TensorFlow 代码动态过程，并使其他开发人员更容易理解预编写的代码。
 
 管理和跟踪变量是 TF 1.x 中另一个复杂的过程。 使用了许多方法来控制和访问这些变量，这为线性代码增加了更多的维度。 TF 2.0 更加强调使用`tf.keras`层和`tf.estimator`模型来管理模型中的变量。
 
@@ -86,7 +86,7 @@ for x, y in small_dataset:
 tf.saved_model.save(trunk, output_path)
 ```
 
-所有尚未存储在内存中的数据集都应使用`tf.dataset`进行存储和流传输。 数据集在 TF 2.0 中是可迭代的，因此在急切的执行模式下，它们可以像任何其他 Python 可迭代的一样使用，例如列表和元组。 您还可以通过使用`tf.function`包装数据集迭代来利用数据集异步预取和流传输功能，该迭代将 Python 交互转换为与 AutoGraph 等效的图形操作。 正如我们在本书前面所提到的，AutoGraph 采用默认的 Python 流并将其转换为基于图形的代码。 例如，诸如`if...else`块之类的控制流将转换为`tf.condition`语句。 以下代码块向您展示了如何使用`for`块训练模型：
+所有尚未存储在内存中的数据集都应使用`tf.dataset`进行存储和流传输。 数据集在 TF 2.0 中是可迭代的，因此在急切的执行模式下，它们可以像任何其他 Python 可迭代的一样使用，例如列表和元组。 您还可以通过使用`tf.function`包装数据集迭代来利用数据集异步预取和流传输功能，该迭代将 Python 交互转换为与 AutoGraph 等效的图操作。 正如我们在本书前面所提到的，AutoGraph 采用默认的 Python 流并将其转换为基于图的代码。 例如，诸如`if...else`块之类的控制流将转换为`tf.condition`语句。 以下代码块向您展示了如何使用`for`块训练模型：
 
 ```py
 @tf.function
@@ -116,7 +116,7 @@ model.fit(dataset)
 
 # 转换 TF 1.x 模型
 
-第一步是将所有`tf.Session.run()`调用替换为 Python 函数。 这意味着将`tf.placeholder`和`feed_dict`转换为函数参数。 这些成为函数的返回值。 此更改意味着与 TF 1.x 不同，可以使用标准的 Python 工具（例如`pdb`）来逐步调试该功能。 构建函数后，可以添加`tf.function`注解以在图形模式下运行该函数，以及 TF 1.x 中等效的`tf.Session.run`调用的效率。
+第一步是将所有`tf.Session.run()`调用替换为 Python 函数。 这意味着将`tf.placeholder`和`feed_dict`转换为函数参数。 这些成为函数的返回值。 此更改意味着与 TF 1.x 不同，可以使用标准的 Python 工具（例如`pdb`）来逐步调试该功能。 构建函数后，可以添加`tf.function`注解以在图模式下运行该函数，以及 TF 1.x 中等效的`tf.Session.run`调用的效率。
 
 使用`tf.layers` API 创建的 TF 1.x 模型可以相对容易地转换为 TF 2.0。 `tf.layers`模块用于包含依赖于`tf.variable_scope`定义和重用变量的层函数。
 
@@ -194,7 +194,7 @@ with tf.Session() as sess:
                 feed_dict={in_a: [1, 0], in_b: [0, 1]})
 ```
 
-可以通过将前向函数更改为用`tf.function`注解的函数进行基于图形的计算，删除`session.run`函数和变量范围并添加简单的函数调用来转换此代码。 将不会在`W`变量上全局调用正则化； 相反，它将被手动调用，而无需引用全局集合：
+可以通过将前向函数更改为用`tf.function`注解的函数进行基于图的计算，删除`session.run`函数和变量范围并添加简单的函数调用来转换此代码。 将不会在`W`变量上全局调用正则化； 相反，它将被手动调用，而无需引用全局集合：
 
 ```py
 W = tf.Variable(tf.ones(shape=(2,2)), name="W")
@@ -213,7 +213,7 @@ reg_loss = regularizer(W)
 
 正如我们所看到的，TF 2.0 代码比以前的 TF 1.x 代码更加 Python 化和简洁。
 
-使用`tf.placeholder`的好处之一是可以控制图形输入的形状，如果输入与预定形状不匹配，则会返回错误。 在 TF 2.0 中，仍然可以通过使用 Python 内置的`assert`命令来完成此操作。 这可以用来断言该函数的输入自变量的形状与输入自变量所期望的形状匹配。
+使用`tf.placeholder`的好处之一是可以控制图输入的形状，如果输入与预定形状不匹配，则会返回错误。 在 TF 2.0 中，仍然可以通过使用 Python 内置的`assert`命令来完成此操作。 这可以用来断言该函数的输入自变量的形状与输入自变量所期望的形状匹配。
 
 现有的 TF 1.x 代码通常同时包含较低级别的 TF 1.x 变量和具有较高级别`tf.layers`的操作。 这意味着上述示例都不足以转换 TF 1.x 代码，并且需要`tf.keras`编程的更复杂形式，称为模型或层子类。
 
@@ -367,7 +367,7 @@ print(' accuracy: {:.3f}'.format(mean_accuracy))
 
 **用 TF 2.0 编写的代码的速度是否与基于图的 TF 1.x 代码相同？**
 
-是的，使用`tf.function`或`tf.keras`在 TF 2.0 中编写的代码将具有与 TF 1.x 相同的速度和最优性。 正如我们在本章前面提到的那样，使用`tf.function`注解主要功能允许模型以图模式运行，并且该功能中的所有计算和逻辑都将编译为一个计算图。 使用`tf.keras`定义和训练 TensorFlow 模型也是如此。 使用`model.fit`方法还将在图形模式下训练模型，并具有所有优点和优化功能，这些优点和优点包括：
+是的，使用`tf.function`或`tf.keras`在 TF 2.0 中编写的代码将具有与 TF 1.x 相同的速度和最优性。 正如我们在本章前面提到的那样，使用`tf.function`注解主要功能允许模型以图模式运行，并且该功能中的所有计算和逻辑都将编译为一个计算图。 使用`tf.keras`定义和训练 TensorFlow 模型也是如此。 使用`model.fit`方法还将在图模式下训练模型，并具有所有优点和优化功能，这些优点和优点包括：
 
 # TF 2.0 的未来