2020-08-05 22:04:36

docs/hands-on-dl-tf-zh/ch01.md

@@ -24,7 +24,7 @@ TensorFlow 是 Google 最近发布的新的机器学习和图计算库。 其 Py
 
 ## 通过`pip`安装
 
-对于`pip`安装，您可以选择使用 Python 2 或 Python 3 版本。 另外，您可以在 CPU 和 GPU 版本之间进行选择。 如果您的计算机具有功能强大的显卡，则可能适合您使用 GPU 版本。
+对于`pip`安装，您可以选择使用 Python2 或 Python3 版本。 另外，您可以在 CPU 和 GPU 版本之间进行选择。 如果您的计算机具有功能强大的显卡，则可能适合您使用 GPU 版本。
 
 ![Installing via pip](img/00003.jpg)
 
@@ -52,14 +52,14 @@ wget  https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.2.1-cp34-
 
 如果下载此文件，它将很快被您的计算机抓住。
 
-现在，您需要做的就是将文件名从`cp34`（代表 Python 3.4）更改为您使用的任何版本的 Python 3。 在这种情况下，我们将其更改为使用 Python 3.5 的版本，因此我们将`4`更改为`5`：
+现在，您需要做的就是将文件名从`cp34`（代表 Python 3.4）更改为您使用的任何版本的 Python3。 在这种情况下，我们将其更改为使用 Python 3.5 的版本，因此我们将`4`更改为`5`：
 
 ```py
 mv tensorflow-1.2.1-cp34-cp34m-linux_x86_64.whl tensorflow-1.2.1-cp35-cp35m-linux_x86_64.whl
 
 ```
 
-现在您可以通过简单地将安装行更改为`pip3 install`并将新 wheel 文件的名称更改为 3.5 后，来安装 TensorFlow for Python 3.5：
+现在您可以通过简单地将安装行更改为`pip3 install`并将新 wheel 文件的名称更改为 3.5 后，来为 Python 3.5 安装 TensorFlow：
 
 ```py
 sudo pip3 install ./tensorflow-1.2.1-cp35-cp35m-linux_x86_64.whl
@@ -88,11 +88,11 @@ sudo pip3 install ./tensorflow-1.2.1-cp35-cp35m-linux_x86_64.whl
 
 Jupyter 是与 IPython 进行交互的便捷方法，也是使用 CoCalc 进行这些计算的主要手段。 加载可能需要几秒钟。
 
-进入下面的屏幕快照中所示的界面时，您需要做的第一件事是通过转到内核|将内核更改为 Anaconda Python 3。 更改内核…| Python 3（Anaconda）：
+进入下面的屏幕快照中所示的界面时，您需要做的第一件事是通过转到“内核 | 更改内核… | Python3（Anaconda）”将内核更改为 Anaconda Python3：
 
 ![Installing via CoCalc](img/00008.jpg)
 
-这将为您提供适当的依赖关系以使用 TensorFlow。 更改内核可能需要几秒钟。 连接到新内核后，可以在单元格中键入`import tensorflow`，然后转到 Cell |。 运行单元格以检查其是否有效：
+这将为您提供适当的依赖关系以使用 TensorFlow。 更改内核可能需要几秒钟。 连接到新内核后，可以在单元格中键入`import tensorflow`，然后转到“单元格 | 运行单元格”以检查其是否有效：
 
 ![Installing via CoCalc](img/00009.jpg)
 
@@ -142,9 +142,9 @@ N = tf.constant([[1., 2.],[3.,4.]])     # Matrix, 2d
 K = tf.constant([[[1., 2.],[3.,4.]]])   # Tensor, 3d+
 ```
 
-`V1`向量（一维张量）作为`[1\. , 2.]`的 Python 列表传递。 这里的点只是强制 Python 将数字存储为十进制值而不是整数。 `V2`向量是`[3\. , 4\. ]`的另一个 Python 列表。 `M`变量是由 Python 中的列表列表构成的二维矩阵，在 TensorFlow 中创建了二维张量。 `N`变量也是二维矩阵。 请注意，这一行实际上有多行。 最后，`K`是一个真实的张量，包含三个维度。 请注意，最终维度仅包含一个条目，即一个 2 x 2 框。
+`V1`向量（一维张量）作为`[1\. , 2.]`的 Python 列表传递。 这里的点只是强制 Python 将数字存储为十进制值而不是整数。 `V2`向量是`[3\. , 4\. ]`的另一个 Python 列表。 `M`变量是由 Python 中的列表列表构成的二维矩阵，在 TensorFlow 中创建了二维张量。 `N`变量也是二维矩阵。 请注意，这一行实际上有多行。 最后，`K`是一个真实的张量，包含三个维度。 请注意，最终维度仅包含一个条目，即一个`2 x 2`框。
 
-如果该术语有点混乱，请不要担心。 每当您看到一个奇怪的新变量时，都可以跳回到这一点以了解它可能是什么。
+如果该项有点混乱，请不要担心。 每当您看到一个奇怪的新变量时，都可以跳回到这一点以了解它可能是什么。
 
 ## 张量计算
 
@@ -260,7 +260,7 @@ print(W.eval())
 
 ## 查看和替换中间值
 
-在执行 TensorFlow 计算时，您可以返回或提供任意节点。 让我们定义一个新节点，但同时在 fetch 调用中返回另一个节点。 首先，让我们定义新节点`E`，如下所示：
+在执行 TensorFlow 计算时，您可以返回或提供任意节点。 让我们定义一个新节点，但同时在`fetch`调用中返回另一个节点。 首先，让我们定义新节点`E`，如下所示：
 
 ```py
 E = d + b # 1*2 + 2 = 4
@@ -368,7 +368,7 @@ plt.ion()
 
 ![Introducing the font classification dataset](img/00019.jpg)
 
-是的，他们很浮华。 在数据集中，每个图像都表示为像素暗度值的 36 x 36 二维矩阵。 0 值表示白色像素，而 255 表示黑色像素。 两者之间的一切都是灰色阴影。 这是在您自己的计算机上显示这些字体的代码：
+是的，他们很浮华。 在数据集中，每个图像都表示为像素暗度值的`36 x 36`二维矩阵。 0 值表示白色像素，而 255 表示黑色像素。 两者之间的一切都是灰色阴影。 这是在您自己的计算机上显示这些字体的代码：
 
 ```py
 # Let's look at a subplot of one of A in each font
@@ -379,13 +379,13 @@ for i in range(5):
                    cmap=plt.cm.gray_r)
 ```
 
-如果您的图看起来确实很宽，则可以使用鼠标轻松调整窗口大小。 如果您只是以交互方式进行绘图，则在 Python 中提前调整其大小通常需要做很多工作。 鉴于我们还有许多其他标记的字体图像，我们的目标是确定图像属于哪种字体。 为了扩展数据集并避免过拟合，我们还在 36 x 36 区域内抖动了每个字符，为我们提供了 9 倍的数据点。
+如果您的图看起来确实很宽，则可以使用鼠标轻松调整窗口大小。 如果您只是以交互方式进行绘图，则在 Python 中提前调整其大小通常需要做很多工作。 鉴于我们还有许多其他标记的字体图像，我们的目标是确定图像属于哪种字体。 为了扩展数据集并避免过拟合，我们还在`36 x 36`区域内抖动了每个字符，为我们提供了 9 倍的数据点。
 
 在使用较新的模型后重新回到这一点可能会有所帮助。 无论最终模型有多高级，记住原始数据都非常重要。
 
 ## 逻辑回归
 
-如果您熟悉线性回归，那么您将了解逻辑回归。 基本上，我们将为图像中的每个像素分配一个权重，然后对这些像素进行加权求和（权重为 beta，像素为`X`）。 这将为我们提供该图像是特定字体的分数。 每种字体都有自己的权重集，因为它们对像素的重视程度不同。 要将这些分数转换为适当的概率（由`Y`表示），我们将使用`softmax`函数将其总和强制在 0 到 1 之间，如下所示。 对于特定图像而言，无论最大概率是多少，我们都将其分类为关联的类别。
+如果您熟悉线性回归，那么您将了解逻辑回归。 基本上，我们将为图像中的每个像素分配一个权重，然后对这些像素进行加权求和（权重为`beta`，像素为`X`）。 这将为我们提供该图像是特定字体的分数。 每种字体都有自己的权重集，因为它们对像素的重视程度不同。 要将这些分数转换为适当的概率（由`Y`表示），我们将使用`softmax`函数将其总和强制在 0 到 1 之间，如下所示。 对于特定图像而言，无论最大概率是多少，我们都将其分类为关联的类别。
 
 您可以在大多数统计建模教科书中阅读有关逻辑回归理论的更多信息。 这是它的公式：
 
@@ -420,7 +420,7 @@ def to_onehot(labels,nclasses = 5):
 onehot = to_onehot(labels)
 ```
 
-对于像素，在这种情况下，我们实际上并不需要矩阵，因此我们将 36 x 36 的数字展平为长度为 1,296 的一维向量，但这会在以后出现。 另外，回想一下，我们已经重新调整了 0-255 的像素值，使其介于 0 和 1 之间。
+对于像素，在这种情况下，我们实际上并不需要矩阵，因此我们将`36 x 36`的数字展平为长度为 1,296 的一维向量，但这会在以后出现。 另外，回想一下，我们已经重新调整了 0-255 的像素值，使其介于 0 和 1 之间。
 
 好的，我们的最后准备是将数据集分为训练和验证集。 这将有助于我们稍后解决过拟合问题。 训练集将帮助我们确定逻辑回归模型中的权重，而验证集将仅用于确认这些权重在新数据上是否合理：
 
@@ -487,7 +487,7 @@ y = tf.nn.softmax(tf.matmul(x,W) + b)
 
 # 逻辑回归训练
 
-首先，您将了解我们的机器学习分类器的损失函数，并在 TensorFlow 中实现它。 然后，我们将通过评估正确的 TensorFlow 节点来快速训练模型。 最后，我们将验证我们的模型是否合理准确，权重是否合理。
+首先，您将了解我们的机器学习分类器的损失函数，并在 TensorFlow 中实现它。 然后，我们将通过求值正确的 TensorFlow 节点来快速训练模型。 最后，我们将验证我们的模型是否合理准确，权重是否合理。
 
 ## 定义损失函数
 
@@ -576,7 +576,7 @@ plt.plot(test_acc,'rx')
 
 ![Evaluating the model accuracy](img/00021.jpg)
 
-验证精度似乎在经过约 400-500 次迭代后趋于平稳； 除此之外，我们的模型可能过拟合或没有学到更多。 同样，即使最终精度大约是 40％，看起来也很差，但请记住，对于五个类别，完全随机的猜测将仅具有 20％的精度。 有了这个有限的数据集，简单的模型就可以做到。
+验证精度似乎在经过约 400-500 次迭代后趋于平稳； 除此之外，我们的模型可能过拟合或没有学到更多。 同样，即使最终精度大约是 40%，看起来也很差，但请记住，对于五个类别，完全随机的猜测将仅具有 20%的精度。 有了这个有限的数据集，简单的模型就可以做到。
 
 查看计算出的权重通常也很有帮助。 这些可以为您提供有关模型认为重要的线索。 让我们按给定类的像素位置绘制它们：
 

docs/hands-on-dl-tf-zh/ch02.md

@@ -222,13 +222,13 @@ plt.plot(test_acc,'rx')
 
 ![Single hidden layer explained](img/00031.jpg)
 
-同样，如果您没有 Matplotlib，那就没关系。 您可以只查看数组值本身。 请注意，训练精度（蓝色）通常比测试精度（红色）好一点。 这并不奇怪，因为测试图像对于模型来说是全新的，并且可能包含以前看不见的特征。 另外，观察精度通常会攀升到更多的周期，然后逐渐上升，然后逐渐上升。 我们的模型在这里达到约 60％的准确率； 并非完美，但对简单逻辑回归进行了改进。
+同样，如果您没有 Matplotlib，那就没关系。 您可以只查看数组值本身。 请注意，训练精度（蓝色）通常比测试精度（红色）好一点。 这并不奇怪，因为测试图像对于模型来说是全新的，并且可能包含以前看不见的特征。 另外，观察精度通常会攀升到更多的周期，然后逐渐上升，然后逐渐上升。 我们的模型在这里达到约 60%的准确率； 并非完美，但对简单逻辑回归进行了改进。
 
 要查看我们的模型在哪里混淆，创建混淆矩阵会很有帮助。 也就是说，我们将寻找一个可以说的实际绘图类别。 该模型将其分类为什么？ 形式上是 5x5 矩阵。 对于每个测试图像，如果图像实际上是类别`i`和模型预测类别`j`，则我们增加值和位置`i j`。 请注意，当模型正确时，则为`i = j`。
 
-一个好的模型在对角线上将具有很大的价值，而在其他地方则没有很多。 通过这种类型的分析，很容易看出两个类是否经常彼此混淆，或者模型很少选择某些类。
+一个好的模型在对角线上将具有很大的值，而在其他地方则没有很多。 通过这种类型的分析，很容易看出两个类是否经常彼此混淆，或者模型很少选择某些类。
 
-在以下示例中，我们通过评估`y`（类概率）来创建预测类：
+在以下示例中，我们通过求值`y`（类概率）来创建预测类：
 
 ```py
 pred = np.argmax(y.eval(feed_dict={x: 
@@ -258,7 +258,7 @@ for i in range(32):
     plts[i//8, i%8].pcolormesh(W1.eval()[:,i].reshape([36,36]))
 ```
 
-但是，现在我们有 128 个神经元，每个神经元的权重都来自输入像素，权重为 36x36。 让我们看看其中的一些，以了解他们的发现。 同样，如果您没有 Matplotlib，则可以简单地打印出数组以查看相同的行为。 在这里，我们将研究 128 个神经元中的 32 个。 因此，让我们将子图的格式设置为四行八列。 现在，我们逐步评估每个神经元的权重，并将其重塑为图像大小。 双斜杠（`//`）使用整数除法将图像放入适当的行，而百分号（`%`）使用余数（实际上是模块化算术）来选择列。
+但是，现在我们有 128 个神经元，每个神经元的权重都来自输入像素，权重为 36x36。 让我们看看其中的一些，以了解他们的发现。 同样，如果您没有 Matplotlib，则可以简单地打印出数组以查看相同的行为。 在这里，我们将研究 128 个神经元中的 32 个。 因此，让我们将子图的格式设置为四行八列。 现在，我们逐步求值每个神经元的权重，并将其重塑为图像大小。 双斜杠（`//`）使用整数除法将图像放入适当的行，而百分号（`%`）使用余数（实际上是模块化算术）来选择列。
 
 ![Understanding weights of the model](img/00033.jpg)
 
@@ -398,7 +398,7 @@ plt.plot(test_acc,'rx')
 
 ![Understanding the multiple hidden layers graph](img/00037.jpg)
 
-从前面的输出图中，我们可以达到约 68％的训练精度，也许还有 63％的验证精度。 这还不错，但是确实留出了一些改进的空间。
+从前面的输出图中，我们可以达到约 68%的训练精度，也许还有 63%的验证精度。 这还不错，但是确实留出了一些改进的空间。
 
 让我们花点时间看一下准确率在许多周期如何增长。 当然，它起步非常糟糕，并且存在一些最初的麻烦，但是权重是随机的，并且在那个时候仍在学习，并且在最初的数千个周期中它很快得到了改善。 虽然可能会暂时卡在局部最大值中，但通常会爬出并最终减慢其重音。 请注意，它仍然可以很好地进入训练阶段。 只是到了尽头，模型才可能达到其最大容量。 根据随机初始化，您的曲线可能看起来有些不同，但这没关系； 这是您的模型，非常好。
 

docs/hands-on-dl-tf-zh/ch03.md

@@ -159,7 +159,7 @@ sess.run(tf.global_variables_initializer())
 
 现在，您有了一个有效的卷积。 太好了！ 让我们快速看一下我们劳动成果。
 
-首先，我们需要评估`h1`节点，并将示例图像作为数据传递：
+首先，我们需要求值`h1`节点，并将示例图像作为数据传递：
 
 ```py
 # Peek inside
@@ -278,7 +278,7 @@ p1f = tf.reshape(p1, [-1, p1_size ])
 P = p1.eval(feed_dict = {x: image})
 ```
 
-首先，我们必须根据给定输入图像来实际评估池输出。
+首先，我们必须根据给定输入图像来实际求值池输出。
 
 由于池化层取决于卷积层，因此 TensorFlow 会自动将图像首先放置在其中。 我们可以以与卷积输出完全相同的方式查看结果。
 
@@ -451,13 +451,13 @@ for i in tqdm(range(epochs), ascii=True):
 
 ![CNN to classify our fonts](img/00058.jpg)
 
-我们可以看到，该模型优于旧的紧密连接模型，现在达到了 76％的训练准确率和约 68％的验证。
+我们可以看到，该模型优于旧的紧密连接模型，现在达到了 76%的训练准确率和约 68%的验证。
 
 这可能是因为字体即使创建许多不同的字母也以相同的方式使用了许多小范围的特征。 让我们也看看混淆矩阵。
 
 ![CNN to classify our fonts](img/00059.jpg)
 
-在这里，我们看到该模型仍不完美，但正在取得进展。 第一类仍然没有得到很好的代表，但是它至少在某种程度上是正确的，这与某些以前的模型从来都不是正确的不同。 其他班级大多都不错。 第三课实际上是完美的。 这不是一个容易的问题，因此任何改进都是好的。 我们还设置了一些代码来专门检查权重，但是我们将在以后的部分中保存它。 不过，请随时与他们一起玩耍。 您可以将模型权重和信息保存在检查点文件中。
+在这里，我们看到该模型仍不完美，但正在取得进展。 第一类仍然没有得到很好的代表，但是它至少在某种程度上是正确的，这与某些以前的模型从来都不是正确的不同。 其他类大多都不错。 第三类实际上是完美的。 这不是一个容易的问题，因此任何改进都是好的。 我们还设置了一些代码来专门检查权重，但是我们将在以后的部分中保存它。 不过，请随时与他们一起玩耍。 您可以将模型权重和信息保存在检查点文件中。
 
 ```py
 # Save the weights
@@ -495,7 +495,7 @@ load_all()
 
 # 更深的 CNN
 
-在本节中，我们将向模型添加另一个卷积层。 不用担心，我们将逐步遍历参数以使尺寸调整一致，并且我们将学习什么是 dropout 训练。
+在本节中，我们将向模型添加另一个卷积层。 不用担心，我们将逐步遍历参数以使尺寸调整一致，并且我们将学习什么是丢弃训练。
 
 ## 将 CNN 的一层添加到另一层
 
@@ -561,7 +561,7 @@ keep_prob = tf.placeholder("float")
 h3_drop = tf.nn.dropout(h3, keep_prob)
 ```
 
-dropout 是一种从模型中暂时切断神经元的方法。 我们在训练过程中这样做是为了避免过拟合。 每批 TensorFlow 将在此连接层选择不同的神经元输出以进行删除。 面对训练期间的细微变化，这有助于模型变得健壮。 `keep_prob`是保持特定神经元输出的概率。 在训练过程中通常将其设置为`0.5`。
+丢弃是一种从模型中暂时切断神经元的方法。 我们在训练过程中这样做是为了避免过拟合。 每批 TensorFlow 将在此连接层选择不同的神经元输出以进行删除。 面对训练期间的细微变化，这有助于模型变得健壮。 `keep_prob`是保持特定神经元输出的概率。 在训练过程中通常将其设置为`0.5`。
 
 再一次，最终的逻辑回归层和训练节点代码与之前的相同：
 
@@ -622,7 +622,7 @@ for i in tqdm(range(epochs), ascii=True):
 
 # 深度 CNN 总结
 
-我们将通过评估模型的准确率来总结深层的 CNN。 上一次，我们建立了最终的字体识别模型。 现在，让我们看看它是如何工作的。 在本节中，我们将学习如何在训练期间处理 dropout 问题。 然后，我们将看到模型达到了什么精度。 最后，我们将权重可视化以了解模型学到了什么。
+我们将通过评估模型的准确率来总结深层的 CNN。 上一次，我们建立了最终的字体识别模型。 现在，让我们看看它是如何工作的。 在本节中，我们将学习如何在训练期间处理丢弃问题。 然后，我们将看到模型达到了什么精度。 最后，我们将权重可视化以了解模型学到了什么。
 
 确保在上一个模型中进行训练后，在 IPython 会话中接手。 回想一下，当我们训练模型时，我们使用`dropout`删除了一些输出。
 
@@ -643,7 +643,7 @@ for i in tqdm(range(epochs), ascii=True):
 
 ![Wrapping up deep CNN](img/00060.jpg)
 
-这里的训练准确率高达 85％，并且测试准确率也相差不远。还不错。模型的效果取决于输入数据的噪声。 如果我们仅包含少量信息，无论是示例数量还是参数或像素数量，那么我们都无法期望模型表现完美。
+这里的训练准确率高达 85%，并且测试准确率也相差不远。还不错。模型的效果取决于输入数据的噪声。 如果我们仅包含少量信息，无论是示例数量还是参数或像素数量，那么我们都无法期望模型表现完美。
 
 在这种情况下，您可以应用的一种度量标准是人类将单个字母的图像分类到这些字体中的每种字体的程度。 一些字体非常有特色，而另一些则相似，尤其是某些字母。 由于这是一个新颖的数据集，因此没有直接的基准可以与之进行比较，但是您可以挑战自己以击败本课程中介绍的模型。 如果这样做，您可能希望减少训练时间。 当然，具有较少参数和更简单计算的较小网络将更快。 另外，如果您开始使用 GPU 或至少使用多核 CPU，则可以显着提高速度。 通常 10 倍更好，具体取决于硬件。
 

docs/hands-on-dl-tf-zh/ch04.md

@@ -44,7 +44,7 @@ dates = np.array([datetime.datetime.strptime(str(int(d)),
 
 ## 了解 RNN
 
-首先，让我们从压缩的 NumPy 数组中读取数据。 如果您想探索自己的模型，`weather.npz`文件也包括每日数据。 `np.load`将两个数组都读入字典，并将每周设置为我们感兴趣的数据； `num_weeks`自然就是我们拥有多少个数据点，在这里，几十年的信息价值：
+首先，让我们从压缩的 NumPy 数组中读取数据。 如果您想探索自己的模型，`weather.npz`文件也包括每日数据。 `np.load`将两个数组都读入字典，并将每周设置为我们感兴趣的数据； `num_weeks`自然就是我们拥有多少个数据点，在这里，几十年的信息的值：
 
 ```py
 num_weeks = len(weekly)
@@ -57,7 +57,7 @@ dates = np.array([datetime.datetime.strptime(str(int(d)),
                 '%Y%m%d') for d in weekly[:,0]])
 ```
 
-我们可以使用每周的日期来指定其季节。 对于此模型，因为我们正在查看天气数据，所以我们使用气象季节而不是普通的天文季节。 幸运的是，这很容易通过 Python 函数实现。 从`datetime`对象中获取月份，我们可以直接计算出该季节。 春季，零季节是 3 月至 5 月，夏季是 6 月至 8 月，秋天是 9 月至 11 月，最后是冬季 12 月至 2 月。 以下是简单的函数，它仅评估月份并实现该月份：
+我们可以使用每周的日期来指定其季节。 对于此模型，因为我们正在查看天气数据，所以我们使用气象季节而不是普通的天文季节。 幸运的是，这很容易通过 Python 函数实现。 从`datetime`对象中获取月份，我们可以直接计算出该季节。 春季，零季节是 3 月至 5 月，夏季是 6 月至 8 月，秋天是 9 月至 11 月，最后是冬季 12 月至 2 月。 以下是简单的函数，它仅求值月份并实现该月份：
 
 ```py
 def assign_season(date):
@@ -154,7 +154,7 @@ outputs, states = tf.nn.dynamic_rnn(cell,x_,
 
 这可以智能地处理递归，而不是简单地将所有时间步长展开成一个巨大的计算图。 因为我们在一个序列中有成千上万的观测值，所以这对于获得合理的速度至关重要。 在单元格之后，我们指定输入`x_`，然后指定`dtype`以使用 32 位将十进制数字存储在浮点数中，然后指定空的`initial_state`。 我们使用此输出建立一个简单的模型。 从这一点开始，该模型几乎完全符合您对任何神经网络的期望：
 
-我们将 RNN 单元的输出，一些权重相乘，并添加一个偏差以获得该周每个班级的分数：
+我们将 RNN 单元的输出，一些权重相乘，并添加一个偏差以获得该周每个类的分数：
 
 ```py
 W1 = tf.Variable(tf.truncated_normal([state_size,num_classes],
@@ -203,7 +203,7 @@ for i in tqdm(range(epochs), ascii=True):
 
 ![Understanding RNNs](img/00065.jpg)
 
-如果您确实看过准确率，您会发现它做得很好。 比 25％的随机猜测要好得多，但仍有很多东西需要学习。
+如果您确实看过准确率，您会发现它做得很好。 比 25%的随机猜测要好得多，但仍有很多东西需要学习。
 
 # TensorFlowLearn
 
@@ -318,7 +318,7 @@ sklearn.metrics.accuracy_score(test_labels,
 
 我们将使用相同的输入特征，但现在我们将构建一个具有两个隐藏层的 DNN，首先是`10`神经元，然后是`5`。 创建此模型仅需一行 Python 代码； 这再简单不过了。
 
-规格类似于我们的线性模型。 我们仍然需要`SKCompat`，但现在是`learn.DNNClassifier`。 对于参数，还有一个额外的要求：每个隐藏层上的神经元数量，以列表的形式传递。 这个简单的论点真正抓住了 DNN 模型的本质，使深度学习的力量触手可及。
+规格类似于我们的线性模型。 我们仍然需要`SKCompat`，但现在是`learn.DNNClassifier`。 对于参数，还有一个额外的要求：每个隐藏层上的神经元数量，以列表的形式传递。 这个简单的参数真正抓住了 DNN 模型的本质，使深度学习的力量触手可及。
 
 也有一些可选的参数，但是我们只提及`optimizer`。 这样，您就可以在不同的常见优化器例程之间进行选择，例如随机梯度下降（SGD）或 Adam。 很方便！
 
@@ -370,7 +370,7 @@ import tensorflow.contrib.layers as layers
 
 通用接口迫使我们编写为模型创建操作的函数。 您可能会发现这很乏味，但这就是灵活性的代价。
 
-用三个参数启动一个名为`conv_learn`的新函数。 `X`将作为输入数据，`y`将作为输出标签（尚未进行一次热编码），`mode`确定您是训练还是预测。 请注意，您永远不会直接与此特征交互； 您只需将其传递给需要这些参数的构造函数。 因此，如果您想改变层的数量或类型，则需要编写一个新的模型函数（或另一个会生成这种模型函数的函数）：
+用三个参数启动一个名为`conv_learn`的新函数。 `X`将作为输入数据，`y`将作为输出标签（尚未进行一次热编码），`mode`确定您是训练还是预测。 请注意，您永远不会直接与此特征交互； 您只需将其传递给需要这些参数的构造器。 因此，如果您想改变层的数量或类型，则需要编写一个新的模型函数（或另一个会生成这种模型函数的函数）：
 
 ```py
 def conv_learn(X, y, mode):
@@ -412,7 +412,7 @@ def conv_learn(X, y, mode):
 
 现在是时候建立紧密连接的层了。 `layers`模块再次出现，这一次具有`fully_connected`函数（致密层的另一个名称）。 这需要上一层，神经元的数量和激活函数，它们又由通用 TensorFlow 提供。
 
-为了演示的目的，我们也在此处添加一个 dropout 对象。 `layers.dropout`提供了接口。 不出所料，它需要上一层以及保持给定节点输出的概率。 但是它也需要我们传递给原始`conv_learn`函数的`mode`参数。 所有这些复杂的接口只不过是在训练期间丢弃节点。 如果您能解决这个问题，那么我们几乎可以遍历整个模型！
+为了演示的目的，我们也在此处添加一个`dropout`对象。 `layers.dropout`提供了接口。 不出所料，它需要上一层以及保持给定节点输出的概率。 但是它也需要我们传递给原始`conv_learn`函数的`mode`参数。 所有这些复杂的接口只不过是在训练期间丢弃节点。 如果您能解决这个问题，那么我们几乎可以遍历整个模型！
 
 ```py
      # densely connected layer with 32 neurons and dropout

docs/hands-on-dl-tf-zh/ch05.md

@@ -7,7 +7,7 @@
 *   TensorFlow 的未来
 *   其他一些 TensorFlow 项目
 
-现在让我们开始详细研究研究评估。
+现在让我们开始详细研究和评估模型。
 
 # 研究回顾
 
@@ -53,7 +53,7 @@ plt.pcolormesh(all_letters,
 
 ![The logistic regression model](img/00068.jpg)
 
-它具有 36x36 像素外加 1 倍乘以 5 类总权重，即我们需要训练的 6,485 个参数。 经过 1,000 次训练后，此模型的验证准确率达到了 40％。 您的结果可能会有所不同。 这相对较差，但是该模型具有一些优势。
+它具有 36x36 像素外加 1 倍乘以 5 类总权重，即我们需要训练的 6,485 个参数。 经过 1,000 次训练后，此模型的验证准确率达到了 40%。 您的结果可能会有所不同。 这相对较差，但是该模型具有一些优势。
 
 让我们回头看一下代码：
 
@@ -83,7 +83,7 @@ y = tf.nn.softmax(tf.matmul(x,W) + b)
 
 ![The single hidden layer neural network model](img/00069.jpg)
 
-该模型具有 36x36 像素，外加 1 个偏移乘以 128 个节点，再加上 128 个隐藏节点加上 1 个偏移乘以 5 个类的总权重，即 166,661 个参数。 隐藏层使用`sigmoid`激活函数来实现非线性。 在经过 5,000 个周期后，参数的纠缠达到了约 60％的验证准确率，这是一个很大的改进。 但是，此改进的代价是大量增加了计算复杂性中的参数数量，您可以从代码中大致了解一下：
+该模型具有 36x36 像素，外加 1 个偏移乘以 128 个节点，再加上 128 个隐藏节点加上 1 个偏移乘以 5 个类的总权重，即 166,661 个参数。 隐藏层使用`sigmoid`激活函数来实现非线性。 在经过 5,000 个周期后，参数的纠缠达到了约 60%的验证准确率，这是一个很大的改进。 但是，此改进的代价是大量增加了计算复杂性中的参数数量，您可以从代码中大致了解一下：
 
 ```py
 # These will be inputs
@@ -119,7 +119,7 @@ y = tf.nn.softmax(tf.matmul(h1,W2) + b2)
 
 ![Deep neural network](img/00070.jpg)
 
-经过 25,000 个周期后，我们的验证准确率微幅提高了 63％：
+经过 25,000 个周期后，我们的验证准确率微幅提高了 63%：
 
 ```py
 # These will be inputs
@@ -209,7 +209,7 @@ keep_prob = tf.placeholder("float")
 h2_drop = tf.nn.dropout(h2, keep_prob)
 ```
 
-仅训练了 5000 个周期后，我们就清除了 68％的准确率。 我们确实必须对卷积进行编码，但这并不是那么困难。 通过对问题的结构应用一些知识，我们同时减小了模型大小，但提高了准确率。 干得好！
+仅训练了 5000 个周期后，我们就清除了 68%的准确率。 我们确实必须对卷积进行编码，但这并不是那么困难。 通过对问题的结构应用一些知识，我们同时减小了模型大小，但提高了准确率。 干得好！
 
 ## 深度卷积神经网络
 
@@ -217,7 +217,7 @@ h2_drop = tf.nn.dropout(h2, keep_prob)
 
 ![Deep convolutional neural network](img/00072.jpg)
 
-尽管我们使用了较小的 3x3 窗口，但我们在第一个卷积层上计算了 16 个滤镜。 在进行最大 2x2 的池化之后，我们再次使用另一个 3x3 窗口和 4 个过滤器对池化值进行了处理。 另一个合并层再次馈入 32 个紧密连接的神经元和 Softmax 输出。 因为在馈入密集神经网络之前我们在池中有更多的卷积，所以在此模型中实际上我们具有较少的参数（准确地说是 10,765 个），几乎与逻辑回归模型一样少。 但是，该模型以 6,000 个周期的速度达到了 80％的验证准确率，证明了您的新深度学习和 TensorFlow 技能。
+尽管我们使用了较小的 3x3 窗口，但我们在第一个卷积层上计算了 16 个滤镜。 在进行最大 2x2 的池化之后，我们再次使用另一个 3x3 窗口和 4 个过滤器对池化值进行了处理。 另一个合并层再次馈入 32 个紧密连接的神经元和 Softmax 输出。 因为在馈入密集神经网络之前我们在池中有更多的卷积，所以在此模型中实际上我们具有较少的参数（准确地说是 10,765 个），几乎与逻辑回归模型一样少。 但是，该模型以 6,000 个周期的速度达到了 80%的验证准确率，证明了您的新深度学习和 TensorFlow 技能。
 
 ```py
 # Conv layer 1