2020-08-04 21:41:41

docs/mastering-tf-1x-zh/ch01.md

@@ -111,12 +111,12 @@ print(tfs.run(hello))
 
 | **TensorFlow Python API 数据类型** | **描述** |
 | --- | --- |
-| `tf.float16` | 16 位半精度浮点数 |
+| `tf.float16` | 16 位半精度浮点 |
 | `tf.float32` | 32 位单精度浮点 |
 | `tf.float64` | 64 位双精度浮点 |
 | `tf.bfloat16` | 16 位截断浮点 |
-| `tf.complex64` | 64 位单精度复合体 |
-| `tf.complex128` | 128 位双精度复合体 |
+| `tf.complex64` | 64 位单精度复数 |
+| `tf.complex128` | 128 位双精度复数 |
 | `tf.int8` | 8 位有符号整数 |
 | `tf.uint8` | 8 位无符号整数 |
 | `tf.uint16` | 16 位无符号整数 |
@@ -124,13 +124,13 @@ print(tfs.run(hello))
 | `tf.int32` | 32 位有符号整数 |
 | `tf.int64` | 64 位有符号整数 |
 | `tf.bool` | 布尔 |
-| `tf.string` | 串 |
+| `tf.string` | 字符串 |
 | `tf.qint8` | 量化的 8 位有符号整数 |
 | `tf.quint8` | 量化的 8 位无符号整数 |
 | `tf.qint16` | 量化的 16 位有符号整数 |
 | `tf.quint16` | 量化的 16 位无符号整数 |
 | `tf.qint32` | 量化的 32 位有符号整数 |
-| `tf.resource` | 处理可变资源 |
+| `tf.resource` | 可变资源 |
 
 我们建议您避免使用 Python 本地数据类型。 使用 TensorFlow 数据类型来定义张量，而不是 Python 本地数据类型。
 
@@ -791,7 +791,7 @@ print('output : ',output)
 
 # 执行顺序和延迟加载
 
-节点按依赖顺序执行。如果节点`a`依赖于节点`b`，则`a`将在执行`b`之前执行请求`b`。除非未请求执行节点本身或取决于它的其他节点，否则不执行节点。这也称为延迟加载;即，在需要之前不创建和初始化节点对象。
+节点按依赖顺序执行。如果节点`a`依赖于节点`b`，则`a`将在执行`b`之前执行请求`b`。除非未请求执行节点本身或取决于它的其他节点，否则不执行节点。这也称为延迟加载；即，在需要之前不创建和初始化节点对象。
 
 有时，您可能希望控制在图中执行节点的顺序。这可以通过`tf.Graph.control_dependencies()` 函数实现。 例如，如果图具有节点`a, b, c`和`d`并且您想在`a`和`b`之前执行`c`和`d`，请使用以下语句：
 

docs/mastering-tf-1x-zh/ch02.md

@@ -103,17 +103,17 @@ python3 -c 'import tensorflow.contrib.slim as slim; eval = slim.evaluation.evalu
 
 TF Slim 提供了几个模块，可以独立挑选和应用，并与其他 TensorFlow 软件包混合使用。例如，在撰写本书时，TF Slim 有以下主要模块：
 
-| TF Slim 模块 | 模块说明 |
+| TFSlim 模块 | 模块说明 |
 | --- | --- |
-| arg_scope | 提供将元素应用于作用域下定义的所有图节点的机制。 |
-| 层 | 提供几种不同的层，如`fully_connected`，`conv2d`等等。 |
-| 损失 | 提供用于训练优化器的损失函数 |
-| 学习 | 提供训练模型的函数 |
-| 评测 | 提供评估函数 |
-| 指标 | 提供用于评估模型的度量函数 |
-| regularizers | 提供用于创建正则化方法的函数 |
-| 变量 | 提供变量创建的函数 |
-| 网 | 提供各种预制和预训练模型，如 VGG16，InceptionV3，ResNet |
+| `arg_scope` | 提供将元素应用于作用域下定义的所有图节点的机制。 |
+| `layer` | 提供几种不同的层，如`fully_connected`，`conv2d`等等。 |
+| `loss` | 提供用于训练优化器的损失函数 |
+| `learn` | 提供训练模型的函数 |
+| `evaluate` | 提供评估函数 |
+| `metics` | 提供用于评估模型的度量函数 |
+| `regularizers` | 提供用于创建正则化方法的函数 |
+| `variable` | 提供变量创建的函数 |
+| `net` | 提供各种预制和预训练模型，如 VGG16，InceptionV3，ResNet |
 
 TF Slim 的简单工作流程如下：
 
@@ -243,21 +243,21 @@ TFLearn 在`tflearn.layers.conv`模块中提供以下层：
 | `conv_1d` | 该层将 1D 卷积应用于输入数据 |
 | `conv_2d` | 该层将 2D 卷积应用于输入数据 |
 | `conv_3d` | 该层将 3D 卷积应用于输入数据 |
-| `conv_2d_transpose` | 该层将 conv2_d 的转置应用于输入数据 |
-| `conv_3d_transpose` | 该层将 conv3_d 的转置应用于输入数据 |
+| `conv_2d_transpose` | 该层将`conv2_d`的转置应用于输入数据 |
+| `conv_3d_transpose` | 该层将`conv3_d`的转置应用于输入数据 |
 | `atrous_conv_2d` | 该层计算二维动态卷积 |
-| `grouped_conv_2d` | 该层计算深度 2-D 卷积 |
-| `max_pool_1d` | 该层计算 1-D 最大池 |
-| `max_pool_2d` | 该层计算 2D 最大池 |
-| `avg_pool_1d` | 该层计算 1D 平均池 |
-| `avg_pool_2d` | 该层计算 2D 平均池 |
-| `upsample_2d` | 该层应用行和列 2-D 重复操作 |
+| `grouped_conv_2d` | 该层计算深度 2D 卷积 |
+| `max_pool_1d` | 该层计算 1D 最大池化 |
+| `max_pool_2d` | 该层计算 2D 最大池化 |
+| `avg_pool_1d` | 该层计算 1D 平均池化 |
+| `avg_pool_2d` | 该层计算 2D 平均池化 |
+| `upsample_2d` | 该层应用行和列 2D 重复操作 |
 | `upscore_layer` | 该层实现了[这个页面](http://arxiv.org/abs/1411.4038)中规定的最高分。 |
-| `global_max_pool` | 该层实现全局最大池操作 |
-| `global_avg_pool` | 该层实现全局平均池操作 |
-| `residual_block` | 该层实现剩余块以创建深度残留网络 |
-| `residual_bottleneck` | 该层实现深度残留网络的剩余瓶颈块 |
-| `resnext_block` | 该层实现 ResNeXt 块 |
+| `global_max_pool` | 该层实现全局最大池化操作 |
+| `global_avg_pool` | 该层实现全局平均池化操作 |
+| `residual_block` | 该层实现残差块以创建深度残差网络 |
+| `residual_bottleneck` | 该层实现深度残差网络的残差瓶颈块 |
+| `resnext_block` | 该层实现 ResNext 块 |
 
 # TFLearn 循环层
 
@@ -295,7 +295,7 @@ TFLearn 在`tflearn.layers.merge_ops`模块中提供以下层：
 | 层类 | 描述 |
 | --- | --- |
 | `merge_outputs` | 该层将张量列表合并为单个张量，通常用于合并相同形状的输出张量 |
-| `merge` | 该层将张量列表合并为单个张量;您可以指定需要进行合并的轴 |
+| `merge` | 该层将张量列表合并为单个张量；您可以指定需要进行合并的轴 |
 
 # TFLearn 估计层
 

docs/mastering-tf-1x-zh/ch03.md

@@ -219,7 +219,7 @@ Keras 核心层实现基本操作，几乎用于各种网络架构。下表给
 
 # Keras 噪音层
 
-这些层可以添加到模型中，以防止过拟合添加噪音;它们也被称为正则化层。这些层的操作方式与核心层部分中的`Dropout()` 和  `ActivityRegularizer()` 层相同。
+这些层可以添加到模型中，以防止过拟合添加噪音；它们也被称为正则化层。这些层的操作方式与核心层部分中的`Dropout()` 和  `ActivityRegularizer()` 层相同。
 
 | **层名称** | **描述** |
 | --- | --- |
@@ -326,7 +326,7 @@ fit(self, x, y, batch_size=32, epochs=10, verbose=1, callbacks=None,
     class_weight=None, sample_weight=None, initial_epoch=0)
 ```
 
-我们不会详细介绍这种方法的参数; 您可以在[ Keras 网站](https://keras.io/models/sequential/)上阅读详细信息。
+我们不会详细介绍这种方法的参数； 您可以在[ Keras 网站](https://keras.io/models/sequential/)上阅读详细信息。
 
 对于我们之前创建的示例模型，使用以下代码训练模型：
 

docs/mastering-tf-1x-zh/ch04.md

@@ -32,9 +32,9 @@
 
 ![](img/ff368a23-744e-4bc3-9c9a-82686936c8a1.png)
 
-分类是机器学习中的经典问题之一。正在考虑的数据可以属于一个或其他类别，例如，如果提供的图像是数据，则它们可以是猫或狗的图片。因此，在这种情况下，类别是猫和狗。分类是指识别或识别所考虑的数据或对象的标签或类别。分类属于监督机器学习的范畴。在分类问题中，提供具有特征或输入及其相应输出或标签的训练数据集。使用该训练数据集，训练模型;换句话说，计算模型的参数。然后将训练的模型用于新数据以找到其正确的标签。
+分类是机器学习中的经典问题之一。正在考虑的数据可以属于一个或其他类别，例如，如果提供的图像是数据，则它们可以是猫或狗的图片。因此，在这种情况下，类别是猫和狗。分类是指识别或识别所考虑的数据或对象的标签或类别。分类属于监督机器学习的范畴。在分类问题中，提供具有特征或输入及其相应输出或标签的训练数据集。使用该训练数据集，训练模型；换句话说，计算模型的参数。然后将训练的模型用于新数据以找到其正确的标签。
 
-分类问题可以有两种类型：**两类**或**多类**。两类意味着数据被分类为两个不同且不连续的标签，例如，患者患有癌症或患者没有癌症，图像是猫或狗。多类意味着数据将被分类到多个类别中，例如，电子邮件分类问题会将电子邮件分成社交媒体电子邮件，与工作相关的电子邮件，个人电子邮件，与家人相关的电子邮件，垃圾邮件，购物优惠电子邮件等等。 。另一个例子是数字图片的例子;每张图片可以标记在 0 到 9 之间，具体取决于图片所代表的数字。在本章中，我们将看到两种分类的示例。
+分类问题可以有两种类型：**两类**或**多类**。两类意味着数据被分类为两个不同且不连续的标签，例如，患者患有癌症或患者没有癌症，图像是猫或狗。多类意味着数据将被分类到多个类别中，例如，电子邮件分类问题会将电子邮件分成社交媒体电子邮件，与工作相关的电子邮件，个人电子邮件，与家人相关的电子邮件，垃圾邮件，购物优惠电子邮件等等。 。另一个例子是数字图片的例子；每张图片可以标记在 0 到 9 之间，具体取决于图片所代表的数字。在本章中，我们将看到两种分类的示例。
 
 在本章中，我们将进一步扩展以下主题：
 
@@ -52,7 +52,7 @@
 
 # 简单的线性回归
 
-您可能使用过其他机器学习库;现在让我们练习使用 TensorFlow 学习简单的线性回归模型。在继续讨论特定于域的示例之前，我们将首先使用生成的数据集解释这些概念。
+您可能使用过其他机器学习库；现在让我们练习使用 TensorFlow 学习简单的线性回归模型。在继续讨论特定于域的示例之前，我们将首先使用生成的数据集解释这些概念。
 
 我们将使用生成的数据集，以便来自所有不同域的读者可以学习而不会被示例的特定域的细节所淹没。
 
@@ -452,7 +452,7 @@ For test data : MSE = 30.48501778, R2 = 0.64172244
 
 有关正则化的更多详细信息，[请参阅互联网上的这些资源](http://www.statisticshowto.com/regularization/)。
 
-一个简单的经验法则是当我们想要删除某些特征时使用 L1 或 Lasso，从而减少计算时间，但代价是降低了准确性。
+一个简单的经验法则是当我们想要删除某些特征时使用 L1 或 Lasso，从而减少计算时间，但代价是降低了准确率。
 
 现在让我们看看在 TensorFlow 中实现的这些正则化损失函数。我们将继续使用前面示例中使用的 Boston 数据集。
 
@@ -737,10 +737,10 @@ if (y.ndim == 1):
     y = y.reshape(-1,1)
 ```
 
-`make_classification()`的论据是不言自明的; `n_samples`是要生成的数据点数，`n_features`是要生成的特征数，`n_classes`是类的数量，即 2：
+`make_classification()`的论据是不言自明的； `n_samples`是要生成的数据点数，`n_features`是要生成的特征数，`n_classes`是类的数量，即 2：
 
 *   `n_samples`是要生成的数据点数。我们将其保持在 200 以保持数据集较小。
-*   `n_features`是要生成的特征数量;我们只使用两个特征，因此我们可以将它作为一个简单的问题来理解 TensorFlow 命令。
+*   `n_features`是要生成的特征数量；我们只使用两个特征，因此我们可以将它作为一个简单的问题来理解 TensorFlow 命令。
 *   `n_classes`是类的数量，它是 2，因为它是二分类问题。
 
 让我们使用以下代码绘制数据：
@@ -750,7 +750,7 @@ plt.scatter(X[:,0],X[:,1],marker='o',c=y)
 plt.show()
 ```
 
-我们得到以下绘图;您可能会得到一个不同的图，因为每次运行数据生成函数时都会随机生成数据：
+我们得到以下绘图；您可能会得到一个不同的图，因为每次运行数据生成函数时都会随机生成数据：
 
 ![](img/707586af-1084-493a-86a8-f827a115cfa5.png)
 
@@ -884,7 +884,7 @@ num_batches = int(mnist.train.num_examples/batch_size)
 *   `learning_rate`：此参数表示梯度下降优化器算法的学习率。我们将学习率任意设定为 0.001。
 *   `num_epochs`：我们将仅针对一次迭代运行我们的第一个示例，因此我们将周期数设置为 1。
 *   `batch_size`：在现实世界中，我们可能拥有庞大的数据集并加载整个数据集以便训练模型可能是不可能的。因此，我们将输入数据分成随机选择的批次。我们将`batch_size`设置为 100 个图像，可以使用 TensorFlow 的内置算法一次选择。
-*   `num_batches`：此参数设置应从总数据集中选择批次的次数;我们将其设置为等于数据集中的项目数除以批量中的项目数。
+*   `num_batches`：此参数设置应从总数据集中选择批次的次数；我们将其设置为等于数据集中的项目数除以批量中的项目数。
 
 我们鼓励您尝试使用这些参数的不同值。
 
@@ -974,7 +974,7 @@ def tensorflow_classification(num_epochs, num_batches, batch_size,
     plt.show()
 ```
 
-上述函数获取参数并执行训练迭代，打印每次迭代的准确率分数并打印准确率分数。它还可以保存`accuracy_epochs`数组中每个周期的准确率分数。之后，它绘制了每个周期的准确性。让我们使用我们之前设置的参数运行此函数 30 个周期，使用以下代码：
+上述函数获取参数并执行训练迭代，打印每次迭代的准确率分数并打印准确率分数。它还可以保存`accuracy_epochs`数组中每个周期的准确率分数。之后，它绘制了每个周期的准确率。让我们使用我们之前设置的参数运行此函数 30 个周期，使用以下代码：
 
 ```py
 num_epochs=30

docs/mastering-tf-1x-zh/ch05.md

@@ -223,7 +223,7 @@ def mnist_batch_func(batch_size=100):
     return [X_batch, Y_batch]
 ```
 
-此函数不言自明。 TensorFlow 为 MNIST 数据集提供此函数;但是，对于其他数据集，我们可能必须编写自己的批量函数。
+此函数不言自明。 TensorFlow 为 MNIST 数据集提供此函数；但是，对于其他数据集，我们可能必须编写自己的批量函数。
 
 辅助函数`tensorflow_classification()`训练并评估模型。
 
@@ -390,17 +390,17 @@ epoch: 0049   loss = 0.668717
 accuracy=0.85720009
 ```
 
-我们看到单个神经元网络在 50 次迭代中缓慢地将损失从 8.3 降低到 0.66，最终得到几乎 85%的准确率。对于这个具体的例子，这是非常糟糕的准确性，因为这只是使用 TensorFlow 进行分类使用 MLP 的演示。
+我们看到单个神经元网络在 50 次迭代中缓慢地将损失从 8.3 降低到 0.66，最终得到几乎 85%的准确率。对于这个具体的例子，这是非常糟糕的准确率，因为这只是使用 TensorFlow 进行分类使用 MLP 的演示。
 
-我们使用更多层和神经元运行相同的代码，并获得以下准确性：
+我们使用更多层和神经元运行相同的代码，并获得以下准确率：
 
-| 层数 | 每个隐藏层中的神经元数量 | 准确性 |
+| 层数 | 每个隐藏层中的神经元数量 | 准确率 |
 | --- | --- | --- |
 | 0 | 0 | 0.857 |
 | 1 | 8 | 0.616 |
 | 2 | 256 | 0.936 |
 
-因此，通过在每层添加两行和 256 个神经元，我们将精度提高到 0.936。我们鼓励您尝试使用不同变量值的代码来观察它如何影响损失和准确性。
+因此，通过在每层添加两行和 256 个神经元，我们将精度提高到 0.936。我们鼓励您尝试使用不同变量值的代码来观察它如何影响损失和准确率。
 
 # 用于 MNIST 分类的基于 Keras 的 MLP
 
@@ -492,7 +492,7 @@ model.fit(X_train, Y_train,
    epochs=n_epochs)
 ```
 
-在训练模型时，我们可以观察每次训练迭代的损失和准确性：
+在训练模型时，我们可以观察每次训练迭代的损失和准确率：
 
 ```py
 Epoch 1/50
@@ -520,7 +520,7 @@ Epoch 50/50
 55000/55000 [========================] - 4s - loss: 0.0627 - acc: 0.9829 
 ```
 
-1.  评估模型并打印损失和准确性：
+1.  评估模型并打印损失和准确率：
 
 ```py
 score = model.evaluate(X_test, Y_test)
@@ -620,13 +620,13 @@ Test accuracy: 0.9637
 
 # 使用 TensorFlow，Keras 和 TFLearn 的 MLP 摘要
 
-在前面的部分中，我们学习了如何使用 TensorFLow 及其高级库构建简单的 MLP 架构。纯 TensorFlow 的准确率约为 0.93-0.94，Keras 的准确率为 0.96-0.98，TFLearn 的准确率为 0.96-0.97。尽管我们的代码的所有示例都使用下面的 TensorFlow，但相同体系结构和参数的准确性差异可归因于这样的事实：尽管我们初始化了一些重要的超参数，但高级库和 TensorFlow 却抽象了许多其他超级 - 我们没有从默认值修改的参数。
+在前面的部分中，我们学习了如何使用 TensorFLow 及其高级库构建简单的 MLP 架构。纯 TensorFlow 的准确率约为 0.93-0.94，Keras 的准确率为 0.96-0.98，TFLearn 的准确率为 0.96-0.97。尽管我们的代码的所有示例都使用下面的 TensorFlow，但相同体系结构和参数的准确率差异可归因于这样的事实：尽管我们初始化了一些重要的超参数，但高级库和 TensorFlow 却抽象了许多其他超级 - 我们没有从默认值修改的参数。
 
 我们观察到，与 Keras 和 TFLearn 相比，TensorFlow 中的代码非常详细和冗长。高级库使我们更容易构建和训练神经网络模型。
 
 # 用于时间序列回归的 MLP
 
-我们已经看到了图像数据分类的例子;现在让我们看一下时间序列数据的回归。我们将建立并使用 MLP 作为一个较小的单变量时间序列数据集，称为国际航空公司乘客数据集。该数据集包含多年来的乘客总数。该数据集可从此链接获得：
+我们已经看到了图像数据分类的例子；现在让我们看一下时间序列数据的回归。我们将建立并使用 MLP 作为一个较小的单变量时间序列数据集，称为国际航空公司乘客数据集。该数据集包含多年来的乘客总数。该数据集可从此链接获得：
 
 *   <https://www.kaggle.com/andreazzini/international-airline-passengers/data>
 *   <https://datamarket.com/data/set/22u3/international-airline-passengers-monthly-totals-in-thousands-jan-49-dec-60>

docs/mastering-tf-1x-zh/ch06.md

@@ -211,8 +211,8 @@ J. Chung, C. Gulcehre, K. Cho, and Y. Bengio, Empirical Evaluation of Gated Recu
 | --- | --- |
 | BasicRNNCell | 提供 RNN 单元的实现 |
 | BasicLSTMCell | 提供 LSTM RNN 单元的实现，基于[这个页面](http://arxiv.org/abs/1409.2329) |
-| LSTMCell | 提供  LSTM RNN 单元，基于[这个页面](http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf)和[这个页面](https://research.google.com/pubs/archive/43905.pdf) |
-| GRUCell | 提供  GRU RNN 单元，基于[这个页面](http://arxiv.org/abs/1406.1078) |
+| LSTMCell | 提供 LSTM RNN 单元，基于[这个页面](http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf)和[这个页面](https://research.google.com/pubs/archive/43905.pdf) |
+| GRUCell | 提供 GRU RNN 单元，基于[这个页面](http://arxiv.org/abs/1406.1078) |
 | MultiRNNCell | 提供由连续连接的多个简单单元组成的 RNN 单元 |
 
 `tf.contrib.rnn` 模块提供以下额外的类用于在 TensorFlow 中创建不同类型的单元：
@@ -221,12 +221,12 @@ J. Chung, C. Gulcehre, K. Cho, and Y. Bengio, Empirical Evaluation of Gated Recu
 | --- | --- |
 | LSTMBlockCell | 提供块 LSTM RNN 单元，基于[这个页面](http://arxiv.org/abs/1409.2329) |
 | LSTMBlockFusedCell | 提供块融合 LSTM RNN 单元，基于[这个页面](http://arxiv.org/abs/1409.2329) |
-| GLSTMCell | 根据[这个页面](https://arxiv.org/abs/1703.10722)提供组 LSTM 单元 |
+| GLSTMCell | 提供分组 LSTM 单元，基于[这个页面](https://arxiv.org/abs/1703.10722) |
 | GridLSTMCell | 提供网格 LSTM RNN 单元，基于[这个页面](http://arxiv.org/abs/1507.01526) |
 | GRUBlockCell | 提供块 GRU RNN 单元，基于[这个页面](http://arxiv.org/abs/1406.1078) |
 | BidirectionalGridLSTMCell | 仅在频率上而不是在时间上提供双向网格 LSTM |
 | NASCell | 提供神经架构搜索 RNN 单元，基于[这个页面](https://arxiv.org/abs/1611.01578) |
-| UGRNNCell | 提供更新门 RNN 信元，基于[这个页面](https://arxiv.org/abs/1611.09913) |
+| UGRNNCell | 提供更新门 RNN 单元，基于[这个页面](https://arxiv.org/abs/1611.09913) |
 
 # TensorFlow RNN 模型构建类
 
@@ -358,7 +358,7 @@ Non-trainable params: 0
 _________________________________________________________________
 ```
 
-训练模型并打印测试数据集的准确性：
+训练模型并打印测试数据集的准确率：
 
 ```py
 model.fit(X_train, Y_train,

docs/mastering-tf-1x-zh/ch07.md

@@ -104,13 +104,13 @@ n_x=1
 n_y=1 
 ```
 
-1.  设置用于学习的`x`变量的数量;由于当前示例是单变量的，因此设置为 1：
+1.  设置用于学习的`x`变量的数量；由于当前示例是单变量的，因此设置为 1：
 
 ```py
 n_x_vars = 1  
 ```
 
-1.  设置要预测的`y`变量的数量;由于当前示例是单变量的，因此设置为 1：
+1.  设置要预测的`y`变量的数量；由于当前示例是单变量的，因此设置为 1：
 
 ```py
 n_y_vars = 1  
@@ -194,7 +194,7 @@ predictions = [tf.matmul(rnn_output, W) + b \
                 for rnn_output in rnn_outputs]
 ```
 
-1.  输出 Y 是 Tensors 的形状;将其转换为张量列表：
+1.  输出 Y 是 Tensors 的形状；将其转换为张量列表：
 
 ```py
 y_as_list = tf.unstack(Y_p, num=n_timesteps, axis=1)
@@ -457,7 +457,7 @@ Test Score: 54.13 RMSE
 
 ![](img/93bcf886-fc39-4e77-8fa0-d72af7ac310b.png)
 
-我们可以看到，这不像我们在 TensorFlow 部分得到的那样完美;但是，这种差异是因为超参数值。我们留给您尝试不同的超参数值来调整此 Keras 模型以获得更好的结果。
+我们可以看到，这不像我们在 TensorFlow 部分得到的那样完美；但是，这种差异是因为超参数值。我们留给您尝试不同的超参数值来调整此 Keras 模型以获得更好的结果。
 
 # 使用 Keras 的 LSTM
 

docs/mastering-tf-1x-zh/ch08.md

@@ -919,7 +919,7 @@ optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
             .minimize(loss)
 ```
 
-1.  创建我们可以在会话块中运行的准确率函数，以检查训练模式的准确性：
+1.  创建我们可以在会话块中运行的准确率函数，以检查训练模式的准确率：
 
 ```py
 n_correct_pred = tf.equal(tf.argmax(y_out,1), tf.argmax(y_p,1))
@@ -1029,7 +1029,7 @@ Epoch 999, Average loss:0.23202441136042276, Average accuracy:0.9602864583333334
   First 5 prediction: labour spanish they they they movement movement anarcho anarcho two
 ```
 
-生成的文本中的重复单词是常见的，并且应该更好地训练模型。虽然模型的准确性提高到 96%，但仍然不足以生成清晰的文本。尝试增加 LSTM 单元/隐藏层的数量，同时在较大的数据集上运行模型以获取大量周期。
+生成的文本中的重复单词是常见的，并且应该更好地训练模型。虽然模型的准确率提高到 96%，但仍然不足以生成清晰的文本。尝试增加 LSTM 单元/隐藏层的数量，同时在较大的数据集上运行模型以获取大量周期。
 
 现在让我们在 Keras 建立相同的模型：
 

docs/mastering-tf-1x-zh/ch09.md

@@ -363,7 +363,7 @@ Model Trained.
 Accuracy: 0.9884
 ```
 
-现在，与我们在前几章中看到的方法相比，这是一个非常好的准确性。从图像数据中学习 CNN 模型是不是很神奇？
+现在，与我们在前几章中看到的方法相比，这是一个非常好的准确率。从图像数据中学习 CNN 模型是不是很神奇？
 
 # 使用 Keras 的用于 MNIST 的 LeNet CNN
 
@@ -510,7 +510,7 @@ Test loss: 0.0628845927377
 Test accuracy: 0.9785
 ```
 
-准确性的差异可归因于我们在这里使用 SGD 优化器这一事实，它没有实现我们用于 TensorFlow 模型的`AdamOptimizer`提供的一些高级功能。
+准确率的差异可归因于我们在这里使用 SGD 优化器这一事实，它没有实现我们用于 TensorFlow 模型的`AdamOptimizer`提供的一些高级功能。
 
 # 用于 CIFAR10 数据的 LeNet
 
@@ -584,7 +584,7 @@ Model Trained.
 Accuracy: 0.6361
 ```
 
-与我们在 MNIST 数据上获得的准确率相比，我们没有获得良好的准确性。通过调整不同的超参数并改变卷积和池化层的组合，可以实现更好的准确性。我们将其作为挑战，让读者探索并尝试不同的 LeNet 架构和超参数变体，以实现更高的准确性。
+与我们在 MNIST 数据上获得的准确率相比，我们没有获得良好的准确率。通过调整不同的超参数并改变卷积和池化层的组合，可以实现更好的准确率。我们将其作为挑战，让读者探索并尝试不同的 LeNet 架构和超参数变体，以实现更高的准确率。
 
 # 使用 Keras 的用于 CIFAR10 的 ConvNets
 
@@ -655,7 +655,7 @@ Test loss: 0.849927025414
 Test accuracy: 0.7414
 ```
 
-再次，我们将其作为挑战，让读者探索并尝试不同的 LeNet 架构和超参数变体，以实现更高的准确性。
+再次，我们将其作为挑战，让读者探索并尝试不同的 LeNet 架构和超参数变体，以实现更高的准确率。
 
 # 总结
 

docs/mastering-tf-1x-zh/ch10.md

@@ -324,7 +324,7 @@ Epoch 20/20
 
 ![](img/2f99a937-f842-4d85-96ad-1c41e2e5d396.png)
 
-这是我们在能够从 256 个特征生成图像时实现的非常好的准确性。
+这是我们在能够从 256 个特征生成图像时实现的非常好的准确率。
 
 # TensorFlow 中的去噪自编码器
 
@@ -356,7 +356,7 @@ _,batch_loss = tfs.run([optimizer,loss], feed_dict=feed_dict)
 
 笔记本 `ch-10_AutoEncoders_TF_and_Keras`中提供了去噪自编码器的完整代码。
 
-现在让我们首先显示从 DAE 模型生成的测试图像;第一行表示原始的非噪声测试图像，第二行表示生成的测试图像：
+现在让我们首先显示从 DAE 模型生成的测试图像；第一行表示原始的非噪声测试图像，第二行表示生成的测试图像：
 
 ```py
 display_images(test_images.reshape(-1,pixel_size,pixel_size),test_labels)

docs/mastering-tf-1x-zh/ch11.md

@@ -133,7 +133,7 @@ saver = tf.train.Saver({'weights': w})
 
 变量名称可以作为列表或字典传递。如果变量名称作为列表传递，则列表中的每个变量将以其自己的名称保存。变量也可以作为由键值对组成的字典传递，其中键是用于保存的名称，值是要保存的变量的名称。
 
-以下是我们刚看到的示例的代码，但这次我们只保存`w`变量的权重;保存时将其命名为`weights`：
+以下是我们刚看到的示例的代码，但这次我们只保存`w`变量的权重；保存时将其命名为`weights`：
 
 ```py
 # Saving selected variables in a graph in TensorFlow
@@ -369,7 +369,7 @@ y_p = tf.placeholder(dtype=tf.float32, name="y_p",
         shape=[None, num_outputs])
 ```
 
-1.  创建模型，以及损失，优化器，准确性和训练函数：
+1.  创建模型，以及损失，优化器，准确率和训练函数：
 
 ```py
 num_layers = 2

docs/mastering-tf-1x-zh/ch12.md

@@ -94,10 +94,10 @@ inet.load_data(n_classes=1000)
 | **模型名称** | **Top-1 准确率** | **Top-5 准确率** | **Top-5 错误率** | **原始文件的链接** |
 | --- | --- | --- | --- | --- |
 | AlexNet |  |  | 15.3% | <https://www.cs.toronto.edu/~fritz/absps/imagenet.pdf> |
-| 盗梦空间也称为 Inception V1 | 69.8 | 89.6 | 6.67% | <https://arxiv.org/abs/1409.4842> |
-| BN-启-V2 也称为 Inception V2 | 73.9 | 91.8 | 4.9% | <https://arxiv.org/abs/1502.03167> |
+| Inception 也称为 Inception V1 | 69.8 | 89.6 | 6.67% | <https://arxiv.org/abs/1409.4842> |
+| BN-Inception-V2 也称为 Inception V2 | 73.9 | 91.8 | 4.9% | <https://arxiv.org/abs/1502.03167> |
 | Inception v3 | 78.0 | 93.9 | 3.46% | <https://arxiv.org/abs/1512.00567> |
-| 成立 V4 | 80.2 | 95.2 |  | <http://arxiv.org/abs/1602.07261> |
+| Inception V4 | 80.2 | 95.2 |  | <http://arxiv.org/abs/1602.07261> |
 | Inception-Resnet-V2 | 80.4 | 95.2 |  | <http://arxiv.org/abs/1602.07261> |
 | VGG16 | 71.5 | 89.8 | 7.4% | <https://arxiv.org/abs/1409.1556> |
 | VGG19 | 71.1 | 89.8 | 7.3% | <https://arxiv.org/abs/1409.1556> |
@@ -109,11 +109,11 @@ inet.load_data(n_classes=1000)
 | ResNet V2 152 | 77.8 | 94.1 |  | <https://arxiv.org/abs/1603.05027> |
 | ResNet V2 200 | 79.9 | 95.2 |  | <https://arxiv.org/abs/1603.05027> |
 | Xception | 79.0 | 94.5 |  | <https://arxiv.org/abs/1610.02357> |
-| MobileNet V1 版本 | 41.3 至 70.7 | 66.2 至 89.5 |  | <https://arxiv.org/pdf/1704.04861.pdf> |
+| MobileNet V1 | 41.3 至 70.7 | 66.2 至 89.5 |  | <https://arxiv.org/pdf/1704.04861.pdf> |
 
 在上表中，Top-1 和 Top-5 指标指的是模型在 ImageNet 验证数据集上的表现。
 
-Google Research 最近发布了一种名为 MobileNets 的新模型。 MobileNets 采用移动优先策略开发，牺牲了低资源使用的准确性。 MobileNets 旨在消耗低功耗并提供低延迟，以便在移动和嵌入式设备上提供更好的体验。谷歌为 MobileNet 模型提供了 16 个预训练好的检查点文件，每个模型提供不同数量的参数和**乘法累加**（**MAC**）。 MAC 和参数越高，资源使用和延迟就越高。因此，您可以在更高的准确性与更高的资源使用/延迟之间进行选择。
+Google Research 最近发布了一种名为 MobileNets 的新模型。 MobileNets 采用移动优先策略开发，牺牲了低资源使用的准确率。 MobileNets 旨在消耗低功耗并提供低延迟，以便在移动和嵌入式设备上提供更好的体验。谷歌为 MobileNet 模型提供了 16 个预训练好的检查点文件，每个模型提供不同数量的参数和**乘法累加**（**MAC**）。 MAC 和参数越高，资源使用和延迟就越高。因此，您可以在更高的准确率与更高的资源使用/延迟之间进行选择。
 
 | **模型检查点** | **百万 MAC** | **百万参数** | **Top-1 准确率** | **Top-5 准确率** |
 | --- | --- | --- | --- | --- |

docs/mastering-tf-1x-zh/ch13.md

@@ -213,7 +213,7 @@ def policy_random(env,obs):
   return env.action_space.sample()
 ```
 
-1.  接下来，我们定义一个将针对特定数量的剧集运行的实验函数;每一集一直持续到游戏损失，即`done`为`True`。我们使用`rewards_max`来指示何时突破循环，因为我们不希望永远运行实验：
+1.  接下来，我们定义一个将针对特定数量的剧集运行的实验函数；每一集一直持续到游戏损失，即`done`为`True`。我们使用`rewards_max`来指示何时突破循环，因为我们不希望永远运行实验：
 
 ```py
 def experiment(policy, n_episodes, rewards_max):
@@ -854,7 +854,7 @@ experiment(env, policy_q_nn, n_episodes)
 Policy:policy_q_nn, Min reward:8.0, Max reward:150.0, Average reward:41.27
 ```
 
-我们在每一步计算和训练模型;您可能希望在剧集之后探索将其更改为训练。此外，您可以更改代码以丢弃内存重放，并为返回较小奖励的剧集再训练模型。但是，请谨慎实现此选项，因为它可能会减慢您的学习速度，因为初始游戏会更频繁地产生较小的奖励。
+我们在每一步计算和训练模型；您可能希望在剧集之后探索将其更改为训练。此外，您可以更改代码以丢弃内存重放，并为返回较小奖励的剧集再训练模型。但是，请谨慎实现此选项，因为它可能会减慢您的学习速度，因为初始游戏会更频繁地产生较小的奖励。
 
 # 总结
 

docs/mastering-tf-1x-zh/ch14.md

@@ -50,14 +50,14 @@ GAN 已成功应用于各种复杂问题，例如：
 | **GAN 衍生物** | **原始文件** | **示例应用** |
 | --- | --- | --- |
 | StackGAN | <https://arxiv.org/abs/1710.10916> | 文字到图像 |
-| StackGAN ++ | <https://arxiv.org/abs/1612.03242> | 逼真的图像合成 |
+| StackGAN++ | <https://arxiv.org/abs/1612.03242> | 逼真的图像合成 |
 | DCGAN | <https://arxiv.org/abs/1511.06434> | 图像合成 |
 | HR-DCGAN | <https://arxiv.org/abs/1711.06491> | 高分辨率图像合成 |
-| 有条件的 GAN | <https://arxiv.org/abs/1411.1784> | 图像标记 |
+| 条件 GAN | <https://arxiv.org/abs/1411.1784> | 图像标记 |
 | InfoGAN | <https://arxiv.org/abs/1606.03657> | 风格识别 |
 | Wasserstein GAN | <https://arxiv.org/abs/1701.07875> <https://arxiv.org/abs/1704.00028> | 图像生成 |
 | 耦合 GAN | <https://arxiv.org/abs/1606.07536> | 图像转换，域适应 |
-| BEGAN | <https://arxiv.org/abs/1703.10717> | 图像合成 |
+| BEGAN | <https://arxiv.org/abs/1703.10717> | 图像生成 |
 | DiscoGAN | <https://arxiv.org/abs/1703.05192> | 风格迁移 |
 | CycleGAN | <https://arxiv.org/abs/1703.10593> | 风格迁移 |
 

docs/mastering-tf-1x-zh/ch15.md

@@ -368,7 +368,7 @@ worker=2,epoch=49,global_step=82499, local_step=27500, loss = 0.4170967936515808
 worker=2, final accuracy = 0.8894000053405762
 ```
 
-我们打印了全球步骤和本地步骤。全局步骤表示所有工作器任务的步数，而本地步骤是该工作器任务中的计数，这就是为什么本地任务计数高达 27,500 并且每个工作器的每个周期都相同，但是因为工作器正在做按照自己的步伐采取全球性措施，全球步骤的数量在周期或工作器之间没有对称性或模式。此外，我们发现每个工作器的最终准确率是不同的，因为每个工作器在不同的时间执行最终的准确性，当时有不同的参数。
+我们打印了全球步骤和本地步骤。全局步骤表示所有工作器任务的步数，而本地步骤是该工作器任务中的计数，这就是为什么本地任务计数高达 27,500 并且每个工作器的每个周期都相同，但是因为工作器正在做按照自己的步伐采取全球性措施，全球步骤的数量在周期或工作器之间没有对称性或模式。此外，我们发现每个工作器的最终准确率是不同的，因为每个工作器在不同的时间执行最终的准确率，当时有不同的参数。
 
 # 定义并训练图以进行同步更新
 

docs/mastering-tf-1x-zh/ch17.md

@@ -48,15 +48,15 @@ install_tensorflow()
 | --- | --- |
 | `auto` | 自动选择当前平台的默认值 |
 | `virtualenv` | 安装到位于`~/.virtualenvs/r-tensorflow`的虚拟环境中 |
-| `conda` | 安装到名为 r-tensorflow 的 Anaconda Python 环境中 |
+| `conda` | 安装到名为`r-tensorflow`的 Anaconda Python 环境中 |
 | `system` | 安装到系统 Python 环境中 |
 
 1.  默认情况下，安装功能会安装仅限 CPU 的 TensorFlow 版本。要安装 GPU 版本，请使用版本参数：
 
 | | |
 | --- | --- |
-| `gpu` | 安装 tensorflow-gpu |
-| `nightly` | 安装每晚仅限 CPU 的版本 |
+| `gpu` | 安装`tensorflow-gpu` |
+| `nightly` | 安装每晚 CPU 的版本 |
 | `nightly-gpu` | 安装每晚 GPU 构建 |
 | `n.n.n` | 安装特定版本，例如 1.3.0 |
 | `n.n.n-gpu` | 安装特定版本的 GPU 版本，例如 1.3.0 |
@@ -313,7 +313,7 @@ evaluate(classifier,input_fn=mnist_input_fn(mnist$test),steps=200)
 Evaluation completed after 79 steps but 200 steps was specified
 ```
 
-| average_loss | 损失 | global_step | 准确性 |
+| average_loss | 损失 | global_step | 准确率 |
 | --- | --- | --- | --- |
 | 0.35656 | 45.13418 | 100 | 0.9057 |
 

docs/mastering-tf-1x-zh/ch18.md

@@ -46,8 +46,8 @@ tf.Print(
 *   `input_`是一个从函数返回的张量，没有任何操作
 *   `data`是要打印的张量列表
 *   `message`是一个字符串，它作为打印输出的前缀打印出来
-*   `first_n`表示打印输出的步骤数;如果此值为负，则只要执行路径，就始终打印该值
-*   `summarize`表示从张量打印的元素数量;默认情况下，仅打印三个元素
+*   `first_n`表示打印输出的步骤数；如果此值为负，则只要执行路径，就始终打印该值
+*   `summarize`表示从张量打印的元素数量；默认情况下，仅打印三个元素
 
 您可以按照 Jupyter 笔记本中的代码`ch-18_TensorFlow_Debugging`。