2020-09-10 23:00:24

9e53a0e5 · wizardforcel · 74232705 · 9e53a0e5 · 9e53a0e5 · 9e53a0e5
10 changed file
--- a/docs/tf-20-quick-start-guide/00.md
+++ b/docs/tf-20-quick-start-guide/00.md
@@ -22,7 +22,7 @@ TensorFlow 是 Python 中最受欢迎的机器学习框架之一。 通过这本

 第 6 章，“使用 TensorFlow 2 识别图像”，首先查看 Google Quick Draw 1 图像数据集，其次查看 CIFAR 10 图像数据集。

-第 7 章，“TensorFlow 2 和神经风格迁移”，说明如何拍摄内容图像和风格图像，然后生成混合图像。 我们将使用经过训练的 VGG19 模型中的图层来完成此任务。
+第 7 章，“TensorFlow 2 和神经风格迁移”，说明如何拍摄内容图像和风格图像，然后生成混合图像。 我们将使用经过训练的 VGG19 模型中的层来完成此任务。

 第 8 章，“TensorFlow 2 和循环神经网络”首先讨论了 RNN 的一般原理，然后介绍了如何获取和准备一些文本以供模型使用。


--- a/docs/tf-20-quick-start-guide/01.md
+++ b/docs/tf-20-quick-start-guide/01.md
@@ -33,13 +33,13 @@ image1 = tf.zeros([7, 28, 28, 3]) #  example-within-batch by height by width by
 *   `Dataset`由记录组成，这些记录是至少一个文本文件（`TFRecordDataset`）中的行
 *   还有一个类表示通过`Dataset`（`tf.data.Iterator`）进行迭代的状态

-让我们继续进行**估计器**，这是一个高级 API，可让您构建大大简化的机器学习程序。 估计员负责培训，评估，预测和导出服务。
+让我们继续进行**估计器**，这是一个高级 API，可让您构建大大简化的机器学习程序。 估计员负责训练，评估，预测和导出服务。

 **TensorFlow.js** 是 API 的集合，可让您使用底层 JavaScript 线性代数库或高层 API 来构建和训练模型。 因此，可以训练模型并在浏览器中运行它们。

 **TensorFlow Lite** 是适用于移动和嵌入式设备的 TensorFlow 的轻量级版本。 它由运行时解释器和一组工具组成。 这个想法是您在功率更高的机器上训练模型，然后使用工具将模型转换为`.tflite`格式。 然后将模型加载到您选择的设备中。 在撰写本文时，使用 C++ API 在 Android 和 iOS 上支持 TensorFlow Lite，并且具有适用于 Android 的 Java 包装器。 如果 Android 设备支持 **Android 神经网络**（**ANN**）API 进行硬件加速，则解释器将使用此 API，否则它将默认使用 CPU 执行。

-**TensorFlow Hub** 是一个旨在促进机器学习模型的可重用模块的发布，发现和使用的库。 在这种情况下，模块是 TensorFlow 图的独立部分，包括其权重和其他资产。 该模块可以通过称为转移学习的方法在不同任务中重用。 这个想法是您在大型数据集上训练模型，然后将适当的模块重新用于您的其他但相关的任务。 这种方法具有许多优点-您可以使用较小的数据集训练模型，可以提高泛化能力，并且可以大大加快训练速度。
+**TensorFlow Hub** 是一个旨在促进机器学习模型的可重用模块的发布，发现和使用的库。 在这种情况下，模块是 TensorFlow 图的独立部分，包括其权重和其他资产。 该模块可以通过称为迁移学习的方法在不同任务中重用。 这个想法是您在大型数据集上训练模型，然后将适当的模块重新用于您的其他但相关的任务。 这种方法具有许多优点-您可以使用较小的数据集训练模型，可以提高泛化能力，并且可以大大加快训练速度。

 例如，ImageNet 数据集以及许多不同的神经网络架构（例如`inception_v3`）已非常成功地用于解决许多其他图像处理训练问题。

@@ -47,7 +47,7 @@ image1 = tf.zeros([7, 28, 28, 3]) #  example-within-batch by height by width by

 `tf.keras`是用 Python 编写的高级神经网络 API，可与 TensorFlow（和其他各种张量工具）接口。 `tf.k` `eras`支持快速原型设计，并且用户友好，模块化且可扩展。 它支持卷积和循环网络，并将在 CPU 和 GPU 上运行。 Keras 是 TensorFlow 2 中开发的首选 API。

-**TensorBoard** 是一套可视化工具，支持对 TensorFlow 程序的理解，调试和优化。 它与急切和图形执行环境兼容。 您可以在训练期间使用 TensorBoard 可视化模型的各种指标。
+**TensorBoard** 是一套可视化工具，支持对 TensorFlow 程序的理解，调试和优化。 它与急切和图执行环境兼容。 您可以在训练期间使用 TensorBoard 可视化模型的各种指标。

 TensorFlow 的一项最新开发（在撰写本文时仍处于实验形式）将 TensorFlow 直接集成到 Swift 编程语言中。 Swift 中的 TensorFlow 应用是使用命令性代码编写的，即命令急切地（在运行时）执行的代码。 Swift 编译器会自动将此源代码转换为一个 TensorFlow 图，然后在 CPU，GPU 和 TPU 上以 TensorFlow Sessions 的全部性能执行此编译后的代码。


--- a/docs/tf-20-quick-start-guide/02.md
+++ b/docs/tf-20-quick-start-guide/02.md
 # 二、Keras：TensorFlow 2 的高级 API

-在本章中，我们将讨论 Keras，这是 TensorFlow 2 的高级 API。Keras 是由 FrançoisChollet 在 Google 上开发的。 Keras 在快速原型制作，深度学习模型的构建和培训以及研究和生产方面非常受欢迎。 Keras 是一个非常丰富的 API。 正如我们将看到的，它支持急切的执行和数据管道以及其他功能。
+在本章中，我们将讨论 Keras，这是 TensorFlow 2 的高级 API。Keras 是由 FrançoisChollet 在 Google 上开发的。 Keras 在快速原型制作，深度学习模型的构建和训练以及研究和生产方面非常受欢迎。 Keras 是一个非常丰富的 API。 正如我们将看到的，它支持急切的执行和数据管道以及其他功能。

 自 2017 年以来，Keras 已可用于 TensorFlow，但随着 TensorFlow 2.0 的发布，其用途已扩展并进一步集成到 TensorFlow 中。 TensorFlow 2.0 已将 Keras 用作大多数深度学习开发工作的首选 API。

@@ -162,13 +162,13 @@ Keras 基于神经网络模型的概念。 主要模型称为**序列**，是层

 下一步是*使模型拟合数据*。 这通常称为训练模型，是所有计算发生的地方。 可以分批或一次将数据呈现给模型。

-接下来，您评估模型以建立其准确性，损失和其他指标。 最后，在训练好模型之后，您可以使用它对新数据进行预测。 因此，工作流程是：构建，编译，拟合，评估，做出预测。
+接下来，您评估模型以建立其准确率，损失和其他指标。 最后，在训练好模型之后，您可以使用它对新数据进行预测。 因此，工作流程是：构建，编译，拟合，评估，做出预测。

 有两种创建`Sequential`模型的方法。 让我们看看它们中的每一个。

 # 创建顺序模型的第一种方法

-首先，可以将图层实例列表传递给构造器，如以下示例所示。
+首先，可以将层实例列表传递给构造器，如以下示例所示。

 在下一章中，我们将对层进行更多的讨论。 目前，我们将仅作足够的解释，以使您了解此处发生的情况。

@@ -195,11 +195,11 @@ train_y, test_y = tf.cast(train_y,tf.int64),tf.cast(test_y,tf.int64)

 模型定义如下。

-注意在模型定义中我们如何传递图层列表：
+注意在模型定义中我们如何传递层列表：

 *   `Flatten`接受`28 x 28`（即 2D）像素图像的输入，并产生 784（即 1D）向量，因为下一个（密集）层是一维的。
 *   `Dense`是一个完全连接的层，意味着其所有神经元都连接到上一层和下一层中的每个神经元。 下面的示例有 512 个神经元，其输入通过 ReLU（非线性）激活函数传递。
-*   `Dropout`随机关闭上一层神经元的一部分（在这种情况下为 0.2）。 这样做是为了防止任何特定的神经元变得过于专业化，并导致模型*与数据*过拟合，从而影响测试数据上模型的准确性指标（在后面的章节中将对此进行更多介绍）。
+*   `Dropout`随机关闭上一层神经元的一部分（在这种情况下为 0.2）。 这样做是为了防止任何特定的神经元变得过于专业化，并导致模型*与数据*过拟合，从而影响测试数据上模型的准确率指标（在后面的章节中将对此进行更多介绍）。
 *   最后的`Dense`层具有一个称为`softmax`的特殊激活函数，该函数将概率分配给可能的 10 个输出单元中的每一个：

 ```py
@@ -226,7 +226,7 @@ optimiser = tf.keras.optimizers.Adam()
 model1.compile (optimizer= optimiser, loss='sparse_categorical_crossentropy', metrics = ['accuracy'])
 ```

-`optimizer`是一种方法，通过该方法可以调整模型中加权连接的权重以减少损耗。
+`optimizer`是一种方法，通过该方法可以调整模型中加权连接的权重以减少损失。

 `loss`是模型所需输出与实际输出之间差异的度量，而`metrics`是我们评估模型的方式。

@@ -236,14 +236,14 @@ model1.compile (optimizer= optimiser, loss='sparse_categorical_crossentropy', me
 model1.fit(train_x, train_y, batch_size=batch_size, epochs=epochs)
 ```

-调用`fit()`的输出如下，显示了时期训练时间，丢失和准确性：
+调用`fit()`的输出如下，显示了周期训练时间，损失和准确率：

 ```py
 Epoch 1/10 60000/60000 [==============================] - 5s 77us/step - loss: 0.2031 - acc: 0.9394 ...
 Epoch 10/10 60000/60000 [==============================] - 4s 62us/step - loss: 0.0098 - acc: 0.9967
 ```

-最后，我们可以使用`evaluate`方法检查我们训练有素的模型的准确性：
+最后，我们可以使用`evaluate`方法检查我们训练有素的模型的准确率：

 ```py
 model1.evaluate(test_x, test_y)
@@ -255,7 +255,7 @@ model1.evaluate(test_x, test_y)
 10000/10000 [==============================] - 0s 39us/step [0.09151900197149189, 0.9801]
 ```

-这表示测试数据的损失为 0.09，准确性为 0.9801。 精度为 0.98 意味着该模型平均可以识别出 100 个测试数据点中的 98 个。
+这表示测试数据的损失为 0.09，准确率为 0.9801。 精度为 0.98 意味着该模型平均可以识别出 100 个测试数据点中的 98 个。

 # 创建顺序模型的第二种方法

@@ -283,7 +283,7 @@ model2.fit(train_x, train_y, batch_size=batch_size, epochs=epochs)
 model2.evaluate(test_x, test_y)
 ```

-这给我们带来了`0.07`的损失和`0.981`的准确性。
+这给我们带来了`0.07`的损失和`0.981`的准确率。

 因此，这种定义模型的方法产生的结果与第一个结果几乎相同，这是可以预期的，因为它是相同的体系结构，尽管表达方式略有不同，但具有相同的`optimizer`和`loss`函数。 现在让我们看一下函数式 API。

@@ -321,7 +321,7 @@ model3 = tf.keras.Model(inputs=inputs, outputs=predictions)

 ![](img/16862498-ba29-45b2-8070-4bda783bf422.png)

-`None`出现在这里是因为我们没有指定我们有多少输入项（即批处理大小）。 这确实意味着*未提供*。
+`None`出现在这里是因为我们没有指定我们有多少输入项（即批量大小）。 这确实意味着*未提供*。

 其余代码与前面的示例相同：

@@ -342,7 +342,7 @@ model3.evaluate(test_x, test_y)

 Keras `Model`类可以被子类化，如下面的代码所示。 Google 指出，*纯*函数风格（如前面的示例所示）比子类风格更可取（我们在此包括其内容是出于完整性的考虑，因为它很有趣）。

-首先，请注意如何在构造器（`.__init__()`）中分别声明和命名图层。
+首先，请注意如何在构造器（`.__init__()`）中分别声明和命名层。

 然后，注意在`call()`方法中各层如何以函数风格链接在一起。 此方法封装了*前向传播*：

@@ -368,7 +368,7 @@ class MyModel(tf.keras.Model):
 model4 = MyModel()
 ```

-该定义可以代替本章中的任何较早的模型定义使用，它们具有相同的数据下载支持代码，以及相似的用于培训/评估的代码。 下面的代码显示了最后一个示例：
+该定义可以代替本章中的任何较早的模型定义使用，它们具有相同的数据下载支持代码，以及相似的用于训练/评估的代码。 下面的代码显示了最后一个示例：

 ```py
 model4 = MyModel()
@@ -384,7 +384,7 @@ model4.fit(train_x, train_y, batch_size=batch_size, epochs=epochs)
 model4.evaluate(test_x, test_y)
 ```

-结果是`0.068`的损失，准确性为`0.982`； 再次与本章中其他三种模型构建风格产生的结果几乎相同。
+结果是`0.068`的损失，准确率为`0.982`； 再次与本章中其他三种模型构建风格产生的结果几乎相同。

 # 使用数据管道

@@ -420,7 +420,7 @@ model.fit(train_dataset, batch_size=batch_size, epochs=epochs, steps_per_epoch=s

 编译和评估代码与之前看到的类似。

-使用`data.Dataset`迭代器的优点在于，管道可以处理通常用于准备数据的大部分管道，例如批处理和改组。 我们也已经看到，各种操作可以链接在一起。
+使用`data.Dataset`迭代器的优点在于，管道可以处理通常用于准备数据的大部分管道，例如批量和改组。 我们也已经看到，各种操作可以链接在一起。

 # 保存和加载 Keras 模型


--- a/docs/tf-20-quick-start-guide/03.md
+++ b/docs/tf-20-quick-start-guide/03.md
@@ -60,7 +60,7 @@ for item in num_list1_dataset:
    print(num)
 ```

-还有一种`zip`方法，可用于一起显示要素和标签：
+还有一种`zip`方法，可用于一起显示特征和标签：

 ```py
 dataset1 = [1,2,3,4,5]
@@ -337,7 +337,7 @@ ANN 使用的基本数据结构是**层**，许多相互连接的层构成了一

 图 2：人工神经网络

-图层的输出由以下公式给出：
+层的输出由以下公式给出：

 ![](img/3b1b9398-5ec7-4c65-9bca-d3096545e6c1.png)

@@ -363,7 +363,7 @@ ANN 使用的基本数据结构是**层**，许多相互连接的层构成了一

 因此，在下面的示例中，该第一层具有一个大小为`(1, 1)`的过滤器，并且其填充`'valid'`。 其他填充可能性是`'same'`。

-区别在于，使用`'same'`填充，必须在外部填充该层（通常用零填充），以便在卷积发生后，输出大小与该层大小相同。 如果使用`'valid'`填充，则不会进行填充，并且如果跨度和内核大小的组合不能完全适合该层，则该层将被截断。 输出大小小于正在卷积的图层：
+区别在于，使用`'same'`填充，必须在外部填充该层（通常用零填充），以便在卷积发生后，输出大小与该层大小相同。 如果使用`'valid'`填充，则不会进行填充，并且如果跨度和内核大小的组合不能完全适合该层，则该层将被截断。 输出大小小于正在卷积的层：

 ```py
 seqtial_Net = tf.keras.Sequential([tf.keras.layers.Conv2D(   1, (1, 1), strides = 1, padding='valid')
@@ -456,16 +456,16 @@ model2.add(tf.keras.layers.Dense(10,activation=tf.nn.softmax))

 TenorFlow 的一大优势是它能够自动计算梯度以用于梯度下降算法，这当然是大多数机器学习模型的重要组成部分。 TensorFlow 提供了许多用于梯度计算的方法。

-启用急切执行时，有四种自动计算梯度的方法（它们也适用于图形模式）：
+启用急切执行时，有四种自动计算梯度的方法（它们也适用于图模式）：

 1.  `tf.GradientTape`：上下文记录了计算，因此您可以调用`tf.gradient()`来获取记录时针对任何可训练变量计算的任何张量的梯度
 2.  `tfe.gradients_function()`：采用一个函数（例如`f()`）并返回一个梯度函数（例如`fg()`），该函数可以计算`f()`的输出相对于`f()`或其部分参数的梯度
 3.  `tfe.implicit_gradients()`：这非常相似，但是`fg()`会针对这些输出所依赖的所有可训练变量计算`f()`输出的梯度
 4.  `tfe.implicit_value_and_gradients()`：几乎相同，但`fg()`也返回函数`f()`的输出

-我们将看看其中最流行的`tf.GradientTape`。 同样，在其上下文中，随着计算的进行，对这些计算进行记录（录音），以便可以使用`tf.gradient()`重放磁带，并实现适当的自动区分。
+我们将看看其中最流行的`tf.GradientTape`。 同样，在其上下文中，随着计算的进行，对这些计算进行记录（录音），以便可以使用`tf.gradient()`重放磁带，并实现适当的自动微分。

-在以下代码中，当计算`sum`方法时，磁带将在`tf.GradientTape()`上下文中记录计算结果，以便可以通过调用`tape.gradient()`找到自动区分。
+在以下代码中，当计算`sum`方法时，磁带将在`tf.GradientTape()`上下文中记录计算结果，以便可以通过调用`tape.gradient()`找到自动微分。

 注意在`[weight1_grad] = tape.gradient(sum, [weight1])`中的此示例中如何使用列表。

@@ -482,7 +482,7 @@ with tf.GradientTape() as tape:
 print(weight1_grad.numpy()) # 7 , weight1*x diff w.r.t. weight1 is x, 7.0, also see below.
 ```

-在下一个示例中，请注意，参数`persistent=True`已传递给`tf.GradientTape()`。 这使我们可以多次调用`tape.gradient()`。 同样，我们在`tf.GradientTape`上下文中计算一个加权和，然后调用`tape.gradient()`来计算每个术语相对于`weight`变量的导数：
+在下一个示例中，请注意，参数`persistent=True`已传递给`tf.GradientTape()`。 这使我们可以多次调用`tape.gradient()`。 同样，我们在`tf.GradientTape`上下文中计算一个加权和，然后调用`tape.gradient()`来计算每项相对于`weight`变量的导数：

 ```py
 # if you need to call tape.gradient() more than once
@@ -510,7 +510,7 @@ print(weight3_grad.numpy()) #6.0

 # 损失函数

-`loss`函数（即，误差测量）是训练 ANN 的必要部分。 它是网络在训练期间计算出的输出与其所需输出的差异程度的度量。 通过区分`loss`函数，我们可以找到一个量，通过该量可以调整各层之间的连接权重，以使 ANN 的计算输出与所需输出更紧密匹配。
+`loss`函数（即，误差测量）是训练 ANN 的必要部分。 它是网络在训练期间计算出的输出与其所需输出的差异程度的度量。 通过微分`loss`函数，我们可以找到一个量，通过该量可以调整各层之间的连接权重，以使 ANN 的计算输出与所需输出更紧密匹配。

 最简单的`loss`函数是均方误差：

@@ -524,7 +524,7 @@ print(weight3_grad.numpy()) #6.0

 当所有可能的类别中只有一类正确时，使用`loss`函数；当`softmax`函数用作 ANN 的最后一层的输出时，将使用此`loss`函数。

-请注意，这两个函数可以很好地区分，这是反向传播所要求的。
+请注意，这两个函数可以很好地微分，这是反向传播所要求的。

 # 总结


--- a/docs/tf-20-quick-start-guide/04.md
+++ b/docs/tf-20-quick-start-guide/04.md
@@ -17,9 +17,9 @@

 # 线性回归

-线性回归问题是在给定一个或多个其他变量（数据点）的值的情况下，您必须预测一个*连续*变量的值的问题。 例如，根据房屋的占地面积，预测房屋的售价。 在这些示例中，您可以将已知特征及其关联的标签绘制在简单的线性图上，如熟悉的`x, y`散点图，并绘制最适合数据的线 。 这就是最适合的**系列**。 然后，您可以读取对应于该图的`x`范围内的任何要素值的标签。
+线性回归问题是在给定一个或多个其他变量（数据点）的值的情况下，您必须预测一个*连续*变量的值的问题。 例如，根据房屋的占地面积，预测房屋的售价。 在这些示例中，您可以将已知特征及其关联的标签绘制在简单的线性图上，如熟悉的`x, y`散点图，并绘制最适合数据的线 。 这就是最适合的**系列**。 然后，您可以读取对应于该图的`x`范围内的任何特征值的标签。

-但是，线性回归问题可能涉及几个特征，其中使用了术语**多个**或**多元线性回归**。 在这种情况下，不是最适合数据的线，而是一个平面（两个要素）或一个超平面（两个以上要素）。 在房价示例中，我们可以将房间数量和花园的长度添加到要素中。 有一个著名的数据集，称为波士顿住房数据集，[涉及 13 个特征](https://www.kaggle.com/c/ml210-boston)。 考虑到这 13 个特征，此处的回归问题是预测波士顿郊区的房屋中位数。
+但是，线性回归问题可能涉及几个特征，其中使用了术语**多个**或**多元线性回归**。 在这种情况下，不是最适合数据的线，而是一个平面（两个特征）或一个超平面（两个以上特征）。 在房价示例中，我们可以将房间数量和花园的长度添加到特征中。 有一个著名的数据集，称为波士顿住房数据集，[涉及 13 个特征](https://www.kaggle.com/c/ml210-boston)。 考虑到这 13 个特征，此处的回归问题是预测波士顿郊区的房屋中位数。

 术语：特征也称为预测变量或自变量。 标签也称为响应变量或因变量。

@@ -27,7 +27,7 @@

 我们将从一个简单的，人为的，线性回归问题开始设置场景。 在此问题中，我们构建了一个人工数据集，首先在其中创建，因此知道了我们要拟合的线，但是随后我们将使用 TensorFlow 查找这条线。

-我们执行以下操作-在导入和初始化之后，我们进入一个循环。 在此循环内，我们计算总损失（定义为点的数据集`y`的均方误差）。 然后，我们根据我们的体重和偏见来得出这种损失的导数。 这将产生可用于调整权重和偏差以降低损失的值； 这就是所谓的梯度下降。 通过多次重复此循环（技术上称为**周期**），我们可以将损失降低到尽可能低的程度，并且可以使用训练有素的模型进行预测。
+我们执行以下操作-在导入和初始化之后，我们进入一个循环。 在此循环内，我们计算总损失（定义为点的数据集`y`的均方误差）。 然后，我们根据我们的权重和偏置来得出这种损失的导数。 这将产生可用于调整权重和偏差以降低损失的值； 这就是所谓的梯度下降。 通过多次重复此循环（技术上称为**周期**），我们可以将损失降低到尽可能低的程度，并且可以使用训练有素的模型进行预测。

 首先，我们导入所需的模块（回想一下，急切执行是默认的）：

@@ -156,7 +156,7 @@ n_valid = 100

 接下来，我们加载数据集并将其分为训练，验证和测试集。 我们在训练集上进行训练，并在验证集上检查和微调我们的训练模型，以确保例如没有过拟合。 然后，我们使用测试集进行最终精度测量，并查看我们的模型在完全看不见的数据上的表现如何。

-注意`scale`方法。 这用于将数据转换为均值为零且单位标准差为零的集合。 `sklearn.preprocessing`方法`scale`通过从特征集中的每个数据点减去平均值，然后将每个特征除以该特征集的标准偏差来实现此目的。
+注意`scale`方法。 这用于将数据转换为均值为零且单位标准差为零的集合。 `sklearn.preprocessing`方法`scale`通过从特征集中的每个数据点减去平均值，然后将每个特征除以该特征集的标准差来实现此目的。

 这样做是因为它有助于我们模型的收敛。 所有特征也都转换为`float32`数据类型：

@@ -210,7 +210,7 @@ print(W,B)
 print("Initial loss: {:.3f}".format(loss(train_features, train_prices,W, B)))
 ```

-现在，进入我们的主要培训循环。 这里的想法是根据我们的`learning_rate`将`weights`和`bias`进行少量调整，以将损耗逐步降低至我们已经收敛到最佳拟合线的程度。 如前所述，此技术称为**梯度下降**：
+现在，进入我们的主要训练循环。 这里的想法是根据我们的`learning_rate`将`weights`和`bias`进行少量调整，以将损失逐步降低至我们已经收敛到最佳拟合线的程度。 如前所述，此技术称为**梯度下降**：

 ```py
 for e in range(epochs): #iterate for each training epoch
@@ -297,7 +297,7 @@ fashion_labels =

 `x_train`现在由`60000`，`float32`值组成，并且`x_test`保持`10000`相似的值。

-然后，我们展平特征集，准备进行培训：
+然后，我们展平特征集，准备进行训练：

 ```py
 # flatten the feature set for use by the training algorithm
@@ -392,7 +392,7 @@ class LogisticRegression(tf.keras.Model):

 找出`model.compile`和`model.fit`（以及所有其他 Python 或 TensorFlow 类或方法）的所有不同参数的最简单方法是在 Jupyter 笔记本中工作，然后按`Shift + TAB + TAB`，当光标位于相关类或方法调用上时。

-从代码中可以看到，`model.fit`在训练时使用`callbacks`方法（由验证准确性确定）保存最佳模型，然后加载最佳模型。 最后，我们在测试集上评估模型，如下所示：
+从代码中可以看到，`model.fit`在训练时使用`callbacks`方法（由验证准确率确定）保存最佳模型，然后加载最佳模型。 最后，我们在测试集上评估模型，如下所示：

 ```py
 # build the model
@@ -511,7 +511,7 @@ train_indices = np.random.choice(len(x), round(len(x) * split), replace=False)
 test_indices =np.array(list(set(range(len(x))) - set(train_indices)))
 ```

-我们现在可以创建我们的培训和测试特征，以及它们的相关标签：
+我们现在可以创建我们的训练和测试特征，以及它们的相关标签：

 ```py
 # the train-test split
@@ -603,6 +603,6 @@ print("Accuracy = ",accuracy,"%")

 # 总结

-在本章中，我们看到了在涉及线性回归的两种情况下使用 TensorFlow 的示例。 其中将特征映射到具有连续值的已知标签，从而可以对看不见的特征进行预测。 我们还看到了逻辑回归的一个示例，更好地描述为分类，其中将要素映射到分类标签，再次允许对看不见的要素进行预测。 最后，我们研究了用于分类的 KNN 算法。
+在本章中，我们看到了在涉及线性回归的两种情况下使用 TensorFlow 的示例。 其中将特征映射到具有连续值的已知标签，从而可以对看不见的特征进行预测。 我们还看到了逻辑回归的一个示例，更好地描述为分类，其中将特征映射到分类标签，再次允许对看不见的特征进行预测。 最后，我们研究了用于分类的 KNN 算法。

-我们现在将在第 5 章“将 TensorFlow 2 用于无监督学习”，继续进行无监督学习，在该过程中，要素和标签之间没有初始映射，并且 TensorFlow 的任务是发现特征之间的关系。
\ No newline at end of file
+我们现在将在第 5 章“将 TensorFlow 2 用于无监督学习”，继续进行无监督学习，在该过程中，特征和标签之间没有初始映射，并且 TensorFlow 的任务是发现特征之间的关系。
\ No newline at end of file
--- a/docs/tf-20-quick-start-guide/05.md
+++ b/docs/tf-20-quick-start-guide/05.md
@@ -100,13 +100,13 @@ decoder_layer = autoencoder.layers[-1]# retrieve the last layer of the autoencod
 decoder = Model(encoded_input, decoder_layer(encoded_input))# create the decoder model
 ```

-接下来，我们可以编译我们的自编码器。 由于数据几乎是二进制的，因此选择了`binary_crossentropy`损耗，因此，我们可以最小化每个像素的二进制交叉熵：
+接下来，我们可以编译我们的自编码器。 由于数据几乎是二元的，因此选择了`binary_crossentropy`损失，因此，我们可以最小化每个像素的二元交叉熵：

 ```py
 autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
 ```

-我们可以定义两个有用的检查点。 第一个在每个时期后保存模型。 如果`save_best_only=True`，根据监视的数量（验证损失），最新的最佳模型将不会被覆盖。
+我们可以定义两个有用的检查点。 第一个在每个周期后保存模型。 如果`save_best_only=True`，根据监视的数量（验证损失），最新的最佳模型将不会被覆盖。

 其签名如下：

@@ -120,7 +120,7 @@ keras.callbacks.ModelCheckpoint(filepath, monitor='val_loss', verbose=0, save_be
 checkpointer1 = ModelCheckpoint(filepath= 'model.weights.best.hdf5' , verbose =2, save_best_only = True)
 ```

-当监视器中的更改（验证损失）小于`min_delta`时，即小于`min_delta`的更改不算改善时，第二个检查点停止训练。 这对于`patience`时代必定会发生，然后停止训练。 其签名如下：
+当监视器中的更改（验证损失）小于`min_delta`时，即小于`min_delta`的更改不算改善时，第二个检查点停止训练。 这对于`patience`周期必定会发生，然后停止训练。 其签名如下：

 ```py
 EarlyStopping(monitor='val_loss', min_delta=0, patience=0, verbose=0, mode='auto', baseline=None)
@@ -296,7 +296,7 @@ print(test_x.shape)
 numpy.random.normal(loc=0.0, scale=1.0, size=None)
 ```

-在这里，`loc`是分布的中心，`scale`是标准偏差，`size`是输出形状。 因此，我们使用以下代码：
+在这里，`loc`是分布的中心，`scale`是标准差，`size`是输出形状。 因此，我们使用以下代码：

 ```py
 noise = 0.5
@@ -346,7 +346,7 @@ input_image = Input(shape=(28, 28, 1))
 Conv2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs)
 ```

-我们将主要使用默认值； 接下来是我们的第一个`Conv2D`。 注意`(3,3)`的内核大小； 这是 Keras 应用于输入图像的滑动窗口的大小。 还记得`padding='same'`表示图像用 0 左右填充，因此卷积的输入和输出层是内核（过滤器）以其中心“面板”开始于图像中第一个像素时的大小。 。 默认步幅`(1, 1)`表示滑动窗口一次从图像的左侧到末尾水平移动一个像素，然后向下移动一个像素，依此类推。 接下来，我们将研究每个图层的形状，如下所示：
+我们将主要使用默认值； 接下来是我们的第一个`Conv2D`。 注意`(3,3)`的内核大小； 这是 Keras 应用于输入图像的滑动窗口的大小。 还记得`padding='same'`表示图像用 0 左右填充，因此卷积的输入和输出层是内核（过滤器）以其中心“面板”开始于图像中第一个像素时的大小。 。 默认步幅`(1, 1)`表示滑动窗口一次从图像的左侧到末尾水平移动一个像素，然后向下移动一个像素，依此类推。 接下来，我们将研究每个层的形状，如下所示：

 ```py
 im = Conv2D(filters=32, kernel_size=(3, 3), activation='relu', padding='same')(input_image)

--- a/docs/tf-20-quick-start-guide/06.md
+++ b/docs/tf-20-quick-start-guide/06.md
@@ -148,7 +148,7 @@ x_train, x_valid, y_train, y_valid = train_test_split(x_train, y_train, test_siz

 现在，我们准备创建`convNet`模型。

-有两个卷积层（具有 ReLU 激活），每个卷积层都插入最大池化和丢弃层，然后是一个将卷积层的输出展平为一维的层。 在这些层之后是密集的（完全连接的）一维层（同样具有 ReLU 激活），最后的辍学层，最后是具有 10 个单元的 softmax 层。 softmax 层中每个输出单元的激活给出了该图像是 10 张图像之一的可能性。 这种 ANN 架构有足够的实验空间。
+有两个卷积层（具有 ReLU 激活），每个卷积层都插入最大池化和丢弃层，然后是一个将卷积层的输出展平为一维的层。 在这些层之后是密集的（完全连接的）一维层（同样具有 ReLU 激活），最后的丢弃层，最后是具有 10 个单元的 softmax 层。 softmax 层中每个输出单元的激活给出了该图像是 10 张图像之一的可能性。 这种 ANN 架构有足够的实验空间。

 然后使用分类交叉熵的损失来编译模型：

@@ -176,7 +176,7 @@ model.compile(loss=tf.keras.losses.categorical_crossentropy,

 # 训练和测试模型

-现在，我们可以使用`fit`方法训练模型。 注意验证集的使用，它不同于训练集。 `callbacks`列表还可以用于诸如保存最佳模型或在学习停止时终止训练（如果在所有时期完成之前发生这种情况）的操作。 有关详细信息，请参见[这里](https://keras.io/callbacks/)：
+现在，我们可以使用`fit`方法训练模型。 注意验证集的使用，它不同于训练集。 `callbacks`列表还可以用于诸如保存最佳模型或在学习停止时终止训练（如果在所有周期完成之前发生这种情况）的操作。 有关详细信息，请参见[这里](https://keras.io/callbacks/)：

 ```py
 epochs=25
@@ -190,9 +190,9 @@ model.fit( x_train, y_train,
 )
 ```

-根据模型所处的硬件配置，如果该模型在 GPU 上运行，或者在 CPU 上运行缓慢，则训练速度将非常快。 为了说明的目的，可以减少时期的数量。 在 NVIDIA GTX 1080 GPU 上，时间/纪元约为 38 秒。
+根据模型所处的硬件配置，如果该模型在 GPU 上运行，或者在 CPU 上运行缓慢，则训练速度将非常快。 为了说明的目的，可以减少周期的数量。 在 NVIDIA GTX 1080 GPU 上，时间/周期约为 38 秒。

-为了确定模型的准确性，按以下方法使用`evaluate`方法。 请注意，测试集用于此评估：
+为了确定模型的准确率，按以下方法使用`evaluate`方法。 请注意，测试集用于此评估：

 ```py
 score = model.evaluate(x_test, y_test, verbose=1)
@@ -273,7 +273,7 @@ for i in range(20):

 # 使用`.h5`格式保存和加载 NumPy 图像数据

-如果需要保存先前程序中的培训和测试数据，则可以使用以下代码：
+如果需要保存先前程序中的训练和测试数据，则可以使用以下代码：

 ```py
 import h5py
@@ -303,7 +303,7 @@ y_test = np.array(hf["QuickDraw"][:])

 # 使用预训练的模型进行加载和推断

-经过训练的模型`'QDrawModel.h5'`已运行 25 个纪元，并且达到了 90% 以上的测试准确度，已保存在存储库中。 您已经看过此代码； 为方便起见，在此复制。
+经过训练的模型`'QDrawModel.h5'`已运行 25 个周期，并且达到了 90% 以上的测试准确率，已保存在存储库中。 您已经看过此代码； 为方便起见，在此复制。

 因此，重申一下，您可以使用以下代码加载此经过训练的模型：

@@ -473,7 +473,7 @@ y_test = tf.keras.utils.to_categorical(y_test, number_of_classes)
 model.add(Activation('elu'))
 ```

-`elu`激活函数代表指数线性单位。 在[这个页面](https://sefiks.com/2018/01/02/elu-as-a-neural-networks-activation-function/)中有很好的描述。
+`elu`激活函数代表指数线性单元。 在[这个页面](https://sefiks.com/2018/01/02/elu-as-a-neural-networks-activation-function/)中有很好的描述。

 注意，我们正在使用具有卷积层，`BatchNormalization`和 MaxPooling 层的顺序模型。 倒数第二层使结构变平，最后一层使用 softmax 激活，因此我们预测的类将显示为具有最高激活的输出神经元：

@@ -548,7 +548,7 @@ datagen = ImageDataGenerator(
 validation_split=0.1)
 ```

-我们还将建立一个回调，以便如果模型的准确性停止提高，训练将停止，并且将为模型恢复最佳权重。
+我们还将建立一个回调，以便如果模型的准确率停止提高，训练将停止，并且将为模型恢复最佳权重。

 `EarlyStopping`回调的签名如下：

@@ -556,7 +556,7 @@ datagen = ImageDataGenerator(
 keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=0, verbose=0, mode='auto', baseline=None, restore_best_weights=False)
 ```

-`Monitor`是要跟踪的数量，`min_delta`是被算作改进的跟踪数量的最小变化，`patience`是没有变化的纪元数，之后将停止训练，而`mode` 是['min'，'max'，'auto']之一，它分别确定所跟踪的值是应该减少还是增加，或者分别从其名称中确定。 `baseline`是要达到的跟踪值的值，而`restore_best_weights`确定是否应恢复最佳时期的模型权重（如果使用`false`，则使用最新权重）。
+`Monitor`是要跟踪的数量，`min_delta`是被算作改进的跟踪数量的最小变化，`patience`是没有变化的周期数，之后将停止训练，而`mode` 是['min'，'max'，'auto']之一，它分别确定所跟踪的值是应该减少还是增加，或者分别从其名称中确定。 `baseline`是要达到的跟踪值的值，而`restore_best_weights`确定是否应恢复最佳周期的模型权重（如果使用`false`，则使用最新权重）。

 我们将有以下代码：

@@ -614,7 +614,7 @@ for index in indices:
    i+=1
 ```

-在一次运行中，提前停止开始了 43 个纪元，测试准确性为 81.4%，并且前 25 张图像的测试结果如下：
+在一次运行中，提前停止开始了 43 个周期，测试准确率为 81.4%，并且前 25 张图像的测试结果如下：

 ```py
 Learned  True
@@ -646,14 +646,14 @@ truck    truck
 deer     dog
 ```

-可以通过进一步调整模型架构和超参数（例如学习率）来提高此准确性。
+可以通过进一步调整模型架构和超参数（例如学习率）来提高此准确率。

 到此结束了我们对 CIFAR 10 图像数据集的了解。

 # 总结

-本章分为两个部分。 在第一部分中，我们研究了来自 Google 的数据集 QuickDraw。 我们介绍了它，然后看到了如何将其加载到内存中。 这很简单，因为 Google 善意地将数据集作为一组`.npy`文件提供，这些文件可以直接加载到 NumPy 数组中。 接下来，我们将数据分为训练，验证和测试集。 创建`ConvNet`模型后，我们对数据进行了训练并进行了测试。 在测试中，经过 25 个纪元，该模型的准确率刚好超过 90%，我们注意到，通过进一步调整模型，可能会改善这一精度。 最后，我们看到了如何保存经过训练的模型，然后如何重新加载它并将其用于进一步的推断。
+本章分为两个部分。 在第一部分中，我们研究了来自 Google 的数据集 QuickDraw。 我们介绍了它，然后看到了如何将其加载到内存中。 这很简单，因为 Google 善意地将数据集作为一组`.npy`文件提供，这些文件可以直接加载到 NumPy 数组中。 接下来，我们将数据分为训练，验证和测试集。 创建`ConvNet`模型后，我们对数据进行了训练并进行了测试。 在测试中，经过 25 个周期，该模型的准确率刚好超过 90%，我们注意到，通过进一步调整模型，可能会改善这一精度。 最后，我们看到了如何保存经过训练的模型，然后如何重新加载它并将其用于进一步的推断。

-在第二部分中，我们训练了一个模型来识别 CIFAR 10 图像数据集中的图像。 该数据集包含 10 类图像，是用于测试体系结构和进行超参数研究的流行数据集。 我们的准确度刚刚超过 81%。
+在第二部分中，我们训练了一个模型来识别 CIFAR 10 图像数据集中的图像。 该数据集包含 10 类图像，是用于测试体系结构和进行超参数研究的流行数据集。 我们的准确率刚刚超过 81%。

-在下一章中，我们将研究神经风格转移，其中涉及获取一个图像的内容并将第二个图像的风格强加于其上，以生成第三个混合图像。
\ No newline at end of file
+在下一章中，我们将研究神经风格迁移，其中涉及获取一个图像的内容并将第二个图像的风格强加于其上，以生成第三个混合图像。
\ No newline at end of file
--- a/docs/tf-20-quick-start-guide/07.md
+++ b/docs/tf-20-quick-start-guide/07.md
@@ -8,9 +8,9 @@

 此过程中涉及一些技术-使用函数式 API，使用预训练的模型及其特征图以及使用自定义训练循环以最小化`loss`函数。 我们将在下面的代码中满足所有这些要求。

-要充分利用该技术，有两个先决条件-Gatys 等人在 2015 年发表的[原始论文](https://arxiv.org/abs/1508.06576)虽非必要，但确实可以解释该技术。 技术非常好，因此非常有必要了解如何通过梯度下降来减少损耗。
+要充分利用该技术，有两个先决条件-Gatys 等人在 2015 年发表的[原始论文](https://arxiv.org/abs/1508.06576)虽非必要，但确实可以解释该技术。 技术非常好，因此非常有必要了解如何通过梯度下降来减少损失。

-我们将使用 VGG19 架构中的要素图层（已在著名的 ImageNet 数据集上进行了训练，其中包含 1400 万张图像和 1000 个类别）。
+我们将使用 VGG19 架构中的特征层（已在著名的 ImageNet 数据集上进行了训练，其中包含 1400 万张图像和 1000 个类别）。

 我们将检查的代码源自 Google 提供的代码； 它使用了急切的执行程序，我们当然不需要编写代码，因为它是 TensorFlow 2 中的默认代码。该代码在 GPU 上运行得更快，但在耐心等待的情况下仍可以在 CPU 上合理的时间内进行训练。

@@ -204,7 +204,7 @@ number_of_style_layers = len(style_layers)

 然后将这些输出值与 VGG 输入一起使用，以创建可以访问 VGG 层的新模型，即`get_model()`返回 Keras 模型，该模型输出已训练的 VGG19 模型的风格和内容中间层。 不必使用顶层，因为这是 VGG19 中的最终分类层，我们将不再使用。

-我们将创建一个输出图像，以使输出和相应要素图层上的输入/风格之间的距离（差异）最小化：
+我们将创建一个输出图像，以使输出和相应特征层上的输入/风格之间的距离（差异）最小化：

 ```py
 def get_model():
@@ -250,7 +250,7 @@ def gram_matrix(input_tensor):
  return gram / tf.cast(number_of_channels, tf.float32) # scaled by the number of channels.
 ```

-因此，风格丢失（其中`gram_target`将是混合图像上风格激活的 Gram 矩阵）如下：
+因此，风格损失（其中`gram_target`将是混合图像上风格激活的 Gram 矩阵）如下：

 ```py
 def style_loss(style, gram_target):
@@ -258,7 +258,7 @@ def style_loss(style, gram_target):
  return rms_loss(gram_style, gram_target) 
 ```

-接下来，我们通过获取`content_image`和`style_image`并将它们馈入模型来找到`content_features`和`style_features`表示形式。 此代码分为两个块，一个用于`content_features`，另一个用于`style_features`。 对于内容块，我们加载图像，在其上调用我们的模型，最后，提取先前分配的要素图层。 `style_features`的代码是相同的，除了我们首先加载风格图像：
+接下来，我们通过获取`content_image`和`style_image`并将它们馈入模型来找到`content_features`和`style_features`表示形式。 此代码分为两个块，一个用于`content_features`，另一个用于`style_features`。 对于内容块，我们加载图像，在其上调用我们的模型，最后，提取先前分配的特征层。 `style_features`的代码是相同的，除了我们首先加载风格图像：

 ```py
 def get_feature_representations(model, content_path, style_path):
@@ -415,7 +415,7 @@ images = []
 for i in range(number_of_iterations):
 ```

-因此，接下来我们计算梯度，计算损耗，调用优化器以应用梯度，并将图像裁剪到我们先前计算的边界：
+因此，接下来我们计算梯度，计算损失，调用优化器以应用梯度，并将图像裁剪到我们先前计算的边界：

 ```py
   grads, all_loss = compute_grads(config)
@@ -512,6 +512,6 @@ show_results(best_image, content_path, style_path)

 # 总结

-到此结束我们对神经风格迁移的研究。 我们看到了如何拍摄内容图像和风格图像并生成混合图像。 我们使用训练有素的 VGG19 模型中的图层来完成此任务。
+到此结束我们对神经风格迁移的研究。 我们看到了如何拍摄内容图像和风格图像并生成混合图像。 我们使用训练有素的 VGG19 模型中的层来完成此任务。

 在下一章中，我们将研究循环神经网络。 这些网络可以处理顺序的输入值，并且输入值和输出值中的一个或两个具有可变长度。
\ No newline at end of file
--- a/docs/tf-20-quick-start-guide/08.md
+++ b/docs/tf-20-quick-start-guide/08.md
@@ -83,13 +83,13 @@ Next Char Predictions:
 "dUFdZ!mig())'(ZIon“4g&HZ”@\nWGWtlinnqQY*dGJ7ioU'6(vLKL&cJ29LG'lQW8n-,M!JSVy”cjN;1cH\ndEEeMXhtW$U8Mt&sp"
 ```

-这是一些文本，其中包含`Pip`序列，该序列是在模型经过 0.1 个温度（请参阅下文）进行 100 个时期（约 10 秒每个）的训练后创建的：
+这是一些文本，其中包含`Pip`序列，该序列是在模型经过 0.1 个温度（请参阅下文）进行 100 个周期（约 10 秒每个）的训练后创建的：

 ```py
 Pip; it was not to be done. I had been a little while I was a look out and the strength of considerable particular by the windows of the rest of his prospering look at the windows of the room wing and the courtyard in the morning was the first time I had been a very much being strictly under the wall of my own person to me that he had done my sister, and I went on with the street common, I should have been a very little for an air of the river by the fire. For the man who was all the time of the money. My dear Herbert, who was a little way to the marshes he had ever seemed to have had once more than once and the more was a ragged hand before I had ever seemed to have him a dreadful loveriement in his head and with a falling to the table, and I went on with his arms, I saw him ever so many times, and we all the courtyard to the fire to be so often to be on some time when I saw his shoulder as if it were a long time in the morning I was a woman and a singer at the tide was remained by the 
 ```

-对于不了解语法或拼写的系统来说，这并不是一个坏结果。 这显然是荒谬的，但那时我们并不是在追求理性。 只有一个不存在的单词（`loveriement`）。 因此，网络已经完成了学习拼写和学习单词是文本单位的工作。 还要注意，在下面的代码中，仅在短序列（`sequence_length = 100`）上训练网络。
+对于不了解语法或拼写的系统来说，这并不是一个坏结果。 这显然是荒谬的，但那时我们并不是在追求理性。 只有一个不存在的单词（`loveriement`）。 因此，网络已经完成了学习拼写和学习单词是文本单元的工作。 还要注意，在下面的代码中，仅在短序列（`sequence_length = 100`）上训练网络。

 接下来，我们将查看用于设置，训练和测试循环神经网络的代码。

@@ -244,7 +244,7 @@ print ('{} ---- characters mapped to int ---- > {}'.format(repr(text[:15]), text
 "My father's fam" ---- characters mapped to int ---- > [40 78  1 59 54 73 61 58 71  6 72  1 59 54 66]
 ```

-然后，我们设置每个输入的句子长度，并因此设置训练时期中的示例数：
+然后，我们设置每个输入的句子长度，并因此设置训练周期中的示例数：

 ```py
 # The maximum length sentence we want for a single input in characters
@@ -252,7 +252,7 @@ sequence_length = 100
 examples_per_epoch = len(text)//seq_length
 ```

-接下来，我们创建`data.Dataset`以在以后的培训中使用：
+接下来，我们创建`data.Dataset`以在以后的训练中使用：

 ```py
 # Create training examples / targets
@@ -268,13 +268,13 @@ for char in char_dataset.take(5):
 M y f a
 ```

-我们需要批处理此数据以将其馈送到我们的 RNN，因此接下来我们要这样做：
+我们需要批量此数据以将其馈送到我们的 RNN，因此接下来我们要这样做：

 ```py
 sequences = char_dataset.batch(sequence_length+1, drop_remainder=True)
 ```

-请记住，我们已经设置了`sequence_length = 100`，所以批处理中的字符数是 101。
+请记住，我们已经设置了`sequence_length = 100`，所以批量中的字符数是 101。

 现在，我们有了一个函数来创建我们的输入数据和目标数据（必需的输出）。

@@ -324,7 +324,7 @@ for char, (input_index, target_index) in enumerate(zip(input_example[:5], target
 Step 0:      input: 40 ('M'),  expected output: 78 ('y') Step 1:      input: 78 ('y'),  expected output: 1 (' ') Step 2:      input: 1 (' '),  expected output: 59 ('f') Step 3:      input: 59 ('f'),  expected output: 54 ('a') Step 4:      input: 54 ('a'),  expected output: 73 ('t')
 ```

-接下来，我们为培训进行设置，如下所示：
+接下来，我们为训练进行设置，如下所示：

 ```py
 # how many characters in a batch
@@ -380,7 +380,7 @@ else:

 如我们先前所见，一种用于构建模型的技术是将所需的层传递到`tf.keras.Sequential()`构造器中。 在这种情况下，我们分为三层：嵌入层，RNN 层和密集层。

-第一嵌入层是向量的查找表，一个向量用于每个字符的数值。 它的尺寸为`embedding_dimension`。 中间，循环层是 GRU； 其大小为`recurrent_nn_units`。 最后一层是长度为`vocabulary_length`单位的密集输出层。
+第一嵌入层是向量的查找表，一个向量用于每个字符的数值。 它的尺寸为`embedding_dimension`。 中间，循环层是 GRU； 其大小为`recurrent_nn_units`。 最后一层是长度为`vocabulary_length`单元的密集输出层。

 该模型所做的是查找嵌入，使用嵌入作为输入来运行 GRU 一次，然后将其传递给密集层，该层生成下一个字符的对数（对数赔率）。

@@ -571,7 +571,7 @@ model.summary()

 接下来，在给定训练有素的模型，起始字符串和温度的情况下，我们使用一个函数来生成新文本，其值确定文本的随机性（低值给出更多可预测的文本；高值给出更多随机的文本）。

-首先，我们确定要生成的字符数，然后向量化起始字符串，并为其添加空白尺寸。 我们将额外的维添加到`input_string`变量中，因为 RNN 单元需要它（两个必需的维是批处理长度和序列长度）。 然后，我们初始化一个变量，用于存储生成的文本。
+首先，我们确定要生成的字符数，然后向量化起始字符串，并为其添加空白尺寸。 我们将额外的维添加到`input_string`变量中，因为 RNN 单元需要它（两个必需的维是批量长度和序列长度）。 然后，我们初始化一个变量，用于存储生成的文本。

 `temperature`的值确定生成的文本的随机性（较低的随机性较小，意味着更可预测）。

@@ -630,9 +630,9 @@ Pip; it was a much better to and the Aged and weaking his hands of the windows o

 `Loss = 0.6761`； 该文本或多或少地被正确地拼写和标点，尽管其含义（我们并未试图实现）的含义在很大程度上是愚蠢的。 它还没有学习如何正确使用语音标记。 只有两个无意义的单词（`forgetter`和`weaking`），经过检查，在语义上仍然是合理的。 生成的是否为 Charles Dickens 风格是一个悬而未决的问题。

-历元数的实验表明，损耗在约 45 历元时达到最小值，此后它开始增加。
+周期数的实验表明，损失在约 45 周期时达到最小值，此后它开始增加。

-45 个纪元后，输出如下：
+45 个周期后，输出如下：

 ```py
 Pip; or I should
@@ -656,6 +656,6 @@ ago. “Yes, de

 # 总结

-这样就结束了我们对 RNN 的研究。 在本章中，我们首先讨论了 RNN 的一般原理，然后介绍了如何获取和准备一些供模型使用的文本，并指出在此处使用替代文本源很简单。 然后，我们看到了如何创建和实例化我们的模型。 然后，我们训练了模型并使用它从起始字符串中产生文本，并注意到网络已了解到单词是文本的单位以及如何拼写各种各样的单词（有点像文本作者的风格）， 几个非单词。
+这样就结束了我们对 RNN 的研究。 在本章中，我们首先讨论了 RNN 的一般原理，然后介绍了如何获取和准备一些供模型使用的文本，并指出在此处使用替代文本源很简单。 然后，我们看到了如何创建和实例化我们的模型。 然后，我们训练了模型并使用它从起始字符串中产生文本，并注意到网络已了解到单词是文本的单元以及如何拼写各种各样的单词（有点像文本作者的风格）， 几个非单词。

 在下一章中，我们将研究 TensorFlow Hub 的使用，它是一个软件库。
\ No newline at end of file
--- a/docs/tf-20-quick-start-guide/09.md
+++ b/docs/tf-20-quick-start-guide/09.md
@@ -13,7 +13,7 @@

 估计器为 TensorFlow 开发人员带来了许多优势。 与低级 API 相比，使用估计器开发模型更容易，更直观。 特别是，同一模型可以在本地计算机或分布式多服务器系统上运行。 该模型也不了解其所处的处理器，即 CPU，GPU 或 TPU。 估计器还通过简化模型开发人员共享实现的过程，简化了开发过程，并且由于构建在 Keras 层上，因此使自定义更加简单。

-估计器会处理与 TensorFlow 模型一起使用的所有背景管线。 它们支持安全，分布式的训练循环，用于图形构建，变量初始化，数据加载，异常处理，创建检查点文件，从故障中恢复以及为 TensorBoard 保存摘要。 正如我们将看到的，由于它们创建检查点，因此它们支持在给定数量的步骤之后停止和开始训练。
+估计器会处理与 TensorFlow 模型一起使用的所有背景管线。 它们支持安全，分布式的训练循环，用于图构建，变量初始化，数据加载，异常处理，创建检查点文件，从故障中恢复以及为 TensorBoard 保存摘要。 正如我们将看到的，由于它们创建检查点，因此它们支持在给定数量的步骤之后停止和开始训练。

 开发估计器模型的过程分为四个步骤：

@@ -35,7 +35,7 @@ import tensorflow as tf
 import numpy as np
 ```

-接下来，我们获取并预处理数据。 注意，`tf.keras.datasets`中方便地存在`fashion_mnist`。 数据集中的`x`值采用整数 NumPy 数组的形式，每个元素的范围为 0 到 255，代表`28 x 28`像素时尚图像中每个像素的灰度值。 为了进行培训，必须将这些值转换为 0 到 1 范围内的浮点数。`y`值采用无符号 8 位整数`(uint8)`的形式，并且必须转换为 32 位整数（`int32` ），供估计工具再次使用。
+接下来，我们获取并预处理数据。 注意，`tf.keras.datasets`中方便地存在`fashion_mnist`。 数据集中的`x`值采用整数 NumPy 数组的形式，每个元素的范围为 0 到 255，代表`28 x 28`像素时尚图像中每个像素的灰度值。 为了进行训练，必须将这些值转换为 0 到 1 范围内的浮点数。`y`值采用无符号 8 位整数`(uint8)`的形式，并且必须转换为 32 位整数（`int32` ），供估计工具再次使用。

 尽管可以用以下方法试验该超参数值，但将学习率设置为一个很小的值：

@@ -52,7 +52,7 @@ learning_rate = 1e-4

 之后，是我们的训练输入特征。

-当您具有数组中的完整数据集并需要快速进行批处理，混排和/或重复的方法时，将使用`tf.compat.v1.estimator.inputs.numpy_input_fn`。
+当您具有数组中的完整数据集并需要快速进行批量，混排和/或重复的方法时，将使用`tf.compat.v1.estimator.inputs.numpy_input_fn`。

 其签名如下：

@@ -68,7 +68,7 @@ tf.compat.v1.estimator.inputs.numpy_input_fn(
 )
 ```

-将此与我们对函数的调用进行比较，您可以看到`x`值如何作为 NumPy 数组的字典（与张量兼容）传递，以及`y`照原样传递。 在此阶段，我们尚未指定时代数，即该函数将永远运行（稍后将指定步骤），我们的批处理大小（即一步中显示的图像数）为`50`， 并在每一步之前将数据在队列中混洗。 其他参数保留为其默认值：
+将此与我们对函数的调用进行比较，您可以看到`x`值如何作为 NumPy 数组的字典（与张量兼容）传递，以及`y`照原样传递。 在此阶段，我们尚未指定周期数，即该函数将永远运行（稍后将指定步骤），我们的批量大小（即一步中显示的图像数）为`50`， 并在每一步之前将数据在队列中混洗。 其他参数保留为其默认值：

 ```py
 train_input_fn = tf.compat.v1.estimator.inputs.numpy_input_fn(
@@ -82,7 +82,7 @@ train_input_fn = tf.compat.v1.estimator.inputs.numpy_input_fn(

 值得一提的是，尽管这样的便利函数虽然在 TensorFlow 2.0 alpha 中不可用，但仍有望改用 TensorFlow2。

-测试函数具有相同的签名，但是在这种情况下，我们仅指定一个时期，并且正如 Google 所建议的那样，我们不会对数据进行混洗。 同样，其余参数保留为其默认值：
+测试函数具有相同的签名，但是在这种情况下，我们仅指定一个周期，并且正如 Google 所建议的那样，我们不会对数据进行混洗。 同样，其余参数保留为其默认值：

 ```py
 test_input_fn = tf.compat.v1.estimator.inputs.numpy_input_fn(
@@ -113,7 +113,7 @@ tf.feature_column.numeric_column(
 feature_columns = [tf.feature_column.numeric_column("x", shape=[28, 28])]
 ```

-接下来，我们实例化我们的估计器，它将进行分类。 它将为我们构建一个深度神经网络。 它的签名很长很详细，因此我们将带您参考[这里](https://www.tensorflow.org/api_docs/python/tf/estimator/DNNClassifier)，因为我们将主要使用其默认参数。 它的第一个参数是我们刚刚指定的特征，而第二个参数是我们的网络规模。 （输入层和输出层由估计器在后台添加。）`AdamOptimizer`是安全的选择。 `n_classes`对应于我们`fashion_mnist`数据集的`y`标签数量，我们在其中添加了`0.1`的适度`dropout`。 然后，`model_dir`是我们保存模型参数及其图形和检查点的目录。 此目录还用于将检查点重新加载到估计器中以继续训练：
+接下来，我们实例化我们的估计器，它将进行分类。 它将为我们构建一个深度神经网络。 它的签名很长很详细，因此我们将带您参考[这里](https://www.tensorflow.org/api_docs/python/tf/estimator/DNNClassifier)，因为我们将主要使用其默认参数。 它的第一个参数是我们刚刚指定的特征，而第二个参数是我们的网络规模。 （输入层和输出层由估计器在后台添加。）`AdamOptimizer`是安全的选择。 `n_classes`对应于我们`fashion_mnist`数据集的`y`标签数量，我们在其中添加了`0.1`的适度`dropout`。 然后，`model_dir`是我们保存模型参数及其图和检查点的目录。 此目录还用于将检查点重新加载到估计器中以继续训练：

 ```py
 # Build 2 layer DNN classifier
@@ -156,7 +156,7 @@ INFO:tensorflow:Loss for final step: 13.06977.
 classifier.evaluate(input_fn, steps=None, hooks=None, checkpoint_path=None, name=None)
 ```

-这将返回一个字典，因此在我们的调用中，我们正在提取准确性指标。
+这将返回一个字典，因此在我们的调用中，我们正在提取准确率指标。

 在此，`steps`默认为`None`。 这将评估模型，直到`input_fn`引发输入结束异常，即，它将评估整个测试集：

@@ -165,13 +165,13 @@ classifier.evaluate(input_fn, steps=None, hooks=None, checkpoint_path=None, name
 print("\nTest Accuracy: {0:f}%\n".format(accuracy_score*100))
 ```

-我们还可以使用以下命令在 TensorBoard 中查看培训的进度：
+我们还可以使用以下命令在 TensorBoard 中查看训练的进度：

 ```py
 tensorboard --logdir=./tmp/mnist_modelx
 ```

-此处，损耗图如下所示，其中`x`轴以 1,000（k）单位表示：
+此处，损失图如下所示，其中`x`轴以 1,000（k）单位表示：

 ![](img/5b1262f0-e388-4537-ae0f-fe7ee09b7bb9.png)

@@ -185,7 +185,7 @@ TensorFlow Hub 是一个软件库。 其目的是提供可重用的组件（称

 在本节中，我们将研究一种基于 Google 的应用，该应用在**情感分析**中分析了电影评论的 IMDb 的子集。 该子集由斯坦福大学主持，包含每部电影的评论，以及情感积极性等级为 1 到 4（差）和 7 到 10（好）的情感。 问题在于确定关于每个电影的文本句子中表达的视图的极性，即针对每个评论，以确定它是正面评论还是负面评论。 我们将在 TensorFlow Hub 中使用一个模块，该模块先前已经过训练以生成单词嵌入。

-词嵌入是数字的向量，因此具有相似含义的词也具有类似的向量。 这是监督学习的示例，因为评论的训练集将使用 IMDB 数据库提供的阳性值来训练模型。 然后，我们将在测试集上使用经过训练的模型，并查看其预测与 IMDB 数据库中存储的预测相比如何，从而为我们提供了一种准确度度量。
+词嵌入是数字的向量，因此具有相似含义的词也具有类似的向量。 这是监督学习的示例，因为评论的训练集将使用 IMDB 数据库提供的阳性值来训练模型。 然后，我们将在测试集上使用经过训练的模型，并查看其预测与 IMDB 数据库中存储的预测相比如何，从而为我们提供了一种准确率度量。

 可以在[这个页面](http://ai.stanford.edu/~amaas/data/sentiment/)中找到该数据库论文的引文。

@@ -196,7 +196,7 @@ TensorFlow Hub 是一个软件库。 其目的是提供可重用的组件（称
 "The core dataset contains 50,000 reviews split evenly into 25k train and 25k test sets. The overall distribution of labels is balanced (25k pos and 25k neg)."
 "In the entire collection, no more than 30 reviews are allowed for any given movie because reviews for the same movie tend to have correlated ratings. Further, the train and test sets contain a disjoint set of movies, so no significant performance is obtained by memorizing movie-unique terms and their associated with observed labels. In the labeled train/test sets, a negative review has a score <= 4 out of 10, and a positive review has a score >= 7 out of 10\. Thus, reviews with more neutral ratings are not included in the train/test sets."

-这是从 IMDb 火车头的顶部起的五行示例：
+这是从 IMDb 训练头的顶部起的五行示例：

 |  | **句子** | **情感** | **极性** |
 | --- | --- | --- | --- |
@@ -294,7 +294,7 @@ def load(directory):
    return pd.concat([positive_df, negative_df]).sample(frac=1).reset_index(drop=True)
 ```

-第三个也是最后一个函数是`acquire_data()`。 如果缓存中不存在该函数，则使用 Keras 工具从 Stanford URL 中获取我们所需的文件。 默认情况下，高速缓存是位于`~/.keras/datasets`的目录，如有必要，文件将提取到该位置。 该工具将返回到我们的 IMDb 的路径。 然后将其传递给`load_dataset()`的两个调用，以获取火车和测试`DataFrame`：
+第三个也是最后一个函数是`acquire_data()`。 如果缓存中不存在该函数，则使用 Keras 工具从 Stanford URL 中获取我们所需的文件。 默认情况下，高速缓存是位于`~/.keras/datasets`的目录，如有必要，文件将提取到该位置。 该工具将返回到我们的 IMDb 的路径。 然后将其传递给`load_dataset()`的两个调用，以获取训练和测试`DataFrame`：

 ```py
 # Download and process the dataset files.
@@ -331,7 +331,7 @@ tf.compat.v1.estimator.inputs.pandas_input_fn(x, y=None, batch_size=128, num_epo
 train_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(train_df, train_df["polarity"], num_epochs=None, shuffle=True)
 ```

-通过将此调用与函数签名进行比较，我们可以看到训练数据帧`train_df`与每个评论的极性一起传入。 `num_epochs =None`表示对训练纪元的数量没有限制，因为我们将在后面进行指定； `shuffle=True`表示以随机顺序读取记录，即文件的每一行。
+通过将此调用与函数签名进行比较，我们可以看到训练数据帧`train_df`与每个评论的极性一起传入。 `num_epochs =None`表示对训练周期的数量没有限制，因为我们将在后面进行指定； `shuffle=True`表示以随机顺序读取记录，即文件的每一行。

 接下来是预测训练结果的函数：

@@ -377,7 +377,7 @@ estimator = tf.estimator.DNNClassifier(
 , loss_reduction=tf.compat.v1.losses.Reduction.SUM)
 ```

-我们可以看到，我们将使用具有 500 和 100 个单位的隐藏层的神经网络，我们先前定义的要素列，两个输出类（标签）和`ProximalAdagrad`优化器。
+我们可以看到，我们将使用具有 500 和 100 个单元的隐藏层的神经网络，我们先前定义的特征列，两个输出类（标签）和`ProximalAdagrad`优化器。

 请注意，与前面的示例一样，由于我们指定了`model_dir`，因此估计器将保存一个检查点和各种模型参数，以便在重新训练时，将从该目录加载模型并对其进行进一步的训练`steps`。

@@ -391,10 +391,10 @@ estimator.train(input_fn=train_input_fn, steps=steps);

 在我们的上下文中，混淆矩阵是一个图表，显示了经过训练的模型的以下内容：

-*   **真阳性**：已正确预测真实真实感性为正面的评论（右下）
-*   **真阴性**：已将其真实否定性感正确地预测为负面的评论（左上）
-*   **假阳性**：正确的负面情感被错误地预测为正面的评论（右上）
-*   **假阴性**：真实的正面感被错误地预测为负面的评论（左下）
+*   **真阳性**：真实的正面情感被正确地预测为正面的评论（右下）
+*   **真阴性**：真实的负面情感被正确地预测为负面的评论（左上）
+*   **假阳性**：真实的负面情感被错误地预测为正面的评论（右上）
+*   **假阴性**：真实的正面情感被错误地预测为负面的评论（左下）

 以下是我们的训练集的混淆矩阵：