2020-12-28 22:02:49

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

@@ -307,7 +307,7 @@ Michael Heydt 的《学习 Pandas》和 Dan Toomey 的《学习 Jupyter》提供
 
 ##### MNIST 数据集
 
-**国家标准技术混合研究所**（**MNIST**）数据集包含 60,000 张图像的训练集和 10,000 张图像的测试集。 每个图像都包含一个手写数字。 该数据集（是美国政府创建的数据集的衍生产品）最初用于测试解决计算机系统识别手写文本问题的不同方法。 为了提高邮政服务，税收系统和政府服务的绩效，能够做到这一点很重要。 对于现代方法，MNIST 数据集被认为过于幼稚。 在现代研究中（例如 CIFAR）使用了不同的和更新的数据集。 但是，MNIST 数据集对于了解神经网络的工作原理仍然非常有用，因为已知的模型可以高效地达到很高的准确性。
+**国家标准技术混合研究所**（**MNIST**）数据集包含 60,000 张图像的训练集和 10,000 张图像的测试集。 每个图像都包含一个手写数字。 该数据集（是美国政府创建的数据集的衍生产品）最初用于测试解决计算机系统识别手写文本问题的不同方法。 为了提高邮政服务，税收系统和政府服务的表现，能够做到这一点很重要。 对于现代方法，MNIST 数据集被认为过于幼稚。 在现代研究中（例如 CIFAR）使用了不同的和更新的数据集。 但是，MNIST 数据集对于了解神经网络的工作原理仍然非常有用，因为已知的模型可以高效地达到很高的准确性。
 
 ### 注意
 

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

@@ -251,7 +251,7 @@ Keras 提供了`model.evaluate(),`方法，该方法使针对测试集评估训
 
 > “代码段 6”：使用反向点相对归一化技术对数据进行归一化。 `denormalize()`函数从测试的等效一周的第一天起收取第一个收盘价。
 
-现在，我们的结果使用美元将预测值与测试集进行比较。 从“图 5”中可以看出，`bitcoin_lstm_v0` 模型在预测接下来的 7 天比特币价格时似乎表现良好。 但是，我们如何用可解释的术语衡量绩效呢？
+现在，我们的结果使用美元将预测值与测试集进行比较。 从“图 5”中可以看出，`bitcoin_lstm_v0` 模型在预测接下来的 7 天比特币价格时似乎表现良好。 但是，我们如何用可解释的术语衡量表现呢？
 
 ![Model Predictions](img/image03_09.jpg)
 
@@ -261,7 +261,7 @@ Keras 提供了`model.evaluate(),`方法，该方法使针对测试集评估训
 
 我们的最后一步是为我们的预测增加可解释性。 图 6 似乎表明我们的模型预测在某种程度上与测试数据匹配，但是与测试数据的匹配程度如何？
 
-Keras 的`model.evaluate()`功能对于理解模型在每个评估步骤中的执行情况很有用。 但是，鉴于我们通常使用规范化的数据集来训练神经网络，因此`model.evaluate()`方法生成的指标也难以解释。
+Keras 的`model.evaluate()`函数对于理解模型在每个评估步骤中的执行情况很有用。 但是，鉴于我们通常使用规范化的数据集来训练神经网络，因此`model.evaluate()`方法生成的指标也难以解释。
 
 为了解决该问题，我们可以从模型中收集完整的预测集，并使用“表 1”中的两个易于解释的函数将其与测试集进行比较：MAPE 和 RMSE ，分别实现为`mape()`和`rmse()`：
 
@@ -273,7 +273,7 @@ return np.mean(np.abs((A - B) / A)) * 100
   return np.sqrt(np.square(np.subtract(A, B)).mean())
 ```
 
-> “代码段 7”：`mape()`和`rmse()`功能的实现
+> “代码段 7”：`mape()`和`rmse()`函数的实现
 
 ### 注意
 
@@ -580,7 +580,7 @@ ReLU 具有非线性属性。 它们的定义是：
 
 ###### 激活函数 - 实现
 
-在 Keras 中实现激活函数的最简单方法是实例化`Activation()`类，并将其添加到`Sequential()`模型中。 可以使用 Keras 中可用的任何激活函数实例化`Activation()`（有关完整列表，请参见[这里](https://keras.io/activations/)）。 在我们的例子中，我们将使用`tanh`功能。 实现激活函数后，我们将模型的版本更改为`v2`，使其变为`bitcoin_lstm_v3`：
+在 Keras 中实现激活函数的最简单方法是实例化`Activation()`类，并将其添加到`Sequential()`模型中。 可以使用 Keras 中可用的任何激活函数实例化`Activation()`（有关完整列表，请参见[这里](https://keras.io/activations/)）。 在我们的例子中，我们将使用`tanh`函数。 实现激活函数后，我们将模型的版本更改为`v2`，使其变为`bitcoin_lstm_v3`：
 
 ```py
  model = Sequential()
@@ -698,7 +698,7 @@ L2 正则化使用`λ`参数来确定对模型神经元的惩罚程度。 通常
 
 3.  现在，打开名为`Activity_7_Optimizing_a_deep_learning_model.ipynb`的 Jupyter 笔记本，并导航至笔记本的标题并导入所有必需的库。
 
-    我们将像以前的活动一样加载火车和测试数据。 我们还将使用工具功能`split_lstm_input()`将分为训练组和测试组。
+    我们将像以前的活动一样加载火车和测试数据。 我们还将使用工具函数`split_lstm_input()`将分为训练组和测试组。
 
     在本笔记本的每个部分中，我们将在模型中实现新的优化技术。 每次这样做，我们都会训练一个新模型并将其训练后的实例存储在描述模型版本的变量中。 例如，在本笔记本中，我们的第一个模型`bitcoin_lstm_v0,`被称为`model_v0`。 在笔记本的最后，我们使用 MSE，RMSE 和 MAPE 评估所有模型。
 
@@ -730,7 +730,7 @@ L2 正则化使用`λ`参数来确定对模型神经元的惩罚程度。 通常
     activation_function = "tanh"
     ```
 
-    我们在本节中使用了`tanh`功能，但是请随时尝试其他激活函数。 查看[这个页面](https://keras.io/activations/)上可用的列表，然后尝试其他可能性。
+    我们在本节中使用了`tanh`函数，但是请随时尝试其他激活函数。 查看[这个页面](https://keras.io/activations/)上可用的列表，然后尝试其他可能性。
 
     我们的最终选择是尝试不同的正则化策略。 这显然更加复杂，并且可能需要花费一些迭代才能注意到任何收益，尤其是数据量很少时。 此外，添加正则化策略通常会增加网络的训练时间。
 

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

@@ -57,7 +57,7 @@ ReLu 非线性函数-小于零
 
 ReLu 非线性函数-大于零。
 
-由于它是一个非常恒定的函数，因此在计算机内部执行时在数学上是有效的，因此您会看到`relu`在许多生产神经网络模型中使用，只是因为它计算速度更快。 但是`relu`功能的窍门，正如我们在上一章中谈到的标准化时所学到的那样，在于它们可以生成大于 1 的值，因此构建神经网络的各种窍门和技术，包括标准化和创建更多层， 通常需要获得`relu`功能才能正常运行。
+由于它是一个非常恒定的函数，因此在计算机内部执行时在数学上是有效的，因此您会看到`relu`在许多生产神经网络模型中使用，只是因为它计算速度更快。 但是`relu`函数的窍门，正如我们在上一章中谈到的标准化时所学到的那样，在于它们可以生成大于 1 的值，因此构建神经网络的各种窍门和技术，包括标准化和创建更多层， 通常需要获得`relu`函数才能正常运行。
 
 机器学习中发生的许多事情都涉及重复计算这些`relu`和`sigmoid`函数的输入。
 
@@ -143,7 +143,7 @@ Keras 功能模型
 
 编译模型
 
-`loss`函数是一个数学函数，它告诉`optimizer`做得如何。 `optimizer`函数是一种数学程序，可搜索可用参数以最小化`loss`函数。 `metrics`参数是您的机器学习模型的输出，应该为人类可读，以便您可以了解模型的运行状况。 现在，这些`loss`和`optimizer`参数充满了数学运算。 总的来说，您可以将其作为一本秘籍。 使用 Keras 运行机器学习模型时，您应该有效地选择`adam`（默认设置）。 就`loss`功能而言，当您处理诸如 MNIST 数字之类的分类问题时，应使用分类交叉熵。 此秘籍类型的秘籍应该对您有帮助。
+`loss`函数是一个数学函数，它告诉`optimizer`做得如何。 `optimizer`函数是一种数学程序，可搜索可用参数以最小化`loss`函数。 `metrics`参数是您的机器学习模型的输出，应该为人类可读，以便您可以了解模型的运行状况。 现在，这些`loss`和`optimizer`参数充满了数学运算。 总的来说，您可以将其作为一本秘籍。 使用 Keras 运行机器学习模型时，您应该有效地选择`adam`（默认设置）。 就`loss`函数而言，当您处理诸如 MNIST 数字之类的分类问题时，应使用分类交叉熵。 此秘籍类型的秘籍应该对您有帮助。
 
 现在，我们准备用`x`训练数据（由实际的 MNIST 数字图像组成）和`y`训练参数（由零至九个分类输出标签组成）拟合模型。 我们这里有一个新概念是`batch_size`。 这是每个执行循环的图像数。 通常，这受可用内存的限制，但是较小的批量大小（32 到 64）通常会更好。 那么这个奇怪的词呢？ 历元只是指循环数。 例如，当我们说八个周期时，我们的意思是机器学习模型将遍历训练数据八次，并将使用测试数据来查看模型变得八次准确的程度。 当模型反复查看相同的数据时，它会提高准确性，如以下屏幕截图所示：
 
@@ -153,7 +153,7 @@ Keras 功能模型
 
 最后，我们得出验证数据，也称为测试数据。 实际上，这是用来计算精度的。 在每个时期结束时，对模型进行部分训练，然后通过模型运行测试数据，生成一组试验预测，用于对准确性进行评分。 机器学习涉及大量的人类等待。 我们将继续并跳过每个时代的进度； 在运行这些样本时，您将有很多机会观看这些进度条的增长。
 
-现在，让我们谈谈前面的输出。 随着进度栏的增长，您可以看到其正在运行的示例图像的数量。 但是还有`loss`功能和`metrics`参数； 在这里，我们使用准确性。 因此，`loss`功能会反馈给学习器，这实际上就是机器学习的学习方式; 它试图通过迭代设置模型中的数字参数来使`loss`最小化，以使`loss`编号下降。 那里的准确性，以便您可以了解发生了什么。 在这种情况下，精度表示模型猜测正确数字的频率。 因此，就将其视为一本菜谱而言，分类交叉熵是您实际上一直希望用于此类分类问题的`loss`函数，而`adam`是学习算法的最明智的默认选项; `accuracy`是出色的输出`metrics`，您可以用来查看模型的运行状况。
+现在，让我们谈谈前面的输出。 随着进度栏的增长，您可以看到其正在运行的示例图像的数量。 但是还有`loss`函数和`metrics`参数； 在这里，我们使用准确性。 因此，`loss`函数会反馈给学习器，这实际上就是机器学习的学习方式; 它试图通过迭代设置模型中的数字参数来使`loss`最小化，以使`loss`编号下降。 那里的准确性，以便您可以了解发生了什么。 在这种情况下，精度表示模型猜测正确数字的频率。 因此，就将其视为一本菜谱而言，分类交叉熵是您实际上一直希望用于此类分类问题的`loss`函数，而`adam`是学习算法的最明智的默认选项; `accuracy`是出色的输出`metrics`，您可以用来查看模型的运行状况。
 
 # 超参数
 

new/handson-rl-py/02.md

@@ -684,7 +684,7 @@ with tf.Session() as sess:
 
 # 添加范围
 
-范围划分用于降低复杂性，并通过将相关节点分组在一起来帮助我们更好地理解模型。 例如，在前面的示例中，我们可以将图分为两个不同的组，称为计算和结果。 如果看前面的示例，可以看到节点`a`至`e`执行计算，而节点`g`计算结果。 因此，我们可以使用范围将它们分开分组，以便于理解。 可以使用`tf.name_scope()`功能创建作用域。
+范围划分用于降低复杂性，并通过将相关节点分组在一起来帮助我们更好地理解模型。 例如，在前面的示例中，我们可以将图分为两个不同的组，称为计算和结果。 如果看前面的示例，可以看到节点`a`至`e`执行计算，而节点`g`计算结果。 因此，我们可以使用范围将它们分开分组，以便于理解。 可以使用`tf.name_scope()`函数创建作用域。
 
 让我们通过`Computation`使用`tf.name_scope()`函数：
 

new/handson-rl-py/04.md

@@ -304,7 +304,7 @@ if done:
     break
 ```
 
-5.  完整的`generate_episode`功能如下：
+5.  完整的`generate_episode`函数如下：
 
 ```py
 def generate_episode(policy, env):

new/handson-rl-py/08.md

@@ -398,7 +398,7 @@ with tf.Session() as sess:
 
 深度 Q 学习非常酷，对吗？ 它已经普及了玩任何 Atari 游戏的学习。 但是 DQN 的问题在于，它倾向于高估`Q`值。 这是因为`Q`学习方程式中的最大值运算符。 最大运算符在选择和评估动作时使用相同的值。 那是什么意思？假设我们处于`s`状态，并且我们有五个动作`a[1]`至`a[5]`。 假设`a[3]`是最好的动作。 当我们估计状态为`s`的所有这些动作的`Q`值时，估计的`Q`值会有些杂音并且与实际值有所不同。 由于这种噪声，动作`a[2]`会比最佳动作`a[3]`获得更高的值。 现在，如果我们选择最佳动作作为具有最大值的动作，则最终将选择次优动作`a[2]`而不是最佳动作`a[3]`。
 
-我们可以通过具有两个单独的`Q`函数来解决此问题，每个函数都是独立学习的。 一个`Q`功能用于选择一个动作，另一个`Q`功能用于评估一个动作。 我们可以通过调整 DQN 的目标功能来实现。 调用 DQN 的目标函数：
+我们可以通过具有两个单独的`Q`函数来解决此问题，每个函数都是独立学习的。 一个`Q`函数用于选择一个动作，另一个`Q`函数用于评估一个动作。 我们可以通过调整 DQN 的目标功能来实现。 调用 DQN 的目标函数：
 
 ![](img/00268.jpeg)
 
@@ -406,7 +406,7 @@ with tf.Session() as sess:
 
 ![](img/00269.jpeg)
 
-在前面的公式中，我们有两个`Q`函数，每个函数具有不同的权重。 因此，权重为`θ'`的`Q`函数用于选择操作，权重为`θ-`的其他`Q`函数用于评估操作。 我们还可以切换这两个`Q`功能的角色。
+在前面的公式中，我们有两个`Q`函数，每个函数具有不同的权重。 因此，权重为`θ'`的`Q`函数用于选择操作，权重为`θ-`的其他`Q`函数用于评估操作。 我们还可以切换这两个`Q`函数的角色。
 
 # 优先经验回放
 
@@ -438,7 +438,7 @@ with tf.Session() as sess:
 
 我们知道`Q`函数指定智能体在状态`s`下执行动作`a`有多好，而值函数则指定使智能体处于`s`状态有多好。 现在，我们引入一个称为优势函数的新函数，该函数可以定义为值函数和优势函数之间的差。 优势功能指定与其他动作相比，智能体执行一个动作`a`有多好。
 
-因此，值函数指定状态的优劣，而优势函数指定动作的优劣。 如果我们将值函数和优势功能结合起来会发生什么？ 这将告诉我们智能体在状态`s`实际上是我们的`Q`功能下执行动作`a`有多好。 因此，我们可以像`Q(s, a) = V(s) + A(a)`中那样将`Q`函数定义为值函数和优势函数的和。
+因此，值函数指定状态的优劣，而优势函数指定动作的优劣。 如果我们将值函数和优势功能结合起来会发生什么？ 这将告诉我们智能体在状态`s`实际上是我们的`Q`函数下执行动作`a`有多好。 因此，我们可以像`Q(s, a) = V(s) + A(a)`中那样将`Q`函数定义为值函数和优势函数的和。
 
 现在，我们将看到决斗网络架构是如何工作的。 下图显示了决斗 DQN 的架构：
 

new/handson-rl-py/11.md

@@ -537,7 +537,7 @@ for i in range(no_of_episodes):
 
 在 TRPO 中，我们迭代地改进了该策略，并施加了一个约束，以使旧策略和新策略之间的 **Kullback-Leibler**（**KL**）差异要小于某个常数。 ![](img/00326.jpeg)。 该约束称为信任区域约束。
 
-那么什么是 KL 散度？ KL 散度告诉我们两个概率分布如何彼此不同。 由于我们的策略是针对行动的概率分布，因此 KL 差异告诉我们新策略与旧策略有多远。 为什么我们必须使旧策略和新策略之间的距离保持小于恒定值`δ`？ 因为我们不希望我们的新策略与旧策略脱节。 因此，我们施加了约束以使新策略接近旧策略。 同样，为什么我们必须保持旧策略呢？ 当新策略与旧策略相距甚远时，它将影响智能体的学习绩效，并导致完全不同的学习行为。 简而言之，在 TRPO 中，我们朝着改善策略的方向迈出了一步，即使报酬最大化，但我们还应确保满足信任区域约束。 [它使用共轭梯度下降](http://www.idi.ntnu.no/~elster/tdt24/tdt24-f09/cg.pdf)优化网络参数`θ`，同时满足约束条件。 该算法保证了单调策略的改进，并且在各种连续环境中也取得了出色的效果。
+那么什么是 KL 散度？ KL 散度告诉我们两个概率分布如何彼此不同。 由于我们的策略是针对行动的概率分布，因此 KL 差异告诉我们新策略与旧策略有多远。 为什么我们必须使旧策略和新策略之间的距离保持小于恒定值`δ`？ 因为我们不希望我们的新策略与旧策略脱节。 因此，我们施加了约束以使新策略接近旧策略。 同样，为什么我们必须保持旧策略呢？ 当新策略与旧策略相距甚远时，它将影响智能体的学习表现，并导致完全不同的学习行为。 简而言之，在 TRPO 中，我们朝着改善策略的方向迈出了一步，即使报酬最大化，但我们还应确保满足信任区域约束。 [它使用共轭梯度下降](http://www.idi.ntnu.no/~elster/tdt24/tdt24-f09/cg.pdf)优化网络参数`θ`，同时满足约束条件。 该算法保证了单调策略的改进，并且在各种连续环境中也取得了出色的效果。
 
 现在，我们将了解 TRPO 的数学原理。 如果您对数学不感兴趣，可以跳过本节。
 

new/intel-proj-py/01.md

@@ -288,7 +288,7 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 ![](img/4ce6cd6d-4a3d-4c78-9aa6-364d288f20c7.png)
 
-如果我们要预测句子中的下一个单词，则函数`f[2]`通常是词汇表中单词的 softmax 函数。 根据当前问题，`f[1]`功能可以是任何激活函数。
+如果我们要预测句子中的下一个单词，则函数`f[2]`通常是词汇表中单词的 softmax 函数。 根据当前问题，`f[1]`函数可以是任何激活函数。
 
 在 RNN 中，步骤`t`中的输出错误会尝试纠正先前时间步中的预测，并通过`k ∈ 1, 2, ..., t-1`来概括。 通过传播先前时间步长中的错误来实现。 这有助于 RNN 了解彼此相距较远的单词之间的长期依赖性。 实际上，由于梯度问题的消失和爆炸，并非总是可能通过 RNN 学习这么长的依赖关系。
 

new/intel-proj-py/02.md

@@ -774,7 +774,7 @@ Processing Time 26009.3344039917 secs
 
 # 训练期间动态创建小批量
 
-仅加载与小批量对应的数据的一种方法是通过从其位置随机处理图像来动态创建小批量。 小批量处理的图像数量将等于我们指定的小批量大小。 当然，由于在训练期间会动态创建小批量生产，因此在训练过程中会遇到一些瓶颈，但是这一瓶颈可以忽略不计。 特殊的软件包，例如`keras`，具有有效的动态批量创建机制。 我们将在训练过程中利用 keras 中的`flow_from_directory`功能动态创建迷你批，以减少训练过程的内存需求。 我们仍将继续使用`ImageDataGenerator`进行图像增强。 可以如下定义火车生成器和验证生成器。
+仅加载与小批量对应的数据的一种方法是通过从其位置随机处理图像来动态创建小批量。 小批量处理的图像数量将等于我们指定的小批量大小。 当然，由于在训练期间会动态创建小批量生产，因此在训练过程中会遇到一些瓶颈，但是这一瓶颈可以忽略不计。 特殊的软件包，例如`keras`，具有有效的动态批量创建机制。 我们将在训练过程中利用 keras 中的`flow_from_directory`函数动态创建迷你批，以减少训练过程的内存需求。 我们仍将继续使用`ImageDataGenerator`进行图像增强。 可以如下定义火车生成器和验证生成器。
 
 通过将`pre_process`函数作为输入输入到`ImageDataGenerator`的`preprocessing_function`中，完成从三个通道中减去平均图像像素强度的图像预处理步骤：
 
@@ -817,7 +817,7 @@ Processing Time 26009.3344039917 secs
 
 `flow_from_directory`函数将一个图像目录作为输入，并期望一个与该图像目录中的类有关的文件夹。 然后，它从文件夹名称推断类标签。 如果图像目录的图像目录具有以下结构，则将类别推断为`0`，`1`，`2`，`3`，`4`，与类别文件夹`'class0'`，`'class1'`有关 ，`'class2'`，`'class3'`和`'class4'`。
 
-`flow_from_directory`功能的其他重要输入是`batch_size`，`target_size`和`class_mode`。 `target_size`用于指定要馈送到神经网络的图像的尺寸，而`class_mode`用于指定问题的性质。 对于二进制分类，将`class_mode`设置为二进制，而对于多分类，将其设置为`categorical`。
+`flow_from_directory`函数的其他重要输入是`batch_size`，`target_size`和`class_mode`。 `target_size`用于指定要馈送到神经网络的图像的尺寸，而`class_mode`用于指定问题的性质。 对于二进制分类，将`class_mode`设置为二进制，而对于多分类，将其设置为`categorical`。
 
 接下来，我们将通过创建动态批量来训练同一模型，而不是一次将所有数据加载到内存中。 我们只需要使用`flow_from_directory`选项创建一个生成器，然后将其绑定到数据扩充对象即可。 数据生成器对象可以如下生成：
 
@@ -1076,7 +1076,7 @@ class DataGenerator(keras.utils.Sequence):
 
 我们指定的功能是从`keras.utils.Sequence`继承的，因此，这些功能中每个功能的特定活动都无法在其他位置指定。`len`函数用于计算一个时期中的批量数。
 
-类似地，在`on_epoch_end`函数中，我们可以指定在周期结束时要执行的活动，例如打乱周期中要处理输入的顺序。 我们可以在每个时期创建一组不同的数据集进行处理。 当我们有大量数据并且我们不想在每个时期处理所有数据时，这通常很有用。 `__getitem__`功能通过提取与特定于批量的所有数据点索引相对应的数据来帮助创建批量。 如果数据创建过程更复杂，则可以利用`__data_generation `函数具有特定于批量中每个单独数据点提取的逻辑。 例如，我们将与批量中的数据点索引相对应的文件名传递给`__data_generation`函数，以使用`opencv`读取每个图像，并使用`preprocess`函数对其进行预处理，我们必须进行平均像素减法。
+类似地，在`on_epoch_end`函数中，我们可以指定在周期结束时要执行的活动，例如打乱周期中要处理输入的顺序。 我们可以在每个时期创建一组不同的数据集进行处理。 当我们有大量数据并且我们不想在每个时期处理所有数据时，这通常很有用。 `__getitem__`函数通过提取与特定于批量的所有数据点索引相对应的数据来帮助创建批量。 如果数据创建过程更复杂，则可以利用`__data_generation `函数具有特定于批量中每个单独数据点提取的逻辑。 例如，我们将与批量中的数据点索引相对应的文件名传递给`__data_generation`函数，以使用`opencv`读取每个图像，并使用`preprocess`函数对其进行预处理，我们必须进行平均像素减法。
 
 基于回归的迁移学习的训练函数可以编码如下：
 

new/intel-proj-py/03.md

@@ -266,7 +266,7 @@ NMT 与其他传统方法相比的一些优点如下：
 *   从源语言和目标语言文本构建词汇表
 *   将输入的英语和法语语料库处理为数字表示形式，以便可以在神经机器翻译网络中使用它们
 
-此处说明的`read_input_file`功能可用于阅读源语言和目标语言文本：
+此处说明的`read_input_file`函数可用于阅读源语言和目标语言文本：
 
 ```py
     def read_input_file(self,path,num_samples=10e13):
@@ -295,7 +295,7 @@ NMT 与其他传统方法相比的一些优点如下：
         return input_texts,target_texts,input_words,target_words
 ```
 
-`vocab_generation`功能可用于为源语言和目标语言构建单词的词汇集：
+`vocab_generation`函数可用于为源语言和目标语言构建单词的词汇集：
 
 ```py
     def vocab_generation(self,path,num_samples,verbose=True):
@@ -333,7 +333,7 @@ NMT 与其他传统方法相比的一些优点如下：
         dict((i, word) for word, i in self.target_word_index.items())
 ```
 
-`process_input`函数利用先前功能中构建的输入和目标文本以及词汇表，将文本数据转换为数字形式，以供神经翻译机架构使用。 `process_input`功能的代码如下：
+`process_input`函数利用先前功能中构建的输入和目标文本以及词汇表，将文本数据转换为数字形式，以供神经翻译机架构使用。 `process_input`函数的代码如下：
 
 ```py
         def process_input(self,input_texts,target_texts=None,verbose=True):
@@ -392,7 +392,7 @@ NMT 与其他传统方法相比的一些优点如下：
             return encoder_input_data,None,None,np.array(input_texts),None
 ```
 
-`encoder_input_data` 变量将包含输入源数据，并且将是记录数，时间步数以及每个维度的维数的三维数组。 热编码向量。 类似地，`decoder_input_data` 将包含输入目标数据，而`decoder_target_data` 将包含目标标签。 在执行上述功能后，将生成训练机器翻译系统所需的所有相关输入和输出。 以下代码块包含与使用`40000`样本执行`vocab_generation`功能有关的显示统计信息：
+`encoder_input_data` 变量将包含输入源数据，并且将是记录数，时间步数以及每个维度的维数的三维数组。 热编码向量。 类似地，`decoder_input_data` 将包含输入目标数据，而`decoder_target_data` 将包含目标标签。 在执行上述功能后，将生成训练机器翻译系统所需的所有相关输入和输出。 以下代码块包含与使用`40000`样本执行`vocab_generation`函数有关的显示统计信息：
 
 ```py
 
@@ -426,7 +426,7 @@ NMT 与其他传统方法相比的一些优点如下：
 
 图 3.5：训练时机器翻译网络流程的图示
 
-我们基于“图 3.5”中所示的架构，定义了用于训练功能`model_enc_dec`的编码器解码器端到端模型。 在这里，**编码器（LSTM 1）**依次获取源语言文本单词，并在**编码器（LSTM 1）**的最后序列步骤中捕获源语言句子或文本的整个上下文。来自编码器的上下文将作为**解码器（LSTM 2）**的初始状态进行馈送，该学习器将根据当前单词来预测下一个单词，因为在训练过程中我们会得到一个句子 / text 作为目标语言，因此解码器只需将其输入移位一个时间步即可形成目标：
+我们基于“图 3.5”中所示的架构，定义了用于训练函数`model_enc_dec`的编码器解码器端到端模型。 在这里，**编码器（LSTM 1）**依次获取源语言文本单词，并在**编码器（LSTM 1）**的最后序列步骤中捕获源语言句子或文本的整个上下文。来自编码器的上下文将作为**解码器（LSTM 2）**的初始状态进行馈送，该学习器将根据当前单词来预测下一个单词，因为在训练过程中我们会得到一个句子 / text 作为目标语言，因此解码器只需将其输入移位一个时间步即可形成目标：
 
 ```py
     def model_enc_dec(self):
@@ -497,7 +497,7 @@ NMT 与其他传统方法相比的一些优点如下：
 
 # 训练模型
 
-我们首先执行`model_enc_dec` 函数来定义训练模型以及`encoder_model`和`decoder_model`进行推理，然后将其与`categorical_crossentropy`损失和`rmsprop`一起编译 ]优化器。 我们可以尝试使用其他优化器，例如 Adam，具有动量的 SDG 等，但是目前，我们将坚持使用`rmsprop`。`train`功能可以定义如下：
+我们首先执行`model_enc_dec` 函数来定义训练模型以及`encoder_model`和`decoder_model`进行推理，然后将其与`categorical_crossentropy`损失和`rmsprop`一起编译 ]优化器。 我们可以尝试使用其他优化器，例如 Adam，具有动量的 SDG 等，但是目前，我们将坚持使用`rmsprop`。`train`函数可以定义如下：
 
 ```py
 # Run training
@@ -638,7 +638,7 @@ def model_enc_dec(self):
         return decoded_sentence
 ```
 
-训练模型后，我们就对保持数据集进行推断并检查翻译质量。 `inference`功能可以编码如下：
+训练模型后，我们就对保持数据集进行推断并检查翻译质量。 `inference`函数可以编码如下：
 
 ```py
     def inference(self,model,data,encoder_model,decoder_model,in_text):

new/intel-proj-py/04.md

@@ -485,7 +485,7 @@ def build_network(self):
 
 # 建立训练流程
 
-在`train_network`函数中，我们首先为生成器和判别器损失函数定义优化器。 我们将 Adam 优化器用于生成器和判别器，因为这是随机梯度下降优化器的高级版本，在训练 GAN 方面非常有效。 亚当使用梯度的衰减平均值（非常类似于稳定梯度的动量）和平方梯度的衰减平均值，以提供有关成本函数曲率的信息。 与`tf.summary`定义的不同损失有关的变量将写入日志文件，因此可以通过 TensorBoard 进行监视。 以下是`train`功能的详细代码：
+在`train_network`函数中，我们首先为生成器和判别器损失函数定义优化器。 我们将 Adam 优化器用于生成器和判别器，因为这是随机梯度下降优化器的高级版本，在训练 GAN 方面非常有效。 亚当使用梯度的衰减平均值（非常类似于稳定梯度的动量）和平方梯度的衰减平均值，以提供有关成本函数曲率的信息。 与`tf.summary`定义的不同损失有关的变量将写入日志文件，因此可以通过 TensorBoard 进行监视。 以下是`train`函数的详细代码：
 
 ```py
 def train_network(self):

new/intel-proj-py/05.md

@@ -39,7 +39,7 @@
 
 从上图可以看出，从视频中顺序采样的图像经过预训练的卷积神经网络，并且输出最后一个全连接层中的`4,096`单元的激活。 如果将`t`时的视频图像表示为`x[t]`，并且最后一个全连接层的输出表示为`f[t] ∈ R^4096`，然后`f[t] = f[w](x[t])`。 此处，`W`表示直到最后一个全连接层的卷积神经网络的权重。
 
-这些系列的输出功能`f[1], f[2], ..., f[t], ..., f[n]`可以作为循环神经网络的输入，该神经网络学习根据输入特征生成文本标题，如下图所示（“图 5.2”）：
+这些系列的输出函数`f[1], f[2], ..., f[t], ..., f[n]`可以作为循环神经网络的输入，该神经网络学习根据输入特征生成文本标题，如下图所示（“图 5.2”）：
 
 ![](img/c4301074-d0a6-499d-97fb-04b39f20d188.png)
 
@@ -93,11 +93,11 @@ o1, o2, . . . . . ot . . . oN = { "A ","man" "in" "a" "yellow" "helmet" "is" "wo
 
 从指定位置下载数据后，下一个任务是处理视频图像帧，以从预训练的卷积神经网络的最后全连接层中提取特征。 我们使用在 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`卷积神经网络处理这些视频帧。 。
+在通过`VGG16`处理视频中的图像之前，需要从视频中对其进行采样。 我们从视频中采样图像，使每个视频具有`80`帧。 处理来自`VGG16`的`80`图像帧后，每个视频将具有`80`特征向量`f[1], f[2], ..., f[80]`。 这些功能将被馈送到 LSTM 以生成文本序列。 我们在 Keras 中使用了预训练的`VGG16`模型。 我们创建一个`VideoCaptioningPreProcessing`类，该类首先通过函数`video_to_frames`从每个视频中提取`80`视频帧作为图像，然后通过函数`extract_feats_pretrained_cnn`中的预训练`VGG16`卷积神经网络处理这些视频帧。 。
 
 `extract_feats_pretrained_cnn`的输出是每个视频帧尺寸为`4096`的 CNN 特征。 由于我们正在处理每个视频的`80`帧，因此每个视频将具有`80`这样的`4096`维向量。
 
-`video_to_frames`功能可以编码如下：
+`video_to_frames`函数可以编码如下：
 
 ```py
     def video_to_frames(self,video):
@@ -116,7 +116,7 @@ o1, o2, . . . . . ot . . . oN = { "A ","man" "in" "a" "yellow" "helmet" "is" "wo
 
 ```
 
-从前面的代码中，我们可以看到在`video_to_frames`功能中，`ffmpeg`工具用于将 JPEG 格式的视频图像帧转换。 为图像帧指定为`ffmpeg`的尺寸为`300 x 400`。 有关`ffmpeg`工具的更多信息，[请参考以下链接](https://www.ffmpeg.org/)。
+从前面的代码中，我们可以看到在`video_to_frames`函数中，`ffmpeg`工具用于将 JPEG 格式的视频图像帧转换。 为图像帧指定为`ffmpeg`的尺寸为`300 x 400`。 有关`ffmpeg`工具的更多信息，[请参考以下链接](https://www.ffmpeg.org/)。
 
 在`extract_feats_pretrained_cnnfunction`中已建立了从最后一个全连接层中提取特征的预训练 CNN 模型。 该函数的代码如下：
 
@@ -161,7 +161,7 @@ o1, o2, . . . . . ot . . . oN = { "A ","man" "in" "a" "yellow" "helmet" "is" "wo
             shutil.rmtree(self.temp_dest)
 ```
 
-我们首先使用`model_cnn_load`函数加载经过预训练的 CNN 模型，然后针对每个视频，根据`ffmpeg.`指定的采样频率，使用`video_to_frames`函数将多个视频帧提取为图像。 图像通过`ffmpeg`创建的视频中的图像帧，但是我们使用`np.linspace`功能拍摄了`80`等距图像帧。 使用`load_image`功能将`ffmpeg`生成的图像调整为`224 x 224`的空间尺寸。 最后，将这些调整大小后的图像通过预训练的 VGG16 卷积神经网络（CNN），并提取输出层之前的最后一个全连接层的输出作为特征。 这些提取的特征向量存储在`numpy`数组中，并在下一阶段由 LSTM 网络进行处理以产生视频字幕。 本节中定义的功能`model_cnn_load`功能定义如下：
+我们首先使用`model_cnn_load`函数加载经过预训练的 CNN 模型，然后针对每个视频，根据`ffmpeg.`指定的采样频率，使用`video_to_frames`函数将多个视频帧提取为图像。 图像通过`ffmpeg`创建的视频中的图像帧，但是我们使用`np.linspace`函数拍摄了`80`等距图像帧。 使用`load_image`函数将`ffmpeg`生成的图像调整为`224 x 224`的空间尺寸。 最后，将这些调整大小后的图像通过预训练的 VGG16 卷积神经网络（CNN），并提取输出层之前的最后一个全连接层的输出作为特征。 这些提取的特征向量存储在`numpy`数组中，并在下一阶段由 LSTM 网络进行处理以产生视频字幕。 本节中定义的函数`model_cnn_load`函数定义如下：
 
 ```py
    def model_cnn_load(self):
@@ -174,7 +174,7 @@ o1, o2, . . . . . ot . . . oN = { "A ","man" "in" "a" "yellow" "helmet" "is" "wo
 
 从前面的代码可以看出，我们正在加载在 ImageNet 上经过预训练的`VGG16`卷积神经网络，并提取第二层的输出（索引为`-2`）作为维度为`4096`的特征向量 ]。
 
-图像读取和调整大小功能`load_image`定义为在馈入 CNN 之前处理原始`ffmpeg`图像，其定义如下：
+图像读取和调整大小函数`load_image`定义为在馈入 CNN 之前处理原始`ffmpeg`图像，其定义如下：
 
 ```py
     def load_image(self,path):
@@ -233,7 +233,7 @@ def get_clean_caption_data(self,text_path,feat_path):
         return data
 ```
 
-在已定义的`get_data`函数中，我们从`video_corpus.csv`文件中删除了所有非英语的字幕。 完成后，我们首先通过构建视频名称（作为`VideoID`，`Start`和`End`功能的连接）并在功能目录名称前添加前缀来形成视频功能的链接。 然后，我们删除所有未指向`features`目录中任何实际视频特征向量或具有无效非文本描述的视频语料库文件记录。
+在已定义的`get_data`函数中，我们从`video_corpus.csv`文件中删除了所有非英语的字幕。 完成后，我们首先通过构建视频名称（作为`VideoID`，`Start`和`End`函数的连接）并在功能目录名称前添加前缀来形成视频功能的链接。 然后，我们删除所有未指向`features`目录中任何实际视频特征向量或具有无效非文本描述的视频语料库文件记录。
 
 数据如下图所示输出（“图 5.6”）：
 
@@ -273,7 +273,7 @@ def get_clean_caption_data(self,text_path,feat_path):
 
 ![](img/aa71833b-2882-4ace-abe6-d6dad3254469.png)
 
-这些权重`W[ho]`和`b`在以下代码块中定义为`self.word_emb_W`和`self.word_emb_b`。 有关更多详细信息，请参考`build_model`功能。 为了方便解释，构建功能分为三部分。 构建模型有 3 个主要单元
+这些权重`W[ho]`和`b`在以下代码块中定义为`self.word_emb_W`和`self.word_emb_b`。 有关更多详细信息，请参考`build_model`函数。 为了方便解释，构建功能分为三部分。 构建模型有 3 个主要单元
 
 *   **定义阶段**：定义变量，标题词的嵌入层和序列到序列模型的两个 LSTM。
 *   **编码阶段**：在这一阶段中，我们将视频帧图像特征传递给 LSTM1 的时间步长，并将每个时间步长的隐藏状态传递给 LSTM2。此活动一直进行到时间步长`N`其中`N`是从每个视频中采样的视频帧图像的数量。
@@ -431,7 +431,7 @@ unk => A substitute for a word that is not included in the vocabulary
 | `N + 4` | `is`，`h[N + 4]` | `beautiful` |
 | `N + 5` | `beautiful`，`h[N + 5]` | `<eos>` |
 
-用来详细说明单词的`create_word_dict`功能如下所示：
+用来详细说明单词的`create_word_dict`函数如下所示：
 
 ```py
     def create_word_dict(self,sentence_iterator, word_count_threshold=5):
@@ -482,7 +482,7 @@ unk => A substitute for a word that is not included in the vocabulary
 
 在训练期间的每个时期都会记录损失，以了解损失减少的性质。 这里要注意的另一件事是，我们正在使用 TensorFlow 的`tf.train.saver`函数保存经过训练的模型，以便我们可以恢复模型以进行推理。
 
-`train`功能的详细代码在此处说明以供参考：
+`train`函数的详细代码在此处说明以供参考：
 
 ```py
      def train(self):

new/intel-proj-py/06.md

@@ -91,7 +91,7 @@ def model(max_users,max_movies,latent_factors):
     return model
 ```
 
-在前面的`model`功能中，`max_users`和`max_movies`分别确定用户的大小和电影嵌入矩阵。 该模型的参数不过是用户和电影嵌入矩阵的组成部分。 因此，如果我们有`m`个用户和`n`个电影，并且我们选择了`k`的潜在维度，那么我们就有`mxk + nxk = (m + n) * k`个待学习参数。
+在前面的`model`函数中，`max_users`和`max_movies`分别确定用户的大小和电影嵌入矩阵。 该模型的参数不过是用户和电影嵌入矩阵的组成部分。 因此，如果我们有`m`个用户和`n`个电影，并且我们选择了`k`的潜在维度，那么我们就有`mxk + nxk = (m + n) * k`个待学习参数。
 
 数据处理功能可以编码如下：
 
@@ -540,7 +540,7 @@ TensorFlow ops `self.x_`指的是给定隐藏层激活`self.h`的可见层激活
         self.updt = [self.W.assign_add(self.W_add), self.b_v.assign_add(self.bv_add), self.b_h.assign_add(self.bh_add)]
 ```
 
-可以使用如下所示的`read_data`功能在训练和推理期间读取来自预处理步骤的数据：
+可以使用如下所示的`read_data`函数在训练和推理期间读取来自预处理步骤的数据：
 
 ```py
     def read_data(self):
@@ -570,7 +570,7 @@ TensorFlow ops `self.x_`指的是给定隐藏层激活`self.h`的可见层激活
 
 # 训练 RBM
 
-此处说明的`_train`功能可用于训练 RBM。 在此函数中，我们首先调用`_network`函数以构建 RBM 网络结构，然后在激活的 TensorFlow 会话中针对指定时期数训练模型。 使用 TensorFlow 的`saver`函数以指定的时间间隔保存模型：
+此处说明的`_train`函数可用于训练 RBM。 在此函数中，我们首先调用`_network`函数以构建 RBM 网络结构，然后在激活的 TensorFlow 会话中针对指定时期数训练模型。 使用 TensorFlow 的`saver`函数以指定的时间间隔保存模型：
 
 ```py
       def _train(self):

new/intel-proj-py/07.md

@@ -576,13 +576,13 @@ android:id="@+id/Review"
 
 # Android 应用的核心逻辑
 
-Android 应用的核心逻辑是处理用户请求以及传递的数据，然后将结果发送回用户。 作为此移动应用的一部分，核心逻辑将接受用户提供的电影评论，处理原始数据，并将其转换为经过训练的 LSTM 模型可以进行推理的格式。 Java 中的`OnClickListener`功能用于监视用户是否已提交处理请求。 在将输入直接输入经过优化的经过训练的 LSTM 模型进行推理之前，需要将提供的电影评论中的每个单词更改为其索引。 除了优化的 protobuf 模型之外，还为此目的存储了单词及其对应索引的字典。 `TensorFlowInferenceInterface` 方法用于对训练后的模型进行推理。 优化的 protobuf 模型和单词词典及其对应的索引存储在`assets`文件夹中。 总而言之，应用的核心逻辑执行的任务如下：
+Android 应用的核心逻辑是处理用户请求以及传递的数据，然后将结果发送回用户。 作为此移动应用的一部分，核心逻辑将接受用户提供的电影评论，处理原始数据，并将其转换为经过训练的 LSTM 模型可以进行推理的格式。 Java 中的`OnClickListener`函数用于监视用户是否已提交处理请求。 在将输入直接输入经过优化的经过训练的 LSTM 模型进行推理之前，需要将提供的电影评论中的每个单词更改为其索引。 除了优化的 protobuf 模型之外，还为此目的存储了单词及其对应索引的字典。 `TensorFlowInferenceInterface` 方法用于对训练后的模型进行推理。 优化的 protobuf 模型和单词词典及其对应的索引存储在`assets`文件夹中。 总而言之，应用的核心逻辑执行的任务如下：
 
 1.  将索引字典中的单词加载到`WordToInd` `HashMap`中。 词间索引字典是在训练模型之前，在文本的预处理过程中从分词器派生的。
 2.  使用`OnClickListener`方法监视用户是否已提交电影评论以进行推断。
 3.  如果已提交电影评论，则将从与 XML 关联的`Review`变量中读取评论。 该评论会通过删除标点符号等内容进行清理，然后拆分为单词。 使用`HashMap`函数`WordToInd`将这些单词中的每个单词转换为相应的索引。 这些索引构成我们 TensorFlow 模型的`InputVec`输入，以进行推断。 输入向量长度为​​`1000`； 因此，如果评论的字数少于`1000`，则矢量的开头将填充零。
 
-4.  下一步，使用`TensorFlowInferenceInterface`功能创建`mInferenceInterface`对象，将优化的 protobuf 模型（扩展名为`.pb`）从`assets`文件夹加载到内存中。 与原始模型一样，需要定义要参考的 TensorFlow 模型的输入节点和输出节点。 对于我们的模型，它们定义为`INPUT_NODE`和`OUTPUT_NODE`，它们分别包含 TensorFlow 输入占位符的名称和输出情感概率的操作。 `mInferenceInterface` 对象的`feed`方法用于将`InputVec`值分配给的`INPUT_NODE` 模型，而`mInferenceInterface` 的`run`方法执行`OUTPUT_NODE`。 最后，使用`mInferenceInterface` 的`fetch`方法来填充对浮点变量`value_`的推断结果。
+4.  下一步，使用`TensorFlowInferenceInterface`函数创建`mInferenceInterface`对象，将优化的 protobuf 模型（扩展名为`.pb`）从`assets`文件夹加载到内存中。 与原始模型一样，需要定义要参考的 TensorFlow 模型的输入节点和输出节点。 对于我们的模型，它们定义为`INPUT_NODE`和`OUTPUT_NODE`，它们分别包含 TensorFlow 输入占位符的名称和输出情感概率的操作。 `mInferenceInterface` 对象的`feed`方法用于将`InputVec`值分配给的`INPUT_NODE` 模型，而`mInferenceInterface` 的`run`方法执行`OUTPUT_NODE`。 最后，使用`mInferenceInterface` 的`fetch`方法来填充对浮点变量`value_`的推断结果。
 5.  情感分数（情感为正的概率）乘以五将转换为等级。 然后通过`ratingBar` 变量将其馈送到 Android 应用用户界面。
 
 Java 中的移动应用的核心逻辑如下：

new/intel-proj-py/08.md

@@ -305,7 +305,7 @@ def include_start_token(self,Y):
     return Y
 ```
 
-回到训练功能`train_model`，我们看到如果`10`时期的损失没有减少，可以使用`EarlyStopping`回调工具启用提前停止功能。 类似地，如果错误没有在两个时期内减少，则`ReduceLROnPlateau`回调会将现有学习率降低一半（`0.5`）。 只要错误在某个时期减少，就会通过`ModelCheckpoint`回调保存模型。
+回到训练函数`train_model`，我们看到如果`10`时期的损失没有减少，可以使用`EarlyStopping`回调工具启用提前停止功能。 类似地，如果错误没有在两个时期内减少，则`ReduceLROnPlateau`回调会将现有学习率降低一半（`0.5`）。 只要错误在某个时期减少，就会通过`ModelCheckpoint`回调保存模型。
 
 # 从模型生成输出响应
 

new/intel-proj-py/10.md

@@ -167,7 +167,7 @@ def _model_(n_classes):
 
 # 预处理 CAPTCHA 图像
 
-图像的原始像素无法与 CNN 架构配合使用。 标准化图像以使 CNN 更快收敛始终是一个好主意。 通常用作规范化方案的两种方法是平均像素减法或通过将像素值除以`255`将像素缩放到`[0,1]`范围内。 对于我们的 CNN 网络，我们将图像标准化为`[0,1]`。 我们还将处理 CAPTCHA 的灰度图像，这意味着我们将只处理一个颜色通道。 `load_img`功能可用于加载和预处理 CAPTCHA 图像，如以下代码所示：
+图像的原始像素无法与 CNN 架构配合使用。 标准化图像以使 CNN 更快收敛始终是一个好主意。 通常用作规范化方案的两种方法是平均像素减法或通过将像素值除以`255`将像素缩放到`[0,1]`范围内。 对于我们的 CNN 网络，我们将图像标准化为`[0,1]`。 我们还将处理 CAPTCHA 的灰度图像，这意味着我们将只处理一个颜色通道。 `load_img`函数可用于加载和预处理 CAPTCHA 图像，如以下代码所示：
 
 ```py
 def load_img(path,dim=(100,40)):
@@ -268,7 +268,7 @@ class DataGenerator(keras.utils.Sequence):
 
 # 训练 CAPTCHA 破解器
 
-可以通过调用`train`功能来训练 CAPTCHA 破解器模型，如下所示：
+可以通过调用`train`函数来训练 CAPTCHA 破解器模型，如下所示：
 
 ```py
 def train(dest_train,dest_val,outdir,batch_size,n_classes,dim,shuffle,epochs,lr):
@@ -307,7 +307,7 @@ Epoch 20/20
 
 # 测试数据集的准确性
 
-可以通过调用`evaluate`功能来运行测试数据的推断。 `evaluate`功能如下所示，以供参考。 请注意，评估程序的设计应从整体验证码的角度看待准确性，而不是在验证码的字符级别上。 因此，只有当 CAPTCHA 目标的所有四个字符都与预测匹配时，我们才能将 CAPTCHA 标记为被 CNN 正确识别。
+可以通过调用`evaluate`函数来运行测试数据的推断。 `evaluate`函数如下所示，以供参考。 请注意，评估程序的设计应从整体验证码的角度看待准确性，而不是在验证码的字符级别上。 因此，只有当 CAPTCHA 目标的所有四个字符都与预测匹配时，我们才能将 CAPTCHA 标记为被 CNN 正确识别。
 
 用于在测试验证码上运行推理的`evaluate`函数可以编码如下：
 
@@ -360,13 +360,13 @@ def evaluate(model_path,eval_dest,outdir,fetch_target=True):
         print(f'Evaluation file written at: {eval_file} ')
 ```
 
-可以运行以下命令来调用`captcha_solver.py`脚本的`evaluate`功能进行推断：
+可以运行以下命令来调用`captcha_solver.py`脚本的`evaluate`函数进行推断：
 
 ```py
 python captcha_solver.py evaluate  --model_path  /home/santanu/ML_DS_Catalog-/captcha/model/captcha_breaker.h5 --eval_dest '/home/santanu/Downloads/Captcha Generation/captcha_test/' --outdir /home/santanu/ML_DS_Catalog-/captcha/ --fetch_target True 
 ```
 
-在`4000` CAPTCHA 的测试数据集上实现的准确性约为 93%。 运行`evaluate`功能的输出如下：
+在`4000` CAPTCHA 的测试数据集上实现的准确性约为 93%。 运行`evaluate`函数的输出如下：
 
 ```py
 Accuracy: 0.9320972187421699 
@@ -604,9 +604,9 @@ def make_trainable(model, trainable):
 
 `read_data`可用于处理输入数据。 `dir_flag`用于确定我们是否具有原始处理的数据矩阵文件或图像目录。 例如，当我们使用 SVHN 数据集时，`dir_flag`应该设置为`False`，因为我们已经有一个名为`train_32x32.mat`的预处理数据矩阵文件。
 
-但是，最好保持`read_data`函数的通用性，因为这使我们可以将脚本重用于其他数据集。 `scipy.io`中的`loadmat`功能可用于读取`train_32x32.mat`。
+但是，最好保持`read_data`函数的通用性，因为这使我们可以将脚本重用于其他数据集。 `scipy.io`中的`loadmat`函数可用于读取`train_32x32.mat`。
 
-如果输入是放置在目录中的原始图像，那么我们可以读取目录中可用的图像文件并通过`opencv`读取它们。 `load_img`功能可用于使用`opencv`读取原始图像。
+如果输入是放置在目录中的原始图像，那么我们可以读取目录中可用的图像文件并通过`opencv`读取它们。 `load_img`函数可用于使用`opencv`读取原始图像。
 
 最后，为了更好地融合网络，将像素强度归一化为`[-1,1]`范围：
 
@@ -656,7 +656,7 @@ python captcha_gan.py train --dest_train '/home/santanu/Downloads/train_32x32.ma
 | `dis_input_dim` | `(32,32,3)` | 辨别真假房屋号码图像的形状。 |
 | `dis_lr` | `0.001` | 判别器网络的学习率。 |
 | `dis_beta1` | `0.5` | `beta_1`是用于判别器的 Adam 优化器的参数。 |
-| `alpha` | `0.2` | 这是`LeakyReLU`激活的泄漏因子。 当`activation`功能的输入为负时，这有助于提供一个梯度（此处为`0.2`）。 它有助于解决垂死的`ReLU`问题。 如果输入小于或等于`0`，则 ReLU 函数的输出相对于其输入的梯度为`0`。 来自较后层的反向传播错误被此`0`乘以，尽管与该`ReLU.` ReLU 相关的神经元死亡，但没有错误传递至较早层。ReLU 已死亡，许多此类死亡`ReLUs`会影响训练 。 `LeakyReLU`通过甚至为负输入值提供小的梯度来克服了这个问题，从而确保训练不会由于缺乏梯度而停止。 |
+| `alpha` | `0.2` | 这是`LeakyReLU`激活的泄漏因子。 当`activation`函数的输入为负时，这有助于提供一个梯度（此处为`0.2`）。 它有助于解决垂死的`ReLU`问题。 如果输入小于或等于`0`，则 ReLU 函数的输出相对于其输入的梯度为`0`。 来自较后层的反向传播错误被此`0`乘以，尽管与该`ReLU.` ReLU 相关的神经元死亡，但没有错误传递至较早层。ReLU 已死亡，许多此类死亡`ReLUs`会影响训练 。 `LeakyReLU`通过甚至为负输入值提供小的梯度来克服了这个问题，从而确保训练不会由于缺乏梯度而停止。 |
 | `epochs` | `100` | 这是要运行的时期数。 |
 | `smooth_coef` | `0.1` | 设计该平滑系数的目的是减少真实样本对判别器的损失。 例如，`0.1`的`smooth_coef`可以将归因于真实图像的损失减少到原始损失的 90%。 这有助于 GAN 更好地融合。 |
 

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

 # 回归和分类的集成方法
 
-商业企业广泛使用高级分析工具，以解决使用数据的问题。 分析工具的目的是分析数据并提取相关信息，这些信息可用于解决问题或提高业务某些方面的绩效。 它还涉及各种机器学习算法，通过这些算法我们可以创建预测模型以获得更好的结果。
+商业企业广泛使用高级分析工具，以解决使用数据的问题。 分析工具的目的是分析数据并提取相关信息，这些信息可用于解决问题或提高业务某些方面的表现。 它还涉及各种机器学习算法，通过这些算法我们可以创建预测模型以获得更好的结果。
 
 在本章中，我们将探索一个可以大大改善基本预测模型性能的简单想法。
 
@@ -219,7 +219,7 @@ import pandas as pd
 
 ![](img/fe6dbac4-e195-481e-8831-add56f69a0de.png)
 
-让我们在`grad _school`，`university`和`high_school`中产生用于教育的虚拟功能。 不用`sex`一词，使用`male`虚拟功能，而不是使用婚姻，让我们使用`married`功能。 当此人结婚时，此功能的值为 1，否则为 0。 对于`pay_1`功能，我们将做一些简化过程。 如果我们在此处看到一个正数，则表示该客户在`i`个月内延迟付款。 这表示`ID`为 1 的客户将付款延迟了前两个月。 我们可以看到，三个月前，他/她的付款没有延迟。 这是数据集的样子：
+让我们在`grad _school`，`university`和`high_school`中产生用于教育的虚拟功能。 不用`sex`一词，使用`male`虚拟功能，而不是使用婚姻，让我们使用`married`函数。 当此人结婚时，此功能的值为 1，否则为 0。 对于`pay_1`函数，我们将做一些简化过程。 如果我们在此处看到一个正数，则表示该客户在`i`个月内延迟付款。 这表示`ID`为 1 的客户将付款延迟了前两个月。 我们可以看到，三个月前，他/她的付款没有延迟。 这是数据集的样子：
 
 ![](img/f4ab3d2e-f4b8-4deb-a55d-80d918758c2d.png)
 
@@ -299,9 +299,9 @@ def CMatrix(CM, labels=['pay', 'default']):
 
 前面的屏幕快照证明，随机森林模型总体上优于其他模型。
 
-要查看`precision`，`recall`和`threshold`之间的关系，我们可以使用`scikit-learn`中的`precision_recall_curve`功能。 在这里，传递预测值和实际观测值，然后我们得到的结果将包含使我们能够生成`precision_recall_curve`函数代码的对象。
+要查看`precision`，`recall`和`threshold`之间的关系，我们可以使用`scikit-learn`中的`precision_recall_curve`函数。 在这里，传递预测值和实际观测值，然后我们得到的结果将包含使我们能够生成`precision_recall_curve`函数代码的对象。
 
-以下屏幕截图显示了`scikit-learn`中`precision_recall_curve`功能的代码：
+以下屏幕截图显示了`scikit-learn`中`precision_recall_curve`函数的代码：
 
 ![](img/e302b9c0-37ad-41fb-ba88-8fd8b9ebd89e.png)
 

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

@@ -89,7 +89,7 @@ y = diamonds[target_name]
 #X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=55)
 ```
 
-这与我们在第 1 章，“回归和分类的集成方法”中使用的单元格相同。 此处的区别在于我们不使用`train_test_split`功能。 在这里，我们正在生成`X`矩阵，该矩阵包含所有功能并具有我们的目标功能。 因此，我们有了`X`矩阵和`y`向量。
+这与我们在第 1 章，“回归和分类的集成方法”中使用的单元格相同。 此处的区别在于我们不使用`train_test_split`函数。 在这里，我们正在生成`X`矩阵，该矩阵包含所有功能并具有我们的目标功能。 因此，我们有了`X`矩阵和`y`向量。
 
 为了训练模型，我们将实例化`RandomForestRegressor`函数，该函数在此数据集的第 1 章 ，“回归和分类集成方法”中是最佳模型。 。 以下显示了用于实例化`RandomForestRegressor`函数的**代码**：
 
@@ -106,9 +106,9 @@ RF = RandomForestRegressor(n_estimators=50, max_depth=16, random_state=123, n_jo
 from sklearn.model_selection import cross_validate
 ```
 
-此`cross_validate`功能的工作方式如下：
+此`cross_validate`函数的工作方式如下：
 
-*   我们提供了估计器，它将是`RandomForestRegressor`函数。 下面显示了用于应用`RandomForestRegressor`功能的代码：
+*   我们提供了估计器，它将是`RandomForestRegressor`函数。 下面显示了用于应用`RandomForestRegressor`函数的代码：
 
 ```py
  scores = cross_validate(estimator=RF,X=X,y=y,
@@ -184,7 +184,7 @@ from sklearn.ensemble import AdaBoostRegressor
 from sklearn.model_selection import cross_validate
 ```
 
-下一步是使用`cross_validate`功能比较模型。 下面显示了用于比较这三种模型的代码块：
+下一步是使用`cross_validate`函数比较模型。 下面显示了用于比较这三种模型的代码块：
 
 ```py
 ## KNN
@@ -206,7 +206,7 @@ boosting_test_mse = cross_validate(estimator=boosting,X=X,y=y,
  cv=10, n_jobs=-1)['test_score']
 ```
 
-在这里，我们看到了将用于每个模型的测试评估指标的结果。 我们使用`mean_squared_error`功能。 对于每个模型，我们使用十倍交叉验证，得到结果后，我们将获得`test_score`变量。 在这种情况下，此`test_score`变量是均方误差，如以下代码所示：
+在这里，我们看到了将用于每个模型的测试评估指标的结果。 我们使用`mean_squared_error`函数。 对于每个模型，我们使用十倍交叉验证，得到结果后，我们将获得`test_score`变量。 在这种情况下，此`test_score`变量是均方误差，如以下代码所示：
 
 ```py
  mse_models = -1*pd.DataFrame({'KNN':knn_test_mse,
@@ -295,7 +295,7 @@ y = diamonds[target_name]
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=123)
 ```
 
-执行并创建用于建模的对象后，我们执行`train_test_split`功能。 在前面的代码块中，我们将设置 0.1（10%）的数据进行测试，因此在调整超参数后，数据集的这一部分将用于模型评估。
+执行并创建用于建模的对象后，我们执行`train_test_split`函数。 在前面的代码块中，我们将设置 0.1（10%）的数据进行测试，因此在调整超参数后，数据集的这一部分将用于模型评估。
 
 我们将使用以下参数调整`RandomForestRegressor`模型：
 

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

@@ -223,7 +223,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 ![](img/2fcfac44-86fd-447e-a414-866ba15d6164.png)
 
-我们将要做的第一个转换是创建另一种方式来编码`education`功能中的信息。 到目前为止，我们已经在`education`功能中使用了一种编码技术，并且我们将使用`x`变量的上下文来提出另一种编码。 受过研究生教育的人比受过其他教育的人受过更高的教育。 因此，我们可以针对这些功能提出某种积分系统。 例如，我们可以为受过高等教育的人分配 2 分，为受过大学教育的人分配 1 分，而为该数据集中的其他教育水平分配负分。
+我们将要做的第一个转换是创建另一种方式来编码`education`函数中的信息。 到目前为止，我们已经在`education`函数中使用了一种编码技术，并且我们将使用`x`变量的上下文来提出另一种编码。 受过研究生教育的人比受过其他教育的人受过更高的教育。 因此，我们可以针对这些功能提出某种积分系统。 例如，我们可以为受过高等教育的人分配 2 分，为受过大学教育的人分配 1 分，而为该数据集中的其他教育水平分配负分。
 让我们看一下以下屏幕截图，看看如何完成此操作：
 
 ![](img/c0580fcd-23d3-41a8-b5e1-9ec4978e0dd3.png)
@@ -244,7 +244,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 ![](img/fbf447a5-af00-402d-8bb9-b5c0d34cb41d.png)
 
-我们可以使用付费功能执行相同的操作。 从先前的分析中，我们知道`pay_1`功能对于预测接下来要付款的人非常重要。 因此，为了将其他五个`pay_i`功能减少到两个，我们将六个账单金额功能减少到一个，并将六个`pay_i`功能减少到两个。 除此之外，我们再次对其余五个`pay_i`功能应用 PCA 技术，以将这五个功能减少到仅一个。 看一下以下屏幕截图：
+我们可以使用付费功能执行相同的操作。 从先前的分析中，我们知道`pay_1`函数对于预测接下来要付款的人非常重要。 因此，为了将其他五个`pay_i`函数减少到两个，我们将六个账单金额功能减少到一个，并将六个`pay_i`函数减少到两个。 除此之外，我们再次对其余五个`pay_i`函数应用 PCA 技术，以将这五个功能减少到仅一个。 看一下以下屏幕截图：
 
 ![](img/3b49bf31-73fe-48a7-9e42-dc69ef617e7e.png)
 
@@ -318,7 +318,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 ![](img/a543d2e0-8351-4c63-b35c-e118875fb5b4.png)
 
-对于这个问题，我们将执行一个数学运算。 我们将使用前面截图中显示的新功能来预测目标。 现在，帐单金额功能中的大多数信息都已编码为这些功能，不再需要，但是我们可以使用 PCA 技术将六个帐单金额功能减少为一个，而不是丢弃它们。 因此，让我们应用 PCA 技术将六个功能简化为一个组件。 现在有一个名为`bill_amt_new_feat`的新功能。 因此，这是我们执行的第二个功能工程步骤。 最后，对于`pay_i`功能，我们将按原样保留第一个功能，并将 PCA 技术应用于后五个功能`pay_2`，`pay_3`，`pay_4`，`pay_5`和`pay_6`， 将这五个功能简化为仅两个组成部分。 您可以在`PCA`对象上使用`fit_transform`方法来获取组件。
+对于这个问题，我们将执行一个数学运算。 我们将使用前面截图中显示的新功能来预测目标。 现在，帐单金额功能中的大多数信息都已编码为这些功能，不再需要，但是我们可以使用 PCA 技术将六个帐单金额功能减少为一个，而不是丢弃它们。 因此，让我们应用 PCA 技术将六个功能简化为一个组件。 现在有一个名为`bill_amt_new_feat`的新功能。 因此，这是我们执行的第二个功能工程步骤。 最后，对于`pay_i`函数，我们将按原样保留第一个功能，并将 PCA 技术应用于后五个函数`pay_2`，`pay_3`，`pay_4`，`pay_5`和`pay_6`， 将这五个功能简化为仅两个组成部分。 您可以在`PCA`对象上使用`fit_transform`方法来获取组件。
 
 现在，让我们看下面的屏幕快照，显示所有与金钱有关的功能。 如您所见，这里的差异确实很大，因为货币金额很大：
 

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

@@ -43,7 +43,7 @@
 
 ![](img/bd6b7f5e-ef5e-4f6e-aac0-a65a57a01b6b.png)
 
-因此，您具有阈值或偏差`b`的值，并且具有**年龄**，`x1`和**帐单金额**，`x2`。 因此，这三个值进入一个运算，然后得到输出。 现在，我们可以对感知器进行一些修改，这就是添加所谓的**激活函数**。 激活函数是任何可以获取运算结果并使用`f`功能对输入值进行某种转换的功能。 因此，激活函数的输入是来自运算的结果数量，然后在应用激活函数`f`之后，我们将获得以下输出：
+因此，您具有阈值或偏差`b`的值，并且具有**年龄**，`x1`和**帐单金额**，`x2`。 因此，这三个值进入一个运算，然后得到输出。 现在，我们可以对感知器进行一些修改，这就是添加所谓的**激活函数**。 激活函数是任何可以获取运算结果并使用`f`函数对输入值进行某种转换的功能。 因此，激活函数的输入是来自运算的结果数量，然后在应用激活函数`f`之后，我们将获得以下输出：
 
 ![](img/b2e13ce5-8226-4536-a9c6-c425619c50d0.png)
 

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

@@ -230,7 +230,7 @@ y = tf.placeholder(y_train.dtype)
 
 # 损失函数
 
-我们将使用`mean_squared _error`功能-TensorFlow 为我们提供了许多这样的功能。 我们传递观测值和预测值，并且此函数计算均方误差。 以下屏幕截图显示了用于显示`mean_squared _error`功能的代码行：
+我们将使用`mean_squared _error`函数-TensorFlow 为我们提供了许多这样的功能。 我们传递观测值和预测值，并且此函数计算均方误差。 以下屏幕截图显示了用于显示`mean_squared _error`函数的代码行：
 
 ![](img/cedfa97e-88ee-4564-9297-6299ce5e7652.png)
 
@@ -286,7 +286,7 @@ y = tf.placeholder(y_train.dtype)
 
 ![](img/e70a38d6-3326-48a1-a4e2-2a8156ff1188.png)
 
-我们还将从`sklearn.model_selection`导入`train_test_split`功能，从`sklearn.preprocessiong`导入`RobustScaler`功能，并从`sklearn.metrics`导入`precision_score`，`recall_score`和`accuracy_score`。 我们还从`tensorflow.contrib.layers`导入`fully_connected`函数以构建我们的网络层。
+我们还将从`sklearn.model_selection`导入`train_test_split`函数，从`sklearn.preprocessiong`导入`RobustScaler`函数，并从`sklearn.metrics`导入`precision_score`，`recall_score`和`accuracy_score`。 我们还从`tensorflow.contrib.layers`导入`fully_connected`函数以构建我们的网络层。
 
 # DNN 模型的元素
 
@@ -392,7 +392,7 @@ TensorFlow，`tf.nn.elu`中获得此功能，从中您可以获得许多功能
 
 # 评估节点
 
-现在，为了进行评估，我们将计算默认变量和非默认变量的概率； 您可以通过将`softmax`函数应用于`logits`来获得概率。 以下屏幕截图显示了`softmax`功能：
+现在，为了进行评估，我们将计算默认变量和非默认变量的概率； 您可以通过将`softmax`函数应用于`logits`来获得概率。 以下屏幕截图显示了`softmax`函数：
 
 ![](img/c08b33df-ddba-4203-8a20-c7c8d56f40cc.png)
 
@@ -421,10 +421,7 @@ TensorFlow，`tf.nn.elu`中获得此功能，从中您可以获得许多功能
 
 # 使用设定的阈值评估模型
 
-生成`probabilities`对象，以使用
-不同的分类阈值实际评估模型性能。 可以针对二元
-分类问题修改分类阈值，并且可以将其用于计算召回得分，准确性和
-准确性。 使用分类阈值`0.16`时，这些是我们在测试数据集中获得的指标：
+生成`probabilities`对象，以使用不同的分类阈值实际评估模型性能。 可以针对二元分类问题修改分类阈值，并且可以将其用于计算召回得分，精度和准确性。 使用分类阈值`0.16`时，这些是我们在测试数据集中获得的指标：
 
 ![](img/f23f3ebc-019f-4be1-a50d-dd44eaec977b.png)
 

new/whats-new-tf2/2.md

 # Keras 默认集成和急切执行
 
-本章涵盖了两个高级 **TensorFlow 2.0**（**TF 2.0**）API，即 Keras 和估计器。 本章重点关注惰性评估和急切执行的概念，重点介绍如何在 **TensorFlow 1.x**（**TF 1.x**）和 TF 2.0 中评估基础计算图之间的差异 。 本章还提供了有关使用诸如 Keras 之类的高级 API 构建自定义模型（使用自定义低级操作）的详细指南。
+本章涵盖了两个高级 **TensorFlow 2.0**（**TF 2.0**）API，即 Keras 和估计器。 本章重点关注惰性求值和急切执行的概念，重点介绍如何在 **TensorFlow 1.x**（**TF 1.x**）和 TF 2.0 中求值基础计算图之间的差异 。 本章还提供了有关使用诸如 Keras 之类的高级 API 构建自定义模型（使用自定义低级操作）的详细指南。
 
 本章将涵盖以下主题：
 
 *   TF 2.0 中的新抽象
 *   深入了解 Keras API
 *   估计器
-*   评估 TensorFlow 图
+*   求值 TensorFlow 图
 
 # 技术要求
 
@@ -394,11 +394,11 @@ TensorFlow 团队尝试通过引入 Estimators 来解决此问题，Estimators
 
 在 TF 2.0 中，Keras 已经提供了 Estimators 公开的许多功能。 如果您只是入门，那么 Keras 是一个更容易学习的 API。 建议初学者在评估器上使用 Keras API。 一旦用例需要使用 Estimators，就可以查找并了解更多信息。 有关详细指南，请访问[这里](https://www.tensorflow.org/guide/estimators)。
 
-# 评估 TensorFlow 图
+# 求值 TensorFlow 图
 
 TensorFlow 的中心思想是，要求程序员创建计算图以指定需要执行的操作才能获得所需的结果。 然后，程序员指定了硬件和其他环境参数，以针对给定的一组输入来计算此计算图的输出。 这意味着在程序员明确计算图形之前，值和变量没有任何值。 当程序员真正想要的只是数量的值时，这增加了程序员创建和管理会话的开销。
 
-TF 2.0 旨在通过更改评估和计算基础计算图的方式来解决此问题。 用一个句子，TF ...
+TF 2.0 旨在通过更改求值和计算基础计算图的方式来解决此问题。 用一个句子，TF ...
 
 # 延迟加载与急切执行
 
@@ -406,7 +406,7 @@ TF 2.0 旨在通过更改评估和计算基础计算图的方式来解决此问
 
 **急切执行**可以理解为与延迟加载相反。 在此，数量的值一定义就立即计算，而不必等到它被调用。 这意味着当实际请求数量时，该值从内存中返回，而不是从头开始计算。 这有助于最小化返回查询结果所需的时间，因为用户不必等待计算值所花费的时间。
 
-可以通过添加两个常量的简单操作来说明两者之间的区别：`a`和`b`。 首先，让我们看一下 2.0 之前的 TensorFlow 版本。 这些要求用户定义一个计算图，然后使用会话来运行和评估该图。 这可以理解为延迟加载的示例。 让我们看一下以下代码片段，以获得更好的主意：
+可以通过添加两个常量的简单操作来说明两者之间的区别：`a`和`b`。 首先，让我们看一下 2.0 之前的 TensorFlow 版本。 这些要求用户定义一个计算图，然后使用会话来运行和求值该图。 这可以理解为延迟加载的示例。 让我们看一下以下代码片段，以获得更好的主意：
 
 ```py
 # Define constants
@@ -425,7 +425,7 @@ print(f"Value outside session: {c}”)
 Outside session: Tensor("add_1:0", shape=(), dtype=int32)
 ```
 
-在此阶段，我们可以看到`c`的值（即`add`对两个常量进行运算的结果）实际上是张量，没有实际数值。 因此，我们可以看到该图已构建但尚未评估。 为了获得加法运算的实际数值结果，我们必须定义一个会话来运行和评估基础图：
+在此阶段，我们可以看到`c`的值（即`add`对两个常量进行运算的结果）实际上是张量，没有实际数值。 因此，我们可以看到该图已构建但尚未求值。 为了获得加法运算的实际数值结果，我们必须定义一个会话来运行和求值基础图：
 
 ```py
 # Create a session and run graph in it
@@ -439,7 +439,7 @@ with tf.Session() as sess:
 Value inside Session: 42
 ```
 
-这表明添加操作仅在会话中运行后才进行评估。
+这表明添加操作仅在会话中运行后才进行求值。
 
 现在，让我们尝试使用 TF 2.0 及更高版本的相同示例。 我们用相同的变量名称和值定义两个常量。 我们还定义了第三个变量来保存加法的结果。 然后，我们在紧接之后打印加法的值：
 
@@ -459,9 +459,9 @@ print(f"Value outside session: {c}")
 Value outside session: 42
 ```
 
-如我们所见，此阶段的输出在 TensorFlow 2.0+ 和 <2.0 版本之间有所不同。 在这种情况下，`c`变量已经包含加法运算的值。 无需程序员评估任何计算图即可进行计算。 换句话说，加法操作急切地执行。 这是 2.0 及更高版本与旧版本之间的主要区别。
+如我们所见，此阶段的输出在 TensorFlow 2.0+ 和 <2.0 版本之间有所不同。 在这种情况下，`c`变量已经包含加法运算的值。 无需程序员求值任何计算图即可进行计算。 换句话说，加法操作急切地执行。 这是 2.0 及更高版本与旧版本之间的主要区别。
 
-TF 2.0 与 Python 编程语言紧密集成。 急切的执行使张量可以无缝用作本机 Python 对象，而不必担心评估计算图以及管理会话或基础硬件。 好处不止于此。 急切的执行使程序员能够利用宿主编程语言的强大控制流结构。 TensorFlow 代码现在与平台的其余部分更加直观地集成，这为开发人员带来了巨大的价值，因为它不再需要特殊的流控制结构。 这也为实验，调试和笔记本环境增加了重要价值。
+TF 2.0 与 Python 编程语言紧密集成。 急切的执行使张量可以无缝用作本机 Python 对象，而不必担心求值计算图以及管理会话或基础硬件。 好处不止于此。 急切的执行使程序员能够利用宿主编程语言的强大控制流结构。 TensorFlow 代码现在与平台的其余部分更加直观地集成，这为开发人员带来了巨大的价值，因为它不再需要特殊的流控制结构。 这也为实验，调试和笔记本环境增加了重要价值。
 
 # 总结
 

new/whats-new-tf2/4.md

@@ -342,9 +342,9 @@ TF 2.0 中添加的另一个功能是`tf.function`装饰器。 用`tf.function`
 
 并非所有函数都需要使用`tf.function`进行注释，因为在带注释的函数内部调用的任何函数也将在图形模式下运行。 对于具有多个较小操作的图形，此类函数速度更快，但对于其他具有较昂贵操作（例如卷积）的图形，改进效果会较小。
 
-`tf.function`装饰器还可以绘制 Python 控制流图，例如`if`，`while`，`for`，`break`，`continue`和`return`。 运行这些功能可实现更快的评估和硬件加速。
+`tf.function`装饰器还可以绘制 Python 控制流图，例如`if`，`while`，`for`，`break`，`continue`和`return`。 运行这些功能可实现更快的求值和硬件加速。
 
-`tf.function`也可以在`tf.keras`模型和训练循环中使用。 `tf.function`装饰器通常用于模型的`call`方法上，以提供图形模式评估。 另一种更常见的做法是将`tf.function`用于一个训练循环，因为它仅控制流程。 这样，训练过程的更多计算可以带入 TensorFlow 内，并将受益于优化的操作。
+`tf.function`也可以在`tf.keras`模型和训练循环中使用。 `tf.function`装饰器通常用于模型的`call`方法上，以提供图模型来求值。 另一种更常见的做法是将`tf.function`用于一个训练循环，因为它仅控制流程。 这样，训练过程的更多计算可以带入 TensorFlow 内，并将受益于优化的操作。
 
 以下代码段是`tf.keras`中`tf.function`的示例：
 

new/whats-new-tf2/7.md

@@ -303,7 +303,7 @@ test_out = model(test_data, training=False)
 
 由于 TF-Slim 打包在`tf.contrib.layers`库下，因此即使在兼容性模块中，它也无法在 TF 2.0 中使用。 这意味着要将 TF-Slim 代码转换为 TF 2.0 格式，通常需要更改整个代码动态。
 
-这包括从代码中删除参数范围，因为所有参数在 TF 2.0 中都应明确。 `normalizer_fn`和`activation_fn`功能应分为各自的层。 请注意，TF-Slim 层的参数名称和默认值与`tf.keras`层不同。
+这包括从代码中删除参数范围，因为所有参数在 TF 2.0 中都应明确。 `normalizer_fn`和`activation_fn`函数应分为各自的层。 请注意，TF-Slim 层的参数名称和默认值与`tf.keras`层不同。
 
 将 TF-Slim 模型转换为 TF 2.0 的最简单方法是将其转换为 TF 1.x 中的`tf.layers` API，然后将其转换为`tf.keras.layers`。
 

new/whats-new-tf2/pt1.md

 # 第 1 节：TensorFlow 2.0 - 架构和 API 更改
 
-本书的这一部分将为您简要概述 TensorFlow 2.0 中的新增功能，与 TensorFlow 1.x 的比较，惰性评估和热切执行之间的差异，架构级别的更改以及关于`tf.keras`和`Estimator`的 API 使用情况。
+本书的这一部分将为您简要概述 TensorFlow 2.0 中的新增功能，与 TensorFlow 1.x 的比较，惰性求值和急切执行之间的差异，架构级别的更改以及关于`tf.keras`和`Estimator`的 API 使用情况。
 
 本节包含以下章节：