2020-09-09 17:49:25

docs/tf-20-quick-start-guide/02.md

@@ -18,7 +18,7 @@
 
 # Keras 的采用和优势
 
-下图显示了 Keras 在工业和研究领域的广泛应用。 *功率得分*排名由 Jeff Hale 设计，他使用了 7 个不同类别的 11 个数据源来评估框架的使用，兴趣和受欢迎程度。 然后，他对数据进行了加权和合并，[如 2018 年 9 月的这篇文章所示](https://towardsdatascience.com/deep-learning-framework-power-scores-2018-23607ddf297a)：
+下图显示了 Keras 在工业和研究领域的广泛应用。 *PowerScore* 排名由 Jeff Hale 设计，他使用了 7 个不同类别的 11 个数据源来评估框架的使用，兴趣和受欢迎程度。 然后，他对数据进行了加权和合并，[如 2018 年 9 月的这篇文章所示](https://towardsdatascience.com/deep-learning-framework-power-scores-2018-23607ddf297a)：
 
 ![](img/d90b06ca-d15d-4741-9f7c-511735d3181c.png)
 
@@ -52,7 +52,7 @@ Keras 可能是不寻常的，因为它具有作为独立开源项目维护的
 
 尽管 TensorFlow 在`tf.keras`模块中确实具有 Keras 的完整实现，但它独立于 TensorFlow 进行维护。 默认情况下，该实现具有 TensorFlow 特定的增强功能，包括对急切执行的支持。
 
-急切的执行意味着代码的执行是命令式编程环境，而不是基于图的环境，这是在 TensorFlow（v1.5 之前）的初始产品中工作的唯一方法。 这种命令式（即刻）样式允许直观的调试，快速的开发迭代，支持 TensorFlow `SavedModel`格式，并内置支持对 CPU，GPU 甚至 Google 自己的硬件 **Tensor 进行分布式培训 处理单元**（**TPU**）。
+急切的执行意味着代码的执行是命令式编程环境，而不是基于图的环境，这是在 TensorFlow（v1.5 之前）的初始产品中工作的唯一方法。 这种命令式（即刻）样式允许直观的调试，快速的开发迭代，支持 TensorFlow `SavedModel`格式，并内置支持对 CPU，GPU 甚至 Google 自己的硬件**张量处理单元**（**TPU**）进行分布式训练。
 
 TensorFlow 实施还支持`tf.data`，分发策略，导出模型（可通过 TensorFlow Lite 部署在移动和嵌入式设备上）以及用于表示和分类结构化数据的功能列。
 
@@ -75,7 +75,7 @@ $HOME/.keras/keras.json
 默认值如下：
 
 *   `image_data_format`：这是图像格式的字符串，`"channels_last"`或`channels_first`。 在 TensorFlow 之上运行的 Keras 使用默认值。
-*   `epsilon`：这是一个浮点数，是一个数字*模糊*常数，用于在某些操作中避免被零除。
+*   `epsilon`：这是一个浮点数，是一个*模糊*常数，用于在某些操作中避免被零除。
 
 *   `floatx`：这是一个字符串，指定默认的浮点精度，为`"float16"`，`"float32"`或`"float64"`之一。
 *   `backend`：这是一个字符串，指定 Keras 在`"tensorflow"`，`"theano"`或`"cntk"`中的一种之上发现自己的工具。
@@ -130,7 +130,7 @@ const
 
 # 硬数据类型
 
-Keras **数据类型**（**dtypes**）与 TensorFlow Python 数据类型相同，如下表所示：
+Keras **数据类型**（`dtypes`）与 TensorFlow Python 数据类型相同，如下表所示：
 
 | Python 类型 | 描述 |
 | --- | --- |
@@ -156,11 +156,11 @@ Keras 基于神经网络模型的概念。 主要模型称为**序列**，是层
 
 # Keras 顺序模型
 
-要构建 Keras `Sequential`模型，请*向其中添加*层，其顺序与您希望网络进行计算的顺序相同。
+要构建 Keras `Sequential`模型，请*向其中添加层*，其顺序与您希望网络进行计算的顺序相同。
 
 建立模型后，您可以*编译*； 这样可以优化要进行的计算，并且可以在其中分配优化器和希望模型使用的损失函数。
 
-下一步是*使模型适合*数据。 这通常称为训练模型，是所有计算发生的地方。 可以分批或一次将数据呈现给模型。
+下一步是*使模型拟合数据*。 这通常称为训练模型，是所有计算发生的地方。 可以分批或一次将数据呈现给模型。
 
 接下来，您评估模型以建立其准确性，损失和其他指标。 最后，在训练好模型之后，您可以使用它对新数据进行预测。 因此，工作流程是：构建，编译，拟合，评估，做出预测。
 
@@ -199,7 +199,7 @@ 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
@@ -215,9 +215,9 @@ model1 = tf.keras.models.Sequential([
 
 ![](img/8fc9b424-7555-4e7c-a146-7d05f35034c0.png)
 
-`401920`的图形来自输入= 28 x 28 = 784 x 512（`dense_2`层）=给出 *784 * 512 = 401,408* 以及每个`dense_1`层神经元的偏置单元 ，则 *401,408 + 512 = 401,92* 0。
+`401920`的数字来自输入`28 x 28 = 784 x 512`（`dense_2`层）输出`784 * 512 = 401,408`以及每个`dense_1`层神经元的偏置单元 ，则`401,408 + 512 = 401,920`。
 
-`5130`的数字来自 *512 * 10 + 10 = 5,130* 。
+`5130`的数字来自`512 * 10 + 10 = 5,130`。
 
 接下来，我们编译模型，如以下代码所示：
 
@@ -344,7 +344,7 @@ Keras `Model`类可以被子类化，如下面的代码所示。 Google 指出
 
 首先，请注意如何在构造函数（`.__init__()`）中分别声明和命名图层。
 
-然后，注意在`call()`方法中各层如何以功能样式链接在一起。 此方法封装了*前向通过*：
+然后，注意在`call()`方法中各层如何以功能样式链接在一起。 此方法封装了*前向传播*：
 
 ```py
 class MyModel(tf.keras.Model):
@@ -388,7 +388,7 @@ model4.fit(train_x, train_y, batch_size=batch_size, epochs=epochs)
 
 # 使用数据管道
 
-也可以使用以下代码将数据作为`tf.data.Dataset()`迭代器传递到`fit`方法中（数据获取代码与先前描述的相同）。 `from_tensor_slices()`方法将 NumPy 数组转换为数据集。 注意`batch()`和`shuffle()`方法链接在一起。 接下来，`map()`方法在输入图像`x`上调用一种方法，该方法在 *y* 轴上随机翻转其中的两个，有效地增加了图像集的大小。 标签`y`在这里保持不变。 最后，`repeat()`方法意味着在到达数据集的末尾（连续）时，将从头开始重新填充该数据集：
+也可以使用以下代码将数据作为`tf.data.Dataset()`迭代器传递到`fit`方法中（数据获取代码与先前描述的相同）。 `from_tensor_slices()`方法将 NumPy 数组转换为数据集。 注意`batch()`和`shuffle()`方法链接在一起。 接下来，`map()`方法在输入图像`x`上调用一种方法，该方法在`y`轴上随机翻转其中的两个，有效地增加了图像集的大小。 标签`y`在这里保持不变。 最后，`repeat()`方法意味着在到达数据集的末尾（连续）时，将从头开始重新填充该数据集：
 
 ```py
 batch_size = 32

docs/tf-20-quick-start-guide/03.md

@@ -4,7 +4,7 @@
 
 在本章中，我们将介绍以下主题：
 
-*   将数据呈现给**人工神经网络** **twork**（**AN** **N**）
+*   将数据呈现给**人工神经网络**（**ANN**）
 *   神经网络层
 *   梯度下降算法的梯度计算
 *   损失函数
@@ -48,7 +48,7 @@ for item in num_list1_dataset:
     print(num)
 ```
 
-请注意，由于我们使用的是**单发**迭代器，因此在同一程序运行中两次执行此代码会引发错误。
+请注意，由于我们使用的是**单次**迭代器，因此在同一程序运行中两次执行此代码会引发错误。
 
 也可以使用`batch`方法批量访问数据。 请注意，第一个参数是每个批次中要放置的元素数，第二个参数是不言自明的`drop_remainder`参数：
 
@@ -150,7 +150,7 @@ or item in dataset:
 
 由于 TFRecord 文件是二进制字符串序列，因此必须在保存之前指定其结构，以便可以正确地写入并随后回读。 TensorFlow 为此具有两个结构，即`tf.train.Example`和`tf.train.SequenceExample`。 您要做的是将每个数据样本存储在这些结构之一中，然后对其进行序列化，然后使用`tf.python_io.TFRecordWriter`将其保存到磁盘。
 
-在下面的示例中，浮点数组`data`被转换为二进制格式，然后保存到磁盘。 `feature`是一个字典，包含在序列化和保存之前传递给`tf.train.Example`的数据。 *TFRecord 示例 2* 中显示了更详细的示例：
+在下面的示例中，浮点数组`data`被转换为二进制格式，然后保存到磁盘。 `feature`是一个字典，包含在序列化和保存之前传递给`tf.train.Example`的数据。 “TFRecord 示例 2”中显示了更详细的示例：
 
 TFRecords 支持的字节数据类型为`FloatList`，`Int64List`和`BytesList`。
 
@@ -217,7 +217,7 @@ Scores = tf.train.Feature(float_list=tf.train.FloatList(value=data['Scores']))
 example = tf.train.Example(features=tf.train.Features(feature={'ID': ID, 'Name': Name, 'Scores': Scores }))
 ```
 
-将此记录串行化并将其写入光盘与 *TFRecord 示例 1* 相同：
+将此记录串行化并将其写入光盘与“TFRecord 示例 1”相同：
 
 ```py
 writer = tf.io.TFRecordWriter(filename)
@@ -267,9 +267,9 @@ print("Name:",name1,",",name2)
 print("Scores: ",item[2].values.numpy())
 ```
 
-# 一键编码
+# 单热编码
 
-**一键编码**（**OHE**）是根据数据标签构造张量的方法，在每个标签中，与标签值相对应的每个元素中的数字为 1，其他地方为 0； 也就是说，张量中的位之一是热的（1）。
+**单热编码**（**OHE**）是根据数据标签构造张量的方法，在每个标签中，与标签值相对应的每个元素中的数字为 1，其他地方为 0； 也就是说，张量中的位之一是热的（1）。
 
 # OHE 示例 1
 
@@ -319,11 +319,11 @@ print(y_train_ohe[i]) #
 
 接下来，我们将检查神经网络的基本数据结构：神经元的**层**。
 
-# 层数
+# 层
 
-ANN 使用的基本数据结构是**层**，许多相互连接的层构成了一个完整的 ANN。 可以将一层设想为神经元的阵列，尽管使用单词*神经元*可能会产生误导，因为在人脑神经元和构成一层的人工神经元之间只有很少的对应关系。 记住这一点，我们将在下面使用术语*神经元*。 与任何计算机处理单元一样，神经元的特征在于其输入和输出。 通常，神经元具有许多输入和一个输出值。 每个输入连接均带有权重 *w* <sub>*i*</sub> <sub>。</sub>
+ANN 使用的基本数据结构是**层**，许多相互连接的层构成了一个完整的 ANN。 可以将一层设想为神经元的阵列，尽管使用单词*神经元*可能会产生误导，因为在人脑神经元和构成一层的人工神经元之间只有很少的对应关系。 记住这一点，我们将在下面使用术语*神经元*。 与任何计算机处理单元一样，神经元的特征在于其输入和输出。 通常，神经元具有许多输入和一个输出值。 每个输入连接均带有权重`w[i]`。
 
-下图显示了一个神经元。 重要的是要注意，激活函数 **f** 对于平凡的 ANN 而言是非线性的。 网络中的一般神经元接收来自其他神经元的输入，并且每个神经元的权重为 **w <sub>i</sub>** ，如图所示，网络*通过调整这些权重来学习*。 权重，以便输入生成所需的输出：
+下图显示了一个神经元。 重要的是要注意，激活函数`f`对于平凡的 ANN 而言是非线性的。 网络中的一般神经元接收来自其他神经元的输入，并且每个神经元的权重为`w[i]`，如图所示，网络*通过调整这些权重来学习权重*，以便输入生成所需的输出：
 
 ![](img/67592e56-0b8c-42e6-936d-5bae84a9e962.png)
 
@@ -341,7 +341,7 @@ ANN 使用的基本数据结构是**层**，许多相互连接的层构成了一
 
 ![](img/3b1b9398-5ec7-4c65-9bca-d3096545e6c1.png)
 
-在此， *W* 是输入的权重， *X* 是输入向量， *f* 是非线性激活函数。
+在此， `W`是输入的权重， `X`是输入向量， `f`是非线性激活函数。
 
 层的类型很多，支持大量的 ANN 模型结构。 可以在[这个页面](https://www.tensorflow.org/api_docs/python/tf/keras/layers)中找到非常全面的列表。
 
@@ -353,7 +353,7 @@ ANN 使用的基本数据结构是**层**，许多相互连接的层构成了一
 
 `layer = tf.keras.layers.Dense(n)`行构成了一个密集层，其中`n`是输出单元的数量。
 
-注意，致密层是一维的。 请参考*型号*的部分。
+注意，密集层是一维的。 请参考“模型”的部分。
 
 # 卷积层
 
@@ -361,9 +361,9 @@ ANN 使用的基本数据结构是**层**，许多相互连接的层构成了一
 
 对于图像，卷积层具有部分签名`tf.keras.layers.Conv2D(filters, kernel_size, strides=1, padding='valid')`。
 
-因此，在下面的示例中，该第一层具有一个大小为（1,1）的过滤器，并且其填充有效。 其他填充可能性是*相同*。
+因此，在下面的示例中，该第一层具有一个大小为（1,1）的过滤器，并且其填充`'valid'`。 其他填充可能性是`'same'`。
 
-区别在于，使用相同的*填充*，必须在外部填充该层（通常用零填充），以便在卷积发生后，输出大小与该层大小相同。 如果使用有效的填充，则不会进行填充，并且如果跨度和内核大小的组合不能完全适合该层，则该层将被截断。 输出大小小于正在卷积的图层：**
+区别在于，使用`'same'`填充，必须在外部填充该层（通常用零填充），以便在卷积发生后，输出大小与该层大小相同。 如果使用`'valid'`填充，则不会进行填充，并且如果跨度和内核大小的组合不能完全适合该层，则该层将被截断。 输出大小小于正在卷积的图层：
 
 ```py
 seqtial_Net = tf.keras.Sequential([tf.keras.layers.Conv2D(   1, (1, 1), strides = 1, padding='valid')
@@ -401,7 +401,7 @@ tf.keras.layers.BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001, center
 layer = tf.keras.layers.BatchNormalization()
 ```
 
-**退出层**是其中一定百分比的神经元在训练过程中（而不是在推理过程中）随机关闭的层。 由于不鼓励单个神经元对其输入进行专门化，因此这迫使网络在泛化方面变得更好。
+**丢弃层**是其中一定百分比的神经元在训练过程中（而不是在推理过程中）随机关闭的层。 由于不鼓励单个神经元对其输入进行专门化，因此这迫使网络在泛化方面变得更好。
 
 `Dropout`层的签名如下：
 
@@ -431,7 +431,7 @@ layer = tf.keras.layers.Dropout(rate = 0.5)
 model2.add(tf.keras.layers.Dense(10,activation=tf.nn.softmax))
 ```
 
-这将添加具有 10 个神经元的致密 softmax 层，其中神经元的激活总数为 1。
+这将添加具有 10 个神经元的密集 softmax 层，其中神经元的激活总数为 1。
 
 接下来，我们将进一步讨论激活功能。
 
@@ -450,7 +450,7 @@ model2.add(tf.keras.layers.Dense(10,activation=tf.nn.softmax))
 *   **方法 3** ：使用 Keras 功能 API
 *   **方法 4** ：通过将`tf.keras.Model`对象子类化
 
-有关这四种方法的详细信息，请参考 TensorFlow 2 的高级 API 第 2 章和 *Keras。*
+有关这四种方法的详细信息，请参考第 2 章“TensorFlow 2 的高级 API，Keras”。
 
 # 梯度下降算法的梯度计算
 
@@ -516,7 +516,7 @@ print(weight3_grad.numpy()) #6.0
 
 ![](img/1aa3395d-d5c9-498b-9eca-7c82a3a99208.png)，
 
-在此， *y* 是实际标签值，![](img/97fd9641-fe8c-4692-90ef-5485db2fc164.png)是预测标签值。
+在此， `y`是实际标签值，`y_hat`是预测标签值。
 
 特别值得注意的是分类交叉熵`loss`函数，它由以下方程式给出：
 

docs/tf-20-quick-start-guide/04.md

@@ -9,7 +9,7 @@
 *   我们的第一个线性回归示例
 *   波士顿住房数据集
 *   逻辑回归（分类）
-*   **k 最近邻居**（**KNN**）
+*   **k 最近邻**（**KNN**）
 
 # 监督学习
 
@@ -17,7 +17,7 @@
 
 # 线性回归
 
-线性回归问题是在给定一个或多个其他变量（数据点）的值的情况下，您必须预测一个*连续*变量的值的问题。 例如，根据房屋的占地面积，预测房屋的售价。 在这些示例中，您可以将已知特征及其关联的标签绘制在简单的线性图上，如熟悉的 *x* ， *y* 散点图，并绘制最适合数据的线 。 这就是最适合的**系列。 然后，您可以读取对应于该图的 *x* 范围内的任何要素值的标签。**
+线性回归问题是在给定一个或多个其他变量（数据点）的值的情况下，您必须预测一个*连续*变量的值的问题。 例如，根据房屋的占地面积，预测房屋的售价。 在这些示例中，您可以将已知特征及其关联的标签绘制在简单的线性图上，如熟悉的`x, y`散点图，并绘制最适合数据的线 。 这就是最适合的**系列**。 然后，您可以读取对应于该图的`x`范围内的任何要素值的标签。
 
 但是，线性回归问题可能涉及几个特征，其中使用了术语**多个**或**多元线性回归**。 在这种情况下，不是最适合数据的线，而是一个平面（两个要素）或一个超平面（两个以上要素）。 在房价示例中，我们可以将房间数量和花园的长度添加到要素中。 有一个著名的数据集，称为 Boston housing 数据集，[涉及 13 个特征](https://www.kaggle.com/c/ml210-boston)。 考虑到这 13 个特征，此处的回归问题是预测波士顿郊区的房屋中位数。
 
@@ -27,7 +27,7 @@
 
 我们将从一个简单的，人为的，线性回归问题开始设置场景。 在此问题中，我们构建了一个人工数据集，首先在其中创建，因此知道了我们要拟合的线，但是随后我们将使用 TensorFlow 查找这条线。
 
-我们执行以下操作-在导入和初始化之后，我们进入一个循环。 在此循环内，我们计算总损失（定义为点的数据集 *y* 的均方误差）。 然后，我们根据我们的体重和偏见来得出这种损失的导数。 这将产生可用于调整权重和偏差以降低损失的值； 这就是所谓的梯度下降。 通过多次重复此循环（技术上称为**时期**），我们可以将损失降低到尽可能低的程度，并且可以使用训练有素的模型进行预测。
+我们执行以下操作-在导入和初始化之后，我们进入一个循环。 在此循环内，我们计算总损失（定义为点的数据集`y`的均方误差）。 然后，我们根据我们的体重和偏见来得出这种损失的导数。 这将产生可用于调整权重和偏差以降低损失的值； 这就是所谓的梯度下降。 通过多次重复此循环（技术上称为**周期**），我们可以将损失降低到尽可能低的程度，并且可以使用训练有素的模型进行预测。
 
 首先，我们导入所需的模块（回想一下，急切执行是默认的）：
 
@@ -390,7 +390,7 @@ class LogisticRegression(tf.keras.Model):
 
 接下来，我们建立一个`ModelCheckpoint`实例，该实例用于保存训练期间的最佳模型，然后使用`model.fit`调用训练模型。
 
-找出`model.compile`和`model.fit`（以及所有其他 Python 或 TensorFlow 类或方法）的所有不同参数的最简单方法是在 Jupyter Notebook 中工作，然后按 *Shift* + *选项卡* + *选项卡*，当光标位于相关类或方法调用上时。
+找出`model.compile`和`model.fit`（以及所有其他 Python 或 TensorFlow 类或方法）的所有不同参数的最简单方法是在 Jupyter Notebook 中工作，然后按`Shift + TAB + TAB`，当光标位于相关类或方法调用上时。
 
 从代码中可以看到，`model.fit`在训练时使用`callbacks`方法（由验证准确性确定）保存最佳模型，然后加载最佳模型。 最后，我们在测试集上评估模型，如下所示：
 
@@ -458,9 +458,9 @@ for i, index in enumerate(np.random.choice(x_test.shape[0], size = size, replace
 
 到此结束我们对逻辑回归的研究。 现在，我们将看看另一种非常强大的监督学习技术，即 k-Nearest Neighbors。
 
-# k 最近邻居（KNN）
+# k 最近邻（KNN）
 
-KNN 背后的想法相对简单。 给定新的特定数据点的值，请查看该点的 KNN，并根据该 k 个邻居的标签为该点分配标签，其中 *k* 是算法的参数。
+KNN 背后的想法相对简单。 给定新的特定数据点的值，请查看该点的 KNN，并根据该 k 个邻居的标签为该点分配标签，其中`k`是算法的参数。
 
 在这种情况下，没有这样构造的模型。 该算法仅查看数据集中新点与所有其他数据点之间的所有距离，接下来，我们将使用由三种类型的鸢尾花组成的著名数据集：`iris setosa`， `iris virginica`和`iris versicolor`。 对于这些标签中的每一个，特征都是花瓣长度，花瓣宽度，萼片长度和萼片宽度。 有关显示此数据集的图表，请参见[这里](https://en.wikipedia.org/wiki/Iris_flower_data_set#/media/File:Iris_dataset_scatterplot.svg)。
 
@@ -529,9 +529,9 @@ k = 5
 
 接下来，在 Jupyter Notebook 中，我们具有预测测试数据点类别的功能。 我们将逐行对此进行细分。
 
-首先是我们的`distance`功能。 执行此功能后，可变距离包含我们 120 个训练点与 30 个测试点之间的所有（曼哈顿）距离； 也就是说，由 30 行乘 120 列组成的数组-曼哈顿距离，有时也称为**城市街区距离**，是 *x 的两个数据点向量的值之差的绝对值 <sub>1</sub>* 和 *x* *<sub>2</sub>* ； 即 *| x* *<sub>1</sub> -x <sub>2</sub> |* 。 如果需要的话（如本例所示），将使用各个特征差异的总和。
+首先是我们的`distance`功能。 执行此功能后，可变距离包含我们 120 个训练点与 30 个测试点之间的所有（曼哈顿）距离； 也就是说，由 30 行乘 120 列组成的数组-曼哈顿距离，有时也称为**城市街区距离**，是`x[1], x[2]`的两个数据点向量的值之差的绝对值； 即`|x[1] - x[2]|`。 如果需要的话（如本例所示），将使用各个特征差异的总和。
 
-`tf.expand`在`test_x`上增加了一个额外的维数，以便在减法发生之前，可以通过广播使两个阵列*扩大*以使其与减法兼容。 由于`x`具有四个特征，并且`reduce_sum`超过`axis=2`，因此结果是我们 30 个测试点和 120 个训练点之间的距离的 30 行。 所以我们的`prediction`函数是：
+`tf.expand`在`test_x`上增加了一个额外的维数，以便在减法发生之前，可以通过广播使两个阵列*扩展*以使其与减法兼容。 由于`x`具有四个特征，并且`reduce_sum`超过`axis=2`，因此结果是我们 30 个测试点和 120 个训练点之间的距离的 30 行。 所以我们的`prediction`函数是：
 
 ```py
 def prediction(train_x, test_x, train_y,k):
@@ -605,4 +605,4 @@ print("Accuracy = ",accuracy,"%")
 
 在本章中，我们看到了在涉及线性回归的两种情况下使用 TensorFlow 的示例。 其中将特征映射到具有连续值的已知标签，从而可以对看不见的特征进行预测。 我们还看到了逻辑回归的一个示例，更好地描述为分类，其中将要素映射到分类标签，再次允许对看不见的要素进行预测。 最后，我们研究了用于分类的 KNN 算法。
 
-我们现在将在第 5 章和*中使用 TensorFlow 2* 进行无监督学习，继续进行无监督学习，在该过程中，要素和标签之间没有初始映射，并且 TensorFlow 的任务是 发现功能之​​间的关系。
\ No newline at end of file
+我们现在将在第 5 章“将 TensorFlow 2 用于无监督学习”，继续进行无监督学习，在该过程中，要素和标签之间没有初始映射，并且 TensorFlow 的任务是 发现功能之​​间的关系。
\ No newline at end of file

docs/tf-20-quick-start-guide/05.md

@@ -438,14 +438,14 @@ print(decoded.shape)
 
 看看我们如何得出参数数字很有启发性。
 
-公式是参数数量= *过滤器数量 x 内核大小 x 上一层的深度+过滤器数量（用于偏差）*：
+公式是参数数量 = 过滤器数量 x 内核大小 x 上一层的深度 + 过滤器数量（用于偏差）：
 
 *   input_1：这是一个占位符，没有可训练的参数
-*   conv2d：过滤器数量= 32，内核大小= *3 * 3 = 9* ，上一层的深度= 1，因此 *32 * 9 + 32 = 320*
+*   conv2d：过滤器数量`= 32`，内核大小`= 3 * 3 = 9`，上一层的深度`= 1`，因此`32 * 9 + 32 = 320`
 *   max_pooling2d：最大池化层没有可训练的参数。
-*   conv2d_1：过滤器数= 32，内核大小= *3 * 3 = 9* ，上一层的深度= 14，因此 *32 * 9 * 32 + 32 = 9,248*
+*   conv2d_1：过滤器数`= 32`，内核大小`= 3 * 3 = 9`，上一层的深度`= 14`，因此`32 * 9 * 32 + 32 = 9,248`
 *   conv_2d_2，conv2d_3：与 conv2d_1 相同
-*   conv2d_4：*1 * 9 * 32 +1 = 289*
+*   conv2d_4：`1 * 9 * 32 + 1 = 289`
 
 # 模型实例化，编译和训练
 
@@ -518,7 +518,7 @@ tensorboard  --logdir=./tmp/tb
 
 然后，您需要将浏览器指向`http://localhost:6006`。
 
-下图显示了作为训练和验证时间的函数（ *x* -轴）的损失（ *y* -轴）：
+下图显示了作为训练和验证时间的函数（`x`轴）的损失（`y`轴）：
 
 下图显示了训练损失：