2020-12-29 22:08:14

new/begin-app-dev-tf-keras/1.md

@@ -364,7 +364,7 @@ CIFAR 数据集是机器学习数据集，其中包含按不同类别组织的
 
 请在`Code/Lesson-1/activity_2/`中使用`mnist.py`文件作为参考。 在代码编辑器中打开脚本。
 
-在这里，我们还有两个 TensorFlow 变量`W`和`B`。 请注意，这些变量的初始化非常简单：`W`被初始化为修剪后的高斯分布（修剪过`size_in`和`size_out`）的随机值，标准偏差为`0.1,`和`B`（项）初始化为`0.1`（常数）。 这两个值在每次运行期间都会不断变化。 该代码段执行两次，产生两个全连接网络-一个将数据传递到另一个。
+在这里，我们还有两个 TensorFlow 变量`W`和`B`。 请注意，这些变量的初始化非常简单：`W`被初始化为修剪后的高斯分布（修剪过`size_in`和`size_out`）的随机值，标准差为`0.1,`和`B`（项）初始化为`0.1`（常数）。 这两个值在每次运行期间都会不断变化。 该代码段执行两次，产生两个全连接网络-一个将数据传递到另一个。
 
 那 11 行 Python 代码代表了我们完整的神经网络。 我们将在“第 2 课”，“模型架构”中详细介绍使用 Keras 的每个组件。 目前，应重点了解网络在每次运行时都会改变每个层中的`W`和`B`值，以及这些代码片段如何形成不同的层。 这 11 行 Python 是数十年来神经网络研究的高潮。
 
@@ -446,7 +446,7 @@ $ tensorboard --logdir=mnist_example/
 
 在 TensorBoard 页面上，单击**标量**页面，然后放大**精度**图。 现在，将**平滑**滑块移动到`0.9`。
 
-准确率图衡量网络能够猜测测试集标签的准确率。 最初，网络猜测这些标签完全错误。 发生这种情况是因为我们已使用随机值初始化了网络的权重和偏差，因此其首次尝试只是一个猜测。 然后，网络将在第二次运行中更改其层的权重和偏差； 网络将继续通过改变其权重和偏见来投资于那些能带来积极成果的节点，并通过逐渐减少其对网络的影响（最终达到`0`）来惩罚那些没有结果的节点。 如您所见，这是一种非常有效的技术，可以快速产生出色的结果。
+准确率图衡量网络能够猜测测试集标签的准确率。 最初，网络猜测这些标签完全错误。 发生这种情况是因为我们已使用随机值初始化了网络的权重和偏差，因此其首次尝试只是一个猜测。 然后，网络将在第二次运行中更改其层的权重和偏差； 网络将继续通过改变其权重和偏置来投资于那些能带来积极成果的节点，并通过逐渐减少其对网络的影响（最终达到`0`）来惩罚那些没有结果的节点。 如您所见，这是一种非常有效的技术，可以快速产生出色的结果。
 
 让我们将注意力集中在**精度**图表上。 看看在大约 1,000 个周期后，该算法如何达到很高的准确率（`> 95%`）？ 在 1,000 到 2,000 个周期之间会发生什么？ 如果我们继续训练更多的周期，它将变得更加准确吗？
 

new/begin-app-dev-tf-keras/2.md

@@ -49,7 +49,7 @@ CNN 的基本见解是将紧密相关的数据用作训练过程的特征，而
 
 ### 注意
 
-有关更多信息，请参阅 Jakob Uszkoreit 撰写的[《变压器：一种用于语言理解的新型神经网络架构》](https://research.googleblog.com/2017/08/transformer-novel-neural-network.html)。
+有关更多信息，请参阅 Jakob Uszkoreit 撰写的[《转换器：一种用于语言理解的新型神经网络架构》](https://research.googleblog.com/2017/08/transformer-novel-neural-network.html)。
 
 ![Recurrent Neural Networks](img/image02_02.jpg)
 
@@ -120,11 +120,11 @@ GAN 已成功用于数据具有清晰拓扑结构的领域。 它的原始实现
 
 ### Z 得分
 
-当数据以呈正态分布（即高斯）时，可以将每个观测值之间的距离计算为与其平均值的标准偏差。 当标识数据点与分布中更可能出现的地方相距多远时，此规范化很有用。 Z 分数定义为：
+当数据以呈正态分布（即高斯）时，可以将每个观测值之间的距离计算为与其平均值的标准差。 当标识数据点与分布中更可能出现的地方相距多远时，此规范化很有用。 Z 分数定义为：
 
 ![Z-score](img/image02_05.jpg)
 
-此处，`x[i]`是第`i`个观察值，`μ`是平均值，而`σ`是序列的标准偏差。
+此处，`x[i]`是第`i`个观察值，`μ`是平均值，而`σ`是序列的标准差。
 
 ### 注意
 

new/begin-app-dev-tf-keras/4.md

@@ -114,7 +114,7 @@
 
 > “代码段 3”：在我们的 LSTM 模型中实现 TensorBoard 回调的代码段
 
-在 Keras 中，训练模型时，将保留其重量信息-这是模型的状态。 当使用`model.save()`方法时，该状态也被保存。 当调用方法`model.fit()`时，将使用先前的状态作为起点，使用新的数据集重新训练模型。
+在 Keras 中，训练模型时，将保留其权重信息-这是模型的状态。 当使用`model.save()`方法时，该状态也被保存。 当调用方法`model.fit()`时，将使用先前的状态作为起点，使用新的数据集重新训练模型。
 
 在典型的 Keras 模型中，可以毫无问题地使用此技术。 但是，在使用 LSTM 模型时，此技术有一个关键限制：训练数据和验证数据的形状必须相同。 例如，我们的 LSTM 模型（`bitcoin_lstm_v0`）使用 76 周来预测未来的一周。 如果我们尝试在接下来的一周内用 77 周的时间对网络进行训练，则该模型会引发一个异常，其中包含有关数据形状错误的信息。
 

new/handson-meta-learn-py/03.md

@@ -191,7 +191,7 @@ train_dataset.shape
 (4112, 20, 28, 28)
 ```
 
-现在我们已经加载了训练数据，我们需要为它们创建嵌入。 我们使用卷积运算生成嵌入，因为我们的输入值是图像。 因此，我们定义了一个具有 64 个滤波器的卷积块，其中批量标准化和 ReLU 作为激活函数。 接下来，我们执行最大池化操作：
+现在我们已经加载了训练数据，我们需要为它们创建嵌入。 我们使用卷积运算生成嵌入，因为我们的输入值是图像。 因此，我们定义了一个具有 64 个过滤器的卷积块，其中批量标准化和 ReLU 作为激活函数。 接下来，我们执行最大池化操作：
 
 ```py
 def convolution_block(inputs, out_channels, name='conv'):

new/handson-meta-learn-py/09.md

@@ -179,7 +179,7 @@ MIL 中涉及的步骤如下：
 
 但是这种方法的问题在于，由于我们使用的是随机超平面，因此我们的类可能包含完全不同的嵌入，并且还将相关的嵌入保留在不同的类中。 因此，我们可以使用聚类算法来代替使用随机超平面对数据集进行分区。 我们使用 k 均值聚类作为我们的聚类算法来划分数据集。 我们对多个迭代运行 k-means 聚类，并获得`k`聚类（分区）。
 
-我们可以将每个群集视为一个单独的类。 下一个是什么？ 我们如何生成任务？ 假设由于集群，我们有五个集群。 我们从这五个群集中采样`n`个群集。 然后，我们从每个`n`簇中抽取`r`数据点，而无需替换； 这可以表示为`{x[r]}_n`。 之后，我们对`n`个单任务特定标签`l[n]`进行了排列，以为`n`个采样聚类的每一个分配标签。 因此，现在我们有一个数据点`{x[r]}_n`和一个标签`l[n]`。
+我们可以将每个群集视为一个单独的类。 下一个是什么？ 我们如何生成任务？ 假设由于集群，我们有五个集群。 我们从这五个群集中采样`n`个群集。 然后，我们从`n`个群集的每个中抽取`r`数据点，而无需替换； 这可以表示为`{x[r]}_n`。 之后，我们对`n`个单任务特定标签`l[n]`进行了排列，以为`n`个采样聚类的每一个分配标签。 因此，现在我们有一个数据点`{x[r]}_n`和一个标签`l[n]`。
 
 最后，我们可以将任务`T`定义为：
 
@@ -228,7 +228,7 @@ MIL 中涉及的步骤如下：
 
 # 概念判别损失
 
-我们从数据集`D`中采样一些数据点`(x, y)`，将它们馈送到概念生成器，该概念生成器学习概念并将其发送给概念判别器，后者试图预测这些概念的类。 因此，概念判别器的损失意味着我们的概念鉴别符在预测类别方面有多出色，可以表示为：
+我们从数据集`D`中采样一些数据点`(x, y)`，将它们馈送到概念生成器，该概念生成器学习概念并将其发送给概念判别器，后者试图预测这些概念的类。 因此，概念判别器的损失意味着我们的概念判别器在预测类别方面有多出色，可以表示为：
 
 ![](img/8a16d682-8033-4b27-afc0-e43e06f9a95b.png)
 

new/handson-rl-py/07.md

@@ -117,7 +117,7 @@
 
 ![](img/00178.gif)
 
-同样，我们可以表示成本函数，如下所示。 这是成本与重量的关系图。 我们的目标是使成本函数最小化。 也就是说，我们必须达到成本最低的最低点。 该点显示了我们的初始权重（即我们在山上的位置）。 如果将这一点向下移动，则可以到达误差最小的位置，即成本函数上的最低点（山上的最低点）：
+同样，我们可以表示成本函数，如下所示。 这是成本与权重的关系图。 我们的目标是使成本函数最小化。 也就是说，我们必须达到成本最低的最低点。 该点显示了我们的初始权重（即我们在山上的位置）。 如果将这一点向下移动，则可以到达误差最小的位置，即成本函数上的最低点（山上的最低点）：
 
 ![](img/00179.gif)
 
@@ -745,13 +745,13 @@ CNN 通常包含三个主要层：
 
 ![](img/00226.gif)
 
-现在，该滤镜将在我们的输入矩阵上滑动一个像素，并执行逐元素乘法，从而生成一个数字。 困惑？ 看下图：
+现在，该过滤器将在我们的输入矩阵上滑动一个像素，并执行逐元素乘法，从而生成一个数字。 困惑？ 看下图：
 
 ![](img/00227.gif)
 
 也就是说，`(13 * 0) + (8 * 1) + (18 * 0) + (5 * 1) + (3 * 1) + (1 * 1) + (1 * 0) + (9 * 0) + (0 * 1) = 17`。
 
-同样，我们将滤镜矩阵在输入矩阵上移动一个像素，然后执行逐元素乘法：
+同样，我们将过滤器矩阵在输入矩阵上移动一个像素，然后执行逐元素乘法：
 
 ![](img/00228.gif)
 
@@ -765,9 +765,9 @@ CNN 通常包含三个主要层：
 
 ![](img/00230.jpeg)
 
-您可以看到我们的滤镜已检测到实际图像中的边缘并产生了卷积图像。 类似地，使用不同的滤镜从图像中提取不同的特征。
+您可以看到我们的过滤器已检测到实际图像中的边缘并产生了卷积图像。 类似地，使用不同的过滤器从图像中提取不同的特征。
 
-例如，如果我们使用滤镜矩阵，比如说锐化滤镜：
+例如，如果我们使用过滤器矩阵，比如说锐化过滤器：
 
 ![](img/00231.jpeg)
 
@@ -775,15 +775,15 @@ CNN 通常包含三个主要层：
 
 ![](img/00232.jpeg)
 
-因此，过滤器负责通过执行卷积运算从实际图像中提取特征。 将有多个过滤器用于提取生成特征映射的图像的不同特征。 特征映射的深度是我们使用的过滤器的数量。 如果我们使用 5 个滤镜提取特征并生成 5 个特征映射，则特征映射的深度为`5`，如下所示：
+因此，过滤器负责通过执行卷积运算从实际图像中提取特征。 将有多个过滤器用于提取生成特征映射的图像的不同特征。 特征映射的深度是我们使用的过滤器的数量。 如果我们使用 5 个过滤器提取特征并生成 5 个特征映射，则特征映射的深度为`5`，如下所示：
 
 ![](img/00233.gif)
 
-当我们有许多过滤器时，我们的网络将通过提取许多特征来更好地理解图像。 在构建 CNN 时，我们不必为此过滤矩阵指定值。 在训练过程中将学习此滤波器的最佳值。 但是，我们必须指定过滤器的数量和要使用的过滤器的大小。
+当我们有许多过滤器时，我们的网络将通过提取许多特征来更好地理解图像。 在构建 CNN 时，我们不必为此过滤矩阵指定值。 在训练过程中将学习此过滤器的最佳值。 但是，我们必须指定过滤器的数量和要使用的过滤器的大小。
 
-我们可以使用滤波器在输入矩阵上滑动一个像素，然后执行卷积运算。 我们不仅可以滑动一个像素。 我们还可以在输入矩阵上滑动任意数量的像素。 我们在输入矩阵中滑过输入矩阵的像素数称为步幅。
+我们可以使用过滤器在输入矩阵上滑动一个像素，然后执行卷积运算。 我们不仅可以滑动一个像素。 我们还可以在输入矩阵上滑动任意数量的像素。 我们在输入矩阵中滑过输入矩阵的像素数称为步幅。
 
-但是，当滑动窗口（滤波器矩阵）到达图像边界时会发生什么？ 在这种情况下，我们用零填充输入矩阵，以便可以在图像边缘应用滤镜。 图像上带有零的填充称为相同填充，或宽卷积或零填充，如下所示：
+但是，当滑动窗口（过滤器矩阵）到达图像边界时会发生什么？ 在这种情况下，我们用零填充输入矩阵，以便可以在图像边缘应用过滤器。 图像上带有零的填充称为相同填充，或宽卷积或零填充，如下所示：
 
 ![](img/00234.gif)
 
@@ -795,15 +795,15 @@ CNN 通常包含三个主要层：
 
 # 池化层
 
-在卷积层之后，我们有了池化层。 池化层用于减少特征映射的维数，并且仅保留必要的细节，因此可以减少计算量。 例如，要确定图像中是否有一只狗，我们不想了解狗在图像中的哪个位置，我们只需要狗的特征。 因此，池化层通过仅保留重要特征来减小空间大小。 有多种类型的池化操作。 最大池化是最常用的池化操作之一，我们仅从窗口内的特征图中获取最大值。
+在卷积层之后，我们有了池化层。 池化层用于减少特征映射的维数，并且仅保留必要的细节，因此可以减少计算量。 例如，要确定图像中是否有一只狗，我们不想了解狗在图像中的哪个位置，我们只需要狗的特征。 因此，池化层通过仅保留重要特征来减小空间大小。 有多种类型的池化操作。 最大池化是最常用的池化操作之一，我们仅从窗口内的特征映射中获取最大值。
 
 带有`2 x 2`过滤器且步幅为 2 的最大池如下所示：
 
 ![](img/00236.gif)
 
-在平均池中，我们只取窗口内特征图中元素的平均值，而在汇总池中，我们取窗口中特征图中元素的总和。
+在平均池中，我们只取窗口内特征映射中元素的平均值，而在汇总池中，我们取窗口中特征映射中元素的总和。
 
-合并操作不会更改特征图的深度，只会影响高度和宽度。
+合并操作不会更改特征映射的深度，只会影响高度和宽度。
 
 # 全连接层
 
@@ -931,9 +931,9 @@ x_shaped = tf.reshape(x, [-1, 28, 28, 1])
 y = tf.placeholder(tf.float32, [None, 10])
 ```
 
-现在，我们需要定义一个称为`conv2d`的函数，该函数实际上执行卷积运算，即输入矩阵（`x`）与滤波器（`w`）的元素级相乘，步长为`1`。 和`SAME`填充。
+现在，我们需要定义一个称为`conv2d`的函数，该函数实际上执行卷积运算，即输入矩阵（`x`）与过滤器（`w`）的元素级相乘，步长为`1`。 和`SAME`填充。
 
-我们设置`strides = [1, 1, 1, 1]`。 步幅的第一个和最后一个值设置为`1`，这意味着我们不想在训练样本和不同通道之间移动。 步幅的第二个和第三个值也设置为`1`，这意味着我们将滤镜在高度和宽度方向上移动`1`像素：
+我们设置`strides = [1, 1, 1, 1]`。 步幅的第一个和最后一个值设置为`1`，这意味着我们不想在训练样本和不同通道之间移动。 步幅的第二个和第三个值也设置为`1`，这意味着我们将过滤器在高度和宽度方向上移动`1`像素：
 
 ```py
 def conv2d(x, w):
@@ -951,7 +951,7 @@ def maxpool2d(x):
 
 因此，权重矩阵将初始化为`[filter_shape[0],filter_shape[1], number_of_input_channel, filter_size]`。
 
-我们将使用`5 x 5`滤镜，并将滤镜大小设置为`32`。 由于我们使用灰度图像，因此我们的输入通道号将为`1`。 因此，我们的权重矩阵将为`[5,5,1,32]`：
+我们将使用`5 x 5`过滤器，并将过滤器大小设置为`32`。 由于我们使用灰度图像，因此我们的输入通道号将为`1`。 因此，我们的权重矩阵将为`[5,5,1,32]`：
 
 ```py
 w_c1 = tf.Variable(tf.random_normal([5,5,1,32]))

new/handson-rl-py/12.md

@@ -155,9 +155,9 @@ class EnvWrapper:
 
 现在，我们构建决斗 DQN； 我们先构建三个卷积层，然后是两个全连接层，最后一个全连接层将被分为两个单独的层，用于值流和优势流。 我们将使用将值流和优势流结合在一起的聚合层来计算 q 值。 这些层的大小如下：
 
-*   **第 1 层**：32 个`8x8`滤镜，步幅为 4 + RELU
-*   **第 2 层**：64 个`4x4`滤镜，步幅为 2 + RELU
-*   **第 3 层**：64 个`3x3`滤镜，步幅为 1 + RELU
+*   **第 1 层**：32 个`8x8`过滤器，步幅为 4 + RELU
+*   **第 2 层**：64 个`4x4`过滤器，步幅为 2 + RELU
+*   **第 3 层**：64 个`3x3`过滤器，步幅为 1 + RELU
 *   **第 4a 层**：512 个单元的全连接层 + RELU
 *   **第 4b 层**：512 个单元的全连接层 + RELU
 *   **第 5a 层**：1 个 FC + RELU（状态值）

new/intel-proj-py/01.md

@@ -54,7 +54,7 @@
 
 图 1.4：人工神经网络
 
-输入`x ∈ R^N`穿过神经单元的连续层，这些层以分层方式排列。 特定层中的每个神经元都接收来自先前层的神经元的输入，这些输入被它们之间的连接权重所衰减或放大。 权重`w[ij]^(l)`对应于`l`层第`i`个神经元与`l + 1`层第`j`个神经元。 同样，每个神经元单元`i`在特定层`1`中都有一个偏见`b[i]^(l)`。 神经网络为输入向量`x ∈ R^N`预测输出`y_hat`。 如果数据的实际标签是`y`，其中`y`取连续值，则神经元网络将预测误差最小化`(y - y_hat)^2`来学习权重和偏差。 当然，对于所有标记的数据点，必须将误差最小化：`(xi, yi), i ∈ 1, 2, ..., m`。
+输入`x ∈ R^N`穿过神经单元的连续层，这些层以分层方式排列。 特定层中的每个神经元都接收来自先前层的神经元的输入，这些输入被它们之间的连接权重所衰减或放大。 权重`w[ij]^(l)`对应于`l`层第`i`个神经元与`l + 1`层第`j`个神经元。 同样，每个神经元单元`i`在特定层`1`中都有一个偏置`b[i]^(l)`。 神经网络为输入向量`x ∈ R^N`预测输出`y_hat`。 如果数据的实际标签是`y`，其中`y`取连续值，则神经元网络将预测误差最小化`(y - y_hat)^2`来学习权重和偏差。 当然，对于所有标记的数据点，必须将误差最小化：`(xi, yi), i ∈ 1, 2, ..., m`。
 
 如果我们用一个公共向量`W`表示一组权重和偏差，并且预测中的总误差由`C`表示，则在训练过程中，估计的`W`可以表示为：
 
@@ -228,7 +228,7 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 ![](img/d5f34043-fdeb-48ca-bf1b-d1a1915ba77d.png)
 
-因此，一旦我们确定了成本函数相对于神经元总输入的梯度为`∂C/∂s`，则任何权重的梯度`w`贡献了总输入量`s`，可以通过简单地乘以与重量相关的激活`z`来获得。
+因此，一旦我们确定了成本函数相对于神经元总输入的梯度为`∂C/∂s`，则任何权重的梯度`w`贡献了总输入量`s`，可以通过简单地乘以与权重相关的激活`z`来获得。
 
 现在，成本函数相对于总输入的梯度`s[2]^(2)`可以再次通过链式法则得出，如下所示：
 
@@ -248,7 +248,7 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 # 卷积神经网络
 
-**卷积神经网络**（**CNN**）利用卷积运算从具有关联拓扑的数据中提取有用信息。 这最适合图像和音频数据。 输入图像在通过卷积层时会生成多个输出图像，称为**输出特征映射**。 输出特征图将检测特征。 初始卷积层中的输出特征映射可以学习检测基本特征，例如边缘和颜色成分变化。
+**卷积神经网络**（**CNN**）利用卷积运算从具有关联拓扑的数据中提取有用信息。 这最适合图像和音频数据。 输入图像在通过卷积层时会生成多个输出图像，称为**输出特征映射**。 输出特征映射将检测特征。 初始卷积层中的输出特征映射可以学习检测基本特征，例如边缘和颜色成分变化。
 
 第二卷积层可以检测到稍微复杂的特征，例如正方形，圆形和其他几何结构。 随着神经网络的发展，卷积层学会了检测越来越复杂的特征。 例如，如果我们有一个 CNN 可以对图像是猫还是狗进行分类，则神经网络底部的卷积层可能会学会检测诸如头部，腿部等特征。
 
@@ -258,17 +258,17 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 图 1.11：CNN 架构
 
-当我们经过具有多个卷积激活池操作的网络时，图像的空间分辨率会降低，而输出特征映射的数量在每一层中都会增加。 卷积层中的每个输出特征映射都与过滤器内核相关联，该过滤器内核的权重是通过 CNN 训练过程学习的。
+当我们经过具有多个卷积激活池操作的网络时，图像的空间分辨率会降低，而输出特征映射的数量在每一层中都会增加。 卷积层中的每个输出特征映射都与过滤器核相关联，该过滤器核的权重是通过 CNN 训练过程学习的。
 
-在卷积操作中，将滤镜内核的翻转版本放置在整个图像或特征映射上，并为滤镜上每个位置计算滤镜内核输入值与相应图像像素或特征映射值的点积。 输入图像或特征映射。 已经习惯了普通图像处理的读者可能已经使用了不同的滤镜内核，例如高斯滤镜，Sobel 边缘检测滤镜等，其中许多滤镜的权重已预定义。 卷积神经网络的优点是通过训练过程确定不同的滤波器权重。 这意味着，针对卷积神经网络正在处理的问题，可以更好地定制过滤器。
+在卷积操作中，将过滤器核的翻转版本放置在整个图像或特征映射上，并为过滤器上每个位置计算过滤器核输入值与相应图像像素或特征映射值的点积。 输入图像或特征映射。 已经习惯了普通图像处理的读者可能已经使用了不同的过滤器核，例如高斯过滤器，Sobel 边缘检测过滤器等，其中许多过滤器的权重已预定义。 卷积神经网络的优点是通过训练过程确定不同的过滤器权重。 这意味着，针对卷积神经网络正在处理的问题，可以更好地定制过滤器。
 
-当卷积运算涉及在输入的每个位置上覆盖滤波器内核时，该卷积被称为跨度为 1。 如果我们选择在覆盖过滤器内核时跳过一个位置，那么卷积将以两个步幅执行。 通常，如果将`n`位置跳过而将滤波器内核覆盖在输入上，则表示卷积以`n + 1`的步幅执行。 大于 1 的步幅会减小卷积输出的空间大小。
+当卷积运算涉及在输入的每个位置上覆盖过滤器核时，该卷积被称为跨度为 1。 如果我们选择在覆盖过滤器核时跳过一个位置，那么卷积将以两个步幅执行。 通常，如果将`n`位置跳过而将过滤器核覆盖在输入上，则表示卷积以`n + 1`的步幅执行。 大于 1 的步幅会减小卷积输出的空间大小。
 
 通常，卷积层之后是池化层，池化层基本上总结了由池化的接收场确定的邻域中的输出特征映射激活。 例如，一个`2 x 2`的接收场将收集四个相邻的输出特征映射激活的本地信息。 对于最大池操作，将选择四个激活的最大值作为输出，而对于平均池化，将选择四个激活的平均值。 合并降低了特征映射的空间分辨率。 例如，对于具有`2 x 2`接收场的`224 x 224`大小的特征映射池化操作，特征映射的空间大小将减小为`112 x 112`。
 
-要注意的一件事是，卷积运算减少了每层要学习的权重数。 例如，如果我们有一个空间大小为`224 x 224`的输入图像，而下一层的期望输出为大小为` 224 x 224 `的大小，那么对于具有完整连接的传统神经网络来说，要学习的权重数是`224 x 224 x 224 x 224`。对于具有相同输入和输出大小的卷积层，我们需要学习的只是滤波器内核的权重。 因此，如果我们使用`3 x 3`过滤器内核，我们只需要学习 9 个权重即可，而不是`224 x 224 x 224 x 224`权重。 这种简化是有效的，因为局部空间邻域中的图像和音频之类的结构之间具有高度相关性。
+要注意的一件事是，卷积运算减少了每层要学习的权重数。 例如，如果我们有一个空间大小为`224 x 224`的输入图像，而下一层的期望输出为大小为` 224 x 224 `的大小，那么对于具有完整连接的传统神经网络来说，要学习的权重数是`224 x 224 x 224 x 224`。对于具有相同输入和输出大小的卷积层，我们需要学习的只是过滤器核的权重。 因此，如果我们使用`3 x 3`过滤器核，我们只需要学习 9 个权重即可，而不是`224 x 224 x 224 x 224`权重。 这种简化是有效的，因为局部空间邻域中的图像和音频之类的结构之间具有高度相关性。
 
-输入图像经过多层卷积和池化操作。 随着网络的发展，特征映射的数量增加，而图像的空间分辨率降低。 在卷积池层的末端，特征图的输出被馈送到全连接层，然后是输出层。
+输入图像经过多层卷积和池化操作。 随着网络的发展，特征映射的数量增加，而图像的空间分辨率降低。 在卷积池层的末端，特征映射的输出被馈送到全连接层，然后是输出层。
 
 输出单元取决于手头的任务。 如果执行回归，则输出激活单元是线性的，而如果是二分类问题，则输出单元是 Sigmoid 的。 对于多类别分类，输出层是 softmax 单元。
 
@@ -310,7 +310,7 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 ![](img/a5818e53-89c6-4a7a-8f79-f71fdfc2535d.png)
 
-对于 RNN，函数`f[2]`通常为 Sigmoid 或 tanh，其饱受饱和度的困扰，即具有超出指定输入值范围的低梯度。 现在，由于`f[2]`的导数彼此相乘，因此，如果激活函数的输入在饱和区工作，则`∂h[t]^(i)/∂h[k]^(i)`的斜率可以变为零，即使相对`tk`的中等值。 即使`f[2]`函数在饱和区中不起作用，但 Sigmoids 的`f[2]`函数的梯度始终比`1`小，因此很难学习序列中单词之间的远距离依存关系。 同样，可能会由于`u[ii]^(t - k)`因子而出现爆炸性梯度问题。 假设步`t`和`k`之间的距离约为`10`，而重量`u[ii]`，大约两点。 在这种情况下，梯度将被放大两倍，即`2 ^ 10 = 1024`，从而导致爆炸梯度问题。
+对于 RNN，函数`f[2]`通常为 Sigmoid 或 tanh，其饱受饱和度的困扰，即具有超出指定输入值范围的低梯度。 现在，由于`f[2]`的导数彼此相乘，因此，如果激活函数的输入在饱和区工作，则`∂h[t]^(i)/∂h[k]^(i)`的斜率可以变为零，即使相对`tk`的中等值。 即使`f[2]`函数在饱和区中不起作用，但 Sigmoids 的`f[2]`函数的梯度始终比`1`小，因此很难学习序列中单词之间的远距离依存关系。 同样，可能会由于`u[ii]^(t - k)`因子而出现爆炸性梯度问题。 假设步`t`和`k`之间的距离约为`10`，而权重`u[ii]`，大约两点。 在这种情况下，梯度将被放大两倍，即`2 ^ 10 = 1024`，从而导致爆炸梯度问题。
 
 # 长短期记忆（LSTM）单元
 
@@ -366,7 +366,7 @@ ReLU 的限制条件之一是其输入负值的零梯度。 这可能会减慢
 
 # 生成对抗网络
 
-**生成对抗网络**，通常称为 **GAN** ，是通过生成器`G`学习特定概率分布的生成模型。 生成器`G`与判别器`D`进行零和极小极大游戏，并且两者都会随着时间的流逝而逐渐达到纳什均衡。 生成器尝试生成类似于给定概率分布`P(x)`生成的样本，而判别器`D`尝试区分生成器生成的那些假数据样本。`G`来自原始分布的数据样本。 生成器`G`尝试通过转换样本`z`来生成与`P(x)`相似的样本。 噪声分布`P(z)`。 鉴别符`D`在假冒时学会将生成器`G`生成的样本标记为`G(z)`；`x`原始时属于`P(x)`。 在 minimax 游戏的平衡状态下，生成器将学习生成与原始分布`P(x)`相似的样本，因此以下是正确的：
+**生成对抗网络**，通常称为 **GAN** ，是通过生成器`G`学习特定概率分布的生成模型。 生成器`G`与判别器`D`进行零和极小极大游戏，并且两者都会随着时间的流逝而逐渐达到纳什均衡。 生成器尝试生成类似于给定概率分布`P(x)`生成的样本，而判别器`D`尝试区分生成器生成的那些假数据样本。`G`来自原始分布的数据样本。 生成器`G`尝试通过转换样本`z`来生成与`P(x)`相似的样本。 噪声分布`P(z)`。 判别器`D`在假冒时学会将生成器`G`生成的样本标记为`G(z)`；`x`原始时属于`P(x)`。 在 minimax 游戏的平衡状态下，生成器将学习生成与原始分布`P(x)`相似的样本，因此以下是正确的：
 
 ![](img/0bb90a7f-37ac-4079-8896-baa81ed7b81d.png)
 
@@ -484,7 +484,7 @@ Figure 1.14: GAN architecture
 
 当我们在 CNN 中处理图像时，初始层会学会检测非常通用的特征，例如卷曲，边缘，颜色组成等。 随着网络的深入发展，更深层次的卷积层将学会检测与特定种类的数据集相关的更复杂特征。 我们可以使用预训练的网络，并选择不训练前几层，因为它们会学习非常通用的函数。 相反，我们可以只专注于训练最后几层的参数，因为它们将学习针对当前问题的复杂函数。 这样可以确保我们需要训练的参数较少，并且可以明智地使用数据，仅训练所需的复杂参数，而不训练通用特征。
 
-迁移学习已广泛应用于通过 CNN 进行图像处理的过程，其中滤镜充当特征检测器。 用于迁移学习的最常见的预训练 CNN 是`AlexNet`，`VGG16`，`VGG19`，`Inception V3`和`ResNet`等。 下图说明了用于传输学习的预训练`VGG16`网络：
+迁移学习已广泛应用于通过 CNN 进行图像处理的过程，其中过滤器充当特征检测器。 用于迁移学习的最常见的预训练 CNN 是`AlexNet`，`VGG16`，`VGG19`，`Inception V3`和`ResNet`等。 下图说明了用于迁移学习的预训练`VGG16`网络：
 
 ![](img/04ca3848-86ab-45e6-81f2-1c1d1011ef88.png)
 

new/intel-proj-py/02.md

 # 迁移学习
 
-迁移学习是将特定领域中一项任务中获得的知识转移到相似领域中相关任务中的过程。 在深度学习范例中，迁移学习通常是指将预训练模型的重用作为另一个问题的起点。 计算机视觉和自然语言处理中的问题需要大量数据和计算资源，才能训练出有意义的深度学习模型。 迁移学习在视觉和文本领域已变得非常重要，因为它减轻了对大量训练数据和训练时间的需求。 在本章中，我们将使用迁移学习来解决医疗保健问题。
+迁移学习是将特定领域中一项任务中获得的知识迁移到相似领域中相关任务中的过程。 在深度学习范例中，迁移学习通常是指将预训练模型的重用作为另一个问题的起点。 计算机视觉和自然语言处理中的问题需要大量数据和计算资源，才能训练出有意义的深度学习模型。 迁移学习在视觉和文本领域已变得非常重要，因为它减轻了对大量训练数据和训练时间的需求。 在本章中，我们将使用迁移学习来解决医疗保健问题。
 
 我们将在本章中涉及的与迁移学习有关的一些关键主题如下：
 
@@ -286,7 +286,7 @@ InceptionV3 论文链接如下：
 
 [《重新思考计算机视觉的起始架构》](https://arxiv.org/abs/1512.00567)
 
-简而言之，`VGG16`是一个 16 层的 CNN，使用`3 x 3`滤波器和`2 x 2`接收场进行卷积。 整个网络使用的激活函数都是 ReLU。 由 Simonyan 和 Zisserman 开发的 VGG 架构是 2014 年 ILSVRC 竞赛的亚军。 `VGG16`网络由于其简单性而广受欢迎，它是从图像中提取特征的最受欢迎的网络。
+简而言之，`VGG16`是一个 16 层的 CNN，使用`3 x 3`过滤器和`2 x 2`接收场进行卷积。 整个网络使用的激活函数都是 ReLU。 由 Simonyan 和 Zisserman 开发的 VGG 架构是 2014 年 ILSVRC 竞赛的亚军。 `VGG16`网络由于其简单性而广受欢迎，它是从图像中提取特征的最受欢迎的网络。
 
 `ResNet50`是一种深层的 CNN，它实现了残余块的概念，与`VGG16`网络的概念完全不同。 经过一系列的卷积激活池操作之后，该块的输入再次被反馈到输出。 ResNet 架构是由 Kaiming He 等人开发的，尽管具有 152 层，但它不如 VGG 网络复杂。 该架构通过实现 3.57% 的前五位错误率赢得了 2015 年 ILSVRC 竞赛，这比该竞赛数据集上的人类水平表现要好。 通过检查目标是否在概率最高的五类预测中来计算前五个错误率。 原则上，ResNet 网络尝试学习残差映射，而不是直接从输出映射到输入，如下面的残差框图所示：
 
@@ -294,7 +294,7 @@ InceptionV3 论文链接如下：
 
 图 2.8：ResNet 模型的残差块
 
-**InceptionV3** 是 Google 提供的最新的 CNN。 InceptionV3 架构没有在每一层使用固定大小的卷积滤波器，而是使用不同大小的滤波器来提取不同粒度级别的特征。 下图说明了 InceptionV3 层的卷积块：
+**InceptionV3** 是 Google 提供的最新的 CNN。 InceptionV3 架构没有在每一层使用固定大小的卷积过滤器，而是使用不同大小的过滤器来提取不同粒度级别的特征。 下图说明了 InceptionV3 层的卷积块：
 
 ![](img/afb2d8e3-f919-49c3-9ede-13e707b6d72e.png)
 

new/intel-proj-py/04.md

@@ -37,7 +37,7 @@
 
 ![](img/09ada4ef-4d12-45db-a6b8-19064db767e9.png)
 
-仅使前面的损失最小化是不够的。 我们必须确保在域`B`中创建的图像`x[B]`看起来逼真。例如，如果我们将域`A`中的衣服映射到域`B`中的鞋子，我们将确保`x[B]`类似于鞋子。 如果图像不够真实，则在域`B`侧的鉴别符`D[B]`将检测为`x[B]`为假。 鞋子，因此也要考虑与此有关的损失。 通常，在训练过程中，向判别器提供生成的域`B`图像`x[AB] = G[AB](X[A])`，我们选择在这里用`y[B]`表示，以便它学习从假图像中对真实图像进行分类。 您可能还记得，在 GAN 中，生成器和判别器相互进行*零和最小最大值游戏*，以便不断变得更好，直到达到平衡为止。 如果伪造的图像看起来不够逼真，则判别器将对其进行惩罚，这意味着生成器必须学习产生更好的图像`x[AB]`，如果输入图像`x[A]`。 考虑到所有这些因素，我们可以将我们希望最小化的生成器损失公式化为重建损失，以及判别器将`x[AB]`识别为假冒的损失。 第二种损失将试图使生成器在域`B`中生成逼真的图像。将域`A`中的图像`x[A]`映射到域`B`中的图像的生成器损失可以表示如下：
+仅使前面的损失最小化是不够的。 我们必须确保在域`B`中创建的图像`x[B]`看起来逼真。例如，如果我们将域`A`中的衣服映射到域`B`中的鞋子，我们将确保`x[B]`类似于鞋子。 如果图像不够真实，则在域`B`侧的判别器`D[B]`将检测为`x[B]`为假。 鞋子，因此也要考虑与此有关的损失。 通常，在训练过程中，向判别器提供生成的域`B`图像`x[AB] = G[AB](X[A])`，我们选择在这里用`y[B]`表示，以便它学习从假图像中对真实图像进行分类。 您可能还记得，在 GAN 中，生成器和判别器相互进行*零和最小最大值游戏*，以便不断变得更好，直到达到平衡为止。 如果伪造的图像看起来不够逼真，则判别器将对其进行惩罚，这意味着生成器必须学习产生更好的图像`x[AB]`，如果输入图像`x[A]`。 考虑到所有这些因素，我们可以将我们希望最小化的生成器损失公式化为重建损失，以及判别器将`x[AB]`识别为假冒的损失。 第二种损失将试图使生成器在域`B`中生成逼真的图像。将域`A`中的图像`x[A]`映射到域`B`中的图像的生成器损失可以表示如下：
 
 ![](img/f2cdd9c3-d4d4-4c89-a533-e5044ea37592.png)
 
@@ -47,7 +47,7 @@ L2 范数下的重建损失可以表示为：
 
 由于我们正在处理图像，因此可以假设`x[A]`是所有像素的扁平向量，以符合 L2 规范项。 如果我们假设`x[A]`是矩阵，则最好将`||·||_2^2`称为 **Frobenius 范数**。 但是，这些只是数学术语，实质上，我们只是将原始图像和重建图像之间的像素值差的平方和求和。
 
-让我们考虑一下生成器在使变换后的图像`x[AB]`追求时要尽量降低成本的做法。 鉴别者将尝试将图像标记为伪图像，因此生成器`G[AB]`应当在这种情况下产生`x[AB]`使其成为假图片的对数损失的方式尽可能小。 如果域`B`中的鉴别符`D[B]`将真实图像标记为`1`，将伪图像标记为`0`，则图像真实的概率由`D[B](.)`，则生成器应使`x[AB]`在判别器网络下极有可能出现，从而使`D[B](x[B]) = D[B](G[AB](x[A]))`接近`1`）。 就对数损失而言，生成器应使先前概率的负对数最小化，这基本上使我们得到`C[D(AB)]`，如下所示：
+让我们考虑一下生成器在使变换后的图像`x[AB]`追求时要尽量降低成本的做法。 判别器将尝试将图像标记为伪图像，因此生成器`G[AB]`应当在这种情况下产生`x[AB]`使其成为假图片的对数损失的方式尽可能小。 如果域`B`中的判别器`D[B]`将真实图像标记为`1`，将伪图像标记为`0`，则图像真实的概率由`D[B](.)`，则生成器应使`x[AB]`在判别器网络下极有可能出现，从而使`D[B](x[B]) = D[B](G[AB](x[A]))`接近`1`）。 就对数损失而言，生成器应使先前概率的负对数最小化，这基本上使我们得到`C[D(AB)]`，如下所示：
 
 ![](img/549bd16c-1bd7-4f76-b4c1-6179369f92c7.png)
 
@@ -63,11 +63,11 @@ L2 范数下的重建损失可以表示为：
 
 ![](img/bd4d5890-a506-4180-b680-4c842cca1286.png) ![](img/bcb0c1db-84a7-44ac-864c-4e7545fb6016.png)
 
-现在，让我们构建成本函数，这些判别器将尝试最小化以建立零和最小/最大游戏。 每个域中的鉴别符都会尝试将真实图像与伪图像区分开，因此鉴别符`G[B]`会尝试将成本降到最低`C_D[B]`，如下所示：
+现在，让我们构建成本函数，这些判别器将尝试最小化以建立零和最小/最大游戏。 每个域中的判别器都会尝试将真实图像与伪图像区分开，因此判别器`G[B]`会尝试将成本降到最低`C_D[B]`，如下所示：
 
 ![](img/c8b74f9b-c8cb-47d4-99e1-00c9b35eef05.png)
 
-同样，鉴别符`D[A]`会尝试将成本降到最低。`C_D[A]`如下所示：
+同样，判别器`D[A]`会尝试将成本降到最低。`C_D[A]`如下所示：
 
 ![](img/78578465-7cc8-40c5-9662-21aa263baa81.png)
 
@@ -89,7 +89,7 @@ L2 范数下的重建损失可以表示为：
 
 # 学习从草绘的轮廓生成自然手袋
 
-在本章中，我们将使用草绘的轮廓生成手袋，而无需使用 DiscoGAN 进行显式配对。 我们将草图图像表示为属于域`A`，而将自然手袋图像表示为属于域`B`。将有两种生成器：一种生成器，用于获取域`A`的图像并将其映射到在域`B`下看起来逼真的图像，以及另一个与此相反：将域`B`中的手袋图像映射到在域`A`下看起来很逼真的图像。鉴别者将尝试从每个域中真实图像的生成器中识别生成器生成的虚假图像。 生成器和判别器将相互进行 minimax 零和游戏。
+在本章中，我们将使用草绘的轮廓生成手袋，而无需使用 DiscoGAN 进行显式配对。 我们将草图图像表示为属于域`A`，而将自然手袋图像表示为属于域`B`。将有两种生成器：一种生成器，用于获取域`A`的图像并将其映射到在域`B`下看起来逼真的图像，以及另一个与此相反：将域`B`中的手袋图像映射到在域`A`下看起来很逼真的图像。判别器将尝试从每个域中真实图像的生成器中识别生成器生成的虚假图像。 生成器和判别器将相互进行 minimax 零和游戏。
 
 要训​​练该网络，我们将需要两套图像，手袋的草图或轮廓以及手袋的自然图像。 [可以从以下链接下载图像](https://people.eecs.berkeley.edu/~tinghuiz/projects/pix2pix/datasets/edges2handbags.tar.gz)。
 
@@ -189,7 +189,7 @@ the number of input images processed : 30000
 
 # DiscoGAN 的生成器
 
-DiscoGAN 的生成器是前馈卷积神经网络，其中输入和输出是图像。 在网络的第一部分中，图像在空间维度上按比例缩小，而输出特征图的数量随层的进展而增加。 在网络的第二部分中，图像沿空间维度按比例放大，而输出特征映射的数量则逐层减少。 在最终输出层中，将生成具有与输入相同的空间大小的图像。 如果生成器将图像`x[A]`转换为`x[AB]`从域`A`到域`B`表示为`G[AB]`，则我们有`x[AB] = G[AB](x[A])`。
+DiscoGAN 的生成器是前馈卷积神经网络，其中输入和输出是图像。 在网络的第一部分中，图像在空间维度上按比例缩小，而输出特征映射的数量随层的进展而增加。 在网络的第二部分中，图像沿空间维度按比例放大，而输出特征映射的数量则逐层减少。 在最终输出层中，将生成具有与输入相同的空间大小的图像。 如果生成器将图像`x[A]`转换为`x[AB]`从域`A`到域`B`表示为`G[AB]`，则我们有`x[AB] = G[AB](x[A])`。
 
 此处显示的是`build_generator`函数，我们可以使用它来构建 DiscoGAN 网络的生成器：
 
@@ -288,7 +288,7 @@ def build_generator(self,image,reuse=False,name='generator'):
 
 例如，我们可能使用生成器函数创建了两个生成器网络，因此在第一次创建这些网络时不会使用`reuse`选项。 如果再次引用该生成器函数，则使用`reuse`选项。 卷积（下采样）和解卷积（上采样）期间的激活函数是 LReLU，然后进行批量归一化，以实现稳定和快速的收敛。
 
-网络不同层中的输出特征图的数量可以是`self.gf` 或其倍数。 对于我们的 DiscoGAN 网络，我们选择了`self.gf`作为`64`。
+网络不同层中的输出特征映射的数量可以是`self.gf` 或其倍数。 对于我们的 DiscoGAN 网络，我们选择了`self.gf`作为`64`。
 
 生成器中要注意的一件事是输出层的`tanh`激活函数。 这样可以确保生成器生成的图像的像素值在`[-1, +1]`的范围内。 这对于输入图像具有`[-1, +1]`范围内的像素强度非常重要，这可以通过对像素强度进行简单的逐元素变换来实现，如下所示：
 
@@ -300,7 +300,7 @@ def build_generator(self,image,reuse=False,name='generator'):
 
 # DiscoGAN 的判别器
 
-DiscoGAN 的判别器将学会在特定域中将真实图像与假图像区分开。 我们将有两个鉴别符：一个用于域`A`，一个用于域`B`。这些判别器也是可以执行二分类的卷积网络。 与传统的基于分类的卷积网络不同，判别器没有任何全连接层。 使用步长为 2 的卷积对输入图像进行下采样，直到最终层（输出为`1 x 1`）为止。同样，我们使用 LReLU 作为激活函数并使用批量归一化以实现稳定和快速的收敛。 以下代码显示了 TensorFlow 中判别器构建函数的实现：
+DiscoGAN 的判别器将学会在特定域中将真实图像与假图像区分开。 我们将有两个判别器：一个用于域`A`，一个用于域`B`。这些判别器也是可以执行二分类的卷积网络。 与传统的基于分类的卷积网络不同，判别器没有任何全连接层。 使用步长为 2 的卷积对输入图像进行下采样，直到最终层（输出为`1 x 1`）为止。同样，我们使用 LReLU 作为激活函数并使用批量归一化以实现稳定和快速的收敛。 以下代码显示了 TensorFlow 中判别器构建函数的实现：
 
 ```py
 def build_discriminator(self,image,reuse=False,name='discriminator'):
@@ -472,10 +472,10 @@ def build_network(self):
 
 | **不同损失的变量** | **说明** |
 | --- | --- |
-| `self.D_B_loss_real` | 在对域`B`中的真实图像进行分类时，鉴别符`D[B]`的二进制交叉熵损失。（相对于判别器`D[B]`的参数，该损失应最小化） |
-| `self.D_B_loss_fake` | 在对域`B`中的伪造图像进行分类时，鉴别符`D[B]`的二进制交叉熵损失。（相对于判别器`D[B]`的参数，该损失应最小化） |
-| `self.D_A_loss_real` | 在对域`A`中的真实图像进行分类时，鉴别符`D[A]`的二进制交叉熵损失。（相对于判别器`D[A]`的参数，该损失应最小化） |
-| `self.D_A_loss_fake` | 在对域`A`中的伪造图像进行分类时，鉴别符`D[A]`的二进制交叉熵损失。（相对于判别器`D[A]`的参数，该损失应最小化） |
+| `self.D_B_loss_real` | 在对域`B`中的真实图像进行分类时，判别器`D[B]`的二进制交叉熵损失。（相对于判别器`D[B]`的参数，该损失应最小化） |
+| `self.D_B_loss_fake` | 在对域`B`中的伪造图像进行分类时，判别器`D[B]`的二进制交叉熵损失。（相对于判别器`D[B]`的参数，该损失应最小化） |
+| `self.D_A_loss_real` | 在对域`A`中的真实图像进行分类时，判别器`D[A]`的二进制交叉熵损失。（相对于判别器`D[A]`的参数，该损失应最小化） |
+| `self.D_A_loss_fake` | 在对域`A`中的伪造图像进行分类时，判别器`D[A]`的二进制交叉熵损失。（相对于判别器`D[A]`的参数，该损失应最小化） |
 | `self.loss_GABA` | 通过两个生成器`G[AB]`和`G[BA]`将域`A`中的图像映射到`B`，然后再映射回`A`的重建损失，加上假图片`G[AB](x[A])`的二进制交叉熵，由域`B`中的判别器标记为真实图像。（相对于生成器`G[AB]`和`G[BA]`的参数，该损失应最小化） |
 | `self.loss_GBAB` | 通过两个生成器`G[BA]`和`G[AB]`将域`B`中的图像映射到`A`，然后再映射回`B`的重建损失，加上伪图片`G[BA](x[B])`的二元交叉熵，由域`A`中的判别器标记为真实图像。（相对于生成器`G[AB]`和`G[BA]`的参数，该损失应最小化） |
 

new/intel-proj-py/06.md

@@ -361,7 +361,7 @@ RBM 的参数是可见层单元`i`与隐藏层单元之间的广义权重连接`
 
 提出建议时，可以使用受限玻尔兹曼机进行协同过滤。 我们将使用这些 RBM 向用户推荐电影。 使用不同用户为不同电影提供的分级来训练他们。 用户不会观看或评价所有电影，因此可以使用此训练模型来向用户推荐未看过的电影。
 
-我们应该首先遇到的一个问题是如何处理 RBM 中的评分，因为评分本质上是有序的，而 RBM 则针对二进制数据。 可以将评分视为二进制数据，表示评分的单元数量等于每个评分的唯一值的数量。 例如：在评级系统中，评分从 1 到 5 不等，并且将有 5 个二进制单元，其中与评分相对应的 1 个单元设置为 1，其余单元设置为 0。 RBM 可见的单元将是为用户提供给不同电影的评分。 如所讨论的，每个评分将以二进制表示，并且对于每个可见单元，来自所有二进制可见单元的权重连接都与电影评分相对应。 由于每个用户将为一组不同的电影评分，因此每个用户的输入将不同。 但是，从电影分级单元到隐藏单元的重量连接对于所有用户而言都是通用的。
+我们应该首先遇到的一个问题是如何处理 RBM 中的评分，因为评分本质上是有序的，而 RBM 则针对二进制数据。 可以将评分视为二进制数据，表示评分的单元数量等于每个评分的唯一值的数量。 例如：在评级系统中，评分从 1 到 5 不等，并且将有 5 个二进制单元，其中与评分相对应的 1 个单元设置为 1，其余单元设置为 0。 RBM 可见的单元将是为用户提供给不同电影的评分。 如所讨论的，每个评分将以二进制表示，并且对于每个可见单元，来自所有二进制可见单元的权重连接都与电影评分相对应。 由于每个用户将为一组不同的电影评分，因此每个用户的输入将不同。 但是，从电影分级单元到隐藏单元的权重连接对于所有用户而言都是通用的。
 
 下图所示（“图 6.8a”和“图 6.8b”）是用户`A`和用户`B`的 RBM 视图。 **用户**`A`和用户`B`为一组不同的电影评分。 但是，正如我们所看到的，每个用户到每部电影中隐藏单元的权重连接都相同。 关于用户`A`的 RBM 评分如下：
 

new/intel-proj-py/10.md

@@ -394,7 +394,7 @@ SVHN 是一个现实世界的数据集，由于它在对象识别算法中的使
 
 回顾一下，在 GAN 中，我们有一个生成器（`G`）和一个判别器（`D`），它们针对损失函数彼此玩零和极小极大游戏。 随着时间的流逝，生成器和判别器的工作都会越来越好，直到我们到达一个固定点为止，两者都无法进一步改善。 该固定点是相对于损失函数的鞍点。 对于我们的应用，生成器`G`会将给定分布`P(z)`的噪声`z`转换​​为门牌号图像`x`，以使`x = G(z)`。
 
-生成的图像通过判别器`D`传递，判别器`D`尝试检测此生成的图像`x`为伪造，并从 SVHN 数据集中检测真实的门牌号码图像为真实。 同时，生成器将尝试创建图像`x = G(z)`，以使判别器发现图像是真实的。 如果我们将真实图像标记为`1`，而将生成器生成的伪图像标记为`0`，则判别器将尝试在给定两个类别的分类器网络中最小化二进制交叉熵损失。 鉴别符`D`所导致的损失可以写成如下：
+生成的图像通过判别器`D`传递，判别器`D`尝试检测此生成的图像`x`为伪造，并从 SVHN 数据集中检测真实的门牌号码图像为真实。 同时，生成器将尝试创建图像`x = G(z)`，以使判别器发现图像是真实的。 如果我们将真实图像标记为`1`，而将生成器生成的伪图像标记为`0`，则判别器将尝试在给定两个类别的分类器网络中最小化二进制交叉熵损失。 判别器`D`所导致的损失可以写成如下：
 
 ![](img/ae36b54b-0a7c-4c94-8c4b-4e5209859d44.png)
 
@@ -422,7 +422,7 @@ SVHN 是一个现实世界的数据集，由于它在对象识别算法中的使
 
 ![](img/c113c328-2c94-47ed-80d2-1f63f3820b12.png)
 
-替代地，生成器将尝试最大化相同的效用。 由于鉴别符`D`没有生成器的任何参数，因此工具的第二项不会影响生成器的优化。 可以这样表示：
+替代地，生成器将尝试最大化相同的效用。 由于判别器`D`没有生成器的任何参数，因此工具的第二项不会影响生成器的优化。 可以这样表示：
 
 ![](img/ee7b47ef-5a40-4a4c-8dcc-57425720a85a.png)
 
@@ -434,9 +434,9 @@ SVHN 是一个现实世界的数据集，由于它在对象识别算法中的使
 
 # 生成器网络
 
-生成器网络将吸收随机噪声，并尝试输出类似于 SVHN 图像的图像作为输出。 随机噪声是`100`维输入向量。 每个维度都是遵循标准正态分布的随机变量，平均值为`0`，标准偏差为`1`。
+生成器网络将吸收随机噪声，并尝试输出类似于 SVHN 图像的图像作为输出。 随机噪声是`100`维输入向量。 每个维度都是遵循标准正态分布的随机变量，平均值为`0`，标准差为`1`。
 
-最初的致密层具有`8192`单元，将其重塑为形状为`4 x 4 x 512`的三维张量。 使用`512`滤镜可以将张量视为`4 x 4`图像。 为了增加张量的空间大小，我们进行了一系列转置 2D 卷积，步幅为`2`，内核滤波器大小为`5 x5`。步幅大小决定了转置卷积的缩放比例。 例如，跨度为 2 的跨度将输入图像的每个空间大小加倍，然后进行转置卷积，通常会进行批归一化，以实现更好的收敛性。 除了激活层，网络使用`LeakyReLU`作为激活函数。 网络的最终输出是大小为`32 x 32 x 3`的图像。
+最初的密集层具有`8192`单元，将其重塑为形状为`4 x 4 x 512`的三维张量。 使用`512`过滤器可以将张量视为`4 x 4`图像。 为了增加张量的空间大小，我们进行了一系列转置 2D 卷积，步幅为`2`，核过滤器大小为`5 x5`。步幅大小决定了转置卷积的缩放比例。 例如，跨度为 2 的跨度将输入图像的每个空间大小加倍，然后进行转置卷积，通常会进行批归一化，以实现更好的收敛性。 除了激活层，网络使用`LeakyReLU`作为激活函数。 网络的最终输出是大小为`32 x 32 x 3`的图像。
 
 在最后一层中使用`tanh`激活，以便对`[-1,1]`范围内的图像像素值进行标准化。
 
@@ -594,7 +594,7 @@ def make_trainable(model, trainable):
 
 # 噪音分布
 
-输入到 GAN 的噪声需要遵循特定的概率分布。 通常使用均匀分布`U[-1,1]`或标准正态分布，即均值`0`和标准偏差`1`的正态分布对噪声向量的每个维度进行采样。 从经验上可以看出，从标准正态分布中采样噪声似乎比从均匀分布中采样噪声更好。 在此实现中，我们将使用标准正态分布来采样随机噪声。
+输入到 GAN 的噪声需要遵循特定的概率分布。 通常使用均匀分布`U[-1,1]`或标准正态分布，即均值`0`和标准差`1`的正态分布对噪声向量的每个维度进行采样。 从经验上可以看出，从标准正态分布中采样噪声似乎比从均匀分布中采样噪声更好。 在此实现中，我们将使用标准正态分布来采样随机噪声。
 
 # 数据预处理
 

new/master-pred-anal-sklearn-tf/1.md

@@ -33,7 +33,7 @@
 
 许多集成学习方法都使用一种称为引导抽样的统计技术。 数据集的引导样本是另一个数据集，它是通过对原始数据集中的观测值**带放回随机抽样**而获得的。
 
-例如，该技术在统计中大量使用。 它用于估计样本统计量的标准误差，例如平均值或标准偏差。
+例如，该技术在统计中大量使用。 它用于估计样本统计量的标准误差，例如平均值或标准差。
 
 让我们通过看下面的图来更多地了解这项技术：
 

new/master-pred-anal-sklearn-tf/2.md

@@ -232,7 +232,7 @@ boosting_test_mse = cross_validate(estimator=boosting,X=X,y=y,
 
 因此，查看这些评估指标的箱形图，我们看到，随机森林表现最佳。
 
-要检查这些模型的可变程度，我们可以分析回归模型的测试 MSE 的标准偏差。 以下屏幕截图显示了用于检查变异程度的代码，以及显示了这些模型的标准偏差的图：
+要检查这些模型的可变程度，我们可以分析回归模型的测试 MSE 的标准差。 以下屏幕截图显示了用于检查变异程度的代码，以及显示了这些模型的标准差的图：
 
 ![](img/e98e483d-748c-4067-ab99-27a387d6d1c6.png)
 

new/whats-new-tf2/3.md

@@ -20,9 +20,9 @@
 
 # 将数据拆分为训练，验证和测试数据
 
-ML 模型训练的数据准备的关键特征之一是能够将现有数据分为训练，验证和测试集。 训练数据是已看到并用于拟合或训练模型的数据； 例如，神经网络的学习权重和偏见。 验证数据（有时称为开发数据）用于微调模型的超参数，例如学习率，要使用的优化程序等等。 模型会经常查看此数据（例如，在每次迭代或新周期之后）并评估模型。
+ML 模型训练的数据准备的关键特征之一是能够将现有数据分为训练，验证和测试集。 训练数据是已看到并用于拟合或训练模型的数据； 例如，神经网络的学习权重和偏置。 验证数据（有时称为开发数据）用于微调模型的超参数，例如学习率，要使用的优化程序等等。 模型会经常查看此数据（例如，在每次迭代或新周期之后）并评估模型。
 
-请注意，验证数据仅可帮助您微调模型。 它不会更新权重和偏见。
+请注意，验证数据仅可帮助您微调模型。 它不会更新权重和偏置。
 
 最后，测试数据是...
 

new/whats-new-tf2/4.md

@@ -256,7 +256,7 @@ model.load_weights(checkpoint_path) ...
 
 # 手动保存和恢复权重
 
-模型权重也可以保存在检查点文件中。 这可以用来节省训练后的体重，以便将来进行进一步的训练：
+模型权重也可以保存在检查点文件中。 这可以用来保存训练后的权重，以便将来进行进一步的训练：
 
 ```py
 # Save the weights