2020-12-27 15:06:03

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

@@ -149,7 +149,7 @@
 
 节点是网络中表示数据的地方。 有两个与节点关联的值：偏差和权重。 这两个值都影响数据如何由节点表示并传递到其他节点。 当网络*学习*时，它会有效地调整这些值以满足优化功能。
 
-神经网络中的大部分工作都发生在隐藏层中。 不幸的是，没有明确的规则来确定网络应具有多少层或节点。 在实现神经网络时，人们可能会花费时间来尝试不同的层和节点组合。 建议始终从单个图层开始，并且总是以反映输入数据具有的要素数量（即，数据集中有多少*列*可用）的数量的节点开始。 然后，将继续添加层和节点，直到获得令人满意的性能-或每当网络开始过度适应训练数据时。
+神经网络中的大部分工作都发生在隐藏层中。 不幸的是，没有明确的规则来确定网络应具有多少层或节点。 在实现神经网络时，人们可能会花费时间来尝试不同的层和节点组合。 建议始终从单个层开始，并且总是以反映输入数据具有的要素数量（即，数据集中有多少*列*可用）的数量的节点开始。 然后，将继续添加层和节点，直到获得令人满意的性能-或每当网络开始过度适应训练数据时。
 
 当前的神经网络实践通常仅限于实验，该实验涉及节点和层的数量（例如，网络的深度）以及在每一层执行的操作的种类。 在许多成功的实例中，仅通过调整这些参数，神经网络的性能就优于其他算法。
 

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

@@ -436,7 +436,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
 具有单个隐藏层的神经网络在许多问题上的表现都相当不错。 我们的第一个比特币模型（`bitcoin_lstm_v0`）是一个很好的例子：它可以使用单个 LSTM 层预测（根据测试集）未来七天的比特币价格（错误率约为 8.4% ）。 但是，并非所有问题都可以用单层建模。
 
-您正在预测的功能越复杂，则需要添加更多图层的可能性就越高。 确定是否添加新层是一个好主意，这是了解它们在神经网络中的作用。
+您正在预测的功能越复杂，则需要添加更多层的可能性就越高。 确定是否添加新层是一个好主意，这是了解它们在神经网络中的作用。
 
 每一层都创建其输入数据的模型表示。 链中较早的层创建较低级别的表示，较晚的层创建较高的级别。
 
@@ -444,7 +444,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
 ##### 添加更多节点
 
-图层所需的神经元数量与输入和输出数据的结构方式有关。 例如，如果您要将`4 x 4`像素图像分为两类之一，则可以从一个具有 12 个神经元的隐藏层（每个可用像素一个）和一个只有两个神经元的输出层开始（每个预测类一个）。
+层所需的神经元数量与输入和输出数据的结构方式有关。 例如，如果您要将`4 x 4`像素图像分为两类之一，则可以从一个具有 12 个神经元的隐藏层（每个可用像素一个）和一个只有两个神经元的输出层开始（每个预测类一个）。
 
 通常在添加新层的同时添加新神经元。 然后，可以添加一层具有与前一层相同数量的神经元，或者是前一层的神经元数量的倍数的层。 例如，如果您的第一个隐藏层具有 12 个神经元，则可以尝试添加第二个具有 12、6 或 24 个层的神经元。
 
@@ -556,7 +556,7 @@ TensorFlow 和 Keras 提供了许多激活函数-偶尔会添加新的激活函
 
 ![Hyperbolic Tangent (Tanh)](img/image03_22.jpg)
 
-表示将连续评估它们对节点的影响。 同样，由于其非线性，可以使用此功能来更改一层如何影响链中的下一层。 使用非线性函数时，图层会以不同的方式激活神经元，从而使从数据中学习不同的表示更为容易。 但是，它们具有类似于 Sigmoid 的图案，可反复惩罚极端节点值，从而导致称为的问题，即消失梯度。 消失的梯度对网络的学习能力产生负面影响：
+表示将连续评估它们对节点的影响。 同样，由于其非线性，可以使用此功能来更改一层如何影响链中的下一层。 使用非线性函数时，层会以不同的方式激活神经元，从而使从数据中学习不同的表示更为容易。 但是，它们具有类似于 Sigmoid 的图案，可反复惩罚极端节点值，从而导致称为的问题，即消失梯度。 消失的梯度对网络的学习能力产生负面影响：
 
 ![Hyperbolic Tangent (Tanh)](img/image03_24.jpg)
 

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

@@ -127,7 +127,7 @@ Keras 功能模型
 
 模型摘要输出
 
-因此，您可以从中看到，首先将参数传递给图层，然后将图层本身传递以形成链。 那么，这些`Dropout`和`Flatten`层又如何呢？ `Dropout`参数本质上是一个技巧。 当我们设置`Dropout`参数（这里是`0.1`）时，我们告诉神经网络要做的是在每个训练周期中随机断开 10% 的激活。 这是使神经网络学习概括。 这是真正的学习，而不是简单地记住输入数据。 `Flatten`层处理尺寸。 因为我们有一个二维的`28x28`像素输入图像，所以我们使用`Flatten`将其转换为`784`的长的一维数字字符串。 这被馈送到输出`softmax`层。
+因此，您可以从中看到，首先将参数传递给层，然后将层本身传递以形成链。 那么，这些`Dropout`和`Flatten`层又如何呢？ `Dropout`参数本质上是一个技巧。 当我们设置`Dropout`参数（这里是`0.1`）时，我们告诉神经网络要做的是在每个训练周期中随机断开 10% 的激活。 这是使神经网络学习概括。 这是真正的学习，而不是简单地记住输入数据。 `Flatten`层处理尺寸。 因为我们有一个二维的`28x28`像素输入图像，所以我们使用`Flatten`将其转换为`784`的长的一维数字字符串。 这被馈送到输出`softmax`层。
 
 打印出模型摘要是弄清参数大小和尺寸的好方法。 这最终成为使用 Keras 的棘手部分之一，例如当您有一组输入样本（在我们的示例中为`28x28`图像），并且在进入`softmax`时，您需要到那时将它们转换成包含十个可能输出值的单个数组。 您可以看到形状在我们穿过每一层时如何变化。 最后，`Flatten`将每个样本的维数降低为一个维，然后将其转换为具有十个可能的输出值的维。
 
@@ -161,7 +161,7 @@ Keras 功能模型
 
 我们还将介绍可训练的参数（这些是求解器学习的参数），不可训练的参数（模型中不需要训练的其他参数），最后，超参数（传统的求解器不能学习的参数）。
 
-在我们的“模型摘要输出”的屏幕截图中，请注意屏幕截图底部代码中突出显示的部分中可训练参数的数量。 这就是我们的模型`adam`优化器与我们的分类交叉熵`loss`函数一起将在模型内部包含的单个浮点数的数目，以便找到可能的最佳参数值。 因此，此可训练的参数编号是我们的`optimizer`函数学习的唯一编号集合。 但是，此代码和前面的屏幕快照中还有许多其他数字。 这些不可训练的参数呢？ 在我们当前的模型中，有零个不可训练参数。 但是，Keras 中不同种类的图层可能具有恒定值，因此它们将显示为不可训练的。 再次，这只是意味着不需要对其进行训练，并且我们的`optimizer`函数将不会尝试更改其值。
+在我们的“模型摘要输出”的屏幕截图中，请注意屏幕截图底部代码中突出显示的部分中可训练参数的数量。 这就是我们的模型`adam`优化器与我们的分类交叉熵`loss`函数一起将在模型内部包含的单个浮点数的数目，以便找到可能的最佳参数值。 因此，此可训练的参数编号是我们的`optimizer`函数学习的唯一编号集合。 但是，此代码和前面的屏幕快照中还有许多其他数字。 这些不可训练的参数呢？ 在我们当前的模型中，有零个不可训练参数。 但是，Keras 中不同种类的层可能具有恒定值，因此它们将显示为不可训练的。 再次，这只是意味着不需要对其进行训练，并且我们的`optimizer`函数将不会尝试更改其值。
 
 那么，什么是超参数？ 好吧，非常简单，超参数是模型本身之外的值（参数）。 因此，认为超参数最简单的是实际的模型结构。 在这种情况下，我们创建层的次数是一个超参数，层的大小是一个超参数，我们在密集层中选择的`32`单位是一个超参数，`0.1`的丢弃设置是超参数，甚至激活函数本身（例如，选择`relu`而不是`sigmoid`）都是超参数。 现在您可能在想，“请稍等，我不得不在这里选择很多参数；我以为机器应该在学习”。 它是！ 但是，诀窍在于`optimizer`无法学习我们需要了解的所有知识，以组成一个最佳模型。
 

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

@@ -32,7 +32,7 @@
 
 首先，我们从支持集中获取每个图像`x[i]`，并将其传递给嵌入函数`f[φ](x[i])`，以提取特征。 由于我们的支持集包含图像，因此我们可以使用卷积网络作为我们的嵌入函数来学习嵌入。 嵌入函数将为我们提供支持集中每个数据点的特征向量。 类似地，我们将把查询图像`x[j]`传递给嵌入函数`f[φ](x[j])`来学习其嵌入。
 
-因此，一旦有了支持集`f[φ](x[i])`和查询集`f[φ](x[j])`的特征向量，就可以使用运算符`Z`组合它们。 `Z`可以是任何组合运算符； 我们使用串联作为运算符，以合并支持和查询集的特征向量，即`Z(f[φ](x[i]), f[φ](x[j]))`。
+因此，一旦有了支持集`f[φ](x[i])`和查询集`f[φ](x[j])`的特征向量，就可以使用运算符`Z`组合它们。 `Z`可以是任何组合运算符； 我们使用连接作为运算符，以合并支持和查询集的特征向量，即`Z(f[φ](x[i]), f[φ](x[j]))`。
 
 如下图所示，我们将合并支持集`f[φ](x[i])`和查询集`f[φ](x[j])`的特征向量。 但是这样的组合有什么用呢？ 这将帮助我们理解支持集中图像的特征向量与查询图像的特征向量之间的关系。 在我们的示例中，它将帮助我们理解狮子，大象和狗的图像的特征向量与查询图像的特征向量之间的关系：
 
@@ -72,7 +72,7 @@
 
 既然我们已经了解了如何在单发和少发学习任务中使用关系网络，我们将看到如何在零发学习设置中使用关系网络，在这种情况下，每个类别下都没有任何数据点。 但是，在零射击学习中，我们将具有元信息，该元信息是有关每个类的属性的信息，并将被编码到语义向量`v[c]`中，其中下标`c`表示类。
 
-我们没有使用单个嵌入函数来学习支持和查询集的嵌入，而是分别使用了两个不同的嵌入函数`f[φ1]`和`f[φ2]`。 首先，我们将使用`f[φ1]`学习语义向量`v[c]`的嵌入，并使用`f[φ2]`学习查询集`x[j]`的嵌入。 现在，我们将使用串联操作`Z`来串联这些嵌入：
+我们没有使用单个嵌入函数来学习支持和查询集的嵌入，而是分别使用了两个不同的嵌入函数`f[φ1]`和`f[φ2]`。 首先，我们将使用`f[φ1]`学习语义向量`v[c]`的嵌入，并使用`f[φ2]`学习查询集`x[j]`的嵌入。 现在，我们将使用连接操作`Z`来连接这些嵌入：
 
 ![](img/d30a1e84-e7f0-486f-ba63-07bd509357ca.png)
 
@@ -204,7 +204,7 @@ def relation_function(x):
     return y
 ```
 
-现在，我们将支持集和查询集的串联特征向量传递给关系函数，并获得关系得分：
+现在，我们将支持集和查询集的连接特征向量传递给关系函数，并获得关系得分：
 
 ```py
 relation_scores = relation_function(Z)

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

@@ -37,7 +37,7 @@
 # 第 4 章：使用 TensorFlow 的关系和匹配网络
 
 1.  关系网络由两个重要功能组成：嵌入函数（由`f[φ]`表示）和关系函数由`g[φ]`表示。
-2.  有了支持集`f[φ](x[i])`和查询集`f[φ](x[j])`的特征向量后，就可以使用运算符`Z`组合它们。 在这里，`Z`可以是任何组合运算符; 我们使用串联作为运算符来组合支持集和查询集的特征向量：
+2.  有了支持集`f[φ](x[i])`和查询集`f[φ](x[j])`的特征向量后，就可以使用运算符`Z`组合它们。 在这里，`Z`可以是任何组合运算符; 我们使用连接作为运算符来组合支持集和查询集的特征向量：
 
     ![](img/5c9ca5d1-2ec0-451c-a1d9-3fbd7dacd2a6.png)。
 

new/handson-rl-py/07.md

@@ -807,7 +807,7 @@ CNN 通常包含三个主要层：
 
 # 全连接层
 
-我们可以有多个卷积层，然后是池化层。 但是，这些图层只会从输入图像中提取特征并生成激活图。 我们如何仅凭激活图对图像中是否有一条狗进行分类？ 我们必须引入一个称为全连接层的新层。 当激活图（现在基本上是图像的特征）应用激活函数时，它将接收输入，并产生输出。 全连接层实际上是正常的神经网络，其中我们具有输入层，隐藏层和输出层。 在这里，我们使用卷积和池化层代替输入层，它们一起产生激活图作为输入。
+我们可以有多个卷积层，然后是池化层。 但是，这些层只会从输入图像中提取特征并生成激活图。 我们如何仅凭激活图对图像中是否有一条狗进行分类？ 我们必须引入一个称为全连接层的新层。 当激活图（现在基本上是图像的特征）应用激活函数时，它将接收输入，并产生输出。 全连接层实际上是正常的神经网络，其中我们具有输入层，隐藏层和输出层。 在这里，我们使用卷积和池化层代替输入层，它们一起产生激活图作为输入。
 
 # CNN 架构
 
@@ -1054,7 +1054,7 @@ with tf.Session() as sess:
 
 # 总结
 
-在本章中，我们学习了神经网络的实际工作原理，然后使用 TensorFlow 构建了一个神经网络来对手写数字进行分类。 我们还看到了不同类型的神经网络，例如 RNN，可以记住内存中的信息。 然后，我们看到了 LSTM 网络，该网络用于通过保持多个门来将信息保留在内存中（只要需要）来克服消失的梯度问题。 我们还看到了另一个有趣的神经网络，用于识别图像，称为 CNN。 我们看到了 CNN 如何使用不同的图层来理解图像。 之后，我们学习了如何使用 TensorFlow 构建 CNN 以识别时尚产品。
+在本章中，我们学习了神经网络的实际工作原理，然后使用 TensorFlow 构建了一个神经网络来对手写数字进行分类。 我们还看到了不同类型的神经网络，例如 RNN，可以记住内存中的信息。 然后，我们看到了 LSTM 网络，该网络用于通过保持多个门来将信息保留在内存中（只要需要）来克服消失的梯度问题。 我们还看到了另一个有趣的神经网络，用于识别图像，称为 CNN。 我们看到了 CNN 如何使用不同的层来理解图像。 之后，我们学习了如何使用 TensorFlow 构建 CNN 以识别时尚产品。
 
 在下一章第 8 章，“使用深度 Q 网络玩 Atari 游戏”中，我们将看到神经网络实际上将如何帮助我们的 RL 智能体更有效地学习。
 

new/intel-proj-py/02.md

@@ -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/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 网络的生成器：
 

new/intel-proj-py/05.md

@@ -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”）：
 

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

@@ -142,11 +142,11 @@ import pandas as pd
 
 # 装袋模型
 
-装袋是一种整体学习模型。 装袋方法可以使用任何估算器。 因此，让我们来看一下使用 KNN 的情况，如以下屏幕截图所示：
+装袋是一种整体学习模型。 装袋方法可以使用任何估计器。 因此，让我们来看一下使用 KNN 的情况，如以下屏幕截图所示：
 
 ![](img/6e77b966-f186-47b0-a62d-df853ab1477c.png)
 
-使用`n_estimators`参数，我们可以产生 15 个独立估算器的集合。 结果，这将产生训练数据集的 15 个引导程序样本，然后，在每个这些样本中，它将使这些 KNN 回归变量之一与 20 个邻居匹配。 最后，我们将使用装袋法获得各个预测。 该算法用于给出单个预测的方法是多数表决。
+使用`n_estimators`参数，我们可以产生 15 个独立估计器的集合。 结果，这将产生训练数据集的 15 个引导程序样本，然后，在每个这些样本中，它将使这些 KNN 回归变量之一与 20 个邻居匹配。 最后，我们将使用装袋法获得各个预测。 该算法用于给出单个预测的方法是多数表决。
 
 # 随机森林模型
 
@@ -158,7 +158,7 @@ import pandas as pd
 
 # 提升模型
 
-提升也是一种整体学习模型。 在这里，我们使用`AdaBoostRegressor`模型，我们将再次产生`50`估算器。 以下屏幕截图显示了用于此模型的算法：
+提升也是一种整体学习模型。 在这里，我们使用`AdaBoostRegressor`模型，我们将再次产生`50`估计器。 以下屏幕截图显示了用于此模型的算法：
 
 ![](img/a8b9a936-0158-41a2-a251-428a10e3d4e2.png)
 
@@ -281,7 +281,7 @@ def CMatrix(CM, labels=['pay', 'default']):
 
 # 提升模型
 
-在提升模型的分类中，我们将使用`AdaBoostClassifier`对象。 在这里，我们还将使用`50`估算器来组合各个预测。 我们将在这里使用的学习率是`0.1`，这是该模型的另一个超参数。
+在提升模型的分类中，我们将使用`AdaBoostClassifier`对象。 在这里，我们还将使用`50`估计器来组合各个预测。 我们将在这里使用的学习率是`0.1`，这是该模型的另一个超参数。
 
 以下屏幕截图显示了代码和混淆矩阵：
 

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

@@ -108,7 +108,7 @@ from sklearn.model_selection import cross_validate
 
 此`cross_validate`功能的工作方式如下：
 
-*   我们提供了估算器，它将是`RandomForestRegressor`函数。 下面显示了用于应用`RandomForestRegressor`功能的代码：
+*   我们提供了估计器，它将是`RandomForestRegressor`函数。 下面显示了用于应用`RandomForestRegressor`功能的代码：
 
 ```py
  scores = cross_validate(estimator=RF,X=X,y=y,
@@ -240,7 +240,7 @@ boosting_test_mse = cross_validate(estimator=boosting,X=X,y=y,
 
 # 超参数调优简介
 
-用于为特定数据集选择最佳估计量或为所有超参数选择最佳值的方法称为**超参数调优**。 超参数是无法在估算器中直接学习的参数。 它们的价值由建模者决定。
+用于为特定数据集选择最佳估计量或为所有超参数选择最佳值的方法称为**超参数调优**。 超参数是无法在估计器中直接学习的参数。 它们的价值由建模者决定。
 
 例如，在`RandomForestClassifier`对象中，有很多超参数，例如`n_estimators`，`max_depth`，`max_features`和`min_samples_split`。 建模人员确定这些超参数的值。
 
@@ -328,11 +328,11 @@ RF = RandomForestRegressor(random_state=55, n_jobs=-1)
 from sklearn.model_selection import GridSearchCV
 ```
 
-在这里，我们传递要调整的估算器，在这种情况下为`RandomForestRegressor`。 以下屏幕截图显示了所使用的代码和我们获得的输出：
+在这里，我们传递要调整的估计器，在这种情况下为`RandomForestRegressor`。 以下屏幕截图显示了所使用的代码和我们获得的输出：
 
 ![](img/7c374323-bcaa-4d95-b126-082372f965e8.png)
 
-然后，我们传递要尝试的参数网格。 在这里，`refit`表示此估算器对象将使用通过网格搜索和交叉验证过程找到的最佳参数进行调整。 这是此对象将用于评估超参数的所有可能组合的评估度量。 在这种情况下，我们将使用十倍交叉验证。 创建完之后，我们可以使用`fit`方法并传递训练对象。 由于我们使用 32 种组合的十倍交叉验证，因此该模型将评估 320 个模型。
+然后，我们传递要尝试的参数网格。 在这里，`refit`表示此估计器对象将使用通过网格搜索和交叉验证过程找到的最佳参数进行调整。 这是此对象将用于评估超参数的所有可能组合的评估度量。 在这种情况下，我们将使用十倍交叉验证。 创建完之后，我们可以使用`fit`方法并传递训练对象。 由于我们使用 32 种组合的十倍交叉验证，因此该模型将评估 320 个模型。
 
 我们可以从使用`GridSearchCV`方法创建的对象中使用`cv _results_`属性获得结果。 以下屏幕截图显示了用于获取结果的代码，并显示了结果：
 

new/whats-new-tf2/1.md

 # TensorFlow 2.0 入门
 
-本书旨在使读者熟悉 **TensorFlow 2.0**（**TF 2.0**）中引入的新功能，并在构建机器学习应用程序时使您发挥其潜力。 本章概述了 TF 2.0 中新的架构和 API 级别的变化。 我们将介绍 TF 2.0 的安装和设置，并将比较有关 **TensorFlow 1.x**（**TF 1.x**）的更改，例如 Keras API 和 Layer API。 我们还将涵盖丰富的扩展，例如 TensorFlow 概率，Tensor2Tensor，参差不齐的 Tensors，以及新的针对损失函数的自定义训练逻辑。 本章还总结了对图层 API 和其他 API 的更改。
+本书旨在使读者熟悉 **TensorFlow 2.0**（**TF 2.0**）中引入的新功能，并在构建机器学习应用程序时使您发挥其潜力。 本章概述了 TF 2.0 中新的架构和 API 级别的变化。 我们将介绍 TF 2.0 的安装和设置，并将比较有关 **TensorFlow 1.x**（**TF 1.x**）的更改，例如 Keras API 和 Layer API。 我们还将涵盖丰富的扩展，例如 TensorFlow 概率，Tensor2Tensor，参差不齐的 Tensors，以及新的针对损失函数的自定义训练逻辑。 本章还总结了对层 API 和其他 API 的更改。
 
 以下主题将...
 
@@ -11,7 +11,7 @@
 *   Python 3.4 或更高版本
 *   具有 Ubuntu 16.04 或更高版本的计算机（对于大多数基于 \*NIX 的系统，例如 macOS 或其他 Linux 变体，说明仍然相似）
 
-# 什么是新的？
+# 什么是新增的？
 
 TF 2.0 的理念基于简单性和易用性。 主要更新包括使用`tf.keras`轻松构建模型并急切执行，可在任何平台上进行生产和商业使用的强大模型部署，强大的实验技术和研究工具，以及用于简化 API 的 API 简化。
 
@@ -21,7 +21,7 @@ TF 2.0 的理念基于简单性和易用性。 主要更新包括使用`tf.keras
 
 上图着重于使用 Python API 进行训练和部署； 但是，其他受支持的语言（包括 Julia，JavaScript 和 R）也遵循相同的过程。TF 2.0 的流程是...
 
-# 从 TF 1.x 更改
+# 来自 TF 1.x 的更改
 
 TF 1.x 和 TF 2.0 之间的第一个主要区别是 API 的组织。 TF 2.0 减少了 API 结构中的冗余。 主要更改包括删除`tf.app`，`tf.flags`和`tf.logging`，以支持其他 Python 模块，例如`absl-py`和内置的日志记录功能。
 

new/whats-new-tf2/2.md

@@ -6,7 +6,7 @@
 
 *   TF 2.0 中的新抽象
 *   深入了解 Keras API
-*   估算器
+*   估计器
 *   评估 TensorFlow 图
 
 # 技术要求
@@ -35,7 +35,7 @@ Keras 是用于构建和训练深度学习模型的流行的高级 API。 Keras
 
 Keras 是用明确的...
 
-# 建筑模型
+# 构建模型
 
 机器学习从根本上讲是一系列统计计算，这些统计计算可以实现最终目的。 这些核心统计组件可以封装为模型。 此外，一些标准计算可被视为与此核心的交互。 从程序员的角度来看，将模型看成一个包含大量数学方程的黑匣子可能会很有用。 然后，其他动作可以描述为与此黑匣子的一组交互。
 
@@ -43,11 +43,11 @@ Keras 是用明确的...
 
 Keras 大致采用了我们刚刚讨论的抽象范式，以帮助用户使用基于神经网络的模型轻松地构建，训练和预测。 在随后的小节中，我们将详细介绍 Keras 为上述任务中的每一项提供的选项。 我们还将探讨使 Keras 成为不可忽视的强大力量的其他辅助功能。
 
-在 Keras 中，模型是通过组合图层来构建的。 每个 Keras 层大致对应于神经网络架构中的层。 模型也可以看作是层的组合。 Keras 提供了多种选择来组合这些层以形成基于神经网络的模型。 接下来的两个小节重点介绍 Keras 为构建模型而公开的两种最流行的 API，也称为**数学**和**统计核心**。
+在 Keras 中，模型是通过组合层来构建的。 每个 Keras 层大致对应于神经网络架构中的层。 模型也可以看作是层的组合。 Keras 提供了多种选择来组合这些层以形成基于神经网络的模型。 接下来的两个小节重点介绍 Keras 为构建模型而公开的两种最流行的 API，也称为**数学**和**统计核心**。
 
-# Keras 图层 API
+# Keras 层 API
 
-在用于模型构建的高级 Keras API 中，Keras 层是基本构建块。 **模型**通常定义为这些层的某种图形。 这些层也可以被编程为彼此交互。 由于这些是基本的构建块，因此我们可以在训练和推理阶段定义和自定义图层的行为。 换句话说，我们具有在前进和后退过程中定义图层行为的能力（如果适用）。 从程序员的角度来看，可以将一层视为封装状态和逻辑的数据结构，以从给定的一组输入生成特定的输出。
+在用于模型构建的高级 Keras API 中，Keras 层是基本构建块。 **模型**通常定义为这些层的某种图形。 这些层也可以被编程为彼此交互。 由于这些是基本的构建块，因此我们可以在训练和推理阶段定义和自定义层的行为。 换句话说，我们具有在前进和后退过程中定义层行为的能力（如果适用）。 从程序员的角度来看，可以将一层视为封装状态和逻辑的数据结构，以从给定的一组输入生成特定的输出。
 
 层...
 
@@ -57,7 +57,7 @@ Keras 大致采用了我们刚刚讨论的抽象范式，以帮助用户使用
 
 该 API 的主要组件是`tf.keras.Sequential`。
 
-这对于简单，连续的图层组合很有用。 假设您有一个`n`层神经网络。 假设这些层定义为`[layer_1, layer_2, …. , layer_n]`。
+这对于简单，连续的层组合很有用。 假设您有一个`n`层神经网络。 假设这些层定义为`[layer_1, layer_2, …. , layer_n]`。
 
 请注意，这些层中的每一层都是 Keras 层，如前所述。 对于我们的实现，这意味着该层对象将是`tf.keras.layers`中公开的层之一，或者是对基础 Keras 层实现进行子类化的用户定义层。
 
@@ -111,7 +111,7 @@ new_model = tf.keras.Sequential(layers=layer_list)
 
 这也可以用其他方式使用。 一个示例是将层规范和模型创建过程分开。 让我们进一步探讨这个想法。 假设您有一个用例，其中模型需要多个仅在运行时可用的层。
 
-一种简单的方法是编写一个用于创建图层的函数。 让我们编写一个示例函数`get_layers(n)`，它使用整数值`n`并一个接一个地返回许多`Dense`层。 为了说明 API 的灵活性，让我们使用 Python 生成器实现该功能：
+一种简单的方法是编写一个用于创建层的函数。 让我们编写一个示例函数`get_layers(n)`，它使用整数值`n`并一个接一个地返回许多`Dense`层。 为了说明 API 的灵活性，让我们使用 Python 生成器实现该功能：
 
 ```py
 def get_layers(n):
@@ -122,7 +122,7 @@ def get_layers(n):
 
 如果您不熟悉 Python 生成器，请在继续操作之前参阅[这里](https://realpython.com/introduction-to-python-generators/)。
 
-前一个代码块中定义的函数接受`n`的正整数值并返回`generator`对象。 此生成器生成的每个元素都是一个图层。 以下代码段显示了如何使用此函数创建模型：
+前一个代码块中定义的函数接受`n`的正整数值并返回`generator`对象。 此生成器生成的每个元素都是一个层。 以下代码段显示了如何使用此函数创建模型：
 
 ```py
 model_using_generator = tf.keras.Sequential(layers=get_layers(10))
@@ -132,9 +132,9 @@ model_using_generator = tf.keras.Sequential(layers=get_layers(10))
 
 随着机器学习任务的日益成熟，具有多阶段输入和输出的模型变得越来越普遍。 大量实际使用案例涉及具有多阶段输入和输出的模型。 具有多个输入的真实世界模型的一个示例是文本分类模型，该模型可以查看输入文本中的单词和字符序列。
 
-尽管`Sequential` API 在以串行方式组合层方面做得非常好，但是它不能用于描述基础层的并行组成。 通常，它不能用于构建不具有线性拓扑的图层图。 在需要利用特定层的情况下，其实用性也受到限制。
+尽管`Sequential` API 在以串行方式组合层方面做得非常好，但是它不能用于描述基础层的并行组成。 通常，它不能用于构建不具有线性拓扑的层图。 在需要利用特定层的情况下，其实用性也受到限制。
 
-# 训练模式
+# 训练模型
 
 **训练模型**指的是为不同网络组件学习权重的过程，这些过程在给定的一组示例中将损失函数降至最低。 简而言之，训练神经网络意味着找到网络价值的最佳组合。 如您所知，训练过程也与评估和预测过程紧密相关。 借助抽象的强大功能，Keras 提供了强大的高级界面来实现和管理端到端的训练过程。 让我们看一下它为使用顺序和函数式 API 创建的模型提供的训练 API。 它为此阶段提供的一些功能如下：
 
@@ -204,7 +204,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 数组列表并更新内存中的模型。
 
@@ -270,7 +270,7 @@ my_model_replica.set_weights(
 
 在以下各节中，我们将简要讨论方法及其语法。 我们还提供了有关何时使用它们的见解。
 
-# 用力
+# 使用 Keras
 
 可以将使用`Sequential` API 或`functional` API 构建的模型保存在单个文件中。 也可以从此文件中加载此模型，而与构建模型所用的代码无关。
 
@@ -297,7 +297,7 @@ loaded_model = tf.keras.models.load_model(
 
 这是一种非常直接的方法，在 Python API 中交换模型时效果很好。
 
-# 使用 SavedModel API
+# 使用`SavedModel` API
 
 `SavedModel`是在 TensorFlow 生态系统中存储对象的默认方式。 由于这种标准化的性质，它可以用于在不同的 TensorFlow 实现之间交换模型。 使用`SavedModel`保存的模型除包含模型架构和权重外，还包含实际的 TensorFlow 代码。 `SavedModel`文件的确切内容可以列出如下：
 
@@ -312,7 +312,7 @@ loaded_model = tf.keras.models.load_model(
 
 除了非常强大的 API 规范外，TensorFlow 的`tf.keras` Keras 实现还附带了许多附加组件。 在以下各节中，我们将简要讨论其中最相关的两个。
 
-# keras.applications 模块
+# `keras.applications`模块
 
 `keras.applications`模块包含具有流行模型权重的预构建架构。 这些可以直接用于进行预测。 用户还可以使用它们来创建其他网络的输入功能。 该软件包中突出的预建实现包括：
 
@@ -361,29 +361,29 @@ import tensorflow as tfimport tensorflow.keras as keras
 
 3.  在前面的代码段中，数据作为`numpy`数组加载到内存中。 ...
 
-# 估算器
+# 估计器
 
 从头开始构建机器学习模型时，从业人员通常会经历多个高级阶段。 其中包括训练，评估，预测和装运，以供大规模使用（或出口）。 到目前为止，开发人员必须编写自定义代码才能实现这些步骤中的每个步骤。 在所有应用程序中，运行这些过程所需的许多样板代码都保持不变。 更糟的是，此代码很容易需要在低抽象级别上进行操作。 这些问题放在一起，可能会在开发过程中造成极大的效率低下。
 
-TensorFlow 团队尝试通过引入 Estimators 来解决此问题，Estimators 是一个高级 API，旨在抽象出在上述阶段执行不同任务时产生的许多复杂性。 具体来说，估算器是用于封装以下类别任务的高级 API：
+TensorFlow 团队尝试通过引入 Estimators 来解决此问题，Estimators 是一个高级 API，旨在抽象出在上述阶段执行不同任务时产生的许多复杂性。 具体来说，估计器是用于封装以下类别任务的高级 API：
 
 *   训练
 *   评价
 *   预测
 *   模型共享（导出和运输模型）
 
-用户可以从一组预先构建的估算器中进行选择，甚至可以实现自己的估算器。 标准库中提供了针对各种常用机器学习和深度学习算法的估算器的实现。
+用户可以从一组预先构建的估计器中进行选择，甚至可以实现自己的估计器。 标准库中提供了针对各种常用机器学习和深度学习算法的估计器的实现。
 
-估算器具有以下优点：
+估计器具有以下优点：
 
 *   基于估计器的模型与硬件和环境无关：
     *   程序员不必担心 Estimator 是在本地计算机上运行还是在远程计算网格上运行。
     *   程序员可以在 CPU，GPU 或 TPU 上运行基于 Estimator 的模型，而无需重新编码他们的模型。
 *   估计器简​​化了团队中不同开发人员之间或使用不同环境或堆栈的团队之间的共享实现。
 *   程序员可以使用高级直观代码来开发高性能和前沿模型。 换句话说，程序员不必在管理低级 TensorFlow API 的复杂性上浪费时间。
-*   估算器建立在`tf.keras.layers`本身上，从而简化了自定义。
-*   估算器为您构建图表。
-*   估算器提供了一个安全分布的训练循环，该循环控制如何以及何时执行以下操作：
+*   估计器建立在`tf.keras.layers`本身上，从而简化了自定义。
+*   估计器为您构建图表。
+*   估计器提供了一个安全分布的训练循环，该循环控制如何以及何时执行以下操作：
     *   建立图
     *   初始化变量
     *   加载数据中
@@ -465,6 +465,6 @@ TF 2.0 与 Python 编程语言紧密集成。 急切的执行使张量可以无
 
 # 总结
 
-在本章中，我们了解了 TF 2.0 中可用于模型构建，训练，保存和加载的高级抽象。 深入研究 Keras API，我们了解了如何通过使用`Sequential`和`functional` API 组合图层来构建模型。 我们还了解了如何利用 Keras API 的高级抽象来训练模型。 本章还研究了在各种配置和模式下加载和保存模型的复杂性。 我们已经了解了保存模型，架构和权重的不同方法，本章对每种方法进行了深入的说明，并描述了何时应该选择一种方法。
+在本章中，我们了解了 TF 2.0 中可用于模型构建，训练，保存和加载的高级抽象。 深入研究 Keras API，我们了解了如何通过使用`Sequential`和`functional` API 组合层来构建模型。 我们还了解了如何利用 Keras API 的高级抽象来训练模型。 本章还研究了在各种配置和模式下加载和保存模型的复杂性。 我们已经了解了保存模型，架构和权重的不同方法，本章对每种方法进行了深入的说明，并描述了何时应该选择一种方法。
 
 将讨论的所有概念放在一起...
\ No newline at end of file

new/whats-new-tf2/3.md

@@ -226,7 +226,7 @@ image_dataset = image_path_dataset.map(preprocess_image)
 *   **数据重排**：选择部分数据而不是获取整个数据集可能需要这些。 它们对于使用数据子集进行实验很有用。
 *   **数据清除**：这些非常重要。 就像清除日期格式（例如从`YYYY/MM/DD`到`MM-DD-YYYY`）或删除具有缺失值或错误数字的数据一样简单。 
 
-# 地图功能
+# `map`函数
 
 此转换 API 在数据集的每个元素上执行`map_func`输入。 对于那些使用 Pandas`Dataframe.apply(...)`的人来说，`map(...)`与之非常相似。 作为`map(...)` API 的自变量，它采用了一个应用于数据集每个元素的函数。 该函数继而从输入数据集中获取表示单个元素的`tf.Tensor`对象，并返回新转换的`tf.Tensor`对象。 请注意，输出中元素的顺序与输入数据集的顺序相同：
 
@@ -286,15 +286,17 @@ Dataset.zip((a, b, c)) # ==> [ (1, 4, [7, 8]),
 Dataset.zip((a, d)) # ==> [ (1, 13), (2, 14) ]
 ```
 
-# 串联功能
+# `concatenate`函数
 
 此转换 API 通过将输入数据集与此数据集连接来创建新的数据集：
 
 ```py
-a = tf.data.Dataset.range(1, 4) # ==> [ 1, 2, 3 ]b = tf.data.Dataset.range(4, 8) # ==> [ 4, 5, 6, 7 ]c = a.concatenate(b) # ==> [ 1, 2, 3, 4, 5, 6, 7 ]
+a = tf.data.Dataset.range(1, 4) # ==> [ 1, 2, 3 ]
+b = tf.data.Dataset.range(4, 8) # ==> [ 4, 5, 6, 7 ]
+c = a.concatenate(b) # ==> [ 1, 2, 3, 4, 5, 6, 7 ]
 ```
 
-# 交错功能
+# `interleave`函数
 
 该 API 使用`map_func`转换数据集的每个元素，并交织结果。 例如，您可以使用`Dataset.interleave()`同时处理许多输入文件：
 
@@ -330,11 +332,11 @@ a.interleave(lambda x: Dataset.from_tensors(x).repeat(6),
 
 只要`map_func`是纯函数，此变换产生的元素的顺序就是确定性的。 如果`map_func`包含任何有状态操作，则该状态的访问顺序不确定。
 
-# 收盘（计数）功能
+# `take(count)`函数
 
 `take(count)`函数使用当前数据集中的计数最多的元素创建一个新数据集。 通常，这可用于减少数据集的大小，以用于调试或简化目的。 此外，如果将计数指定为`-1`，或者如果计数大于数据集的大小，则新数据集将包含先前数据集的所有元素。
 
-# 过滤器（谓词）功能
+# `filter`函数
 
 此 API 根据条件谓词函数过滤当前数据集：
 
@@ -343,9 +345,9 @@ ds = tf.data.Dataset.from_tensor_slices([1, 2, 3])
 ds = ds.filter(lambda x: x > 3) # ==> [1, 2]
 ```
 
-# 改组和重复使用`tf.data.Dataset`
+# 打乱和重复`tf.data.Dataset`
 
-机器学习模型必须从训练，验证和测试步骤的总体分布中合理地表示数据。 通常，原始数据可以按特定顺序存储，例如相对于每个类一起存储，或者数据可以一起存储在特定源中。 必须对原始数据进行混洗，以确保训练，验证和测试数据分布在整个数据分布中。 另外，建议在每个时期之后对数据进行混洗。 下图显示了改组和重复使用`tf.data.Dataset`的流程：
+机器学习模型必须从训练，验证和测试步骤的总体分布中合理地表示数据。 通常，原始数据可以按特定顺序存储，例如相对于每个类一起存储，或者数据可以一起存储在特定源中。 必须对原始数据进行混洗，以确保训练，验证和测试数据分布在整个数据分布中。 另外，建议在每个时期之后对数据进行混洗。 下图显示了打乱和重复使用`tf.data.Dataset`的流程：
 
 良好的随机播放还有助于减少数据的差异，该数据用于模型...
 
@@ -396,7 +398,7 @@ for data in ds:
 
 # 将创建的数据集馈入模型
 
-一旦创建，转换和改组数据集对象并完成批量，就需要将其馈入模型（从本章开头记住 ETL 的 L）。 此步骤在 TF 2.0 中进行了重大更改。
+一旦创建，转换和打乱数据集对象并完成批量，就需要将其馈入模型（从本章开头记住 ETL 的 L）。 此步骤在 TF 2.0 中进行了重大更改。
 
 TF 2.0 中创建输入数据管道的一个主要区别在于其简单性。 TF 1.x 需要一个迭代器才能将数据集提供给模型。 为了做到这一点，有几个迭代器可以迭代一批数据。 一种是通过使用数据集对象中的`tf.data.Iterator` API。 TF 1.x 中有一个一次性的，可初始化的，可重新初始化的和可填充的迭代器。 尽管这些迭代器功能非常强大，但它们也增加了大量的复杂性，无论从术语上还是...
 
@@ -437,8 +439,8 @@ def create_tfrecords(cifar10_data_folder, validation_data_idx):  """ function to
 
 这是在 TF 2.0 中建立有效的输入数据管道时应遵循的最佳实践的摘要：
 
-*   建议在重复转换之前使用改组（`shuffle`）API。
-*   使用预取转换可以重叠生产者（获取下一批数据）和使用者（使用当前数据进行训练）的工作。 另外，非常重要的一点是要注意，在对数据管道进行改组（改组），重复（重复）和批量（批量）之后，应将预取转换添加到输入管道的末尾。 看起来应该像这样：
+*   建议在重复转换之前使用打乱（`shuffle`）API。
+*   使用预取转换可以重叠生产者（获取下一批数据）和使用者（使用当前数据进行训练）的工作。 另外，非常重要的一点是要注意，在对数据管道进行打乱（打乱），重复（重复）和批量（批量）之后，应将预取转换添加到输入管道的末尾。 看起来应该像这样：
 
 ```py
 # buffer_size could be either 1 or 2 which represents 1 or 2 batches of data

new/whats-new-tf2/4.md

@@ -2,7 +2,7 @@
 
 本章详细介绍了机器学习训练管道，以构建，训练和验证包括深度神经网络在内的最新机器学习模型。 它描述了如何集成输入数据管道，创建基于`tf.keras`的模型，以分布式方式进行训练以及运行验证以微调模型的超参数。 它还涉及有关如何导出和保存 TensorFlow 模型以进行部署和推理的各种概念。 模型调试和可视化是用于调试和提高模型准确性和性能的关键工具。 本章还概述了 TensorBoard 的用法，在 TF 2.0 中的更改以及如何使用 TensorBoard 进行模型调试以及对模型的速度和性能进行性能分析。
 
-TensorFlow 1.x 版本强烈支持低级和中级 API，以构建机器学习模型。 它还具有 Estimator API，包括预制的估算器，例如`LinearClassifier`和`DNNRegressor`，以及用作高级 TF API 的定制估算器。 TF 1.x 中对估算器的支持是提供高级 API，与低级和中级 TF API 相比，它们更易于构建。 从 TensorFlow 2.0 开始，主要变化之一是采用 Keras API 标准作为高级 API 而不是 Estimators。 对于 TensorFlow 开发团队而言，这非常有意义，因为 Keras API 是迄今为止机器学习社区中采用的最大 API 集，并且 Keras 的创建者 Francois Chollet 也是一位出色的人工智能（AI）研究人员，现在已经加入 TensorFlow 开发团队的成员。 TensorFlow 1.x 版本已经提供对`tf.keras`的初始支持; 但是，在 TF 2.0 版本中可以获得`tf.keras`的完整而完整的体验。
+TensorFlow 1.x 版本强烈支持低级和中级 API，以构建机器学习模型。 它还具有 Estimator API，包括预制的估计器，例如`LinearClassifier`和`DNNRegressor`，以及用作高级 TF API 的定制估计器。 TF 1.x 中对估计器的支持是提供高级 API，与低级和中级 TF API 相比，它们更易于构建。 从 TensorFlow 2.0 开始，主要变化之一是采用 Keras API 标准作为高级 API 而不是 Estimators。 对于 TensorFlow 开发团队而言，这非常有意义，因为 Keras API 是迄今为止机器学习社区中采用的最大 API 集，并且 Keras 的创建者 Francois Chollet 也是一位出色的人工智能（AI）研究人员，现在已经加入 TensorFlow 开发团队的成员。 TensorFlow 1.x 版本已经提供对`tf.keras`的初始支持; 但是，在 TF 2.0 版本中可以获得`tf.keras`的完整而完整的体验。
 
 在本章中，我们将浏览`tf.keras` API，包括 API 的顺序，功能和模型子分类类型。 您将学习如何使用`tf.data.Dataset`将输入数据流水线馈入模型流水线，以及特征列的可能分类结构。 我们还将介绍如何定义损失函数，最常见的优化器，基于 TensorBoard 的数据，模型调试，可视化和性能分析等。 从 TensorFlow 2.0 开始，`tf.keras` API 已紧密集成到 TensorFlow 生态系统中，其中包括对`tf.data`的改进支持和最新可用的分发策略，可用于跨多种 GPU 和 TPU 进行分布式训练。 `tf.keras`还无缝支持导出训练有素的模型，这些模型可以使用 TensorFlow 服务和其他技术在 TensorFlow Lite 的移动和嵌入式设备上进行服务和部署。
 
@@ -25,9 +25,9 @@ TensorFlow 1.x 版本强烈支持低级和中级 API，以构建机器学习模
 
 Keras（定义 Keras API 标准的原始网站）是一个开源项目，由于其简单和强大而受到 ML 工程师和数据科学家的极大关注。 最初，Keras 的默认后端引擎（请记住，Keras 是一组 API）是 Theano; 但是，最近它发生了变化，现在 TensorFlow 作为其默认后端引擎。 您还可以将默认后端引擎设置为 MXNet，CNTK 等。 Keras API 非常易于使用，模块化且可组合。 此外，还可以轻松扩展您的特定需求。 TensorFlow 采用了 Keras API 标准，从那时起，使用 TensorFlow 核心功能的`tf.keras`开发就如火如荼地进行。 现在，随着 TF 2.0 的发布，TF 开发团队为`tf.keras`高级 API 提供了紧密而有效的支持。 另外，值得一提的是 Keras 和`tf.keras`是两个完全不同的软件包，作为 TF 2.0 的一部分，应使用`tf.keras`。 在版本方面，在 TensorFlow 2.0 中，TensorFlow 和`tf.keras`的版本号仍然存在差异，您可以尝试使用`tf.__version__`和`tf.keras.__version__`查看此版本。
 
-# 比较估算器和`tf.keras`
+# 比较估计器和`tf.keras`
 
-TensorFlow 1.x 已建议为其高级 API 集使用`tf.estimator` API，该 API 集具有内置模型（例如`LinearRegressor`和`DNNClassifier`）可用的预制估算器。 此外，对于更细化和定制的模型，TF 1.x 具有定制的估计器。 从 TF 2.0 开始，建议仅使用与线性分类器，DNN 分类器，组合 DNN 线性分类器和梯度提升树打包在一起的丰富的预制估算器 API 集。 这些模型已准备就绪，可以广泛使用。 对于任何自定义模型，建议直接使用`tf.keras`而不是`tf.estimator` API。 另外，值得注意的是，与`tf.keras, ...`有更好的协同作用
+TensorFlow 1.x 已建议为其高级 API 集使用`tf.estimator` API，该 API 集具有内置模型（例如`LinearRegressor`和`DNNClassifier`）可用的预制估计器。 此外，对于更细化和定制的模型，TF 1.x 具有定制的估计器。 从 TF 2.0 开始，建议仅使用与线性分类器，DNN 分类器，组合 DNN 线性分类器和梯度提升树打包在一起的丰富的预制估计器 API 集。 这些模型已准备就绪，可以广泛使用。 对于任何自定义模型，建议直接使用`tf.keras`而不是`tf.estimator` API。 另外，值得注意的是，与`tf.keras, ...`有更好的协同作用
 
 # 机器学习分类法和 TF 支持的快速回顾
 
@@ -145,7 +145,7 @@ self.num_filters = 32
         self.my_input_shape = (28, 28, 1)
 ```
 
-现在定义图层：
+现在定义层：
 
 ```py
         # first conv layer
@@ -169,7 +169,7 @@ self.num_filters = 32
         self.do_layer = tf.keras.layers.Dropout(0.5)
 ```
 
-展平图层：
+展平层：
 
 ```py
         self.ft_layer = tf.keras.layers.Flatten()

new/whats-new-tf2/7.md

@@ -373,7 +373,7 @@ print(' accuracy: {:.3f}'.format(mean_accuracy))
 
 TF 2.0 目前处于 beta 版本，因此仍在开发中。 即将出现的一些关键功能包括对软件包的修改，例如 TensorBoard，TensorFlow Lite，TensorFlow.js，用于 TensorFlow 的 Swift 和 TensorFlow Extended，以及对基本 API 的微小更改。 TensorBoard 将看到增强功能，例如改进的超参数调优功能，引入托管功能以使共享仪表板变得容易，并使插件能够使用不同的前端技术，例如 ReactJS。 TensorFlow Lite 将扩大支持的操作范围，将 TF 2.0 模型更轻松地转换为 TFLite，并扩展对 Edge TPU 和 AIY 板的支持。 TensorFlow.js 和用于 TensorFlow 的 Swift 都将看到速度和性能方面的改进，并且很快将包含一组丰富的示例和带有端到端教程的入门指南。 TF Extended 即将与 TF 2.0 基本 API 完全集成，并将包括完全协调的端到端工作流程和训练功能。
 
-TF 2.0 基本 API 将包括针对任务的更多预制估算器，例如增强树，随机森林，最近邻搜索和 k 均值聚类。 `tf.distribute.Strategy`模型将扩展其对 Keras 子模型，TPU 和多节点训练的支持，以在多个处理器上实现更优化和更快的训练。
+TF 2.0 基本 API 将包括针对任务的更多预制估计器，例如增强树，随机森林，最近邻搜索和 k 均值聚类。 `tf.distribute.Strategy`模型将扩展其对 Keras 子模型，TPU 和多节点训练的支持，以在多个处理器上实现更优化和更快的训练。
 
 当前正在开发的另一个主要附加功能是`tf-agents`模块。 该模块将核心强化学习算法实现为**智能体**，该算法定义了与环境进行交互的策略并从集体经验中训练了该策略。 `TF-agents`与 OpenAI Gym 框架一起实现，并抽象了许多用于开发的关键强化学习算法。 该模块当前处于预发布状态，但将于今年晚些时候发布。