diff --git a/docs/tf-ml-cookbook-2e-zh/ch01.md b/docs/tf-ml-cookbook-2e-zh/ch01.md
index 1409dcc2bf7fd46f72d351e0ac7ec27fb566105a..c3850f80d19a17009e82cd037a12e1179eea9ba4 100644
--- a/docs/tf-ml-cookbook-2e-zh/ch01.md
+++ b/docs/tf-ml-cookbook-2e-zh/ch01.md
@@ -364,7 +364,7 @@ print(sess.run(tf.matrix_determinant(D)))
 -38.0 
 ```
 
-1.  反向：要查找方阵的倒数，请参阅以下内容：
+1.  逆：要查找方阵的逆，请参阅以下内容：
 
 ```py
 print(sess.run(tf.matrix_inverse(D))) 
diff --git a/docs/tf-ml-cookbook-2e-zh/ch02.md b/docs/tf-ml-cookbook-2e-zh/ch02.md
index 43f3dabb425ec89f36be9bbac3719440892528de..469ad29658c51d40167361a29be5478192ccb11e 100644
--- a/docs/tf-ml-cookbook-2e-zh/ch02.md
+++ b/docs/tf-ml-cookbook-2e-zh/ch02.md
@@ -107,7 +107,7 @@ prod2 = tf.matmul(prod1, m2)
 add1 = tf.add(prod2, a1)
 ```
 
-1.  最后，我们通过图提供数据：
+1.  最后，我们为图提供数据：
 
 ```py
 for x_val in x_vals: 
@@ -425,7 +425,7 @@ import numpy as np
 import tensorflow as tf 
 ```
 
-1.  现在，我们开始图会话：
+1.  现在，我们启动图会话：
 
 ```py
 sess = tf.Session() 
@@ -619,7 +619,7 @@ Loss = [[ 0.04099189]]
 
 为了使 TensorFlow 计算反向传播的可变梯度，我们必须测量样本或多个样本的损失。随机训练一次只适用于一个随机抽样的数据 - 目标对，就像我们在上一个秘籍中所做的那样。另一种选择是一次放置大部分训练样例并平均梯度计算的损失。训练批次的大小可以一次变化，直到并包括整个数据集。在这里，我们将展示如何将先前的回归示例（使用随机训练）扩展到批量训练。
 
-我们将首先加载`numpy`，`matplotlib`和`tensorflow`，然后开始图会话，如下所示：
+我们将首先加载`numpy`，`matplotlib`和`tensorflow`，然后启动图会话，如下所示：
 
 ```py
 import matplotlib as plt 
diff --git a/docs/tf-ml-cookbook-2e-zh/ch04.md b/docs/tf-ml-cookbook-2e-zh/ch04.md
index e16e4279c9e5815519d34b2b35dee3f3ed3f9bc7..125acd0027aead25294e986c0dccafa70534d1d4 100644
--- a/docs/tf-ml-cookbook-2e-zh/ch04.md
+++ b/docs/tf-ml-cookbook-2e-zh/ch04.md
@@ -3,8 +3,8 @@
 本章将介绍有关如何在 TensorFlow 中使用，实现和评估支持向量机（SVM）的一些重要秘籍。将涵盖以下领域：
 
 *   使用线性 SVM
-*   减少到线性回归
-*   在 TensorFlow 中使用内核
+*   回退到线性回归
+*   在 TensorFlow 中使用核
 *   实现非线性 SVM
 *   实现多类 SVM
 
@@ -344,7 +344,7 @@ for i in range(200):
         print('Test Loss = ' + str(temp_test_loss)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Generation: 50 
@@ -422,13 +422,13 @@ plt.show()
 
 直觉上，我们可以将 SVM 回归看作是一个函数，试图尽可能多地在`2ε`宽度范围内拟合点。该线的拟合对该参数有些敏感。如果我们选择太小的`ε`，算法将无法适应边距中的许多点。如果我们选择太大的`ε`，将会有许多行能够适应边距中的所有数据点。我们更喜欢较小的`ε`，因为距离边缘较近的点比较远的点贡献较少的损失。
 
-# 在 TensorFlow 中使用内核
+# 在 TensorFlow 中使用核
 
-先前的 SVM 使用线性可分数据。如果我们分离非线性数据，我们可以改变将线性分隔符投影到数据上的方式。这是通过更改 SVM 损失函数中的内核来完成的。在本章中，我们将介绍如何更改内核并分离非线性可分离数据。
+先前的 SVM 使用线性可分数据。如果我们分离非线性数据，我们可以改变将线性分隔符投影到数据上的方式。这是通过更改 SVM 损失函数中的核来完成的。在本章中，我们将介绍如何更改核并分离非线性可分离数据。
 
 ## 准备
 
-在本文中，我们将激励支持向量机中内核的使用。在线性 SVM 部分，我们用特定的损失函数求解了软边界。这种方法的另一种方法是解决所谓的优化问题的对偶。可以证明线性 SVM 问题的对偶性由以下公式给出：
+在本文中，我们将激励支持向量机中核的使用。在线性 SVM 部分，我们用特定的损失函数求解了软边界。这种方法的另一种方法是解决所谓的优化问题的对偶。可以证明线性 SVM 问题的对偶性由以下公式给出：
 
 ![](img/a311abb6-b9c9-4aef-9cac-88438abb5879.png)
 
@@ -438,21 +438,21 @@ plt.show()
 
 这里，模型中的变量将是`b`向量。理想情况下，此向量将非常稀疏，仅对我们数据集的相应支持向量采用接近 1 和 -1 的值。我们的数据点向量由`x[i]`表示，我们的目标（1 或 -1）`y[i]`表示。
 
-前面等式中的内核是点积`x[i] · y[j]`，它给出了线性内核。该内核是一个方形矩阵，填充了数据点`i, j`的点积。
+前面等式中的核是点积`x[i] · y[j]`，它给出了线性核。该核是一个方形矩阵，填充了数据点`i, j`的点积。
 
 我们可以将更复杂的函数扩展到更高的维度，而不是仅仅在数据点之间进行点积，而在这些维度中，类可以是线性可分的。这似乎是不必要的复杂，但我们可以选择一个具有以下属性的函数`k`：
 
 ![](img/eb618f1d-e0d3-49a7-bbec-c8e5ab9049d4.png)
 
-这里`, k`被称为核函数。更常见的内核是使用高斯内核（也称为径向基函数内核或 RBF 内核）。该内核用以下等式描述：
+这里`, k`被称为核函数。更常见的核是使用高斯核（也称为径向基函数核或 RBF 核）。该核用以下等式描述：
 
 ![](img/91bc4d05-6bc2-4b0d-85ac-70a964eae981.png)
 
-为了对这个内核进行预测，比如说`p[i]`，我们只需在内核中的相应方程中用预测点替换，如下所示：
+为了对这个核进行预测，比如说`p[i]`，我们只需在核中的相应方程中用预测点替换，如下所示：
 
 ![](img/284cc0b5-9a95-4a09-bf23-39776df87409.png)
 
-在本节中，我们将讨论如何实现高斯内核。我们还将在适当的位置记下在何处替换实现线性内核。我们将使用的数据集将手动创建，以显示高斯内核更适合在线性内核上使用的位置。
+在本节中，我们将讨论如何实现高斯核。我们还将在适当的位置记下在何处替换实现线性核。我们将使用的数据集将手动创建，以显示高斯核更适合在线性核上使用的位置。
 
 ## 操作步骤
 
@@ -489,7 +489,7 @@ prediction_grid = tf.placeholder(shape=[None, 2], dtype=tf.float32)
 b = tf.Variable(tf.random_normal(shape=[1,batch_size])) 
 ```
 
-1.  我们现在将创建高斯内核。该内核可以表示为矩阵运算，如下所示：
+1.  我们现在将创建高斯核。该核可以表示为矩阵运算，如下所示：
 
 ```py
 gamma = tf.constant(-50.0) 
@@ -499,7 +499,7 @@ sq_dists = tf.add(tf.subtract(dist, tf.multiply(2., tf.matmul(x_data, tf.transpo
 my_kernel = tf.exp(tf.multiply(gamma, tf.abs(sq_dists)))  
 ```
 
-> 注意`add`和`subtract`操作的`sq_dists`行中广播的使用。 另外，请注意线性内核可以表示为`my_kernel = tf.matmul(x_data, tf.transpose(x_data))`。
+> 注意`add`和`subtract`操作的`sq_dists`行中广播的使用。 另外，请注意线性核可以表示为`my_kernel = tf.matmul(x_data, tf.transpose(x_data))`。
 
 1.  现在，我们宣布了本秘籍中之前所述的双重问题。最后，我们将使用`tf.negative()`函数最小化损失函数的负值，而不是最大化。我们使用以下代码完成此任务：
 
@@ -512,7 +512,7 @@ second_term = tf.reduce_sum(tf.multiply(my_kernel, tf.multiply(b_vec_cross, y_ta
 loss = tf.negative(tf.subtract(first_term, second_term))
 ```
 
-1.  我们现在创建预测和准确率函数。首先，我们必须创建一个预测内核，类似于步骤 4，但是我们拥有带有预测数据的点的核心，而不是点的内核。然后预测是模型输出的符号。这实现如下：
+1.  我们现在创建预测和准确率函数。首先，我们必须创建一个预测核，类似于步骤 4，但是我们拥有带有预测数据的点的核心，而不是点的核。然后预测是模型输出的符号。这实现如下：
 
 ```py
 rA = tf.reshape(tf.reduce_sum(tf.square(x_data), 1),[-1,1]) 
@@ -525,7 +525,7 @@ prediction = tf.sign(prediction_output-tf.reduce_mean(prediction_output))
 accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.squeeze(prediction), tf.squeeze(y_target)), tf.float32)) 
 ```
 
-> 为了实现线性预测内核，我们可以编写`pred_kernel = tf.matmul(x_data, tf.transpose(prediction_grid))`。
+> 为了实现线性预测核，我们可以编写`pred_kernel = tf.matmul(x_data, tf.transpose(prediction_grid))`。
 
 1.  现在，我们可以创建一个优化函数并初始化所有变量，如下所示：
 
@@ -560,7 +560,7 @@ for i in range(500):
         print('Loss = ' + str(temp_loss)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Step #100 
@@ -622,15 +622,15 @@ plt.show()
 
 图 7：非线性可分离数据上的线性 SVM
 
-以下屏幕截图显示了高斯内核可以更好地拟合非线性数据：
+以下屏幕截图显示了高斯核可以更好地拟合非线性数据：
 
 ![](img/942b3cec-7ca0-42d5-bc2b-7fddb0a4d4e4.png)Figure 8: Non-linear SVM with Gaussian kernel results on non-linear ring data
 
-如果我们使用高斯内核来分离我们的非线性环数据，我们会得到更好的拟合。
+如果我们使用高斯核来分离我们的非线性环数据，我们会得到更好的拟合。
 
 ## 工作原理
 
-有两个重要的代码需要了解：我们如何实现内核，以及我们如何为 SVM 双优化问题实现损失函数。我们已经展示了如何实现线性和高斯核，并且高斯核可以分离非线性数据集。
+有两个重要的代码需要了解：我们如何实现核，以及我们如何为 SVM 双优化问题实现损失函数。我们已经展示了如何实现线性和高斯核，并且高斯核可以分离非线性数据集。
 
 我们还应该提到另一个参数，即高斯核中的伽马值。此参数控制影响点对分离曲率的影响程度。通常选择小值，但它在很大程度上取决于数据集。理想情况下，使用交叉验证等统计技术选择此参数。
 
@@ -638,23 +638,23 @@ plt.show()
 
 ## 更多
 
-如果我们这样选择，我们可以实现更多内核。以下是一些更常见的非线性内核列表：
+如果我们这样选择，我们可以实现更多核。以下是一些更常见的非线性核列表：
 
 *   多项式齐次核：
 
 ![](img/3233ad1f-7336-40e8-b9de-895eb041bb5b.png)
 
-*   多项式非均匀内核：
+*   多项式非齐次核：
 
 ![](img/bdb676cb-da55-47f7-a656-2a0406ff4ab3.png)
 
-*   双曲正切内核：
+*   双曲正切核：
 
 ![](img/5d9c1c9e-e1ce-4497-9fc4-5f7be14ce1b3.png)
 
 # 实现非线性 SVM
 
-对于此秘籍，我们将应用非线性内核来拆分数据集。
+对于此秘籍，我们将应用非线性核来拆分数据集。
 
 ## 准备
 
@@ -664,7 +664,7 @@ plt.show()
 
 我们按如下方式处理秘籍：
 
-1.  我们首先加载必要的库，其中包括`scikit-learn`数据集，以便我们可以加载鸢尾数据。然后，我们将开始图会话。使用以下代码：
+1.  我们首先加载必要的库，其中包括`scikit-learn`数据集，以便我们可以加载鸢尾数据。然后，我们将启动图会话。使用以下代码：
 
 ```py
 import matplotlib.pyplot as plt 
@@ -698,7 +698,7 @@ prediction_grid = tf.placeholder(shape=[None, 2], dtype=tf.float32)
 b = tf.Variable(tf.random_normal(shape=[1,batch_size]))
 ```
 
-1.  接下来，我们声明我们的高斯内核。这个内核依赖于伽马值，我们将在本文后面的各个伽玛值对分类的影响进行说明。使用以下代码：
+1.  接下来，我们声明我们的高斯核。这个核依赖于伽马值，我们将在本文后面的各个伽玛值对分类的影响进行说明。使用以下代码：
 
 ```py
 gamma = tf.constant(-10.0) 
@@ -715,7 +715,7 @@ second_term = tf.reduce_sum(tf.multiply(my_kernel, tf.multiply(b_vec_cross, y_ta
 loss = tf.negative(tf.subtract(first_term, second_term)) 
 ```
 
-1.  为了使用 SVM 执行预测，我们必须创建预测内核函数。之后，我们还会声明一个准确率计算，它只是使用以下代码正确分类的点的百分比：
+1.  为了使用 SVM 执行预测，我们必须创建预测核函数。之后，我们还会声明一个准确率计算，它只是使用以下代码正确分类的点的百分比：
 
 ```py
 rA = tf.reshape(tf.reduce_sum(tf.square(x_data), 1),[-1,1]) 
@@ -806,7 +806,7 @@ plt.show()
 
 实现多类分类器的另一种方法是执行一对一策略，我们为`k`类的每个类创建一个分类器。点的预测类将是创建最大 SVM 边距的类。这是我们将在本节中实现的策略。
 
-在这里，我们将加载鸢尾数据集并使用高斯内核执行多类非线性 SVM。鸢尾数据集是理想的，因为有三个类（山鸢尾，弗吉尼亚和杂色鸢尾）。我们将为每个类创建三个高斯核 SVM，并预测存在最高边界的点。
+在这里，我们将加载鸢尾数据集并使用高斯核执行多类非线性 SVM。鸢尾数据集是理想的，因为有三个类（山鸢尾，弗吉尼亚和杂色鸢尾）。我们将为每个类创建三个高斯核 SVM，并预测存在最高边界的点。
 
 ## 操作步骤
 
@@ -882,7 +882,7 @@ second_term = tf.reduce_sum(tf.multiply(my_kernel, tf.multiply(b_vec_cross, y_ta
 loss = tf.reduce_sum(tf.negative(tf.subtract(first_term, second_term))) 
 ```
 
-1.  现在，我们可以创建预测内核。请注意，我们必须小心`reduce_sum`函数并且不要在所有三个 SVM 预测中减少，因此我们必须告诉 TensorFlow 不要用第二个索引参数对所有内容求和。使用以下代码：
+1.  现在，我们可以创建预测核。请注意，我们必须小心`reduce_sum`函数并且不要在所有三个 SVM 预测中减少，因此我们必须告诉 TensorFlow 不要用第二个索引参数对所有内容求和。使用以下代码：
 
 ```py
 rA = tf.reshape(tf.reduce_sum(tf.square(x_data), 1),[-1,1]) 
@@ -891,7 +891,7 @@ pred_sq_dist = tf.add(tf.subtract(rA, tf.multiply(2., tf.matmul(x_data, tf.trans
 pred_kernel = tf.exp(tf.multiply(gamma, tf.abs(pred_sq_dist))) 
 ```
 
-1.  当我们完成预测内核时，我们可以创建预测。这里的一个重大变化是预测不是输出的`sign()`。由于我们正在实现一对一策略，因此预测是具有最大输出的分类器。为此，我们使用 TensorFlow 的内置`argmax()`函数，如下所示：
+1.  当我们完成预测核时，我们可以创建预测。这里的一个重大变化是预测不是输出的`sign()`。由于我们正在实现一对一策略，因此预测是具有最大输出的分类器。为此，我们使用 TensorFlow 的内置`argmax()`函数，如下所示：
 
 ```py
 prediction_output = tf.matmul(tf.mul(y_target,b), pred_kernel) 
@@ -899,7 +899,7 @@ prediction = tf.arg_max(prediction_output-tf.expand_dims(tf.reduce_mean(predicti
 accuracy = tf.reduce_mean(tf.cast(tf.equal(prediction, tf.argmax(y_target,0)), tf.float32)) 
 ```
 
-1.  现在我们已经拥有了内核，损失和预测函数，我们只需要声明我们的优化函数并初始化我们的变量，如下所示：
+1.  现在我们已经拥有了核，损失和预测函数，我们只需要声明我们的优化函数并初始化我们的变量，如下所示：
 
 ```py
 my_opt = tf.train.GradientDescentOptimizer(0.01) 
diff --git a/docs/tf-ml-cookbook-2e-zh/ch05.md b/docs/tf-ml-cookbook-2e-zh/ch05.md
index fe489665ea6ba0caeccad4ae1ce87af84a0d5b53..147f4caa5a62ca13c032b348708d221573182ffd 100644
--- a/docs/tf-ml-cookbook-2e-zh/ch05.md
+++ b/docs/tf-ml-cookbook-2e-zh/ch05.md
@@ -4,19 +4,19 @@
 
 在本章中，我们将介绍以下内容：
 
-*   与最近邻居合作
+*   使用最近邻
 *   使用基于文本的距离
 *   计算混合距离函数
-*   使用地址匹配示例
-*   使用最近邻居进行图像识别
+*   使用地址匹配的示例
+*   使用最近邻进行图像识别
 
 > 请注意，所有最新代码均可在 [Github](https://github.com/nfmcclure/tensorflow_cookbook) 和 [Packt 仓库](https://github.com/PacktPublishing/TensorFlow-Machine-Learning-Cookbook-Second-Edition)获得。
 
 # 介绍
 
-最近邻方法植根于基于距离的概念思想。我们认为我们的训练设定了一个模型，并根据它们与训练集中的点的接近程度对新点进行预测。一种简单的方法是使预测类与最接近的训练数据点类相同。但由于大多数数据集包含一定程度的噪声，因此更常见的方法是采用一组`k-`最近邻居的加权平均值。该方法称为 K 最近邻居（KNN）。
+最近邻方法植根于基于距离的概念思想。我们认为我们的训练设定了一个模型，并根据它们与训练集中的点的接近程度对新点进行预测。一种简单的方法是使预测类与最接近的训练数据点类相同。但由于大多数数据集包含一定程度的噪声，因此更常见的方法是采用一组`k-`最近邻的加权平均值。该方法称为 K 最近邻（KNN）。
 
-给定具有相应目标（`y[1], y[2]....y[n]`）的训练数据集（`x[1],x[2].....x[n]`），我们可以通过查看一组最近邻居来对点`z`进行预测。实际的预测方法取决于我们是进行回归（连续`y[i]`）还是分类（离散`y[i]`）。
+给定具有相应目标（`y[1], y[2]....y[n]`）的训练数据集（`x[1],x[2].....x[n]`），我们可以通过查看一组最近邻来对点`z`进行预测。实际的预测方法取决于我们是进行回归（连续`y[i]`）还是分类（离散`y[i]`）。
 
 对于离散分类目标，可以通过最大投票方案给出预测，通过到预测点的距离加权：
 
@@ -43,11 +43,11 @@
 
 # 使用最近邻
 
-我们将通过实现最近邻来预测住房价值来开始本章。这是从最近邻居开始的好方法，因为我们将处理数字特征和连续目标。
+我们将通过实现最近邻来预测住房价值来开始本章。这是从最近邻开始的好方法，因为我们将处理数字特征和连续目标。
 
 ## 准备
 
-为了说明如何在 TensorFlow 中使用最近邻居进行预测，我们将使用波士顿住房数据集。在这里，我们将预测邻域住房价值中位数作为几个特征的函数。
+为了说明如何在 TensorFlow 中使用最近邻进行预测，我们将使用波士顿住房数据集。在这里，我们将预测邻域住房价值中位数作为几个特征的函数。
 
 由于我们考虑训练集训练模型，我们将找到预测点的 KNN，并将计算目标值的加权平均值。
 
@@ -55,7 +55,7 @@
 
 我们按如下方式处理秘籍：
 
-1.  我们将从加载所需的库并开始图会话开始。我们将使用`requests`模块从 UCI 机器学习库加载必要的波士顿住房数据：
+1.  我们将从加载所需的库并启动图会话开始。我们将使用`requests`模块从 UCI 机器学习库加载必要的波士顿住房数据：
 
 ```py
 import matplotlib.pyplot as plt 
@@ -189,7 +189,7 @@ plt.show()
 
 # 使用基于文本的距离
 
-最近邻居比处理数字更通用。只要我们有一种方法来测量特征之间的距离，我们就可以应用最近邻算法。在本文中，我们将介绍如何使用 TensorFlow 测量文本距离。
+最近邻比处理数字更通用。只要我们有一种方法来测量特征之间的距离，我们就可以应用最近邻算法。在本文中，我们将介绍如何使用 TensorFlow 测量文本距离。
 
 ## 准备
 
@@ -289,7 +289,7 @@ print(sess.run(edit_distances, feed_dict=feed_dict))
 
 ## 工作原理
 
-在这个秘籍中，我们展示了我们可以使用 TensorFlow 以多种方式测量文本距离。这对于在具有文本特征的数据上执行最近邻居非常有用。当我们执行地址匹配时，我们将在本章后面看到更多内容。
+在这个秘籍中，我们展示了我们可以使用 TensorFlow 以多种方式测量文本距离。这对于在具有文本特征的数据上执行最近邻非常有用。当我们执行地址匹配时，我们将在本章后面看到更多内容。
 
 ## 更多
 
@@ -357,7 +357,7 @@ weight_diagonal = x_vals.std(0)
 weight_matrix = tf.cast(tf.diag(weight_diagonal), dtype=tf.float32)
 ```
 
-1.  现在，我们将数据分成训练和测试集。我们还将声明`k`，最近邻居的数量，并使批量大小等于测试集大小：
+1.  现在，我们将数据分成训练和测试集。我们还将声明`k`，最近邻的数量，并使批量大小等于测试集大小：
 
 ```py
 train_indices = np.random.choice(len(x_vals), round(len(x_vals)*0.8), replace=False) 
@@ -454,7 +454,7 @@ plt.show()
 
 ## 准备
 
-最近邻是一种用于地址匹配的好算法。地址匹配是一种记录匹配，其中我们在多个数据集中具有地址并且想要匹配它们。在地址匹配中，我们可能在地址，不同城市或不同的邮政编码中存在拼写错误，但它们可能都指向相同的地址。在地址的数字和字符组件上使用最近邻居算法可以帮助我们识别实际上相同的地址。
+最近邻是一种用于地址匹配的好算法。地址匹配是一种记录匹配，其中我们在多个数据集中具有地址并且想要匹配它们。在地址匹配中，我们可能在地址，不同城市或不同的邮政编码中存在拼写错误，但它们可能都指向相同的地址。在地址的数字和字符组件上使用最近邻算法可以帮助我们识别实际上相同的地址。
 
 在此示例中，我们将生成两个数据集。每个数据集将包含街道地址和邮政编码。但是，一个数据集在街道地址中存在大量拼写错误。我们将非拼写数据集作为我们的黄金标准，并将为每个拼写错误地址返回一个地址，该地址最接近字符串距离（对于街道）和数字距离（对于邮政编码）的函数。
 
@@ -750,7 +750,7 @@ for i in range(len(actuals)):
 
 ## 更多
 
-我们还可以使用最近邻居算法来评估用户看不见的数字。有关使用此模型评估用户输入数字的方法，[请参阅在线仓库](https://github.com/nfmcclure/tensorflow_cookbook)。
+我们还可以使用最近邻算法来评估用户看不见的数字。有关使用此模型评估用户输入数字的方法，[请参阅在线仓库](https://github.com/nfmcclure/tensorflow_cookbook)。
 
 在本章中，我们探讨了如何使用 KNN 算法进行回归和分类。我们讨论了距离函数的不同用法，以及如何将它们混合在一起。我们鼓励读者探索不同的距离度量，权重和`k`值，以优化这些方法的准确率。
 
diff --git a/docs/tf-ml-cookbook-2e-zh/ch06.md b/docs/tf-ml-cookbook-2e-zh/ch06.md
index 6388e527ebcfb5d6f222625c5a1c4c014afa1d25..83aa8b04d5d80fa85670e1375a0ac25daf656a93 100644
--- a/docs/tf-ml-cookbook-2e-zh/ch06.md
+++ b/docs/tf-ml-cookbook-2e-zh/ch06.md
@@ -488,7 +488,7 @@ plt.show()
 
 我们将首先看一维数据。我们需要使用以下步骤为此任务生成随机数据数组：
 
-1.  我们首先加载我们需要的库并开始图会话，如下所示：
+1.  我们首先加载我们需要的库并启动图会话，如下所示：
 
 ```py
 import tensorflow as tf 
diff --git a/docs/tf-ml-cookbook-2e-zh/ch07.md b/docs/tf-ml-cookbook-2e-zh/ch07.md
index ad81b2441a34090605ea14ff182526afe24e1482..33cc9fd3626004f533290882c3d36c8841cfcfd1 100644
--- a/docs/tf-ml-cookbook-2e-zh/ch07.md
+++ b/docs/tf-ml-cookbook-2e-zh/ch07.md
@@ -9,7 +9,7 @@
 *   使用 Skip-Gram 嵌入
 *   使用 CBOW 嵌入
 *   使用 word2vec 进行预测
-*   使用 doc2vec 进行情绪分析
+*   使用 doc2vec 进行情感分析
 
 请注意，读者可以在 [Github](https://github.com/nfmcclure/tensorflow_cookbook) 和 [Packt 仓库](https://github.com/PacktPublishing/TensorFlow-Machine-Learning-Cookbook-Second-Edition)中找到本章的所有代码。
 
@@ -236,7 +236,7 @@ for ix, t in enumerate(vocab_processor.fit_transform(texts_train)):
         train_acc_avg.append(np.mean(train_acc_all[-50:]))
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Starting Training Over 4459 Sentences. 
@@ -472,7 +472,7 @@ for i in range(10000):
         print('Generation # {}. Train Loss (Test Loss): {:.2f} ({:.2f}). Train Acc (Test Acc): {:.2f} ({:.2f})'.format(*acc_and_loss)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Generation # 500\. Train Loss (Test Loss): 0.69 (0.73). Train Acc (Test Acc): 0.62 (0.57) 
@@ -810,7 +810,7 @@ for i in range(generations):
 
 > 在前面的代码中，我们在调用`argsort`方法之前采用相似矩阵的否定。我们这样做是因为我们想要找到从最高相似度值到最低相似度值的索引，而不是相反。
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Loss at step 500 : 13.387781143188477 
@@ -1025,7 +1025,7 @@ for i in range(generations):
         print('Model saved in file: {}'.format(save_path)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Loss at step 100 : 62.04829025268555 
@@ -1068,7 +1068,7 @@ elif method=='cbow':
 
 ## 准备
 
-现在我们已经创建并保存了 CBOW 字嵌入，我们需要使用它们来对电影数据集进行情感预测。在本文中，我们将学习如何加载和使用预先训练的嵌入，并使用这些嵌入来通过训练逻辑线性模型来预测好的或坏的评论来执行情绪分析。
+现在我们已经创建并保存了 CBOW 字嵌入，我们需要使用它们来对电影数据集进行情感预测。在本文中，我们将学习如何加载和使用预先训练的嵌入，并使用这些嵌入来通过训练逻辑线性模型来预测好的或坏的评论来执行情感分析。
 
 情感分析是一项非常艰巨的任务，因为人类语言使得很难掌握所谓意义的真实含义的微妙之处和细微差别。讽刺，笑话和含糊不清的引用都使这项任务成倍增加。我们将在电影评论数据集上创建一个简单的逻辑回归，以查看我们是否可以从我们在上一个秘籍中创建并保存的 CBOW 嵌入中获取任何信息。由于本文的重点是加载和使用已保存的嵌入，我们不会追求更复杂的模型。
 
@@ -1076,7 +1076,7 @@ elif method=='cbow':
 
 我们将按如下方式处理秘籍：
 
-1.  我们将首先加载必要的库并开始图会话：
+1.  我们将首先加载必要的库并启动图会话：
 
 ```py
 import tensorflow as tf 
@@ -1283,11 +1283,11 @@ plt.show()
 
 ## 更多
 
-我们可以看到，我们在预测情绪方面几乎达到了 60% 的准确率。例如，要知道单词`great;`背后的含义是一项艰巨的任务，它可以在评论中用于消极或积极的背景。
+我们可以看到，我们在预测情感方面几乎达到了 60% 的准确率。例如，要知道单词`great;`背后的含义是一项艰巨的任务，它可以在评论中用于消极或积极的背景。
 
-为了解决这个问题，我们希望以某种方式为文档本身创建嵌入并解决情绪问题。通常，整个评论是积极的，或者整个评论是否定的。我们可以利用这个优势，我们将在下面的使用 doc2vec 以获取情绪分析方法中查看如何执行此操作。
+为了解决这个问题，我们希望以某种方式为文档本身创建嵌入并解决情感问题。通常，整个评论是积极的，或者整个评论是否定的。我们可以利用这个优势，我们将在下面的使用 doc2vec 以获取情感分析方法中查看如何执行此操作。
 
-# 使用 doc2vec 进行情绪分析
+# 使用 doc2vec 进行情感分析
 
 既然我们知道如何训练单词嵌入，我们也可以扩展这些方法以进行文档嵌入。我们将在以下部分中探讨如何执行此操作。
 
@@ -1295,17 +1295,17 @@ plt.show()
 
 在前面关于 word2vec 方法的部分中，我们设法捕获了单词之间的位置关系。我们没有做的是捕捉单词与它们来自的文档（或电影评论）之间的关系。 word2vec 的一个扩展来捕获文档效果，称为 doc2vec。
 
-doc2vec 的基本思想是引入文档嵌入，以及可能有助于捕获文档基调的单词嵌入。例如，只知道单词`movie`和`love`彼此接近可能无法帮助我们确定评论的情绪。评论可能是谈论他们如何热爱电影或他们如何不爱电影。但是如果评论足够长并且在文档中找到了更多否定词，那么我们可以采用可以帮助我们预测后续词语的整体语气。
+doc2vec 的基本思想是引入文档嵌入，以及可能有助于捕获文档基调的单词嵌入。例如，只知道单词`movie`和`love`彼此接近可能无法帮助我们确定评论的情感。评论可能是谈论他们如何热爱电影或他们如何不爱电影。但是如果评论足够长并且在文档中找到了更多否定词，那么我们可以采用可以帮助我们预测后续词语的整体语气。
 
 Doc2vec 只是为文档添加了一个额外的嵌入矩阵，并使用一个单词窗口加上文档索引来预测下一个单词。文档中的所有文字窗口都具有相同的文档索引。值得一提的是，考虑如何将文档嵌入与单词嵌入相结合是很重要的。我们通过对它们求和来将单词嵌入组合在单词窗口中。将这些嵌入与文档嵌入相结合有两种主要方式：通常，文档嵌入要么添加到单词嵌入中，要么连接到单词嵌入的末尾。如果我们添加两个嵌入，我们将文档嵌入大小限制为与嵌入字大小相同的大小。如果我们连接，我们解除了这个限制，但增加了逻辑回归必须处理的变量数量。为了便于说明，我们将向您展示如何处理此秘籍中的串联。但总的来说，对于较小的数据集，添加是更好的选择。
 
-第一步是将文档和单词嵌入适用于整个电影评论集。然后我们将进行训练测试分组，训练逻辑模型，看看我们是否可以更准确地预测评论情绪。
+第一步是将文档和单词嵌入适用于整个电影评论集。然后我们将进行训练测试分组，训练逻辑模型，看看我们是否可以更准确地预测评论情感。
 
 ## 操作步骤
 
 我们将按如下方式处理秘籍：
 
-1.  我们将从加载必要的库并开始图会话开始，如下所示：
+1.  我们将从加载必要的库并启动图会话开始，如下所示：
 
 ```py
 import tensorflow as tf 
@@ -1481,7 +1481,7 @@ for i in range(generations):
         print('Model saved in file: {}'.format(save_path)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Loss at step 100 : 126.176816940307617 
@@ -1498,7 +1498,7 @@ Nearest to woman: innocuous, scenes, prove, except, lady,
 Model saved in file: /.../temp/doc2vec_movie_embeddings.ckpt 
 ```
 
-1.  现在我们已经训练了 doc2vec 嵌入，我们可以在逻辑回归中使用这些嵌入来预测评论情绪。首先，我们为逻辑回归设置了一些参数。使用以下代码执行此操作：
+1.  现在我们已经训练了 doc2vec 嵌入，我们可以在逻辑回归中使用这些嵌入来预测评论情感。首先，我们为逻辑回归设置了一些参数。使用以下代码执行此操作：
 
 ```py
 max_words = 20 # maximum review word length 
@@ -1568,7 +1568,7 @@ init = tf.global_variables_initializer()
 sess.run(init) 
 ```
 
-1.  现在我们可以开始后勤模型训练了：
+1.  现在我们可以开始 Logistic 模型训练了：
 
 ```py
 train_loss = [] 
@@ -1616,7 +1616,7 @@ for i in range(10000):
         print('Generation # {}. Train Loss (Test Loss): {:.2f} ({:.2f}). Train Acc (Test Acc): {:.2f} ({:.2f})'.format(*acc_and_loss)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Generation # 500\. Train Loss (Test Loss): 5.62 (7.45). Train Acc (Test Acc): 0.52 (0.48) Generation # 10000\. Train Loss (Test Loss): 2.35 (2.51). Train Acc (Test Acc): 0.59 (0.58) 
@@ -1668,7 +1668,7 @@ def generate_batch_data(sentences, batch_size, window_size, method='skip_gram'):
 
 ## 工作原理
 
-在这个秘籍中，我们进行了两个训练循环。第一个是适合 doc2vec 嵌入，第二个循环是为了适应电影情绪的逻辑回归。
+在这个秘籍中，我们进行了两个训练循环。第一个是适合 doc2vec 嵌入，第二个循环是为了适应电影情感的逻辑回归。
 
-虽然我们没有大幅度提高情绪预测准确率（它仍然略低于 60%），但我们在电影语料库中成功实现了 doc2vec 的连接版本。为了提高我们的准确率，我们应该为 doc2vec 嵌入和可能更复杂的模型尝试不同的参数，因为逻辑回归可能无法捕获自然语言中的所有非线性行为。
+虽然我们没有大幅度提高情感预测准确率（它仍然略低于 60%），但我们在电影语料库中成功实现了 doc2vec 的连接版本。为了提高我们的准确率，我们应该为 doc2vec 嵌入和可能更复杂的模型尝试不同的参数，因为逻辑回归可能无法捕获自然语言中的所有非线性行为。
 
diff --git a/docs/tf-ml-cookbook-2e-zh/ch08.md b/docs/tf-ml-cookbook-2e-zh/ch08.md
index 2064f617f0ca3dd2762e6239ae939366f138b5b4..7ad1c1400a3dafa1f85a331f1caf799ece5ac005 100644
--- a/docs/tf-ml-cookbook-2e-zh/ch08.md
+++ b/docs/tf-ml-cookbook-2e-zh/ch08.md
@@ -3,7 +3,7 @@
 卷积神经网络（CNN）负责过去几年中图像识别的重大突破。在本章中，我们将介绍以下主题：
 
 *   实现简单的 CNN
-*   实现先进的 CNN
+*   实现高级的 CNN
 *   重新训练现有的 CNN 模型
 *   应用 Stylenet 和神经式项目
 *   实现 DeepDream
@@ -209,7 +209,7 @@ for i in range(generations):
         print('Generation # {}. Train Loss: {:.2f}. Train Acc (Test Acc): {:.2f} ({:.2f})'.format(*acc_and_loss)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Generation # 5\. Train Loss: 2.37\. Train Acc (Test Acc): 7.00 (9.80) 
@@ -290,7 +290,7 @@ CNN 非常适合图像识别。造成这种情况的部分原因是卷积层创
 *   [迈克尔·尼尔森的深度学习](http://neuralnetworksanddeeplearning.com/chap6.html)
 *   [吴建新介绍卷积神经网络](https://pdfs.semanticscholar.org/450c/a19932fcef1ca6d0442cbf52fec38fb9d1e5.pdf)
 
-# 实现先进的 CNN
+# 实现高级的 CNN
 
 能够扩展 CNN 模型以进行图像识别非常重要，这样我们才能理解如何增加网络的深度。如果我们有足够的数据，这可能会提高我们预测的准确率。扩展 CNN 网络的深度是以标准方式完成的：我们只是重复卷积，最大池和 ReLU，直到我们对深度感到满意为止。许多更精确的图像识别网络以这种方式操作。
 
@@ -575,7 +575,7 @@ for i in range(generations):
         print(acc_output) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 ...
@@ -785,7 +785,7 @@ git clone https://github.com/tensorflow/models/tree/master/research/inception
     --input_queue_memory_factor=1
 ```
 
-1.  这应该导致输出类似于以下内容：
+1.  这应该使输出类似于以下内容：
 
 ```py
 2018-06-02 11:10:10.557012: step 1290, loss = 2.02 (1.2  examples/sec; 23.771 sec/batch)
@@ -1097,7 +1097,7 @@ me@computer:~$ wget https://storage.googleapis.com/download.tensorflow.org/model
 me@computer:~$ unzip inception5h.zip 
 ```
 
-1.  我们首先加载必要的库并开始图会话：
+1.  我们首先加载必要的库并启动图会话：
 
 ```py
 import os 
diff --git a/docs/tf-ml-cookbook-2e-zh/ch09.md b/docs/tf-ml-cookbook-2e-zh/ch09.md
index 608024bdec44efa8cb8c75f2394aa708f2519adc..b68a2ffdc4ac16b7dfa524eefe7e576897083938 100644
--- a/docs/tf-ml-cookbook-2e-zh/ch09.md
+++ b/docs/tf-ml-cookbook-2e-zh/ch09.md
@@ -6,7 +6,7 @@
 *   实现 LSTM 模型
 *   堆叠多个 LSTM 层
 *   创建序列到序列模型
-*   训练暹罗相似性度量
+*   训练 Siamese 相似性度量
 
 本章的所有代码都可以在 [Github](https://github.com/nfmcclure/tensorflow_cookbook) 和 [Packt 在线仓库](https://github.com/PacktPublishing/TensorFlow-Machine-Learning-Cookbook-Second-Edition)。
 
@@ -134,7 +134,7 @@ text_processed = np.array(list(vocab_processor.fit_transform(text_data_train)))
 
 > 请注意，`contrib.learn.preprocessing`中的函数目前已弃用（使用当前的 TensorFlow 版本，1.10）。目前的替换建议 TensorFlow 预处理包仅在 Python2 中运行。将 TensorFlow 预处理移至 Python3 的工作目前正在进行中，并将取代前两行。请记住，所有当前和最新的代码都可以在[这个 GitHub 页面](https://www.github.com/nfmcclure/tensorflow_cookbook)，和 [Packt 仓库](https://github.com/PacktPublishing/TensorFlow-Machine-Learning-Cookbook-Second-Edition)找到。
 
-1.  接下来，我们将数据随机化以使其随机化：
+1.  接下来，我们打乱数据以使其随机化：
 
 ```py
 text_processed = np.array(text_processed) 
@@ -256,7 +256,7 @@ for epoch in range(epochs):
     print('Epoch: {}, Test Loss: {:.2}, Test Acc: {:.2}'.format(epoch+1, temp_test_loss, temp_test_acc)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Vocabulary Size: 933 
@@ -622,7 +622,7 @@ for epoch in range(epochs):
         iteration_count += 1 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Loading Shakespeare Data 
@@ -1371,7 +1371,7 @@ while global_step < hparams.num_train_steps:
 
 ## 操作步骤
 
-1.  我们首先加载必要的库并开始图会话：
+1.  我们首先加载必要的库并启动图会话：
 
 ```py
 import os 
@@ -1673,7 +1673,7 @@ print('Query Addresses: {}'.format(test_queries))
 print('Model Found Matches: {}'.format(best_fit_refs)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Query Addresses: ['111 abbey ln', '271 doner cicle', '314 king avenue', 'tensorflow is fun'] 
diff --git a/docs/tf-ml-cookbook-2e-zh/ch10.md b/docs/tf-ml-cookbook-2e-zh/ch10.md
index 5c5bcd9bb7a68c6375e966f24e27436a601f41cd..9640eefd31f81dbcd3680d6df4102cacfe28adb1 100644
--- a/docs/tf-ml-cookbook-2e-zh/ch10.md
+++ b/docs/tf-ml-cookbook-2e-zh/ch10.md
@@ -6,7 +6,7 @@
 *   使用多个执行程序
 *   并行化 TensorFlow
 *   将 TensorFlow 投入生产
-*   生成 TensorFlow 的一个例子
+*   生产环境 TensorFlow 的一个例子
 *   使用 TensorFlow 服务
 
 # 介绍
diff --git a/docs/tf-ml-cookbook-2e-zh/ch11.md b/docs/tf-ml-cookbook-2e-zh/ch11.md
index 21e23d6adbfafc0e00f8d0b8bc9d6413c5a99e18..5857cb62b83ed8d6fd53403c4108694bd952aec6 100644
--- a/docs/tf-ml-cookbook-2e-zh/ch11.md
+++ b/docs/tf-ml-cookbook-2e-zh/ch11.md
@@ -2,7 +2,7 @@
 
 在本章中，我们将介绍以下秘籍：
 
-*   可视化 TensorBoard 中的图
+*   在 TensorBoard 中可视化的图
 *   使用遗传算法
 *   使用 K 均值聚类
 *   求解常微分方程组
@@ -352,7 +352,7 @@ for i in range(generations):
        print('Generation: {}, Best Fitness (lowest MSE): {:.2}'.format(i, -best_fit)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Generation: 0, Best Fitness (lowest MSE): 1.5 
@@ -476,7 +476,7 @@ for i in range(generations):
     print('Group counts: {}'.format(group_count)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Calculating gen 0, out of 25\. Group counts: [50, 28, 72] Calculating gen 1, out of 25\. Group counts: [50, 35, 65] Calculating gen 23, out of 25\. Group counts: [50, 38, 62] Calculating gen 24, out of 25\. Group counts: [50, 38, 62] 
@@ -498,7 +498,7 @@ accuracy = (group0_count + group1_count + group2_count)/150\.
 print('Accuracy: {:.2}'.format(accuracy)) 
 ```
 
-1.  这导致以下输出：
+1.  这产生以下输出：
 
 ```py
 Accuracy: 0.89 
@@ -581,7 +581,7 @@ Lotka-Volterra 系统于 1920 年在一篇论文中发表（参见图 1，标量
 
 ## 操作步骤
 
-1.  我们首先加载库并开始图会话：
+1.  我们首先加载库并启动图会话：
 
 ```py
 import matplotlib.pyplot as plt 
@@ -623,7 +623,7 @@ init = tf.global_variables_initializer() sess.run(init) # Run the ODE prey_value
 
 A steady state (and cyclic) solution to this specific system, the Lotka-Volterra equations, very much depends on specific parameters and population values. We encourage the reader to try different parameters and values to see what can happen.
 
-1.  现在，我们可以绘制捕食者和猎物的价值：
+1.  现在，我们可以绘制捕食者和猎物的值：
 
 ```py
 plt.plot(prey_values, label="Prey") 
@@ -743,7 +743,7 @@ for ix, column in enumerate(x_train.T):
 input_fun = tf.estimator.inputs.numpy_input_fn(X_dtrain, y=y_train, batch_size=batch_size,        num_epochs=10, shuffle=True)
 ```
 
-1.  现在，我们宣布我们的模型并开始训练：
+1.  现在，我们定义我们的模型并开始训练：
 
 ```py
 model = regression_classifier(feature_columns=feature_cols,
@@ -878,7 +878,7 @@ model.compile(optimizer=tf.train.AdamOptimizer(0.001),
               metrics=['accuracy'])
 ```
 
-1.  这将导致输出应类似于以下内容：
+1.  这将使输出应类似于以下内容：
 
 ```py
 Epoch 1/5