From 8b3e57484a844dab16f1cca6df0234727cbd77f1 Mon Sep 17 00:00:00 2001
From: wizardforcel <562826179@qq.com>
Date: Thu, 6 Aug 2020 15:04:12 +0800
Subject: [PATCH] 2020-08-06 15:04:11

---
 docs/mastering-tf-1x-zh/ch01.md |  8 ++++----
 docs/mastering-tf-1x-zh/ch02.md |  8 ++++----
 docs/mastering-tf-1x-zh/ch03.md |  2 +-
 docs/mastering-tf-1x-zh/ch04.md |  2 +-
 docs/mastering-tf-1x-zh/ch05.md |  4 ++--
 docs/mastering-tf-1x-zh/ch06.md |  8 ++++----
 docs/mastering-tf-1x-zh/ch07.md |  2 +-
 docs/mastering-tf-1x-zh/ch08.md | 10 +++++-----
 docs/mastering-tf-1x-zh/ch09.md |  2 +-
 docs/mastering-tf-1x-zh/ch10.md |  2 +-
 docs/mastering-tf-1x-zh/ch11.md | 10 +++++-----
 docs/mastering-tf-1x-zh/ch12.md |  4 ++--
 docs/mastering-tf-1x-zh/ch13.md |  4 ++--
 docs/mastering-tf-1x-zh/ch15.md |  6 +++---
 docs/mastering-tf-1x-zh/ch16.md |  8 ++++----
 docs/mastering-tf-1x-zh/ch17.md | 26 +++++++++++++-------------
 docs/mastering-tf-1x-zh/ch19.md |  2 +-
 17 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/docs/mastering-tf-1x-zh/ch01.md b/docs/mastering-tf-1x-zh/ch01.md
index 6ca41034..fbba76eb 100644
--- a/docs/mastering-tf-1x-zh/ch01.md
+++ b/docs/mastering-tf-1x-zh/ch01.md
@@ -68,7 +68,7 @@ import tensorflow as tf
 tfs = tf.InteractiveSession()
 ```
 
-`Session()`和`InteractiveSession()`之间的唯一区别是用`InteractiveSession()`创建的会话成为默认会话。因此，我们不需要指定会话上下文以便稍后执行与会话相关的命令。例如，假设我们有一个会话对象`tfs`和一个常量对象`hello`。如果`tfs`是一个`InteractiveSession()`对象，那么我们可以使用代码`hello.eval()`来评估`hello`。如果`tfs`是`Session()`对象，那么我们必须使用`tfs.hello.eval()`或`with`块。最常见的做法是使用`with`块，这将在本章后面介绍。
+`Session()`和`InteractiveSession()`之间的唯一区别是用`InteractiveSession()`创建的会话成为默认会话。因此，我们不需要指定会话上下文以便稍后执行与会话相关的命令。例如，假设我们有一个会话对象`tfs`和一个常量对象`hello`。如果`tfs`是一个`InteractiveSession()`对象，那么我们可以使用代码`hello.eval()`来求值`hello`。如果`tfs`是`Session()`对象，那么我们必须使用`tfs.hello.eval()`或`with`块。最常见的做法是使用`with`块，这将在本章后面介绍。
 
 1.  定义 TensorFlow 常量，`hello`：
 
@@ -136,7 +136,7 @@ print(tfs.run(hello))
 
 可以通过以下方式创建张量：
 
-*   通过定义常量，操作和变量，并将值传递给它们的构造函数。
+*   通过定义常量，操作和变量，并将值传递给它们的构造器。
 *   通过定义占位符并将值传递给`session.run()`。
 *   通过`tf.convert_to_tensor()`函数转换 Python 对象，如标量值，列表和 NumPy 数组。
 
@@ -526,7 +526,7 @@ run(y,{x:[1,2,3,4]}) :  [ 0\.          0.30000001  0.60000002  0.90000004]
 
 # 从库函数生成的张量
 
-张量也可以从各种 TensorFlow 函数生成。这些生成的张量可以分配给常量或变量，也可以在初始化时提供给它们的构造函数。
+张量也可以从各种 TensorFlow 函数生成。这些生成的张量可以分配给常量或变量，也可以在初始化时提供给它们的构造器。
 
 例如，以下代码生成 100 个零的向量并将其打印出来：
 
@@ -766,7 +766,7 @@ graph = tf.get_default_graph()
 
 在 TensorFlow 中，前一图像中的添加操作将对应于代码`y = tf.add( x1 + x2 + x3 )`。
 
-在我们创建变量，常量和占位符时，它们会添加到图中。然后我们创建一个会话对象，以执行操作对象，评估张量对象。
+在我们创建变量，常量和占位符时，它们会添加到图中。然后我们创建一个会话对象，以执行操作对象，求值张量对象。
 
 让我们构建并执行一个计算图来计算`y = w × x + b`，正如我们在前面的例子中已经看到的那样：
 
diff --git a/docs/mastering-tf-1x-zh/ch02.md b/docs/mastering-tf-1x-zh/ch02.md
index 72e17067..9e637da9 100644
--- a/docs/mastering-tf-1x-zh/ch02.md
+++ b/docs/mastering-tf-1x-zh/ch02.md
@@ -17,7 +17,7 @@ TensorFlow 有几个高级库和接口（API），允许我们使用 TFLearn，T
 
 # TFEstimator - 以前的 TF 学习
 
-TFEstimator 是一个高级 API，通过封装训练，评估，预测和导出函数，可以轻松创建和训练模型。 TensorFlow 最近重新命名并在 TensorFlow 中以新名称 TFEstimator 发布了 TFLearn 软件包，可能是为了避免与 tflearn.org 的 TFLearn 软件包混淆。 TFEstimator API 对原始 TF 学习包进行了重大改进，这些包在 KDD 17 会议上提供的研究论文中有所描述，[可以在此链接中找到](https://doi.org/10.1145/3097983.3098171)。
+TFEstimator 是一个高级 API，通过封装训练，评估，预测和导出函数，可以轻松创建和训练模型。 TensorFlow 最近重新命名并在 TensorFlow 中以新名称 TFEstimator 发布了 TFLearn 包，可能是为了避免与 tflearn.org 的 TFLearn 包混淆。 TFEstimator API 对原始 TF 学习包进行了重大改进，这些包在 KDD 17 会议上提供的研究论文中有所描述，[可以在此链接中找到](https://doi.org/10.1145/3097983.3098171)。
 
 TFEstimator 接口设计灵感来自流行的机器学习库 SciKit Learn，允许从不同类型的可用模型创建估计器对象，然后在任何类型的估计器上提供四个主要函数：
 
@@ -101,7 +101,7 @@ TFSlim 是一个基于 TensorFlow 核心构建的轻量级库，用于定义和
 python3 -c 'import tensorflow.contrib.slim as slim; eval = slim.evaluation.evaluate_once'
 ```
 
-TFSlim 提供了几个模块，可以独立挑选和应用，并与其他 TensorFlow 软件包混合使用。例如，在撰写本书时，TFSlim 有以下主要模块：
+TFSlim 提供了几个模块，可以独立挑选和应用，并与其他 TensorFlow 包混合使用。例如，在撰写本书时，TFSlim 有以下主要模块：
 
 | TFSlim 模块 | 模块说明 |
 | --- | --- |
@@ -157,7 +157,7 @@ final loss=1.6131552457809448
 
 TFLearn 是 Python 中的模块化库，它构建在核心 TensorFlow 之上。
 
-TFLearn 与 TensorFlow Learn 软件包不同，后者也称为 TFLearn（TF 和 Learn 之间有一个空格）。[TFLearn 可从此链接获得](http://tflearn.org)，[源代码可在 GitHub 上的此链接获得](https://github.com/tflearn/tflearn)。
+TFLearn 与 TensorFlow Learn 包不同，后者也称为 TFLearn（TF 和 Learn 之间有一个空格）。[TFLearn 可从此链接获得](http://tflearn.org)，[源代码可在 GitHub 上的此链接获得](https://github.com/tflearn/tflearn)。
 
 可以使用以下命令在 Python 3 中安装 TFLearn：
 
@@ -514,7 +514,7 @@ pip3 install dm-sonnet
 
 在 Sonnet 库中构建模型的工作流程如下：
 
-1.  为从`sonnet.AbstractModule`继承的数据集和网络体系结构创建类。在我们的示例中，我们创建了一个 MNIST 类和一个 MLP 类。
+1.  为从`sonnet.AbstractModule`继承的数据集和网络架构创建类。在我们的示例中，我们创建了一个 MNIST 类和一个 MLP 类。
 2.  定义参数和超参数。
 3.  从上一步中定义的数据集类定义测试和训练数据集。
 4.  使用定义的网络类定义模型。例如，在我们的案例中，`model = MLP([20, n_classes])`创建了一个 MLP 网络，其中包含两层 20 和每个神经元`n_classes`的数量。
diff --git a/docs/mastering-tf-1x-zh/ch03.md b/docs/mastering-tf-1x-zh/ch03.md
index f420954f..d4a53df7 100644
--- a/docs/mastering-tf-1x-zh/ch03.md
+++ b/docs/mastering-tf-1x-zh/ch03.md
@@ -70,7 +70,7 @@ model = Sequential()
 
 您现在可以将层添加到此模型中，我们将在下一节中看到。
 
-或者，您也可以将所有层作为列表传递给构造函数。例如，我们通过使用以下代码将它们传递给构造函数来添加四个层：
+或者，您也可以将所有层作为列表传递给构造器。例如，我们通过使用以下代码将它们传递给构造器来添加四个层：
 
 ```py
 model = Sequential([ Dense(10, input_shape=(256,)), 
diff --git a/docs/mastering-tf-1x-zh/ch04.md b/docs/mastering-tf-1x-zh/ch04.md
index c0af572e..ac3e84fc 100644
--- a/docs/mastering-tf-1x-zh/ch04.md
+++ b/docs/mastering-tf-1x-zh/ch04.md
@@ -328,7 +328,7 @@ plt.show()
 
 这基本上表明该模型以 R 的平均值开始，但随着模型的训练并减少误差，R 平方的值开始变高，最终在某一点变得稳定略高于 0.6。
 
-绘制 MSE 和 R 平方可以让我们看到我们的模型得到多快的训练以及它开始变得稳定的地方，以便进一步的训练在减少错误方面产生微不足道的好处或几乎没有好处。
+绘制 MSE 和 R 平方可以让我们看到我们的模型得到多快的训练以及它开始变得稳定的地方，以便进一步的训练在减少误差方面产生微不足道的好处或几乎没有好处。
 
 # 使用训练的模型进行预测
 
diff --git a/docs/mastering-tf-1x-zh/ch05.md b/docs/mastering-tf-1x-zh/ch05.md
index 4d04c868..945a3efc 100644
--- a/docs/mastering-tf-1x-zh/ch05.md
+++ b/docs/mastering-tf-1x-zh/ch05.md
@@ -620,7 +620,7 @@ 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 中的代码非常详细和冗长。高级库使我们更容易构建和训练神经网络模型。
 
@@ -755,5 +755,5 @@ plt.show()
 
 构建和训练 MLP 网络模型的技术对于任何其他类型的数据（例如数字或文本）是相同的。然而，对于图像数据集，CNN 架构已被证明是最佳架构，对于序列数据集，例如时间序列和文本，RNN 模型已被证明是最佳架构。
 
-虽然我们在本章中仅使用简单的数据集示例来演示 MLP 体系结构，但在后面的章节中，我们将介绍具有一些大型和高级数据集的 CNN 和 RNN 体系结构。
+虽然我们在本章中仅使用简单的数据集示例来演示 MLP 架构，但在后面的章节中，我们将介绍具有一些大型和高级数据集的 CNN 和 RNN 架构。
 
diff --git a/docs/mastering-tf-1x-zh/ch06.md b/docs/mastering-tf-1x-zh/ch06.md
index 6aedb138..90a3c2af 100644
--- a/docs/mastering-tf-1x-zh/ch06.md
+++ b/docs/mastering-tf-1x-zh/ch06.md
@@ -77,7 +77,7 @@ RNN 架构已经以多种方式扩展，以适应某些问题中的额外需求
 *   **双向 RNN**（**BRNN**）用于输出依赖于序列的前一个和后一个元素的情况。 BRNN 通过堆叠两个 RNN（称为前向和后向层）来实现，输出是前向和后向层 RNN 的隐藏状态的结果。在前向层中，存储器状态 h 从时间步长`t`流向时间步长`t + 1`，并且在后向层中，存储器状态从时间步长`t`流出。到时间步`t-1`。两个层在时间步`t`时采用相同的输入`x[t]`，但它们在时间步`t`共同产生输出。
 
 *   **深双向 RNN**（**DBRNN**）通过添加多个层进一步扩展 BRNN。 BRNN 在时间维度上隐藏了层或单元。但是，通过堆叠 BRNN，我们可以在 DBRNN 中获得分层表示。其中一个显着差异是，在 BRNN 中，我们对同一层中的每个单元使用相同的参数，但在 DBRNN 中，我们对每个堆叠层使用不同的参数。
-*   **长短期记忆**（**LSTM**）网络通过使用涉及多个非线性函数而不是一个简单非线性函数的架构来扩展 RNN 隐藏状态。 LSTM 由称为**单元**的黑盒组成，取三个输入：时间`t-1`的工作记忆（`h[t-1]`），当前输入（`x[t]`）和时间`t-1`的长期记忆（`c[t-1]`），并产生两个输出：更新的工作记忆（`h[t]`）和长期记忆（`c[t]`）。单元使用称为门的功能来决定从记忆中选择性地保存和擦除的内容。我们在下面的部分中详细描述了 LSTM。
+*   **长短期记忆**（**LSTM**）网络通过使用涉及多个非线性函数而不是一个简单非线性函数的架构来扩展 RNN 隐藏状态。 LSTM 由称为**单元**的黑盒组成，取三个输入：时间`t-1`的工作记忆（`h[t-1]`），当前输入（`x[t]`）和时间`t-1`的长期记忆（`c[t-1]`），并产生两个输出：更新的工作记忆（`h[t]`）和长期记忆（`c[t]`）。单元使用称为门的函数来决定从记忆中选择性地保存和擦除的内容。我们在下面的部分中详细描述了 LSTM。
 
 阅读以下关于 LSTM 的研究论文，以获得有关 LSTM 起源的更多信息：
 
@@ -85,7 +85,7 @@ RNN 架构已经以多种方式扩展，以适应某些问题中的额外需求
 S. Hochreiter and J. Schmidhuber, Long Short-Term Memory, Neural Comput., vol. 9, no. 8, pp. 1735–1780, 1997.http://www.bioinf.jku.at/publications/older/2604.pdf
 ```
 
-*   **门控递归单元**（**GRU**）网络是 LSTM 的简化变体。 结合遗忘和输入的功能，在更简单的更新门中进行门控。它还将隐藏状态和单元状态组合成一个单一状态。因此，与 LSTM 相比，GRU 在计算上更便宜。 我们在下面的部分中详细描述了 GRU。
+*   **门控循环单元**（**GRU**）网络是 LSTM 的简化变体。 结合遗忘和输入的功能，在更简单的更新门中进行门控。它还将隐藏状态和单元状态组合成一个单一状态。因此，与 LSTM 相比，GRU 在计算上更便宜。 我们在下面的部分中详细描述了 GRU。
 
 阅读以下研究论文以探索 GRU 的更多细节：
 
@@ -107,7 +107,7 @@ J. Chung, C. Gulcehre, K. Cho, and Y. Bengio, Empirical Evaluation of Gated Recu
 S. Hochreiter and J. Schmidhuber, Long Short-Term Memory, Neural Comput., vol. 9, no. 8, pp. 1735–1780, 1997. http://www.bioinf.jku.at/publications/older/2604.pdf
 ```
 
-在 RNN 中，使用重复使用的学习函数`φ`的单个神经网络层，而在 LSTM 中，使用由四个主要函数组成的重复模块。构建 LSTM 网络的模块称为**单元**。 LSTM 单元通过选择性地学习或擦除信息，有助于在长序列通过时更有效地训练模型。组成单元的功能也称为门，因为它们充当传入和传出单元的信息的网守。
+在 RNN 中，使用重复使用的学习函数`φ`的单个神经网络层，而在 LSTM 中，使用由四个主要函数组成的重复模块。构建 LSTM 网络的模块称为**单元**。 LSTM 单元通过选择性地学习或擦除信息，有助于在长序列通过时更有效地训练模型。组成单元的函数也称为门，因为它们充当传入和传出单元的信息的网守。
 
 LSTM 模型有两种记忆：
 
@@ -156,7 +156,7 @@ LSTM 模型有两种记忆：
 
 # GRU 网络
 
-LSTM 网络的计算成本很高，因此，研究人员发现了一种几乎同样有效的 RNN 配置，称为**门控递归单元**（**GRU**）架构。
+LSTM 网络的计算成本很高，因此，研究人员发现了一种几乎同样有效的 RNN 配置，称为**门控循环单元**（**GRU**）架构。
 
 在 GRU 中，不使用工作和长期记忆，只使用一种记忆，用`h`（隐藏状态）表示。 GRU 单元通过**复位**和**更新**门，将信息添加到此状态存储器，或从该状态存储器中删除信息。
 
diff --git a/docs/mastering-tf-1x-zh/ch07.md b/docs/mastering-tf-1x-zh/ch07.md
index bb98e17c..3de9d35d 100644
--- a/docs/mastering-tf-1x-zh/ch07.md
+++ b/docs/mastering-tf-1x-zh/ch07.md
@@ -266,7 +266,7 @@ test rmse = 0.09375710758446143
 
 这非常令人印象深刻。
 
-这是一个非常简单的例子，只用一个变量值预测一个时间步。在现实生活中，输出受到多个特征的影响，并且需要预测不止一个时间步。后一类问题被称为多变量多时间步进预测问题。这些问题是使用递归神经网络进行更好预测的积极研究领域。
+这是一个非常简单的例子，只用一个变量值预测一个时间步。在现实生活中，输出受到多个特征的影响，并且需要预测不止一个时间步。后一类问题被称为多变量多时间步进预测问题。这些问题是使用循环神经网络进行更好预测的积极研究领域。
 
 现在让我们重新调整预测和原始值并绘制原始值（请在笔记本中查找代码）。
 
diff --git a/docs/mastering-tf-1x-zh/ch08.md b/docs/mastering-tf-1x-zh/ch08.md
index 66fa952d..a1a0a191 100644
--- a/docs/mastering-tf-1x-zh/ch08.md
+++ b/docs/mastering-tf-1x-zh/ch08.md
@@ -40,7 +40,7 @@ NLP 与 TensorFlow 深度学习技术是一个广阔的领域，很难在一章
 
 word2vec 系列模型使用两种架构构建：
 
-*   **CBOW**：训练模型以学习给定上下文词的中心词的概率分布。因此，给定一组上下文单词，模型以您在高中语言课程中所做的填空方式预测中心单词。 CBOW 体系结构最适用于具有较小词汇表的数据集。
+*   **CBOW**：训练模型以学习给定上下文词的中心词的概率分布。因此，给定一组上下文单词，模型以您在高中语言课程中所做的填空方式预测中心单词。 CBOW 架构最适用于具有较小词汇表的数据集。
 *   **SkipGram**：训练模型以学习给定中心词的上下文词的概率分布。因此，给定一个中心词，模型以您在高中语言课程中完成的句子方式预测语境词。
 
 例如，让我们考虑一下这句话：
@@ -82,7 +82,7 @@ Pennington, J., R. Socher, and C. Manning. GloVe: Global Vectors for Word Repres
 
 我们将使用流行的 PTB 和 text8 数据集进行演示。
 
-**PennTreebank**（**PTB**）数据集是在 UPenn 进行的 [Penn Treebank 项目](https://catalog.ldc.upenn.edu/ldc99t42)的副产品。 PTB 项目团队在华尔街日报三年的故事中提取了大约一百万字，并以 Treebank II 风格对其进行了注释。 PTB 数据集有两种形式：  基本示例，大小约为 35 MB，  高级示例，大小约为 235 MB。我们将使用由 929K 字组成的简单数据集进行训练，73K 字用于验证，82K 字用于测试。建议您浏览高级数据集。有关 PTB 数据集的更多详细信息，[请访问此链接](http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz) 。
+**PennTreebank**（**PTB**）数据集是在 UPenn 进行的 [Penn Treebank 项目](https://catalog.ldc.upenn.edu/ldc99t42)的副产品。 PTB 项目团队在华尔街日报三年的故事中提取了大约一百万字，并以 Treebank II 风格对其进行了标注。 PTB 数据集有两种形式：  基本示例，大小约为 35 MB，  高级示例，大小约为 235 MB。我们将使用由 929K 字组成的简单数据集进行训练，73K 字用于验证，82K 字用于测试。建议您浏览高级数据集。有关 PTB 数据集的更多详细信息，[请访问此链接](http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz) 。
 
 [可以从此链接下载 PTB 数据集](http://www.fit.vutbr.cz/~imikolov/rnnlm/rnn-rt07-example.tar.gz)。
 
@@ -344,7 +344,7 @@ embed_ltable = tf.nn.embedding_lookup(embed_matrix, inputs)
 
 NCE 的基本数学细节可以在以下 NIPS 论文中找到：使用噪声对比估计高效学习词嵌入，作者 Andriy Mnih 和 Koray Kavukcuoglu。[该论文可从此链接获得](http://papers.nips.cc/paper/5165-learning-word-embeddings-efficiently-with-noise-contrastive-estimation.pdf)。
 
-`tf.nn.nce_loss()`函数在评估计算损耗时自动生成负样本：参数`num_sampled`设置为等于负样本数（`n_negative_samples`）。此参数指定要绘制的负样本数。
+`tf.nn.nce_loss()`函数在求值计算损耗时自动生成负样本：参数`num_sampled`设置为等于负样本数（`n_negative_samples`）。此参数指定要绘制的负样本数。
 
 ```py
 # define noise-contrastive estimation (NCE) loss layer
@@ -594,7 +594,7 @@ plot_with_labels(low_dim_embeddings, labels)
 
 使用 Keras 的嵌入模型的流程与 TensorFlow 保持一致。
 
-*   在 Keras 函数式或顺序模型中创建网络体系结构
+*   在 Keras 函数式或顺序模型中创建网络架构
 *   将目标和上下文单词的真实性对提供给网络
 *   查找目标和上下文单词的单词向量
 *   执行单词向量的点积来获得相似性得分
@@ -684,7 +684,7 @@ labels=np.array(labels,dtype=np.int32)
 labels=dsu.to2d(labels,unit_axis=1)
 ```
 
-1.  定义网络的体系结构。正如我们所讨论的，必须将目标和上下文单词输入网络，并且需要从嵌入层中查找它们的向量。因此，首先我们分别为目标和上下文单词定义输入，嵌入和重塑层：
+1.  定义网络的架构。正如我们所讨论的，必须将目标和上下文单词输入网络，并且需要从嵌入层中查找它们的向量。因此，首先我们分别为目标和上下文单词定义输入，嵌入和重塑层：
 
 ```py
 # build the target word model
diff --git a/docs/mastering-tf-1x-zh/ch09.md b/docs/mastering-tf-1x-zh/ch09.md
index cf015f38..6dedbbae 100644
--- a/docs/mastering-tf-1x-zh/ch09.md
+++ b/docs/mastering-tf-1x-zh/ch09.md
@@ -553,7 +553,7 @@ dataset.scaleX()
 tf.nn.dropout(layer1_pool, keep_prob)
 ```
 
-在预测和评估期间，占位符`keep_prob`设置为 1。这样我们就可以重复使用相同的模型进行培训以及预测和评估。
+在预测和评估期间，占位符`keep_prob`设置为 1。这样我们就可以重复使用相同的模型进行训练以及预测和评估。
 
 有关 CIFAR10 数据的 LeNet 模型的完整代码在笔记本`ch-09b_CNN_CIFAR10_TF_and_Keras`中提供。
 
diff --git a/docs/mastering-tf-1x-zh/ch10.md b/docs/mastering-tf-1x-zh/ch10.md
index d23b099e..aa86bd8a 100644
--- a/docs/mastering-tf-1x-zh/ch10.md
+++ b/docs/mastering-tf-1x-zh/ch10.md
@@ -4,7 +4,7 @@
 
 自编码器架构有两个阶段：编码器和解码器。在编码器阶段，模型学习表示具有较小维度的压缩向量的输入，并且在解码器阶段，模型学习将压缩向量表示为输出向量。损失计算为输出和输入之间的熵距离，因此通过最小化损失，我们学习将输入编码成能够产生输入的表示的参数，以及另一组学习参数。
 
-在本章中，您将学习如何使用 TensorFlow 和 Keras 在以下主题中创建自编码器体系结构：
+在本章中，您将学习如何使用 TensorFlow 和 Keras 在以下主题中创建自编码器架构：
 
 *   自编码器类型
 *   TensorFlow 和 Keras 中的栈式自编码器
diff --git a/docs/mastering-tf-1x-zh/ch11.md b/docs/mastering-tf-1x-zh/ch11.md
index 8c13644e..0d3f810d 100644
--- a/docs/mastering-tf-1x-zh/ch11.md
+++ b/docs/mastering-tf-1x-zh/ch11.md
@@ -124,7 +124,7 @@ output=[ 0\.          0.30000001  0.60000002  0.90000004]
 
 # 使用保存器类保存和恢复所选变量
 
-默认情况下，`Saver()`类将所有变量保存在图中，但您可以通过将变量列表传递给`Saver()`类的构造函数来选择要保存的变量：
+默认情况下，`Saver()`类将所有变量保存在图中，但您可以通过将变量列表传递给`Saver()`类的构造器来选择要保存的变量：
 
 ```py
 # create saver object
@@ -211,13 +211,13 @@ output=[ 0.30000001  0.60000002  0.90000004  1.20000005]
 
 在 Keras 中，保存和恢复模型非常简单。 Keras 提供三种选择：
 
-*   使用其网络体系结构，权重（参数），训练配置和优化器状态保存完整模型。
+*   使用其网络架构，权重（参数），训练配置和优化器状态保存完整模型。
 *   仅保存架构。
 *   仅保存权重。
 
 要保存完整模型，请使用`model.save(filepath)`函数。这将把完整的模型保存在 HDF5 文件中。可以使用`keras.models.load_model(filepath)`函数加载保存的模型。此函数将所有内容加载回来，然后还编译模型。
 
-要保存模型的体系结构，请使用`model.to_json()`或`model.to_yaml()`函数。这些函数返回一个可以写入磁盘文件的字符串。在恢复架构时，可以回读字符串，并使用`keras.models.model_from_json(json_string)`或`keras.models.model_from_yaml(yaml_string)`函数恢复模型架构。这两个函数都返回一个模型实例。
+要保存模型的架构，请使用`model.to_json()`或`model.to_yaml()`函数。这些函数返回一个可以写入磁盘文件的字符串。在恢复架构时，可以回读字符串，并使用`keras.models.model_from_json(json_string)`或`keras.models.model_from_yaml(yaml_string)`函数恢复模型架构。这两个函数都返回一个模型实例。
 
 要保存模型的权重，请使用`model.save_weights(path_to_h5_file)`函数。可以使用`model.load_weights(path_to_h5_file)`函数恢复权重。
 
@@ -275,7 +275,7 @@ $ sudo apt-get update && sudo apt-get upgrade tensorflow-model-server
 $ tensorflow-model-server
 ```
 
-1.  要连接到`tensorflow-model-server`，请使用 PIP 安装 python 客户端软件包：
+1.  要连接到`tensorflow-model-server`，请使用 PIP 安装 python 客户端包：
 
 ```py
 $ sudo pip2 install tensorflow-serving-api
@@ -1075,5 +1075,5 @@ root@mnist-deployment-59dfc5df64-bb24q:~#
 
 在本章中，我们学习了如何利用 TensorFlow 服务来为生产环境中的模型提供服务。我们还学习了如何使用 TensorFlow 和 Keras 保存和恢复完整模型或选择模型。我们构建了一个 Docker 容器，并从官方 TensorFlow 服务仓库中提供了 Docker 容器中的示例 MNIST 示例代码。我们还安装了一个本地 Kubernetes 集群，并部署了 MNIST 模型，用于在 Kubernetes pod 中运行的 TensorFlow 服务。我们鼓励读者在这些例子的基础上进行尝试并尝试提供不同的模型。 TF 服务文档描述了各种选项，并提供了其他信息，使您可以进一步探索此主题。
 
-在接下来的章节中，我们将继续使用迁移学习的高级模型。 TensorFlow 仓库中提供的预训练模型是使用 TF 服务练习服务 TF 模型的最佳候选者。我们使用 Ubuntu 软件包安装了 TF 服务，但您可能希望尝试从源代码构建以优化生产环境的 TF 服务安装。
+在接下来的章节中，我们将继续使用迁移学习的高级模型。 TensorFlow 仓库中提供的预训练模型是使用 TF 服务练习服务 TF 模型的最佳候选者。我们使用 Ubuntu 包安装了 TF 服务，但您可能希望尝试从源代码构建以优化生产环境的 TF 服务安装。
 
diff --git a/docs/mastering-tf-1x-zh/ch12.md b/docs/mastering-tf-1x-zh/ch12.md
index 71304d68..0c1f649d 100644
--- a/docs/mastering-tf-1x-zh/ch12.md
+++ b/docs/mastering-tf-1x-zh/ch12.md
@@ -25,7 +25,7 @@
 
 ImageNet 是根据 WordNet 层次结构组织的图像数据集。WordNet 中的每个有意义的概念，可能由多个单词或单词短语描述，称为同义词集或 synset。
 
-ImageNet 有大约 100K 个同义词集，平均每个同义词集约有 1,000 个人工注释图像。 ImageNet 仅存储对图像的引用，而图像存储在互联网上的原始位置。在深度学习论文中，ImageNet-1K 是指作为 ImageNet 的**大规模视觉识别挑战**（**ILSVRC**）的一部分发布的数据集，用于将数据集分类为 1,000 个类别：
+ImageNet 有大约 100K 个同义词集，平均每个同义词集约有 1,000 个人工标注图像。 ImageNet 仅存储对图像的引用，而图像存储在互联网上的原始位置。在深度学习论文中，ImageNet-1K 是指作为 ImageNet 的**大规模视觉识别挑战**（**ILSVRC**）的一部分发布的数据集，用于将数据集分类为 1,000 个类别：
 
 可以在以下 URL 找到 1,000 个挑战类别：
 
@@ -460,7 +460,7 @@ with tf.Session() as tfs:
     probs=probs[0]
 ```
 
-让我们看看我们得到的课程：
+让我们看看我们得到的类：
 
 ```py
 disp(images_test,id2label=inet.id2label,probs=probs,scale=True)
diff --git a/docs/mastering-tf-1x-zh/ch13.md b/docs/mastering-tf-1x-zh/ch13.md
index b57bbdf1..bc3726e5 100644
--- a/docs/mastering-tf-1x-zh/ch13.md
+++ b/docs/mastering-tf-1x-zh/ch13.md
@@ -413,7 +413,7 @@ Policy:policy_logic, Min reward:24.0, Max reward:63.0, Average reward:41.94
     
         ![](img/11dc9c49-c717-4115-b9a5-2015befdef3a.png)
 
-*   **值函数**根据当前状态中的所选动作预测长期奖励的数量。因此，值函数特定于智能体使用的策略。奖励表示行动的直接收益，而价值函数表示行动的累积或长期未来收益。奖励由环境返回，价值函数由智能体在每个时间步骤估计。
+*   **值函数**根据当前状态中的所选动作预测长期奖励的数量。因此，值函数特定于智能体使用的策略。奖励表示行动的直接收益，而值函数表示行动的累积或长期未来收益。奖励由环境返回，值函数由智能体在每个时间步骤估计。
 
 *   **模型**表示智能体在内部保存的环境。该模型可能是环境的不完美表示。智能体使用该模型来估计所选动作的奖励和下一个状态。
 
@@ -465,7 +465,7 @@ Policy:policy_logic, Min reward:24.0, Max reward:63.0, Average reward:41.94
     *   **策略迭代学习** ： 在策略迭代学习方法中，智能体通过初始化随机策略`p`开始，然后重复更新策略，直到找到最大奖励。
 
 *   **模型不可用**：如果模型不可用，则智能体只能通过观察其动作的结果来学习。因此，从观察，行动和奖励的历史来看，智能体会尝试估计模型或尝试直接推导出最优策略：
-    *   **基于模型的学习**：在基于模型的学习中，智能体首先从历史中估计模型，然后使用策略或基于价值的方法来找到最优策略。
+    *   **基于模型的学习**：在基于模型的学习中，智能体首先从历史中估计模型，然后使用策略或基于值的方法来找到最优策略。
     *   **无模型学习**：在无模型学习中，智能体不会估计模型，而是直接从历史中估计最优策略。 Q-Learning 是无模型学习的一个例子。
 
 作为示例，值迭代学习的算法如下：
diff --git a/docs/mastering-tf-1x-zh/ch15.md b/docs/mastering-tf-1x-zh/ch15.md
index 11dbd6fe..2e83da06 100644
--- a/docs/mastering-tf-1x-zh/ch15.md
+++ b/docs/mastering-tf-1x-zh/ch15.md
@@ -111,7 +111,7 @@ server = tf.train.Server(clusterSpec,
                          )
 ```
 
-在此代码中，`job_name`和`task_index`取自命令行传递的参数。软件包`tf.flags`是一个花哨的解析器，可以访问命令行参数。 Python 文件在每个物理节点上执行如下（如果您仅使用本地主机，则在同一节点上的单独终端中执行）：
+在此代码中，`job_name`和`task_index`取自命令行传递的参数。包`tf.flags`是一个花哨的解析器，可以访问命令行参数。 Python 文件在每个物理节点上执行如下（如果您仅使用本地主机，则在同一节点上的单独终端中执行）：
 
 ```py
 # the model should be run in each physical node 
@@ -168,7 +168,7 @@ elif FLAGS.job_name=='worker':
 worker_device='/job:worker/task:{}'.format(FLAGS.task_index)
 ```
 
-1.  接下来，使用`replica_device_setter`定义设备功能，传递集群规范和当前工作设备。`replica_device_setter`函数从集群规范中计算出参数服务器，如果有多个参数服务器，则默认情况下以循环方式在它们之间分配参数。参数放置策略可以更改为`tf.contrib`包中的用户定义函数或预构建策略。
+1.  接下来，使用`replica_device_setter`定义设备函数，传递集群规范和当前工作设备。`replica_device_setter`函数从集群规范中计算出参数服务器，如果有多个参数服务器，则默认情况下以循环方式在它们之间分配参数。参数放置策略可以更改为`tf.contrib`包中的用户定义函数或预构建策略。
 
 ```py
 device_func = tf.train.replica_device_setter(
@@ -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 并且每个工作器的每个周期都相同，但是因为工作器正在做按照自己的步骤采取全局性措施，全局步骤的数量在周期或工作器之间没有对称性或模式。此外，我们发现每个工作器的最终准确率是不同的，因为每个工作器在不同的时间执行最终的准确率，当时有不同的参数。
 
 # 定义并训练图以进行同步更新
 
diff --git a/docs/mastering-tf-1x-zh/ch16.md b/docs/mastering-tf-1x-zh/ch16.md
index fb3a0ab2..ae60a403 100644
--- a/docs/mastering-tf-1x-zh/ch16.md
+++ b/docs/mastering-tf-1x-zh/ch16.md
@@ -1,6 +1,6 @@
 # 十六、移动和嵌入式平台上的 TensorFlow 模型
 
-TensorFlow 模型还可用于在移动和嵌入式平台上运行的应用。 TensorFlow Lite 和 TensorFlow Mobile 是资源受限移动设备的两种 TensorFlow。与 TensorFlow Mobile 相比，TensorFlow Lite 支持功能的子集。由于较小的二进制大小和较少的依赖性，TensorFlow Lite 可以获得更好的表现。
+TensorFlow 模型还可用于在移动和嵌入式平台上运行的应用。 TensorFlow Lite 和 TensorFlow Mobile 是资源受限移动设备的两种 TensorFlow。与 TensorFlow Mobile 相比，TensorFlow Lite 支持功能的子集。由于较小的二进制大小和较少的依赖项，TensorFlow Lite 可以获得更好的表现。
 
 要将 TensorFlow 集成到您的应用中，首先，使用我们在整本书中提到的技术训练模型，然后保存模型。现在可以使用保存的模型在移动应用中进行推理和预测。
 
@@ -31,7 +31,7 @@ TensorFlow 可以集成到移动应用中，用于涉及以下一项或多项机
 *   经过训练和保存的模型，可用于预测
 *   TensorFlow 二进制文件，可以接收输入，应用模型，生成预测，并将预测作为输出发送
 
-高级体系结构如下图所示：
+高级架构如下图所示：
 
 ![](img/e64ec954-a6af-4d25-a484-8fb12d371828.png)
 
@@ -119,9 +119,9 @@ def nativeBuildSystem = 'none'
 
 ![](img/80c9846f-82a8-408a-9b7d-2e109654839e.png)
 
-Android 模拟器中的 TF 示例应用程序
+Android 模拟器中的 TF 示例应用
 
-[您还可以按照此链接中的说明使用 Bazel 或 Cmake 从源构建整个演示应用程序](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/examples/android)。
+[您还可以按照此链接中的说明使用 Bazel 或 Cmake 从源构建整个演示应用](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/examples/android)。
 
 # iOS 应用中的 TFMobile
 
diff --git a/docs/mastering-tf-1x-zh/ch17.md b/docs/mastering-tf-1x-zh/ch17.md
index 16cdc8fe..99767b18 100644
--- a/docs/mastering-tf-1x-zh/ch17.md
+++ b/docs/mastering-tf-1x-zh/ch17.md
@@ -5,20 +5,20 @@ R 是一个开源平台，包括用于统计计算的环境和语言。它还有
 *   `tensorflow`包提供对 TF 核心 API 的支持
 *   `tfestimators`包提供对 TF 估计器 API 的支持
 *   `keras`包提供对 Keras API 的支持
-*   `tfruns`包用于 TensorBoard 风格的模型和训练课程可视化
+*   `tfruns`包用于 TensorBoard 风格的模型和训练类可视化
 
 在本章中，我们将学习如何在 R 中使用 TensorFlow，并将涵盖以下主题：
 
-*   在 R 中安装 TensorFlow 和 Keras 软件包
+*   在 R 中安装 TensorFlow 和 Keras 包
 *   R 中的 TF 核心 API
 *   R 中的 TF 估计器 API
 *   R 中的 Keras API
 *   R 中的 TensorBoard
 *   R 中的`tfruns`包
 
-# 在 R 中安装 TensorFlow 和 Keras 软件包
+# 在 R 中安装 TensorFlow 和 Keras 包
 
-要在 R 中安装支持 TensorFlow 和 Keras 的三个 R 软件包，请在 R 中执行以下命令。
+要在 R 中安装支持 TensorFlow 和 Keras 的三个 R 包，请在 R 中执行以下命令。
 
 1.  首先，安装`devtools`：
 
@@ -40,7 +40,7 @@ library(tensorflow)
 install_tensorflow()   
 ```
 
-1.  默认情况下，安装功能会创建虚拟环境并在虚拟环境中安装`tensorflow `软件包。
+1.  默认情况下，安装功能会创建虚拟环境并在虚拟环境中安装`tensorflow `包。
 
 有四种可用的安装方法，可以使用`method`参数指定：
 
@@ -325,7 +325,7 @@ Evaluation completed after 79 steps but 200 steps was specified
 
 # R 中的 Keras API
 
-我们在第 3 章中了解了 Keras API。在 R 中，此 API 使用`keras` R 包实现。`keras` R 软件包实现了 Keras Python 接口的大部分功能，包括顺序 API 和函数式 API。
+我们在第 3 章中了解了 Keras API。在 R 中，此 API 使用`keras` R 包实现。`keras` R 包实现了 Keras Python 接口的大部分功能，包括顺序 API 和函数式 API。
 
 作为示例，我们提供了 MLP 模型的演练，[用于在此链接中对来自 MNIST 数据集的手写数字进行分类](https://keras.rstudio.com/articles/examples/mnist_mlp.html)。
 
@@ -451,7 +451,7 @@ Test accuracy: 0.9816
 
 [在此链接中查找更多关于 R 中的 Keras 的示例](https://keras.rstudio.com/articles/examples/index.html)。
 
-[有关 Keras R 软件包的更多文档可在此链接中找到](https://keras.rstudio.com/reference/index.html)。
+[有关 Keras R 包的更多文档可在此链接中找到](https://keras.rstudio.com/reference/index.html)。
 
 # R 中的 TensorBoard
 
@@ -467,9 +467,9 @@ tensorboard('logs')
 
 数据将显示为执行周期并记录数据。在 R 中，收集 TensorBoard 的数据取决于所使用的包：
 
-*   如果您使用的是`tensorflow`软件包，请将`tf$summary$scalar`操作附加到图中
-*   如果您使用的是`tfestimators`软件包，则 TensorBoard 数据会自动写入创建估计器时指定的`model_dir`参数
-*   如果您正在使用`keras`软件包，则必须在使用`fit()`函数训练模型时包含`callback_tensorboard()`函数
+*   如果您使用的是`tensorflow`包，请将`tf$summary$scalar`操作附加到图中
+*   如果您使用的是`tfestimators`包，则 TensorBoard 数据会自动写入创建估计器时指定的`model_dir`参数
+*   如果您正在使用`keras`包，则必须在使用`fit()`函数训练模型时包含`callback_tensorboard()`函数
 
 我们修改了之前提供的 Keras 示例中的训练，如下所示：
 
@@ -507,7 +507,7 @@ TensorBoard 计算图的可视化有关 R 中 TensorBoard 的更多文档，[请
 
 您可以按照 Jupyter R 笔记本中的代码`ch-17d_TensorBoard_in_R`。
 
-`tfruns`软件包是 R 中提供的非常有用的工具，有助于跟踪多次运行以训练模型。对于使用`keras` `tfestimators`软件包在 R 中构建的模型，`tfruns`软件包自动捕获运行数据。使用`tfruns`非常简单易行。只需在 R 文件中创建代码，然后使用`training_run()`函数执行该文件。例如，如果你有一个`mnist_model.R `文件 ，那么在交互式 R 控制台中使用`training_run()`函数执行它，如下所示：
+`tfruns`包是 R 中提供的非常有用的工具，有助于跟踪多次运行以训练模型。对于使用`keras` `tfestimators`包在 R 中构建的模型，`tfruns`包自动捕获运行数据。使用`tfruns`非常简单易行。只需在 R 文件中创建代码，然后使用`training_run()`函数执行该文件。例如，如果你有一个`mnist_model.R `文件 ，那么在交互式 R 控制台中使用`training_run()`函数执行它，如下所示：
 
 ```r
 library(tfruns)
@@ -522,7 +522,7 @@ training_run('mnist_model.R')
 
 ![](img/cf30d6bc-8aea-4c3f-84e1-7567857412db.png)tfruns visualization of the accuracy and loss values
 
-`tfruns`软件包将一个插件安装到 RStudio，也可以从`Addins`菜单选项访问。该软件包还允许您比较多个运行并将运行报告发布到 RPub 或 RStudio Connect。您还可以选择在本地保存报告。
+`tfruns`包将一个插件安装到 RStudio，也可以从`Addins`菜单选项访问。该包还允许您比较多个运行并将运行报告发布到 RPub 或 RStudio Connect。您还可以选择在本地保存报告。
 
 有关 R 中`tfruns`包的更多文档，请访问以下链接：
 
@@ -532,7 +532,7 @@ training_run('mnist_model.R')
 
 # 总结
 
-在本章中，我们学习了如何在 R 中使用 TensorFlow 核心，TensorFlow 估计器和 Keras 包来构建和训练机器学习模型。我们提供了来自 RStudio 的 MNIST 示例的演练，并提供了有关 TensorFlow 和 Keras R 软件包的进一步文档的链接。我们还学习了如何使用 R 中的可视化工具 TensorBoard。我们还介绍了一个来自 R Studio 的新工具`tfruns`，它允许您为多次运行创建报告，分析和比较它们，并在本地保存或发布它们。
+在本章中，我们学习了如何在 R 中使用 TensorFlow 核心，TensorFlow 估计器和 Keras 包来构建和训练机器学习模型。我们提供了来自 RStudio 的 MNIST 示例的演练，并提供了有关 TensorFlow 和 Keras R 包的进一步文档的链接。我们还学习了如何使用 R 中的可视化工具 TensorBoard。我们还介绍了一个来自 R Studio 的新工具`tfruns`，它允许您为多次运行创建报告，分析和比较它们，并在本地保存或发布它们。
 
 直接在 R 中工作的能力很有用，因为大量的生产数据科学和机器学习代码是使用 R 编写的，现在您可以将 TensorFlow 集成到相同的代码库中并在 R 环境中运行它。
 
diff --git a/docs/mastering-tf-1x-zh/ch19.md b/docs/mastering-tf-1x-zh/ch19.md
index 72d174c8..3211213e 100644
--- a/docs/mastering-tf-1x-zh/ch19.md
+++ b/docs/mastering-tf-1x-zh/ch19.md
@@ -4,7 +4,7 @@
 
 ![](img/1dc1da7c-6209-49fc-b670-698bcc3c4d42.png)The Architecture of TPUImage from: https://cloud.google.com/blog/big-data/2017/05/images/149454602921110/tpu-15.png
 
-TensorFlow 提供了一个编译器和软件堆栈，可将 API 调用从 TensorFlow 图转换为 TPU 指令。以下框图描述了在 TPU 堆栈顶部运行的 TensorFlow 模型的体系结构：
+TensorFlow 提供了一个编译器和软件栈，可将 API 调用从 TensorFlow 图转换为 TPU 指令。以下框图描述了在 TPU 栈顶部运行的 TensorFlow 模型的架构：
 
 ![](img/d57598de-e922-4cfe-941c-883553bf35e0.png)
 
-- 
GitLab