2020-09-09 18:32:01

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

@@ -32,7 +32,7 @@ TensorFlow 是 Python 中最受欢迎的机器学习框架之一。 通过这本
 
 # 充分利用这本书
 
-假定熟悉 Python 3.6，并且熟悉 Jupyter Notebook 的使用。
+假定熟悉 Python 3.6，并且熟悉 Jupyter 笔记本的使用。
 
 本书的编写是假定读者比以文本形式出现的冗长文本解释更高兴以代码段和完整程序的形式给出的解释，当然，后者以不同的风格出现在本书中。
 

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

@@ -37,7 +37,7 @@ image1 = tf.zeros([7, 28, 28, 3]) #  example-within-batch by height by width by
 
 **TensorFlow.js** 是 API 的集合，可让您使用底层 JavaScript 线性代数库或高层 API 来构建和训练模型。 因此，可以训练模型并在浏览器中运行它们。
 
-**TensorFlow Lite** 是适用于移动和嵌入式设备的 TensorFlow 的轻量级版本。 它由运行时解释器和一组实用程序组成。 这个想法是您在功率更高的机器上训练模型，然后使用实用程序将模型转换为`.tflite`格式。 然后将模型加载到您选择的设备中。 在撰写本文时，使用 C ++ API 在 Android 和 iOS 上支持 TensorFlow Lite，并且具有适用于 Android 的 Java 包装器。 如果 Android 设备支持 **Android 神经​​网络**（**ANN**）API 进行硬件加速，则解释器将使用此 API，否则它将默认使用 CPU 执行。
+**TensorFlow Lite** 是适用于移动和嵌入式设备的 TensorFlow 的轻量级版本。 它由运行时解释器和一组实用程序组成。 这个想法是您在功率更高的机器上训练模型，然后使用实用程序将模型转换为`.tflite`格式。 然后将模型加载到您选择的设备中。 在撰写本文时，使用 C++ API 在 Android 和 iOS 上支持 TensorFlow Lite，并且具有适用于 Android 的 Java 包装器。 如果 Android 设备支持 **Android 神经​​网络**（**ANN**）API 进行硬件加速，则解释器将使用此 API，否则它将默认使用 CPU 执行。
 
 **TensorFlow Hub** 是一个旨在促进机器学习模型的可重用模块的发布，发现和使用的库。 在这种情况下，模块是 TensorFlow 图的独立部分，包括其权重和其他资产。 该模块可以通过称为转移学习的方法在不同任务中重用。 这个想法是您在大型数据集上训练模型，然后将适当的模块重新用于您的其他但相关的任务。 这种方法具有许多优点-您可以使用较小的数据集训练模型，可以提高泛化能力，并且可以大大加快训练速度。
 
@@ -57,7 +57,7 @@ TensorFlow 的一项最新开发（在撰写本文时仍处于实验形式）将
 
 TensorFlow 的最佳编程支持是为 Python 提供的（尽管确实存在 Java，C 和 Go 的库，而其他语言的库正在积极开发中）。
 
-Web 上有大量信息可用于安装 TensorFlow for Python。
+Web 上有大量信息可用于为 Python 安装 TensorFlow。
 
 Google 也建议在虚拟环境中安装 TensorFlow，这是一种标准做法，该环境将一组 API 和代码与其他 API 和代码以及系统范围的环境隔离开来。
 
@@ -75,7 +75,7 @@ TensorFlow 有两种不同的版本-一个用于在 CPU 上执行，另一个用
 
 # 内务和急切的操作
 
-我们将首先介绍如何导入 TensorFlow，然后介绍 TensorFlow 编码风格，以及如何进行一些基本的整理工作。 之后，我们将看一些基本的 TensorFlow 操作。 您可以为这些代码片段创建 Jupyter Notebook，也可以使用自己喜欢的 IDE 创建源代码。 该代码在 GitHub 存储库中都可用。
+我们将首先介绍如何导入 TensorFlow，然后介绍 TensorFlow 编码风格，以及如何进行一些基本的整理工作。 之后，我们将看一些基本的 TensorFlow 操作。 您可以为这些代码片段创建 Jupyter 笔记本，也可以使用自己喜欢的 IDE 创建源代码。 该代码在 GitHub 存储库中都可用。
 
 # 导入 TensorFlow
 
@@ -90,13 +90,13 @@ print("Keras version: {}".format(tf.keras.__version__))
 
 # TensorFlow 的编码风格约定
 
-对于 Python 应用程序，Google 遵守 PEP8 标准约定。 特别是，他们将 CamelCase 用于类（例如`hub.LatestModuleExporter`），将`snake_case`用于功能，方法和属性（例如`tf.math.squared_difference`）。 Google 还遵守《 Google Python 风格指南》，该指南可在[这个页面](https://github.com/google/styleguide/blob/gh-pages/pyguide.md)中找到。
+对于 Python 应用程序，Google 遵守 PEP8 标准约定。 特别是，他们将 CamelCase 用于类（例如`hub.LatestModuleExporter`），将`snake_case`用于功能，方法和属性（例如`tf.math.squared_difference`）。 Google 还遵守《Google Python 风格指南》，该指南可在[这个页面](https://github.com/google/styleguide/blob/gh-pages/pyguide.md)中找到。
 
 # 使用急切的执行
 
 急切执行是 TensorFlow 2 中的默认设置，因此不需要特殊设置。
 
-以下代码可用于查找是否正在使用 CPU 或 GPU，如果它是 GPU，则该 GPU 是否为＃0。
+以下代码可用于查找是否正在使用 CPU 或 GPU，如果它是 GPU，则该 GPU 是否为`#0`。
 
 我们建议键入代码，而不要使用复制和粘贴。 这样，您将对以下命令有所了解：
 
@@ -113,7 +113,7 @@ else:
 
 # 声明急切变量
 
-声明 TensorFlow eager 变量的方法如下：
+声明 TensorFlow 急切变量的方法如下：
 
 ```py
 t0 = 24 # python variable
@@ -255,7 +255,7 @@ t3
 <tf.Tensor: id=75, shape=(), dtype=float32, numpy=8.0>
 ```
 
-# 将张量转换为 NumPy / Python 变量
+# 将张量转换为 NumPy/Python 变量
 
 如果需要，可以将张量转换为`numpy`变量，如下所示：
 
@@ -665,7 +665,7 @@ tf.Tensor(
 
 这是一个适合从[这个页面](https://colab.research.google.com/notebooks/mlcc/creating_and_manipulating_tensors.ipynb#scrollTo=6UUluecQSCvr)执行的小示例。
 
-请注意，此示例显示了如何通过调用 TensorFlow 函数来初始化 eager 变量。
+请注意，此示例显示了如何通过调用 TensorFlow 函数来初始化急切变量。
 
 ```py
  dice1 = tf.Variable(tf.random.uniform([10, 1], minval=1, maxval=7, dtype=tf.int32))
@@ -760,7 +760,7 @@ indices of min across cols: tf.Tensor([0 1 1], shape=(3,), dtype=int64)
 
 # 使用检查点保存和恢复张量值
 
-为了保存和加载张量值，这是最好的方法（有关保存完整模型的方法，请参见第 2 章和 “Keras，TensorFlow 2” 的高级 API） ）：
+为了保存和加载张量值，这是最好的方法（有关保存完整模型的方法，请参见第 2 章和 “Keras，TensorFlow 2” 的高级 API）：
 
 ```py
 variable = tf.Variable([[1,3,5,7],[11,13,17,19]])
@@ -779,7 +779,7 @@ print(variable)
 <tf.Variable 'Variable:0' shape=(2, 4) dtype=int32, numpy= array([[ 1, 3, 5, 7],  [11, 13, 17, 19]], dtype=int32)>
 ```
 
-# 使用 tf.function
+# 使用`tf.function`
 
 `tf.function`是将采用 Python 函数并返回 TensorFlow 图的函数。 这样做的好处是，图可以在 Python 函数（`func`）中应用优化并利用并行性。 `tf.function`是 TensorFlow 2 的新功能。
 

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

@@ -80,7 +80,7 @@ $HOME/.keras/keras.json
 *   `floatx`：这是一个字符串，指定默认的浮点精度，为`"float16"`，`"float32"`或`"float64"`之一。
 *   `backend`：这是一个字符串，指定 Keras 在`"tensorflow"`，`"theano"`或`"cntk"`中的一种之上发现自己的工具。
 
-对于所有这些值，在`keras.backend`中有 getter 和 setter 方法。 参见[这里](https://keras.io/backend/)。
+对于所有这些值，在`keras.backend`中有获取器和设置器方法。 参见[这里](https://keras.io/backend/)。
 
 例如，在以下集合中，供 Keras 使用的浮点类型为`floatx`，其中`floatx`参数是以下命令中所示的三种精度之一：
 
@@ -152,7 +152,7 @@ Keras **数据类型**（`dtypes`）与 TensorFlow Python 数据类型相同，
 
 # 硬模型
 
-Keras 基于神经网络模型的概念。 主要模型称为**序列**，是层的线性堆栈。 还有一个使用 Keras 功能 API 的系统。
+Keras 基于神经网络模型的概念。 主要模型称为**序列**，是层的线性堆栈。 还有一个使用 Keras 函数式 API 的系统。
 
 # Keras 顺序模型
 
@@ -172,7 +172,7 @@ Keras 基于神经网络模型的概念。 主要模型称为**序列**，是层
 
 在下一章中，我们将对层进行更多的讨论。 目前，我们将仅作足够的解释，以使您了解此处发生的情况。
 
-采集数据。 `mnist`是手绘数字的数据集，每个数字在 28 x 28 像素的网格上。 每个单独的数据点都是一个无符号的 8 位整数（`uint8`），如标签所示：
+采集数据。 `mnist`是手绘数字的数据集，每个数字在`28 x 28`像素的网格上。 每个单独的数据点都是一个无符号的 8 位整数（`uint8`），如标签所示：
 
 ```py
 mnist = tf.keras.datasets.mnist
@@ -197,7 +197,7 @@ train_y, test_y = tf.cast(train_y,tf.int64),tf.cast(test_y,tf.int64)
 
 注意在模型定义中我们如何传递图层列表：
 
-*   `Flatten`接受 28 x 28（即 2D）像素图像的输入，并产生 784（即 1D）矢量，因为下一个（密集）层是一维的。
+*   `Flatten`接受`28 x 28`（即 2D）像素图像的输入，并产生 784（即 1D）矢量，因为下一个（密集）层是一维的。
 *   `Dense`是一个完全连接的层，意味着其所有神经元都连接到上一层和下一层中的每个神经元。 下面的示例有 512 个神经元，其输入通过 ReLU（非线性）激活函数传递。
 *   `Dropout`随机关闭上一层神经元的一部分（在这种情况下为 0.2）。 这样做是为了防止任何特定的神经元变得过于专业化，并导致模型*与数据*过拟合，从而影响测试数据上模型的准确性指标（在后面的章节中将对此进行更多介绍）。
 *   最后的`Dense`层具有一个称为`softmax`的特殊激活函数，该函数将概率分配给可能的 10 个输出单元中的每一个：
@@ -287,11 +287,11 @@ model2.evaluate(test_x, test_y)
 
 因此，这种定义模型的方法产生的结果与第一个结果几乎相同，这是可以预期的，因为它是相同的体系结构，尽管表达方式略有不同，但具有相同的`optimizer`和`loss`函数。 现在让我们看一下功能性 API。
 
-# Keras 功能 API
+# Keras 函数式 API
 
 与以前看到的`Sequential`模型的简单线性堆栈相比，功能性 API 使您可以构建更复杂的体系结构。 它还支持更高级的模型。 这些模型包括多输入和多输出模型，具有共享层的模型以及具有剩余连接的模型。
 
-这是功能 API 的使用的简短示例，其架构与前两个相同。
+这是函数式 API 的使用的简短示例，其架构与前两个相同。
 
 设置代码与先前演示的相同：
 
@@ -340,7 +340,7 @@ model3.evaluate(test_x, test_y)
 
 # 子类化 Keras 模型类
 
-Keras `Model`类可以被子类化，如下面的代码所示。 Google 指出，*纯*功能风格（如前面的示例所示）比子类风格更可取（我们在此包括其内容是出于完整性的考虑，因为它很有趣）。
+Keras `Model`类可以被子类化，如下面的代码所示。 Google 指出，*纯*函数风格（如前面的示例所示）比子类风格更可取（我们在此包括其内容是出于完整性的考虑，因为它很有趣）。
 
 首先，请注意如何在构造函数（`.__init__()`）中分别声明和命名图层。
 
@@ -467,4 +467,4 @@ model.load_weights('./model_weights.h5')
 
 在本章中，我们使用通用注释和见解探索了 Keras API，然后以四种不同的方式表示相同的基本体系结构，以训练`mnist`数据集。
 
-在下一章中，我们将通过探索许多有监督的学习场景，包括线性回归，逻辑回归和 k 近邻，开始认真使用 TensorFlow。
\ No newline at end of file
+在下一章中，我们将通过探索许多有监督的学习场景，包括线性回归，逻辑回归和 K 近邻，开始认真使用 TensorFlow。
\ No newline at end of file

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

@@ -140,7 +140,7 @@ or item in dataset:
 # decode as string is in binary format.
 ```
 
-# TF 唱片
+# TFRecord
 
 另一种流行的存储数据选择是 TFRecord 格式。 这是一个二进制文件格式。 对于大文件，这是一个不错的选择，因为二进制文件占用的磁盘空间更少，复制所需的时间更少，并且可以非常有效地从磁盘读取。 所有这些都会对数据管道的效率以及模型的训练时间产生重大影响。 该格式还以多种方式与 TensorFlow 一起进行了优化。 这有点复杂，因为在存储之前必须将数据转换为二进制格式，并在回读时将其解码。
 
@@ -361,7 +361,7 @@ ANN 使用的基本数据结构是**层**，许多相互连接的层构成了一
 
 对于图像，卷积层具有部分签名`tf.keras.layers.Conv2D(filters, kernel_size, strides=1, padding='valid')`。
 
-因此，在下面的示例中，该第一层具有一个大小为（1,1）的过滤器，并且其填充`'valid'`。 其他填充可能性是`'same'`。
+因此，在下面的示例中，该第一层具有一个大小为`(1, 1)`的过滤器，并且其填充`'valid'`。 其他填充可能性是`'same'`。
 
 区别在于，使用`'same'`填充，必须在外部填充该层（通常用零填充），以便在卷积发生后，输出大小与该层大小相同。 如果使用`'valid'`填充，则不会进行填充，并且如果跨度和内核大小的组合不能完全适合该层，则该层将被截断。 输出大小小于正在卷积的图层：
 
@@ -417,7 +417,7 @@ tf.keras.layers.Dropout(rate, noise_shape=None, seed=None)
 layer = tf.keras.layers.Dropout(rate = 0.5)
 ```
 
-随机选择的 50％的神经元将被关闭。
+随机选择的 50% 的神经元将被关闭。
 
 # Softmax 层
 
@@ -439,7 +439,7 @@ model2.add(tf.keras.layers.Dense(10,activation=tf.nn.softmax))
 
 重要的是要注意，神经网络具有非线性激活函数，即应用于神经元加权输入之和的函数。 除了平凡的神经网络模型外，线性激活单元无法将输入层映射到输出层。
 
-有许多常用的激活功能，包括 S 型，tanh，ReLU 和泄漏的 ReLU。 一个很好的总结，以及这些功能的图表，[可以在这里找到](https://towardsdatascience.com/activation-functions-neural-networks-1cbd9f8d91d6)。
+有许多常用的激活功能，包括 Sigmoid，tanh，ReLU 和泄漏的 ReLU。 一个很好的总结，以及这些功能的图表，[可以在这里找到](https://towardsdatascience.com/activation-functions-neural-networks-1cbd9f8d91d6)。
 
 # 建立模型
 
@@ -447,7 +447,7 @@ model2.add(tf.keras.layers.Dense(10,activation=tf.nn.softmax))
 
 *   **方法 1** ：参数已传递给`tf.keras.Sequential`
 *   **方法 2** ：使用`tf.keras.Sequential`的`.add`方法
-*   **方法 3** ：使用 Keras 功能 API
+*   **方法 3** ：使用 Keras 函数式 API
 *   **方法 4** ：通过将`tf.keras.Model`对象子类化
 
 有关这四种方法的详细信息，请参考第 2 章“TensorFlow 2 的高级 API，Keras”。
@@ -532,4 +532,4 @@ print(weight3_grad.numpy()) #6.0
 
 我们涵盖了到 ANN 的数据表示，ANN 的各层，创建模型，梯度下降算法的梯度计算，损失函数以及保存和恢复模型的内容。 这些主题是在开发神经网络模型时将在后续章节中遇到的概念和技术的重要前提。
 
-确实，在下一章中，我们将通过探索许多有监督的学习场景，包括线性回归，逻辑回归和 k 近邻，来认真地使用 TensorFlow。
\ No newline at end of file
+确实，在下一章中，我们将通过探索许多有监督的学习场景，包括线性回归，逻辑回归和 K 近邻，来认真地使用 TensorFlow。
\ No newline at end of file

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

 # 使用 TensorFlow 2 进行监督的机器学习
 
-在本章中，我们将讨论并举例说明 TensorFlow 2 在以下情况下的监督机器学习问题中的使用：线性回归，逻辑回归和 **k 最近邻**（**KNN**） 。
+在本章中，我们将讨论并举例说明 TensorFlow 2 在以下情况下的监督机器学习问题中的使用：线性回归，逻辑回归和 **K 最近邻**（**KNN**） 。
 
 在本章中，我们将研究以下主题：
 
@@ -9,7 +9,7 @@
 *   我们的第一个线性回归示例
 *   波士顿住房数据集
 *   逻辑回归（分类）
-*   **k 最近邻**（**KNN**）
+*   **K 最近邻**（**KNN**）
 
 # 监督学习
 
@@ -19,7 +19,7 @@
 
 线性回归问题是在给定一个或多个其他变量（数据点）的值的情况下，您必须预测一个*连续*变量的值的问题。 例如，根据房屋的占地面积，预测房屋的售价。 在这些示例中，您可以将已知特征及其关联的标签绘制在简单的线性图上，如熟悉的`x, y`散点图，并绘制最适合数据的线 。 这就是最适合的**系列**。 然后，您可以读取对应于该图的`x`范围内的任何要素值的标签。
 
-但是，线性回归问题可能涉及几个特征，其中使用了术语**多个**或**多元线性回归**。 在这种情况下，不是最适合数据的线，而是一个平面（两个要素）或一个超平面（两个以上要素）。 在房价示例中，我们可以将房间数量和花园的长度添加到要素中。 有一个著名的数据集，称为 Boston housing 数据集，[涉及 13 个特征](https://www.kaggle.com/c/ml210-boston)。 考虑到这 13 个特征，此处的回归问题是预测波士顿郊区的房屋中位数。
+但是，线性回归问题可能涉及几个特征，其中使用了术语**多个**或**多元线性回归**。 在这种情况下，不是最适合数据的线，而是一个平面（两个要素）或一个超平面（两个以上要素）。 在房价示例中，我们可以将房间数量和花园的长度添加到要素中。 有一个著名的数据集，称为波士顿住房数据集，[涉及 13 个特征](https://www.kaggle.com/c/ml210-boston)。 考虑到这 13 个特征，此处的回归问题是预测波士顿郊区的房屋中位数。
 
 术语：功能也称为预测变量或自变量。 标签也称为响应变量或因变量。
 
@@ -238,7 +238,7 @@ print("Predicted median house value ",y_pred.numpy()," in $10K")
 
 这类问题的名称令人迷惑，因为正如我们所看到的，回归意味着连续价值标签，例如房屋的中位数价格或树的高度。
 
-Logistic 回归并非如此。 当您遇到需要逻辑回归的问题时，这意味着标签为`categorical`； 例如，零或一，`True`或`False`，是或否，猫或狗，或者它可以是两个以上的分类值； 例如，红色，蓝色或绿色，或一，二，三，四或五，或给定花的类型。 标签通常具有与之相关的概率； 例如，P（cat = 0.92），P（dog = 0.08）。 因此，逻辑回归也称为**分类**。
+逻辑回归并非如此。 当您遇到需要逻辑回归的问题时，这意味着标签为`categorical`； 例如，零或一，`True`或`False`，是或否，猫或狗，或者它可以是两个以上的分类值； 例如，红色，蓝色或绿色，或一，二，三，四或五，或给定花的类型。 标签通常具有与之相关的概率； 例如，`P(cat = 0.92)`，`P(dog = 0.08)`。 因此，逻辑回归也称为**分类**。
 
 在下一个示例中，我们将使用`fashion_mnist`数据集使用逻辑回归来预测时尚商品的类别。
 
@@ -314,7 +314,7 @@ split = 50000
  (y_train, y_valid) = y_train[:split], y_train[split:]
 ```
 
-如果标签是单热编码的，那么许多机器学习算法效果最好，因此我们接下来要做。 但请注意，我们会将产生的一束热张量转换回（一束热）NumPy 数组，以备稍后由 Keras 使用：
+如果标签是单热编码的，那么许多机器学习算法效果最好，因此我们接下来要做。 但请注意，我们会将产生的一束热张量转换回（单热）NumPy 数组，以备稍后由 Keras 使用：
 
 ```py
 # one hot encode the labels using TensorFLow.
@@ -357,7 +357,7 @@ for i in range(10):
 
 对于我们的逻辑回归示例，我们需要在子类中编写两个方法。 首先，我们需要编写一个构造函数，该构造函数调用超类的构造函数，以便正确创建模型。 在这里，我们传入正在使用的类数（`10`），并在实例化模型以创建单个层时使用此构造函数。 我们还必须声明`call`方法，并使用该方法来编程在模型训练的正向传递过程中发生的情况。
 
-稍后，当我们考虑具有前向和后向传递的神经网络时，我们将对这种情况进行更多说明。 对于我们当前的目的，我们只需要知道在 call 方法中，我们采用输入的`softmax`来产生输出。 `softmax`函数的作用是获取一个矢量（或张量），然后在其元素具有该矢量最大值的位置上用几乎为 1 的值覆盖，在所有其他位置上使用几乎为零的值覆盖。 这与单热编码很相似。 请注意，在此方法中，由于`softmax`未为 GPU 实现，因此我们必须在 CPU 上强制执行：
+稍后，当我们考虑具有前向和后向传递的神经网络时，我们将对这种情况进行更多说明。 对于我们当前的目的，我们只需要知道在`call`方法中，我们采用输入的`softmax`来产生输出。 `softmax`函数的作用是获取一个矢量（或张量），然后在其元素具有该矢量最大值的位置上用几乎为 1 的值覆盖，在所有其他位置上使用几乎为零的值覆盖。 这与单热编码很相似。 请注意，在此方法中，由于`softmax`未为 GPU 实现，因此我们必须在 CPU 上强制执行：
 
 ```py
 # model definition (the canonical Google way)
@@ -380,7 +380,7 @@ class LogisticRegression(tf.keras.Model):
 
 现在，我们准备编译和训练我们的模型。
 
-首先，我们确定可用的设备，然后使用它。 然后，使用我们开发的类声明模型。 声明要使用的优化程序后，我们将编译模型。 我们使用的损失，分类交叉熵（也称为**对数损失**），通常用于 logistic 回归，因为要求预测是概率。
+首先，我们确定可用的设备，然后使用它。 然后，使用我们开发的类声明模型。 声明要使用的优化程序后，我们将编译模型。 我们使用的损失，分类交叉熵（也称为**对数损失**），通常用于逻辑回归，因为要求预测是概率。
 
 优化器是一个选择和有效性的问题，[有很多可用的方法](https://www.tensorflow.org/api_guides/python/train#Optimizers)。 接下来是带有三个参数的`model.compile`调用。 我们将很快看到，它为我们的训练模型做准备。
 
@@ -390,7 +390,7 @@ class LogisticRegression(tf.keras.Model):
 
 接下来，我们建立一个`ModelCheckpoint`实例，该实例用于保存训练期间的最佳模型，然后使用`model.fit`调用训练模型。
 
-找出`model.compile`和`model.fit`（以及所有其他 Python 或 TensorFlow 类或方法）的所有不同参数的最简单方法是在 Jupyter Notebook 中工作，然后按`Shift + TAB + TAB`，当光标位于相关类或方法调用上时。
+找出`model.compile`和`model.fit`（以及所有其他 Python 或 TensorFlow 类或方法）的所有不同参数的最简单方法是在 Jupyter 笔记本中工作，然后按`Shift + TAB + TAB`，当光标位于相关类或方法调用上时。
 
 从代码中可以看到，`model.fit`在训练时使用`callbacks`方法（由验证准确性确定）保存最佳模型，然后加载最佳模型。 最后，我们在测试集上评估模型，如下所示：
 
@@ -456,9 +456,9 @@ for i, index in enumerate(np.random.choice(x_test.shape[0], size = size, replace
 
 时尚标签
 
-到此结束我们对逻辑回归的研究。 现在，我们将看看另一种非常强大的监督学习技术，即 k-Nearest Neighbors。
+到此结束我们对逻辑回归的研究。 现在，我们将看看另一种非常强大的监督学习技术，即 K 最近邻。
 
-# k 最近邻（KNN）
+# K 最近邻（KNN）
 
 KNN 背后的想法相对简单。 给定新的特定数据点的值，请查看该点的 KNN，并根据该 k 个邻居的标签为该点分配标签，其中`k`是算法的参数。
 
@@ -527,7 +527,7 @@ test_indices =np.array(list(set(range(len(x))) - set(train_indices)))
 k = 5
 ```
 
-接下来，在 Jupyter Notebook 中，我们具有预测测试数据点类别的功能。 我们将逐行对此进行细分。
+接下来，在 Jupyter 笔记本中，我们具有预测测试数据点类别的功能。 我们将逐行对此进行细分。
 
 首先是我们的`distance`功能。 执行此功能后，可变距离包含我们 120 个训练点与 30 个测试点之间的所有（曼哈顿）距离； 也就是说，由 30 行乘 120 列组成的数组-曼哈顿距离，有时也称为**城市街区距离**，是`x[1], x[2]`的两个数据点向量的值之差的绝对值； 即`|x[1] - x[2]|`。 如果需要的话（如本例所示），将使用各个特征差异的总和。
 
@@ -599,7 +599,7 @@ accuracy = round(total/len(test_x),3)*100
 print("Accuracy = ",accuracy,"%")
 ```
 
-如果您自己输入代码，或运行提供的笔记本电脑，则将看到准确率为 96.7％，只有一个`iris versicolor`被误分类为`iris virginica`（测试索引为 25）。
+如果您自己输入代码，或运行提供的笔记本电脑，则将看到准确率为 96.7%，只有一个`iris versicolor`被误分类为`iris virginica`（测试索引为 25）。
 
 # 摘要
 

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

@@ -334,7 +334,7 @@ plt.show()
 
 # 创建编码层
 
-接下来，我们创建编码和解码层。 我们将使用 Keras 功能 API 风格来设置模型。 我们从一个占位符开始，以（下一个）卷积层所需的格式输入：
+接下来，我们创建编码和解码层。 我们将使用 Keras 函数式 API 风格来设置模型。 我们从一个占位符开始，以（下一个）卷积层所需的格式输入：
 
 ```py
 input_image = Input(shape=(28, 28, 1))

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

@@ -303,7 +303,7 @@ y_test = np.array(hf["QuickDraw"][:])
 
 # 使用预先训练的模型进行加载和推断
 
-经过训练的模型`'QDrawModel.h5'`已运行 25 个纪元，并且达到了 90％以上的测试准确度，已保存在存储库中。 您已经看过此代码； 为方便起见，在此复制。
+经过训练的模型`'QDrawModel.h5'`已运行 25 个纪元，并且达到了 90% 以上的测试准确度，已保存在存储库中。 您已经看过此代码； 为方便起见，在此复制。
 
 因此，重申一下，您可以使用以下代码加载此经过训练的模型：
 
@@ -614,7 +614,7 @@ for index in indices:
     i+=1
 ```
 
-在一次运行中，提前停止开始了 43 个纪元，测试准确性为 81.4％，并且前 25 张图像的测试结果如下：
+在一次运行中，提前停止开始了 43 个纪元，测试准确性为 81.4%，并且前 25 张图像的测试结果如下：
 
 ```py
 Learned  True
@@ -652,8 +652,8 @@ deer     dog
 
 # 摘要
 
-本章分为两个部分。 在第一部分中，我们研究了快速抽奖！ 来自 Google 的数据集。 我们介绍了它，然后看到了如何将其加载到内存中。 这很简单，因为 Google 善意地将数据集作为一组`.npy`文件提供，这些文件可以直接加载到 NumPy 数组中。 接下来，我们将数据分为训练，验证和测试集。 创建`ConvNet`模型后，我们对数据进行了训练并进行了测试。 在测试中，经过 25 个纪元，该模型的准确率刚好超过 90％，我们注意到，通过进一步调整模型，可能会改善这一精度。 最后，我们看到了如何保存经过训练的模型，然后如何重新加载它并将其用于进一步的推断。
+本章分为两个部分。 在第一部分中，我们研究了快速抽奖！ 来自 Google 的数据集。 我们介绍了它，然后看到了如何将其加载到内存中。 这很简单，因为 Google 善意地将数据集作为一组`.npy`文件提供，这些文件可以直接加载到 NumPy 数组中。 接下来，我们将数据分为训练，验证和测试集。 创建`ConvNet`模型后，我们对数据进行了训练并进行了测试。 在测试中，经过 25 个纪元，该模型的准确率刚好超过 90%，我们注意到，通过进一步调整模型，可能会改善这一精度。 最后，我们看到了如何保存经过训练的模型，然后如何重新加载它并将其用于进一步的推断。
 
-在第二部分中，我们训练了一个模型来识别 CIFAR 10 图像数据集中的图像。 该数据集包含 10 类图像，是用于测试体系结构和进行超参数研究的流行数据集。 我们的准确度刚刚超过 81％。
+在第二部分中，我们训练了一个模型来识别 CIFAR 10 图像数据集中的图像。 该数据集包含 10 类图像，是用于测试体系结构和进行超参数研究的流行数据集。 我们的准确度刚刚超过 81%。
 
 在下一章中，我们将研究神经风格转移，其中涉及获取一个图像的内容并将第二个图像的风格强加于其上，以生成第三个混合图像。
\ No newline at end of file

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

@@ -457,7 +457,7 @@ bottom = np.sum(top)
 confusion_train = 2*top/bottom
 ```
 
-最后，我们使用`seaborn`方法`heatmap`绘制混淆矩阵。 此方法的签名很长且很详细，因此，查看它的最简单方法是在 Jupyter Notebook 中将光标放在`Shift + TAB`上。
+最后，我们使用`seaborn`方法`heatmap`绘制混淆矩阵。 此方法的签名很长且很详细，因此，查看它的最简单方法是在 Jupyter 笔记本中将光标放在`Shift + TAB`上。
 
 我们在这里只需要四个参数：