2020-08-13 23:06:22

docs/tf-1x-dl-cookbook/00.md

@@ -10,7 +10,7 @@
 
 “回归”讨论了回归及其应用。 我们将讨论回归所涉及的概念，了解回归与聚类和分类的不同之处。 我们将学习可能的不同类型的损失函数以及如何在 Tensorflow 中实现它们。 我们学习如何实现 L1 和 L2 正则化。 我们将讨论梯度下降算法，学习如何优化它并在 Tensorflow 中实现它。 我们将简要了解交叉熵函数及其实现。
 
-“神经网络感知器”，涵盖了人工神经网络，并解释了为什么它可以完成 DNN 最近声称的出色任务。 我们将学习激活功能的不同选择。 我们将使用所有这些来构建一个简单的感知器，并将其用于功能建模。 我们将在训练之前了解数据的正则化。 我们还将学习逐步构建多层感知器（MLP）。 我们将看到 TensorFlow 的自动区分器如何使我们的工作更轻松。
+“神经网络感知器”，涵盖了人工神经网络，并解释了为什么它可以完成 DNN 最近声称的出色任务。 我们将学习激活函数的不同选择。 我们将使用所有这些来构建一个简单的感知器，并将其用于功能建模。 我们将在训练之前了解数据的正则化。 我们还将学习逐步构建多层感知器（MLP）。 我们将看到 TensorFlow 的自动区分器如何使我们的工作更轻松。
 
 “TensorFlow 卷积神经网络”，讨论了卷积的过程及其如何提取特征。 我们将学习 CNN 的三个重要层：卷积层，池化层和完全连接层。 我们还将学习辍学，如何提高性能以及不同的 CNN 架构（例如 LeNET 和 GoogleNET）。
 

docs/tf-1x-dl-cookbook/01.md

@@ -1089,7 +1089,7 @@ with tf.Session as sess:
 
 4.  **定义模型**：建立一个描述网络结构的计算图。 它涉及指定超参数，变量和占位符序列，其中信息从一组神经元流向另一组神经元，并传递损失/错误函数。 您将在本章的后续部分中了解有关计算图的更多信息。
 
-5.  **训练/学习**：DNN 中的学习通常基于梯度下降算法，（将在第 2 章，*回归*中详细介绍） 目的是找到训练变量（权重/偏差），以使误差或损失（由用户在步骤 2 中定义）最小。 这是通过初始化变量并使用`run()`实现的：
+5.  **训练/学习**：DNN 中的学习通常基于梯度下降算法，（将在第 2 章，“回归”中详细介绍） 目的是找到训练变量（权重/偏差），以使误差或损失（由用户在步骤 2 中定义）最小。 这是通过初始化变量并使用`run()`实现的：
 
 ```py
 with tf.Session as sess: 

docs/tf-1x-dl-cookbook/04.md

@@ -16,7 +16,7 @@ CNN 由许多神经网络层组成。 卷积和池化两种不同类型的层通
 
 An example of Convolutional Neural Network as seen is https://commons.wikimedia.org/wiki/File:Typical_cnn.png
 
-卷积网络背后有三个主要的直觉**：本地接受域**，**共享权重**和**池**。 让我们一起回顾一下。
+卷积网络背后有三个主要的直觉：**局部接受域**，**共享权重**和**池化**。 让我们一起回顾一下。
 
 # 当地接受领域
 
@@ -32,13 +32,13 @@ An example of Convolutional Neural Network as seen is https://commons.wikimedia.
 
 # 一个数学例子
 
-一种了解卷积的简单方法是考虑应用于矩阵的滑动窗口函数。 在下面的示例中，给定输入矩阵 **I** 和内核 **K** ，我们得到了卷积输出。 将 3 x 3 内核 **K** （有时称为**过滤器**或**功能** **检测器**）与输入矩阵逐元素相乘，得到一个 输出卷积矩阵中的单元格。 通过在 **I** 上滑动窗口即可获得所有其他单元格：
+一种了解卷积的简单方法是考虑应用于矩阵的滑动窗口函数。 在下面的示例中，给定输入矩阵`I`和内核`K`，我们得到了卷积输出。 将`3 x 3`内核`K`（有时称为**过滤器**或**特征检测器**）与输入矩阵逐元素相乘，得到输出卷积矩阵中的一个单元格。 通过在`I`上滑动窗口即可获得所有其他单元格：
 
 ![](img/d70c6297-0661-4521-bcea-769d611267af.png)
 
 An example of convolutional operation: in bold the cells involved in the computation
 
-在此示例中，我们决定在触摸 **I** 的边界后立即停止滑动窗口（因此输出为 3 x 3）。 或者，我们可以选择用零填充输入（以便输出为 5 x 5）。 该决定与所采用的**填充**选择有关。
+在此示例中，我们决定在触摸`I`的边界后立即停止滑动窗口（因此输出为`3 x 3`）。 或者，我们可以选择用零填充输入（以便输出为 5 x 5）。 该决定与所采用的**填充**选择有关。
 
 另一个选择是关于**步幅**，这与我们的滑动窗口采用的移位类型有关。 这可以是一个或多个。 较大的跨度将生成较少的内核应用程序，并且较小的输出大小，而较小的跨度将生成更多的输出并保留更多信息。
 
@@ -74,7 +74,7 @@ An example of convolutional operation
 
 # 最大池
 
-一个简单而常见的选择是所谓的**最大池运算符**，它仅输出在该区域中观察到的最大激活。 在 TensorFlow 中，如果要定义大小为 2 x 2 的最大池化层，我们将编写以下内容：
+一个简单而常见的选择是所谓的**最大池化运算符**，它仅输出在该区域中观察到的最大激活。 在 TensorFlow 中，如果要定义大小为 2 x 2 的最大池化层，我们将编写以下内容：
 
 ```py
 tf.nn.max_pool(value, ksize, strides, padding, data_format='NHWC', name=None)
@@ -202,7 +202,7 @@ y = tf.placeholder(tf.float32, [None, n_classes])
 keep_prob = tf.placeholder(tf.float32)  
 ```
 
-5.  使用输入`x`，权重`W`，偏差`b`和给定的步幅定义卷积层。 激活功能为 ReLU，填充为`SAME`：
+5.  使用输入`x`，权重`W`，偏差`b`和给定的步幅定义卷积层。 激活函数为 ReLU，填充为`SAME`：
 
 ```py
 def conv2d(x, W, b, strides=1): 
@@ -405,7 +405,7 @@ img_aug.add_random_flip_leftright()
 img_aug.add_random_rotation(max_angle=25.) 
 ```
 
-5.  使用先前定义的图像准备和扩充来创建卷积网络。 网络由三个卷积层组成。 第一个使用 32 个卷积滤波器，滤波器的大小为 3，激活函数为 ReLU。 之后，有一个`max_pool`层用于缩小尺寸。 然后有两个级联的卷积滤波器与 64 个卷积滤波器，滤波器的大小为 3，激活函数为 ReLU。 之后，有一个用于缩小规模的`max_pool`，一个具有 512 个神经元且具有激活功能 ReLU 的全连接网络，其次是辍学的可能性为 50％。 最后一层是具有 10 个神经元和激活功能`softmax`的完全连接的网络，用于确定手写数字的类别。 请注意，已知这种特定类型的 ConvNet 对于 CIFAR-10 非常有效。 在这种特殊情况下，我们将 Adam 优化器与`categorical_crossentropy`和学习率`0.001`结合使用：
+5.  使用先前定义的图像准备和扩充来创建卷积网络。 网络由三个卷积层组成。 第一个使用 32 个卷积滤波器，滤波器的大小为 3，激活函数为 ReLU。 之后，有一个`max_pool`层用于缩小尺寸。 然后有两个级联的卷积滤波器与 64 个卷积滤波器，滤波器的大小为 3，激活函数为 ReLU。 之后，有一个用于缩小规模的`max_pool`，一个具有 512 个神经元且具有激活函数 ReLU 的全连接网络，其次是辍学的可能性为 50％。 最后一层是具有 10 个神经元和激活函数`softmax`的完全连接的网络，用于确定手写数字的类别。 请注意，已知这种特定类型的 ConvNet 对于 CIFAR-10 非常有效。 在这种特殊情况下，我们将 Adam 优化器与`categorical_crossentropy`和学习率`0.001`结合使用：
 
 ```py
 # Convolutional network building 
@@ -452,7 +452,7 @@ An example of Jupyter execution for CIFAR10 classification
 
 # 做好准备
 
-我们将实现在论文中描述的算法*一种艺术风格的神经算法（ [https://arxiv.org/abs/1508.06576](https://arxiv.org/abs/1508.06576) ）*，作者是 Leon A. Gatys，亚历山大 S. Ecker 和 Matthias Bethge。 因此，最好先阅读该论文（ [https://arxiv.org/abs/1508.06576](https://arxiv.org/abs/1508.06576) ）。 此食谱将重复使用在线提供的预训练模型 VGG19（ [http://www.vlfeat.org/matconvnet/models/beta16/imagenet-vgg-verydeep-19.mat](http://www.vlfeat.org/matconvnet/models/beta16/imagenet-vgg-verydeep-19.mat) ），该模型应在本地下载。 我们的风格图片将是一幅可在线获得的梵高著名画作（ [https://commons.wikimedia.org/wiki/File:VanGogh-starry_night.jpg](https://commons.wikimedia.org/wiki/File:VanGogh-starry_night.jpg) ），而我们的内容图片则是玛丽莲（Marilyn）的照片 从 Wikipedia（ [https://commons.wikimedia.org/wiki/File:Marilyn_Monroe_in_1952.jpg](https://commons.wikimedia.org/wiki/File:Marilyn_Monroe_in_1952.jpg) ）下载的梦露。 内容图像将根据 *Van Gogh* 样式重新粉刷。
+我们将实现在论文中描述的算法*一种艺术风格的神经算法（ [https://arxiv.org/abs/1508.06576](https://arxiv.org/abs/1508.06576) ）*，作者是 Leon A. Gatys，亚历山大 S. Ecker 和 Matthias Bethge。 因此，最好先阅读该论文（ [https://arxiv.org/abs/1508.06576](https://arxiv.org/abs/1508.06576) ）。 此食谱将重复使用在线提供的预训练模型 VGG19（ [http://www.vlfeat.org/matconvnet/models/beta16/imagenet-vgg-verydeep-19.mat](http://www.vlfeat.org/matconvnet/models/beta16/imagenet-vgg-verydeep-19.mat) ），该模型应在本地下载。 我们的风格图片将是一幅可在线获得的梵高著名画作（ [https://commons.wikimedia.org/wiki/File:VanGogh-starry_night.jpg](https://commons.wikimedia.org/wiki/File:VanGogh-starry_night.jpg) ），而我们的内容图片则是玛丽莲（Marilyn）的照片 从 Wikipedia（ [https://commons.wikimedia.org/wiki/File:Marilyn_Monroe_in_1952.jpg](https://commons.wikimedia.org/wiki/File:Marilyn_Monroe_in_1952.jpg) ）下载的梦露。 内容图像将根据梵高的样式重新粉刷。
 
 # 怎么做...
 
@@ -531,7 +531,7 @@ imshow(style_image)
 
 An example of Vicent Van Gogh painting as seen in https://commons.wikimedia.org/wiki/File:VanGogh-starry_night_ballance1.jpg
 
-6.  下一步是按照原始论文中的描述定义 VGG 模型。 请注意，深度学习网络相当复杂，因为它结合了具有 ReLU 激活功能和最大池的多个 ConvNet 层。 另外需要注意的是，在原始论文《转移样式》（Leon A. Gatys，Alexander S. Ecker 和 Matthias Bethge 撰写的*一种艺术风格的神经算法*）中，许多实验表明，平均合并实际上优于 最大池化。 因此，我们将改用平均池：
+6.  下一步是按照原始论文中的描述定义 VGG 模型。 请注意，深度学习网络相当复杂，因为它结合了具有 ReLU 激活函数和最大池的多个 ConvNet 层。 另外需要注意的是，在原始论文《转移样式》（Leon A. Gatys，Alexander S. Ecker 和 Matthias Bethge 撰写的《一种艺术风格的神经算法》）中，许多实验表明，平均合并实际上优于 最大池化。 因此，我们将改用平均池：
 
 ```py
 def load_vgg_model(path, image_height, image_width, color_channels):
@@ -1002,7 +1002,7 @@ scores = model.predict_generator(validation_generator, nb_validation_samples/bat
 
 # 创建 DeepDream 网络
 
-Google 于 2014 年在 **ImageNet 上训练了神经网络以应对大规模视觉识别挑战**（**ILSVRC**），并于 2015 年 7 月将其开源。*中介绍了原始算法 深入了解卷积，Christian Szegedy，刘炜，贾阳清，Pierre Sermanet，Scott Reed，Dragomir Anguelov，Dumitru Erhan，Vincent Vanhoucke 和 Andrew Rabinovich（https://arxiv.org/abs/1409.4842）*。 网络学会了每个图像的表示。 较低的层学习诸如线条和边缘之类的底层特征，而较高的层则学习诸如眼睛，鼻子，嘴等更复杂的图案。 因此，如果尝试在网络中代表更高的级别，我们将看到从原始 ImageNet 提取的各种不同特征的混合，例如鸟的眼睛和狗的嘴巴。 考虑到这一点，如果我们拍摄一张新图像并尝试使与网络上层的相似性最大化，那么结果就是一张新的有远见的图像。 在这个有远见的图像中，较高层学习的某些模式在原始图像中被梦到（例如，想象中）。 这是此类有远见的图像的示例：
+Google 于 2014 年训练了神经网络以应对 **ImageNet 大规模视觉识别挑战**（**ILSVRC**），并于 2015 年 7 月将其开源。*中介绍了原始算法 深入了解卷积，Christian Szegedy，刘炜，贾阳清，Pierre Sermanet，Scott Reed，Dragomir Anguelov，Dumitru Erhan，Vincent Vanhoucke 和 Andrew Rabinovich（https://arxiv.org/abs/1409.4842）*。 网络学会了每个图像的表示。 较低的层学习诸如线条和边缘之类的底层特征，而较高的层则学习诸如眼睛，鼻子，嘴等更复杂的图案。 因此，如果尝试在网络中代表更高的级别，我们将看到从原始 ImageNet 提取的各种不同特征的混合，例如鸟的眼睛和狗的嘴巴。 考虑到这一点，如果我们拍摄一张新图像并尝试使与网络上层的相似性最大化，那么结果就是一张新的有远见的图像。 在这个有远见的图像中，较高层学习的某些模式在原始图像中被梦到（例如，想象中）。 这是此类有远见的图像的示例：
 
 ![](img/cbbf2fe8-00f2-4ee3-b340-050425f20a7c.jpg)
 

docs/tf-1x-dl-cookbook/06.md

@@ -75,7 +75,7 @@ LSTM 网络可以控制何时让输入进入神经元，何时记住在上一个
 
 An example of an LSTM cell
 
-首先，我们需要一个逻辑函数σ（请参见第 2 章，*回归*）来计算介于 0 和 1 之间的值，并控制哪些信息流过 LSTM *门[* 。 请记住，逻辑函数是可微的，因此允许反向传播。 然后，我们需要一个运算符⊗，它采用两个相同维的矩阵并生成另一个矩阵，其中每个元素 *ij* 是原始两个矩阵的元素 *ij* 的乘积。 同样，我们需要一个运算符⊕，它采用两个相同维度的矩阵并生成另一个矩阵，其中每个元素 *ij* 是原始两个矩阵的元素 *ij* 之和。 使用这些基本块，我们考虑时间 i 处的输入 X <sub>i</sub> ，并将其与上一步中的输出 Y <sub>i-1</sub> 并置。
+首先，我们需要一个逻辑函数σ（请参见第 2 章，“回归”）来计算介于 0 和 1 之间的值，并控制哪些信息流过 LSTM *门[* 。 请记住，逻辑函数是可微的，因此允许反向传播。 然后，我们需要一个运算符⊗，它采用两个相同维的矩阵并生成另一个矩阵，其中每个元素 *ij* 是原始两个矩阵的元素 *ij* 的乘积。 同样，我们需要一个运算符⊕，它采用两个相同维度的矩阵并生成另一个矩阵，其中每个元素 *ij* 是原始两个矩阵的元素 *ij* 之和。 使用这些基本块，我们考虑时间 i 处的输入 X <sub>i</sub> ，并将其与上一步中的输出 Y <sub>i-1</sub> 并置。
 
 方程 *f <sub>t</sub> =σ（W <sub>f</sub> 。[y <sub>i-1</sub> ，x <sub>t</sub> ] + b [HTG9 f* 实现了控制激活门 log 的逻辑回归，并用于确定应从*先前*候选值 C <sub>i-1</sub> 获取多少信息。 传递给下一个候选值 C <sub>i</sub> （此处 *W <sub>f</sub>* 和 *b <sub>f</sub>* 矩阵和用于 logistic 回归的偏差。）如果 logistic 输出为 1，则表示*不要忘记*先前的单元格状态 C <sub>i-1；</sub> 如果输出 0， 这将意味着*忘记*先前的单元状态 C <sub>i-1</sub> 。（0,1）中的任何数字都将表示要传递的信息量。
 

docs/tf-1x-dl-cookbook/11.md

@@ -95,7 +95,7 @@ def xavier_init(size):
   return xavier_stddev
 ```
 
-3.  定义输入 X 的生成器。首先，我们定义尺寸为[100，K = 128]的矩阵 W1，并根据正态分布对其进行初始化。 注意 100 是 Z 的任意值，Z 是我们的发生器使用的初始噪声。 然后，我们定义尺寸为[K = 256]的偏差 B1。 类似地，我们定义尺寸为[`K=128`，`L=784`]的矩阵 W2 和尺寸为[L = 784]的偏置 B2。 使用步骤 1 中定义的`xavier_init`初始化两个矩阵 W1 和 W2，而使用`tf.constant_initializer()`初始化 B1 和 B2。 之后，我们计算矩阵 *X * W1* 之间的乘法，求和 B1 的偏差，然后将其传递给 RELU 激活函数以获得 fc1。 然后将该密集层与下一个密集层连接，该密集层是通过将矩阵 fc1 与 W2 相乘并求和 B2 的偏差而创建的。 然后将结果通过 S 型函数传递。 这些步骤用于定义用于生成器的两层神经网络：
+3.  定义输入 X 的生成器。首先，我们定义尺寸为[100，K = 128]的矩阵 W1，并根据正态分布对其进行初始化。 注意 100 是 Z 的任意值，Z 是我们的发生器使用的初始噪声。 然后，我们定义尺寸为[K = 256]的偏差 B1。 类似地，我们定义尺寸为[`K=128`，`L=784`]的矩阵 W2 和尺寸为[L = 784]的偏置 B2。 使用步骤 1 中定义的`xavier_init`初始化两个矩阵 W1 和 W2，而使用`tf.constant_initializer()`初始化 B1 和 B2。 之后，我们计算矩阵 *X * W1* 之间的乘法，求和 B1 的偏差，然后将其传递给 RELU 激活函数以获得 fc1。 然后将该密集层与下一个密集层连接，该密集层是通过将矩阵 fc1 与 W2 相乘并求和 B2 的偏差而创建的。 然后将结果通过 Sigmoid 函数传递。 这些步骤用于定义用于生成器的两层神经网络：
 
 ```py
 def generator(X):
@@ -119,7 +119,7 @@ def generator(X):
     return prob
 ```
 
-4.  定义输入 X 的鉴别符。原则上，这与生成器非常相似。 主要区别在于，如果参数重用为 true，则调用`scope.reuse_variables()`触发重用。 然后我们定义两个密集层。 第一层使用尺寸为[`J=784`，`K=128`]的矩阵 W1，尺寸为[`K=128`]的偏差 B1，并且它基于 X 与 W1 的标准乘积。 将该结果添加到 B1 并传递给 RELU 激活函数以获取结果 fc1。 第二个矩阵使用尺寸为[`K=128`，`L=1`]的矩阵 W2 和尺寸为[`L=1`]的偏差 B2，它基于 fc1 与 W2 的标准乘积。 将此结果添加到 B2 并传递给 S 型函数：
+4.  定义输入 X 的鉴别符。原则上，这与生成器非常相似。 主要区别在于，如果参数重用为 true，则调用`scope.reuse_variables()`触发重用。 然后我们定义两个密集层。 第一层使用尺寸为[`J=784`，`K=128`]的矩阵 W1，尺寸为[`K=128`]的偏差 B1，并且它基于 X 与 W1 的标准乘积。 将该结果添加到 B1 并传递给 RELU 激活函数以获取结果 fc1。 第二个矩阵使用尺寸为[`K=128`，`L=1`]的矩阵 W2 和尺寸为[`L=1`]的偏差 B2，它基于 fc1 与 W2 的标准乘积。 将此结果添加到 B2 并传递给 Sigmoid 函数：
 
 ```py
 def discriminator(X, reuse=False):
@@ -337,7 +337,7 @@ def deconv(x, w, b, shape, stride, name):
       name=name) + b
 ```
 
-5.  定义一个标准`LeakyReLU`，这对于 GAN 是非常有效的激活功能：
+5.  定义一个标准`LeakyReLU`，这对于 GAN 是非常有效的激活函数：
 
 ```py
 def lrelu(x, alpha=0.2):
@@ -345,7 +345,7 @@ def lrelu(x, alpha=0.2):
     return tf.maximum(x, alpha * x)
 ```
 
-6.  定义生成器。 首先，我们定义输入大小为 100（Z 的任意大小，即生成器使用的初始噪声）的完全连接层。 全连接层由尺寸为[100，7 * 7 * 256]且根据正态分布初始化的矩阵 W1 和尺寸为[7 * 7 * 256]的偏置 B1 组成。 该层使用 ReLu 作为激活功能。 在完全连接的层之后，生成器将应用两个反卷积运算 deconv1 和 deconv2，两者的步幅均为 2。 完成第一个 deconv1 操作后，将结果批量标准化。 请注意，第二次反卷积运算之前会出现丢失，概率为 40％。 最后一个阶段是一个 Sigmoid，用作非线性激活，如下面的代码片段所示：
+6.  定义生成器。 首先，我们定义输入大小为 100（Z 的任意大小，即生成器使用的初始噪声）的完全连接层。 全连接层由尺寸为[100，7 * 7 * 256]且根据正态分布初始化的矩阵 W1 和尺寸为[7 * 7 * 256]的偏置 B1 组成。 该层使用 ReLu 作为激活函数。 在完全连接的层之后，生成器将应用两个反卷积运算 deconv1 和 deconv2，两者的步幅均为 2。 完成第一个 deconv1 操作后，将结果批量标准化。 请注意，第二次反卷积运算之前会出现丢失，概率为 40％。 最后一个阶段是一个 Sigmoid，用作非线性激活，如下面的代码片段所示：
 
 ```py
 def generator(X, batch_size=64):
@@ -368,7 +368,7 @@ def generator(X, batch_size=64):
     return tf.nn.sigmoid(XX)
 ```
 
-7.  定义鉴别符。 与前面的配方一样，如果参数重用为 true，则调用`scope.reuse_variables()`触发重用。 鉴别器使用两个卷积层。 第一个是批处理归一化，而第二个是概率为 40％的辍学，然后是批处理归一化步骤。 之后，我们得到了一个具有激活功能 ReLU 的致密层，然后是另一个具有基于 S 形激活功能的致密层：
+7.  定义鉴别符。 与前面的配方一样，如果参数重用为 true，则调用`scope.reuse_variables()`触发重用。 鉴别器使用两个卷积层。 第一个是批处理归一化，而第二个是概率为 40％的辍学，然后是批处理归一化步骤。 之后，我们得到了一个具有激活函数 ReLU 的致密层，然后是另一个具有基于 S 形激活函数的致密层：
 
 ```py
 def discriminator(X, reuse=False):
@@ -934,7 +934,7 @@ Squashing function as seen in Hinton's seminal paper
 
 A simple CapsNet architecture
 
-该体系结构很浅，只有两个卷积层和一个完全连接的层。 Conv1 具有 256 个 9×9 卷积核，步幅为 1，并具有 ReLU 激活功能。 该层的作用是将像素强度转换为局部特征检测器的活动，然后将其用作主胶囊的输入。 PrimaryCapsules 是具有 32 个通道的卷积胶囊层。 每个主胶囊包含 8 个卷积单元，其内核为 9×9，步幅为 2 *。* 总计，PrimaryCapsules 具有[32，6，6]胶囊输出（每个输出是 8D 矢量），并且[6，6]网格中的每个胶囊彼此共享重量。 最后一层（DigitCaps）每位数字类具有一个 16D 胶囊，这些胶囊中的每个胶囊都接收来自下一层中所有其他胶囊的输入。 路由仅发生在两个连续的胶囊层之间（例如 PrimaryCapsules 和 DigitCaps）。
+该体系结构很浅，只有两个卷积层和一个完全连接的层。 Conv1 具有 256 个 9×9 卷积核，步幅为 1，并具有 ReLU 激活函数。 该层的作用是将像素强度转换为局部特征检测器的活动，然后将其用作主胶囊的输入。 PrimaryCapsules 是具有 32 个通道的卷积胶囊层。 每个主胶囊包含 8 个卷积单元，其内核为 9×9，步幅为 2 *。* 总计，PrimaryCapsules 具有[32，6，6]胶囊输出（每个输出是 8D 矢量），并且[6，6]网格中的每个胶囊彼此共享重量。 最后一层（DigitCaps）每位数字类具有一个 16D 胶囊，这些胶囊中的每个胶囊都接收来自下一层中所有其他胶囊的输入。 路由仅发生在两个连续的胶囊层之间（例如 PrimaryCapsules 和 DigitCaps）。
 
 # 做好准备
 

docs/tf-1x-dl-cookbook/14.md

@@ -14,7 +14,7 @@ TPU 是 Google 专门为机器学习而定制的定制专用集成电路（**ASI
 
 前两个成分是矩阵乘法的一部分：权重矩阵 ***W*** 需要与输入矩阵 ***X*** 相乘 ***W <sup>T</sup> X*** ； 矩阵乘法在 CPU 上的计算量很大，尽管 GPU 使操作并行化，但仍有改进的余地。
 
-TPU 具有 65,536 个 8 位整数矩阵乘法器单元（**MXU**），峰值吞吐量为 92 TOPS。 GPU 和 TPU 乘法之间的主要区别在于 GPU 包含浮点乘法器，而 TPU 包含 8 位整数乘法器。 TPU 还包含一个统一缓冲区（**UB**），用作寄存器的 24 MB SRAM 和一个包含硬接线激活功能的激活单元（**AU**）。
+TPU 具有 65,536 个 8 位整数矩阵乘法器单元（**MXU**），峰值吞吐量为 92 TOPS。 GPU 和 TPU 乘法之间的主要区别在于 GPU 包含浮点乘法器，而 TPU 包含 8 位整数乘法器。 TPU 还包含一个统一缓冲区（**UB**），用作寄存器的 24 MB SRAM 和一个包含硬接线激活函数的激活单元（**AU**）。
 
 MXU 是使用脉动阵列架构实现的。 它包含一个阵列算术逻辑单元（ALU），该阵列连接到网状拓扑中的少量最近邻居。 每个数据值仅读取一次，但在流过 ALU 数组时会多次用于不同的操作，而无需将其存储回寄存器。 TPU 中的 ALU 仅以固定模式执行乘法和加法。 MXU 已针对矩阵乘法进行了优化，不适用于通用计算。
 
@@ -25,7 +25,7 @@ MXU 是使用脉动阵列架构实现的。 它包含一个阵列算术逻辑单
 *   `Read_Weights`：从内存读取权重
 *   `Read_Host_Memory`：从内存中读取数据
 *   `MatrixMultiply/Convolve`：与数据相乘或卷积并累加结果
-*   `Activate`：应用激活功能
+*   `Activate`：应用激活函数
 *   `Write_Host_Memory`：将结果写入存储器
 
 Google 创建了一个 API 堆栈，以方便 TPU 编程； 它将来自 Tensorflow 图的 API 调用转换为 TPU 指令。