2020-09-10 22:50:36

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

@@ -22,7 +22,7 @@ image1 = tf.zeros([7, 28, 28, 3]) #  example-within-batch by height by width by
 
 # 现代 TensorFlow 生态系统
 
-让我们讨论**急切执行**。 TensorFlow 的第一个化身包括构造由操作和张量组成的计算图，随后必须在 Google 所谓的会话中对其进行评估（这称为声明性编程）。 这仍然是编写 TensorFlow 程序的常用方法。 但是，急于执行的功能（以研究形式从版本 1.5 开始可用，并从版本 1.7 被烘焙到 TensorFlow 中）需要立即评估操作，结果是可以将张量像 NumPy 数组一样对待（这被称为命令式编程）。
+让我们讨论**急切执行**。 TensorFlow 的第一个化身包括构造由操作和张量组成的计算图，随后必须在 Google 所谓的会话中对其进行评估（这称为声明性编程）。 这仍然是编写 TensorFlow 程序的常用方法。 但是，急切执行的功能（以研究形式从版本 1.5 开始可用，并从版本 1.7 被烘焙到 TensorFlow 中）需要立即评估操作，结果是可以将张量像 NumPy 数组一样对待（这被称为命令式编程）。
 
 谷歌表示，急切执行是研究和开发的首选方法，但计算图对于服务 TensorFlow 生产应用将是首选。
 
@@ -90,7 +90,7 @@ 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)中找到。
 
 # 使用急切执行
 
@@ -701,7 +701,7 @@ tf.Tensor(
 
 现在，我们将研究如何在张量轴上查找具有最大值和最小值的元素的索引。
 
-这些功能的签名如下：
+这些函数的签名如下：
 
 ```py
 tf.argmax(input, axis=None, name=None, output_type=tf.int64 )

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

@@ -54,7 +54,7 @@ Keras 可能是不寻常的，因为它具有作为独立开源项目维护的
 
 急切的执行意味着代码的执行是命令式编程环境，而不是基于图的环境，这是在 TensorFlow（v1.5 之前）的初始产品中工作的唯一方法。 这种命令式（即刻）风格允许直观的调试，快速的开发迭代，支持 TensorFlow `SavedModel`格式，并内置支持对 CPU，GPU 甚至 Google 自己的硬件**张量处理单元**（**TPU**）进行分布式训练。
 
-TensorFlow 实施还支持`tf.data`，分发策略，导出模型（可通过 TensorFlow Lite 部署在移动和嵌入式设备上）以及用于表示和分类结构化数据的功能列。
+TensorFlow 实施还支持`tf.data`，分发策略，导出模型（可通过 TensorFlow Lite 部署在移动和嵌入式设备上）以及用于表示和分类结构化数据的特征列。
 
 # 默认的 Keras 配置文件
 
@@ -92,7 +92,7 @@ keras.backend.set_floatx(floatx)
 
 由于其模型级别的库结构，Keras 可能具有处理低级操作（例如卷积，张量乘积等）的不同张量操纵引擎。 这些引擎称为**后端**。 其他后端可用； 我们在这里不考虑它们。
 
-相同的[链接](https://keras.io/backend/)可带您使用许多`keras.backend`功能。
+相同的[链接](https://keras.io/backend/)可带您使用许多`keras.backend`函数。
 
 使用 Keras `backend`的规范方法是：
 
@@ -285,11 +285,11 @@ model2.evaluate(test_x, test_y)
 
 这给我们带来了`0.07`的损失和`0.981`的准确性。
 
-因此，这种定义模型的方法产生的结果与第一个结果几乎相同，这是可以预期的，因为它是相同的体系结构，尽管表达方式略有不同，但具有相同的`optimizer`和`loss`函数。 现在让我们看一下功能性 API。
+因此，这种定义模型的方法产生的结果与第一个结果几乎相同，这是可以预期的，因为它是相同的体系结构，尽管表达方式略有不同，但具有相同的`optimizer`和`loss`函数。 现在让我们看一下函数式 API。
 
 # Keras 函数式 API
 
-与以前看到的`Sequential`模型的简单线性堆栈相比，功能性 API 使您可以构建更复杂的体系结构。 它还支持更高级的模型。 这些模型包括多输入和多输出模型，具有共享层的模型以及具有剩余连接的模型。
+与以前看到的`Sequential`模型的简单线性堆栈相比，函数式 API 使您可以构建更复杂的体系结构。 它还支持更高级的模型。 这些模型包括多输入和多输出模型，具有共享层的模型以及具有剩余连接的模型。
 
 这是函数式 API 的使用的简短示例，其架构与前两个相同。
 
@@ -344,7 +344,7 @@ Keras `Model`类可以被子类化，如下面的代码所示。 Google 指出
 
 首先，请注意如何在构造函数（`.__init__()`）中分别声明和命名图层。
 
-然后，注意在`call()`方法中各层如何以功能风格链接在一起。 此方法封装了*前向传播*：
+然后，注意在`call()`方法中各层如何以函数风格链接在一起。 此方法封装了*前向传播*：
 
 ```py
 class MyModel(tf.keras.Model):
@@ -455,7 +455,7 @@ model.load_weights('./model_weights.h5')
 
 可从 Keras 中获得以下数据集：`boston_housing`，`cifar10`，`cifar100`，`fashion_mnist`，`imdb`，`mnist`和`reuters`。
 
-它们都可以通过`load_data()`功能访问。 例如，要加载`fashion_mnist`数据集，请使用以下命令：
+它们都可以通过`load_data()`函数访问。 例如，要加载`fashion_mnist`数据集，请使用以下命令：
 
 ```py
 (x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()

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

@@ -411,7 +411,7 @@ tf.keras.layers.Dropout(rate, noise_shape=None, seed=None)
 
 `rate`参数是神经元被关闭的部分。
 
-因此，要使用此功能，例如，您需要：
+因此，要使用它，例如，您需要：
 
 ```py
 layer = tf.keras.layers.Dropout(rate = 0.5)
@@ -439,7 +439,7 @@ model2.add(tf.keras.layers.Dense(10,activation=tf.nn.softmax))
 
 重要的是要注意，神经网络具有非线性激活函数，即应用于神经元加权输入之和的函数。 除了平凡的神经网络模型外，线性激活单元无法将输入层映射到输出层。
 
-有许多常用的激活函数，包括 Sigmoid，tanh，ReLU 和泄漏的 ReLU。 一个很好的总结，以及这些功能的图表，[可以在这里找到](https://towardsdatascience.com/activation-functions-neural-networks-1cbd9f8d91d6)。
+有许多常用的激活函数，包括 Sigmoid，tanh，ReLU 和泄漏的 ReLU。 一个很好的总结，以及这些函数的图表，[可以在这里找到](https://towardsdatascience.com/activation-functions-neural-networks-1cbd9f8d91d6)。
 
 # 建立模型
 
@@ -506,11 +506,11 @@ print(weight2_grad.numpy()) #5.0
 print(weight3_grad.numpy()) #6.0
 ```
 
-接下来，我们将研究损失函数。 这些是在训练神经网络模型期间优化的功能。
+接下来，我们将研究损失函数。 这些是在训练神经网络模型期间优化的函数。
 
 # 损失函数
 
-`loss`功能（即，误差测量）是训练 ANN 的必要部分。 它是网络在训练期间计算出的输出与其所需输出的差异程度的度量。 通过区分`loss`函数，我们可以找到一个量，通过该量可以调整各层之间的连接权重，以使 ANN 的计算输出与所需输出更紧密匹配。
+`loss`函数（即，误差测量）是训练 ANN 的必要部分。 它是网络在训练期间计算出的输出与其所需输出的差异程度的度量。 通过区分`loss`函数，我们可以找到一个量，通过该量可以调整各层之间的连接权重，以使 ANN 的计算输出与所需输出更紧密匹配。
 
 最简单的`loss`函数是均方误差：
 

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

@@ -21,7 +21,7 @@
 
 但是，线性回归问题可能涉及几个特征，其中使用了术语**多个**或**多元线性回归**。 在这种情况下，不是最适合数据的线，而是一个平面（两个要素）或一个超平面（两个以上要素）。 在房价示例中，我们可以将房间数量和花园的长度添加到要素中。 有一个著名的数据集，称为波士顿住房数据集，[涉及 13 个特征](https://www.kaggle.com/c/ml210-boston)。 考虑到这 13 个特征，此处的回归问题是预测波士顿郊区的房屋中位数。
 
-术语：功能也称为预测变量或自变量。 标签也称为响应变量或因变量。
+术语：特征也称为预测变量或自变量。 标签也称为响应变量或因变量。
 
 # 我们的第一个线性回归示例
 
@@ -158,7 +158,7 @@ n_valid = 100
 
 注意`scale`方法。 这用于将数据转换为均值为零且单位标准差为零的集合。 `sklearn.preprocessing`方法`scale`通过从特征集中的每个数据点减去平均值，然后将每个特征除以该特征集的标准偏差来实现此目的。
 
-这样做是因为它有助于我们模型的收敛。 所有功能也都转换为`float32`数据类型：
+这样做是因为它有助于我们模型的收敛。 所有特征也都转换为`float32`数据类型：
 
 ```py
 features, prices = load_boston(True)
@@ -178,7 +178,7 @@ features, prices = load_boston(True)
 test_prices = prices[n_train + n_valid : n_train + n_valid + n_test]
 ```
 
-接下来，我们具有与上一个示例相似的功能。 首先，请注意我们现在使用的是更流行的路径，均方误差：
+接下来，我们具有与上一个示例相似的函数。 首先，请注意我们现在使用的是更流行的路径，均方误差：
 
 ```py
 # A loss function using root mean-squared error
@@ -297,7 +297,7 @@ fashion_labels =
 
 `x_train`现在由`60000`，`float32`值组成，并且`x_test`保持`10000`相似的值。
 
-然后，我们展平功能集，准备进行培训：
+然后，我们展平特征集，准备进行培训：
 
 ```py
 # flatten the feature set for use by the training algorithm
@@ -353,7 +353,7 @@ for i in range(10):
 
 现在，我们进入代码的重要且可概括的部分。 Google 建议，对于创建任何类型的机器学习模型，都可以通过将其分类为`tf.keras.Model`来创建模型。
 
-这具有直接的优势，即我们可以在我们的子类化模型中使用`tf.keras.Model`的所有功能，包括编译和训练例程以及图层功能，在后续的章节中，我们将详细介绍。
+这具有直接的优势，即我们可以在我们的子类化模型中使用`tf.keras.Model`的所有功能，包括编译和训练例程以及层功能，在后续的章节中，我们将详细介绍。
 
 对于我们的逻辑回归示例，我们需要在子类中编写两个方法。 首先，我们需要编写一个构造函数，该构造函数调用超类的构造函数，以便正确创建模型。 在这里，我们传入正在使用的类数（`10`），并在实例化模型以创建单个层时使用此构造函数。 我们还必须声明`call`方法，并使用该方法来编程在模型训练的正向传递过程中发生的情况。
 
@@ -501,7 +501,7 @@ y[0:10]
 x = (x - x.min(axis=0)) / (x.max(axis=0) - x.min(axis=0))
 ```
 
-为了使算法正常工作，我们必须使用一组随机的训练功能。 接下来，我们还要通过从数据集的整个范围中删除训练指标来设置测试指标：
+为了使算法正常工作，我们必须使用一组随机的训练特征。 接下来，我们还要通过从数据集的整个范围中删除训练指标来设置测试指标：
 
 ```py
 # create indices for the train-test split
@@ -511,7 +511,7 @@ train_indices = np.random.choice(len(x), round(len(x) * split), replace=False)
 test_indices =np.array(list(set(range(len(x))) - set(train_indices)))
 ```
 
-我们现在可以创建我们的培训和测试功能，以及它们的相关标签：
+我们现在可以创建我们的培训和测试特征，以及它们的相关标签：
 
 ```py
 # the train-test split
@@ -527,9 +527,9 @@ test_indices =np.array(list(set(range(len(x))) - set(train_indices)))
 k = 5
 ```
 
-接下来，在 Jupyter 笔记本中，我们具有预测测试数据点类别的功能。 我们将逐行对此进行细分。
+接下来，在 Jupyter 笔记本中，我们具有预测测试数据点类别的函数。 我们将逐行对此进行细分。
 
-首先是我们的`distance`功能。 执行此功能后，可变距离包含我们 120 个训练点与 30 个测试点之间的所有（曼哈顿）距离； 也就是说，由 30 行乘 120 列组成的数组-曼哈顿距离，有时也称为**城市街区距离**，是`x[1], x[2]`的两个数据点向量的值之差的绝对值； 即`|x[1] - x[2]|`。 如果需要的话（如本例所示），将使用各个特征差异的总和。
+首先是我们的`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`函数是：
 
@@ -569,7 +569,7 @@ predictions_sum = tf.reduce_sum(input_tensor=top_k_labels, axis=1)
 pred = tf.argmax(input=predictions_sum, axis=1)
 ```
 
-返回结果预测`pred`。 作为参考，下面是一个完整的功能：
+返回结果预测`pred`。 作为参考，下面是一个完整的函数：
 
 ```py
 def prediction(train_x, test_x, train_y,k):
@@ -581,7 +581,7 @@ def prediction(train_x, test_x, train_y,k):
      return pred
 ```
 
-打印在此功能中出现的各种张量的形状可能非常有启发性。
+打印在此函数中出现的各种张量的形状可能非常有启发性。
 
 代码的最后一部分很简单。 我们将花朵标签的预测与实际标签压缩（连接）在一起，然后我们可以遍历它们，打印出来并求出正确性总计，然后将精度打印为测试集中数据点数量的百分比 ：
 
@@ -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

 # 五、TensorFlow 2 和无监督学习
 
-在本章中，我们将研究使用 TensorFlow 2 进行无监督学习。无监督学习的目的是在数据中发现以前未标记数据点的模式或关系； 因此，我们只有功能。 这与监督式学习形成对比，在监督式学习中，我们既提供了功能及其标签，又希望预测以前未见过的新功能的标签。 在无监督学习中，我们想找出我们的数据是否存在基础结构。 例如，可以在不事先了解其结构的情况下以任何方式对其进行分组或组织吗？ 这被称为**聚类**。 例如，亚马逊在其推荐系统中使用无监督学习来建议您以书本方式可能购买的商品，例如，通过识别以前购买的商品类别来提出建议。
+在本章中，我们将研究使用 TensorFlow 2 进行无监督学习。无监督学习的目的是在数据中发现以前未标记数据点的模式或关系； 因此，我们只有特征。 这与监督式学习形成对比，在监督式学习中，我们既提供了特征及其标签，又希望预测以前未见过的新特征的标签。 在无监督学习中，我们想找出我们的数据是否存在基础结构。 例如，可以在不事先了解其结构的情况下以任何方式对其进行分组或组织吗？ 这被称为**聚类**。 例如，亚马逊在其推荐系统中使用无监督学习来建议您以书本方式可能购买的商品，例如，通过识别以前购买的商品类别来提出建议。
 
 无监督学习的另一种用途是在数据压缩技术中，其中数据中的模式可以用更少的内存表示，而不会损害数据的结构或完整性。 在本章中，我们将研究两个自编码器，以及如何将它们用于压缩数据以及如何消除图像中的噪声。
 
@@ -12,7 +12,7 @@
 
 自编码是有损的，也就是说，与原始输入相比，解压缩后的输出将变差。 这与 MP3 和 JPEG 压缩格式相似。
 
-自编码是特定于数据的，也就是说，只有与它们经过训练的数据相似的数据才可以正确压缩。 例如，训练有素的自编码器在汽车图片上的表现会很差，这是因为其学习到的功能将是汽车特有的。
+自编码是特定于数据的，也就是说，只有与它们经过训练的数据相似的数据才可以正确压缩。 例如，训练有素的自编码器在汽车图片上的表现会很差，这是因为其学习到的特征将是汽车特有的。
 
 # 一个简单的自编码器
 
@@ -476,7 +476,7 @@ tb = [TensorBoard(log_dir='./tmp/tb', write_graph=True)]
 fit(x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, validation_freq=1)
 ```
 
-注意我们如何将`x_train_noisy`用于功能（输入），并将`x_train`用于标签（输出）：
+注意我们如何将`x_train_noisy`用于特征（输入），并将`x_train`用于标签（输出）：
 
 ```py
 epochs=100

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

@@ -425,7 +425,7 @@ print(x_test.shape[0], 'test samples')
 x_train shape: (50000, 32, 32, 3) 50000 train samples 10000 test samples
 ```
 
-现在，我们有了一个显示图像子集的功能。 这将在网格中显示它们：
+现在，我们有了一个显示图像子集的函数。 这将在网格中显示它们：
 
 ```py
 def show_images(images):
@@ -524,7 +524,7 @@ model.compile(loss='categorical_crossentropy', optimizer=opt,metrics=['accuracy'
 
 为了帮助模型学习和推广，我们将实现实时数据增强。
 
-这是通过`ImageDataGenerator()`功能完成的。 其签名如下：
+这是通过`ImageDataGenerator()`函数完成的。 其签名如下：
 
 ```py
 keras.preprocessing.image.ImageDataGenerator(featurewise_center=False, samplewise_center=False, featurewise_std_normalization=False, samplewise_std_normalization=False, zca_whitening=False, zca_epsilon=1e-06, rotation_range=0, width_shift_range=0.0, height_shift_range=0.0, brightness_range=None, shear_range=0.0, zoom_range=0.0, channel_shift_range=0.0, fill_mode='nearest', cval=0.0, horizontal_flip=False, vertical_flip=False, rescale=None, preprocessing_function=None, data_format=None, validation_split=0.0, dtype=None)

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

@@ -6,7 +6,7 @@
 
 为了开始该过程，用内容图像初始化混合图像。 然后，使用反向传播将内容和内容以及混合图像的风格之间的差异（也称为损失或距离）最小化。 这将创建具有风格参考图像风格和内容图像内容的新图像（即混合图像）。
 
-此过程中涉及一些技术-使用功能性 API，使用预训练的模型及其功能图以及使用自定义训练循环以最小化`loss`功能。 我们将在下面的代码中满足所有这些要求。
+此过程中涉及一些技术-使用函数式 API，使用预训练的模型及其特征图以及使用自定义训练循环以最小化`loss`函数。 我们将在下面的代码中满足所有这些要求。
 
 要充分利用该技术，有两个先决条件-Gatys 等人在 2015 年发表的[原始论文](https://arxiv.org/abs/1508.06576)虽非必要，但确实可以解释该技术。 技术非常好，因此非常有必要了解如何通过梯度下降来减少损耗。
 
@@ -65,7 +65,7 @@ style_path = './tmp/nst/zebra.jpg' # zebra:Yathin S Krishnappa, https://creative
 
 # 预处理图像
 
-下一个功能只需稍作预处理即可加载图像。 `Image.open()`是所谓的惰性操作。 该函数找到文件并将其打开以进行读取，但是实际上直到从您尝试对其进行处理或加载数据以来，才从文件中读取图像数据。 下一组三行会调整图像的大小，以便任一方向的最大尺寸为 512（`max_dimension`）像素。 例如，如果图像为`1,024 x 768`，则`scale`将为 0.5（`512 / 1,024`），并且这将应用于图像的两个尺寸，从而将图像大小调整为`512 x 384`。`Image.ANTIALIAS`参数保留最佳图像质量。 接下来，使用`img_to_array()`调用（`tensorflow.keras.preprocessing`的方法）将 PIL 图像转换为 NumPy 数组。
+下一个函数只需稍作预处理即可加载图像。 `Image.open()`是所谓的惰性操作。 该函数找到文件并将其打开以进行读取，但是实际上直到从您尝试对其进行处理或加载数据以来，才从文件中读取图像数据。 下一组三行会调整图像的大小，以便任一方向的最大尺寸为 512（`max_dimension`）像素。 例如，如果图像为`1,024 x 768`，则`scale`将为 0.5（`512 / 1,024`），并且这将应用于图像的两个尺寸，从而将图像大小调整为`512 x 384`。`Image.ANTIALIAS`参数保留最佳图像质量。 接下来，使用`img_to_array()`调用（`tensorflow.keras.preprocessing`的方法）将 PIL 图像转换为 NumPy 数组。
 
 最后，为了与以后的使用兼容，图像需要沿零轴的批次尺寸（由于图像是彩色的，因此共给出了四个尺寸）。 这可以通过调用`np.expand_dims()`实现：
 
@@ -84,7 +84,7 @@ def load_image(path_to_image):
     return image
 ```
 
-下一个功能显示已由`load_image()`预处理过的图像。 由于我们不需要额外的尺寸来显示，因此可以通过调用`np.squeeze()`将其删除。 之后，根据对`plt.imshow()`的调用（后面带有可选标题）的要求，将图像数据中的值转换为无符号的 8 位整数：
+下一个函数显示已由`load_image()`预处理过的图像。 由于我们不需要额外的尺寸来显示，因此可以通过调用`np.squeeze()`将其删除。 之后，根据对`plt.imshow()`的调用（后面带有可选标题）的要求，将图像数据中的值转换为无符号的 8 位整数：
 
 ```py
 def show_image(image, title=None):
@@ -100,7 +100,7 @@ def show_image(image, title=None):
 
 # 查看原始图像
 
-接下来，我们使用对前面两个函数的调用来显示内容和风格图像，请记住图像像素必须是无符号 8 位整数类型。 `plt.subplot(1,2,1)`功能意味着在位置 1 使用一排两列的网格； `plt.subplot(1,2,2)`表示在位置 2 使用一排两列的网格：
+接下来，我们使用对前面两个函数的调用来显示内容和风格图像，请记住图像像素必须是无符号 8 位整数类型。 `plt.subplot(1,2,1)`函数意味着在位置 1 使用一排两列的网格； `plt.subplot(1,2,2)`表示在位置 2 使用一排两列的网格：
 
 ```py
 channel_means = [103.939, 116.779, 123.68] # means of the BGR channels, for VGG processing
@@ -123,7 +123,7 @@ plt.show()
 
 ![](img/c2cdcfbd-80c8-4aca-bc8d-a0fbf9cab5ce.png)
 
-接下来是加载图像的功能。 正如我们将要提到的那样，在经过训练的`vgg19`模型中，我们需要相应地预处理图像数据。
+接下来是加载图像的函数。 正如我们将要提到的那样，在经过训练的`vgg19`模型中，我们需要相应地预处理图像数据。
 
 `tf.keras`模块为我们提供了执行此操作的方法。 这里的预处理将我们的 RGB 彩色图像翻转为 BGR：
 
@@ -142,7 +142,7 @@ def load_and_process_image(path_to_image):
 
 因此，接下来，我们将这些值添加回 BGR（彩色）通道以恢复原始值，然后将 BGR 序列翻转回 RGB。
 
-最后，对于此功能，我们需要确保我们的值是无符号的 8 位整数，其值在 0 到 255 之间； 这可以通过`np.clip()`功能实现：
+最后，对于此函数，我们需要确保我们的值是无符号的 8 位整数，其值在 0 到 255 之间； 这可以通过`np.clip()`函数实现：
 
 ```py
 def deprocess_image(processed_image):
@@ -194,7 +194,7 @@ number_of_style_layers = len(style_layers)
 
 # 建立模型
 
-现在，接下来是一系列功能，这些功能最终导致执行风格迁移（`run_style_transfer()`）的主要功能。
+现在，接下来是一系列函数，这些函数最终导致执行风格迁移（`run_style_transfer()`）的主要函数。
 
 此序列中的第一个函数`get_model()`创建我们将要使用的模型。
 
@@ -325,7 +325,7 @@ import IPython.display
 
 # 执行风格迁移
 
-执行`style_transfer`的功能很长，因此我们将分节介绍。 其签名如下：
+执行`style_transfer`的函数很长，因此我们将分节介绍。 其签名如下：
 
 ```py
 def run_style_transfer(content_path,
@@ -362,7 +362,7 @@ initial_image = load_and_process_image(content_path)
 initial_image = tf.Variable(initial_image, dtype=tf.float32)
 ```
 
-下一行定义所需的`AdamOptimizer`功能：
+下一行定义所需的`AdamOptimizer`函数：
 
 ```py
 optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=5, beta1=0.99, epsilon=1e-1)
@@ -451,7 +451,7 @@ if i % display_interval== 0:
         .format(loss, style_score, content_score))
 ```
 
-最后，对于此功能，我们显示所有`best_image`和`best_loss`：
+最后，对于此函数，我们显示所有`best_image`和`best_loss`：
 
 ```py
  IPython.display.clear_output(wait=True)
@@ -482,7 +482,7 @@ Image.fromarray(best_image)
 
 # 最终展示
 
-最后，我们有一个功能，它与`best_image`一起显示内容和风格图像：
+最后，我们有一个函数，它与`best_image`一起显示内容和风格图像：
 
 ```py
 def show_results(best_image, content_path, style_path, show_large_final=True):

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

 # 八、TensorFlow 2 和循环神经网络
 
-包括卷积网络（CNN）在内的许多神经网络体系结构的主要缺点之一是它们不允许处理顺序数据。 换句话说，一个完整的功能（例如图像）必须一次全部呈现。 因此，输入是固定长度张量，而输出必须是固定长度张量。 先前特征的输出值也不会以任何方式影响当前特征。 同样，所有输入值（和输出值）都应视为彼此独立。 例如，在我们的`fashion_mnist`模型（第 4 章“使用 TensorFlow 2的监督机器学习”）中，每个输入时尚图像都独立于并且完全不了解先前图像。
+包括卷积网络（CNN）在内的许多神经网络体系结构的主要缺点之一是它们不允许处理顺序数据。 换句话说，一个完整的特征（例如图像）必须一次全部呈现。 因此，输入是固定长度张量，而输出必须是固定长度张量。 先前特征的输出值也不会以任何方式影响当前特征。 同样，所有输入值（和输出值）都应视为彼此独立。 例如，在我们的`fashion_mnist`模型（第 4 章“使用 TensorFlow 2的监督机器学习”）中，每个输入时尚图像都独立于并且完全不了解先前图像。
 
 **循环神经网络**（**RNN**）克服了这个问题，并使许多新的应用成为可能。
 

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

@@ -17,7 +17,7 @@
 
 开发估计器模型的过程分为四个步骤：
 
-1.  采集数据并创建数据功能
+1.  采集数据并创建数据函数
 2.  创建特征列
 3.  实例化估计器
 4.  评估模型的表现
@@ -50,7 +50,7 @@ y_train, y_test = np.int32(y_train), np.int32(y_test)
 learning_rate = 1e-4
 ```
 
-之后，是我们的训练输入功能。
+之后，是我们的训练输入特征。
 
 当您具有数组中的完整数据集并需要快速进行批处理，混排和/或重复的方法时，将使用`tf.compat.v1.estimator.inputs.numpy_input_fn`。
 
@@ -80,9 +80,9 @@ train_input_fn = tf.compat.v1.estimator.inputs.numpy_input_fn(
 )
 ```
 
-值得一提的是，尽管这样的便利功能虽然在 TensorFlow 2.0 alpha 中不可用，但仍有望改用 TensorFlow2。
+值得一提的是，尽管这样的便利函数虽然在 TensorFlow 2.0 alpha 中不可用，但仍有望改用 TensorFlow2。
 
-测试功能具有相同的签名，但是在这种情况下，我们仅指定一个时期，并且正如 Google 所建议的那样，我们不会对数据进行混洗。 同样，其余参数保留为其默认值：
+测试函数具有相同的签名，但是在这种情况下，我们仅指定一个时期，并且正如 Google 所建议的那样，我们不会对数据进行混洗。 同样，其余参数保留为其默认值：
 
 ```py
 test_input_fn = tf.compat.v1.estimator.inputs.numpy_input_fn(
@@ -93,9 +93,9 @@ test_input_fn = tf.compat.v1.estimator.inputs.numpy_input_fn(
 )
 ```
 
-接下来，我们建立功能列。 功能列是一种将数据传递给估计器的方法。
+接下来，我们建立特征列。 特征列是一种将数据传递给估计器的方法。
 
-功能列功能的签名如下。 `key`是唯一的字符串，是与我们先前在输入函数中指定的字典名称相对应的列名称（有关不同类型的功能列的更多详细信息，请参见[这里](https://www.tensorflow.org/api_docs/python/tf/feature_column)）：
+特征列函数的签名如下。 `key`是唯一的字符串，是与我们先前在输入函数中指定的字典名称相对应的列名称（有关不同类型的特征列的更多详细信息，请参见[这里](https://www.tensorflow.org/api_docs/python/tf/feature_column)）：
 
 ```py
 tf.feature_column.numeric_column(
@@ -107,13 +107,13 @@ tf.feature_column.numeric_column(
 )
 ```
 
-在我们的特定功能列中，我们可以看到关键是`"x"`，并且形状就是`fashion_mnist`数据集图像的`28 x 28`像素形状：
+在我们的特定特征列中，我们可以看到关键是`"x"`，并且形状就是`fashion_mnist`数据集图像的`28 x 28`像素形状：
 
 ```py
 feature_columns = [tf.feature_column.numeric_column("x", shape=[28, 28])]
 ```
 
-接下来，我们实例化我们的估计器，它将进行分类。 它将为我们构建一个深度神经网络。 它的签名很长很详细，因此我们将带您参考[这里](https://www.tensorflow.org/api_docs/python/tf/estimator/DNNClassifier)，因为我们将主要使用其默认参数。 它的第一个参数是我们刚刚指定的功能，而第二个参数是我们的网络规模。 （输入层和输出层由估计器在后台添加。）`AdamOptimizer`是安全的选择。 `n_classes`对应于我们`fashion_mnist`数据集的`y`标签数量，我们在其中添加了`0.1`的适度`dropout`。 然后，`model_dir`是我们保存模型参数及其图形和检查点的目录。 此目录还用于将检查点重新加载到估计器中以继续训练：
+接下来，我们实例化我们的估计器，它将进行分类。 它将为我们构建一个深度神经网络。 它的签名很长很详细，因此我们将带您参考[这里](https://www.tensorflow.org/api_docs/python/tf/estimator/DNNClassifier)，因为我们将主要使用其默认参数。 它的第一个参数是我们刚刚指定的特征，而第二个参数是我们的网络规模。 （输入层和输出层由估计器在后台添加。）`AdamOptimizer`是安全的选择。 `n_classes`对应于我们`fashion_mnist`数据集的`y`标签数量，我们在其中添加了`0.1`的适度`dropout`。 然后，`model_dir`是我们保存模型参数及其图形和检查点的目录。 此目录还用于将检查点重新加载到估计器中以继续训练：
 
 ```py
 # Build 2 layer DNN classifier
@@ -260,13 +260,13 @@ optimizer = tf.optimizers.Adagrad(learning_rate=learning_rate)
 
 IMDb 目录/文件层次结构
 
-我们从调用层次结构中的三个功能开始，这些功能获取并预处理审阅数据。
+我们从调用层次结构中的三个函数开始，这些函数获取并预处理审阅数据。
 
 在第一个函数`load_data(directory)`中，`directory_data`是一个字典，其中加载了`directory`中的数据，该数据作为参数传入并作为 pandas `DataFrame`返回。
 
 用`description`和`sentiment`键初始化`directory_data`字典，然后将它们分配为空列表作为值。
 
-然后，该功能循环遍历`directory`中的每个文件，并且对于每个文本文件，读取其内容（作为电影评论）并将其附加到情感列表中。 然后，它使用正则表达式分析文件名并提取数字情感，如前所示，该数字情感紧随文件名中的下划线（`_`）。 该函数将此数字情感附加到`sentiment`列表中。 当所有`.txt`文件都循环通过后，该函数将返回已转换为 pandas `DataFrame`的字典：
+然后，该函数循环遍历`directory`中的每个文件，并且对于每个文本文件，读取其内容（作为电影评论）并将其附加到情感列表中。 然后，它使用正则表达式分析文件名并提取数字情感，如前所示，该数字情感紧随文件名中的下划线（`_`）。 该函数将此数字情感附加到`sentiment`列表中。 当所有`.txt`文件都循环通过后，该函数将返回已转换为 pandas `DataFrame`的字典：
 
 ```py
 # Load all files from a directory into a Pandas DataFrame.
@@ -294,7 +294,7 @@ def load(directory):
     return pd.concat([positive_df, negative_df]).sample(frac=1).reset_index(drop=True)
 ```
 
-第三个也是最后一个功能是`acquire_data()`。 如果缓存中不存在该函数，则使用 Keras 工具从 Stanford URL 中获取我们所需的文件。 默认情况下，高速缓存是位于`~/.keras/datasets`的目录，如有必要，文件将提取到该位置。 该工具将返回到我们的 IMDb 的路径。 然后将其传递给`load_dataset()`的两个调用，以获取火车和测试`DataFrame`：
+第三个也是最后一个函数是`acquire_data()`。 如果缓存中不存在该函数，则使用 Keras 工具从 Stanford URL 中获取我们所需的文件。 默认情况下，高速缓存是位于`~/.keras/datasets`的目录，如有必要，文件将提取到该位置。 该工具将返回到我们的 IMDb 的路径。 然后将其传递给`load_dataset()`的两个调用，以获取火车和测试`DataFrame`：
 
 ```py
 # Download and process the dataset files.
@@ -333,21 +333,21 @@ train_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(train_df, train_d
 
 通过将此调用与函数签名进行比较，我们可以看到训练数据帧`train_df`与每个评论的极性一起传入。 `num_epochs =None`表示对训练纪元的数量没有限制，因为我们将在后面进行指定； `shuffle=True`表示以随机顺序读取记录，即文件的每一行。
 
-接下来是预测训练结果的功能：
+接下来是预测训练结果的函数：
 
 ```py
 # Prediction on the whole training set.
 predict_train_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(train_df, train_df["polarity"], shuffle=False)
 ```
 
-我们还具有预测测试结果的功能：
+我们还具有预测测试结果的函数：
 
 ```py
 # Prediction on the test set.
 predict_test_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(test_df, test_df["polarity"], shuffle=False)
 ```
 
-然后，我们有功能列。 功能列是原始数据和估计器之间的中介。 共有九种功能列类型。 它们根据其类型采用数值或分类数据，然后将数据转换为适用于估计器的格式。 在[这个页面](https://www.tensorflow.org/guide/feature_columns)上有一个出色的描述以及许多示例。
+然后，我们有特征列。 特征列是原始数据和估计器之间的中介。 共有九种特征列类型。 它们根据其类型采用数值或分类数据，然后将数据转换为适用于估计器的格式。 在[这个页面](https://www.tensorflow.org/guide/feature_columns)上有一个出色的描述以及许多示例。
 
 请注意，嵌入来自`tf.hub`：