2020-12-11 22:34:11

new/ai-py/05.md

@@ -734,7 +734,7 @@ X = X_encoded[:, :-1].astype(int)
 y = X_encoded[:, -1].astype(int) 
 ```
 
-使用线性内核创建`SVM`分类器：
+使用线性核创建`SVM`分类器：
 
 ```py
 # Create SVM classifier

new/ai-py/07.md

@@ -204,7 +204,7 @@ from itertools import cycle
 X = np.loadtxt('data_clustering.txt', delimiter=',') 
 ```
 
-估计输入数据的带宽。 带宽是 MeanShift 算法中使用的底层内核密度估计过程的参数。 带宽会影响算法的整体收敛速度，并最终影响最终的簇数。 因此，这是一个关键参数-如果带宽太小，可能会导致群集过多，而如果值太大，则会合并不同的群集。
+估计输入数据的带宽。 带宽是 MeanShift 算法中使用的底层核密度估计过程的参数。 带宽会影响算法的整体收敛速度，并最终影响最终的簇数。 因此，这是一个关键参数-如果带宽太小，可能会导致群集过多，而如果值太大，则会合并不同的群集。
 
 `quantile`参数影响估计带宽的方式。 分位数的较高值将增加估计的带宽，从而导致较少的群集：
 

new/ai-py/20.md

@@ -558,7 +558,7 @@ h_pool2_flat = tf.reshape(h_pool2, [-1, 7`7`64])
 h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1) 
 ```
 
-为了减少过度拟合，我们需要创建一个辍学层。 让我们为概率值创建一个 TensorFlow 占位符，该占位符指定在删除过程中保留神经元输出的概率：
+为了减少过度拟合，我们需要创建一个丢弃层。 让我们为概率值创建一个 TensorFlow 占位符，该占位符指定在删除过程中保留神经元输出的概率：
 
 ```py
 # Define the dropout layer using a probability placeholder 

new/gan-proj/1.md

@@ -82,7 +82,7 @@ GAN 具有一些相当有用的实际应用，其中包括：
 *   **图像到图像的转换**：图像到图像的转换可用于将白天拍摄的图像转换为夜晚拍摄的图像，并将草图转换为绘画 ，以将图像的样式设置为类似于毕加索或梵高的绘画，将航空图像自动转换为卫星图像 ，并转换为 将马的图像转换为斑马的图像。 这些用例具有突破性，因为它们可以节省我们的时间。
 *   **视频合成**： GAN 也可以用于生成视频。 与我们手动创建内容相比，它们可以在更少的时间内生成内容。 它们可以提高电影创作者的工作效率，还可以使想在业余时间制作创意视频的业余爱好者获得支持。
 *   **高分辨率图像生成**：如果使用低分辨率相机拍摄照片，GAN 可以帮助您生成高分辨率图像而不会丢失任何基本细节。 这在网站上可能很有用。
-*   **补齐图像的缺失部分**：如果 您的图像中有些缺失的部分，GAN 可以帮助您恢复这些部分。
+*   **补全图像的缺失部分**：如果 您的图像中有些缺失的部分，GAN 可以帮助您恢复这些部分。
 
 
 
@@ -190,7 +190,7 @@ GAN 的架构具有两个基本元素：生成器网络和判别器网络。 每
 
 
 
-**Jensen-Shannon** 散度（也称为**信息半径**（**IRaD**）或**总散度与平均值**）[ 是两个概率分布之间相似度的另一种度量。 它基于 KL 散度。 但是，与 KL 散度不同，JS 散度本质上是对称的，可用于测量两个概率分布之间的距离。 如果我们采用 Jensen-Shannon 发散的平方根，则会得到 Jensen-Shannon 距离，因此它是距离度量。
+**Jensen-Shannon** 散度（也称为**信息半径**（**IRaD**）或**总散度与平均值**）是两个概率分布之间相似度的另一种度量。 它基于 KL 散度。 但是，与 KL 散度不同，JS 散度本质上是对称的，可用于测量两个概率分布之间的距离。 如果我们采用 Jensen-Shannon 发散的平方根，则会得到 Jensen-Shannon 距离，因此它是距离度量。
 
 以下 等式表示两个概率分布`p`和`q`之间的 Jensen-Shannon 散度：
 
@@ -281,7 +281,7 @@ GAN 的架构具有两个基本元素：生成器网络和判别器网络。 每
 
 
 
-为了克服初始分数的各种缺点，Martin Heusel 等人在他们的论文中提出了**Fréchlet 初始距离**（**FID**），[收敛到局部纳什均衡的两个时间维度更新规则所训练的 GAN](https://arxiv.org/pdf/1706.08500.pdf)。
+为了克服初始分数的各种缺点，Martin Heusel 等人在他们的论文中提出了 **Fréchlet 初始距离**（**FID**），[《收敛到局部纳什均衡的两个时间维度更新规则所训练的 GAN》](https://arxiv.org/pdf/1706.08500.pdf)。
 
 计算 FID 分数的公式如下：
 
@@ -546,7 +546,7 @@ The benefits of batch normalization are as follows:
 *   **更快的训练**：如果从正态/高斯分布中采样值 ，则网络将更快地训练。 批处理规范化有助于将值白化到我们网络的内部层。 总体训练速度更快，但是由于涉及额外的计算，因此每次迭代都会变慢。
 *   **更高的准确性**：批量标准化提供了更好的准确性。
 *   **较高的学习率**：通常，当我们训练神经网络时，我们使用较低的学习率，这需要很长时间才能收敛网络。 通过批量归一化，我们可以使用更高的学习率，从而使我们的网络更快地达到全球最低水平。
-*   **减少了辍学的需求**：当我们使用辍学时，我们会破坏网络内部层中的一些基本信息。 批量归一化充当一个正则化器，这意味着我们可以训练网络而无需退出层。
+*   **减少了丢弃法的需求**：当我们使用丢弃时，我们会破坏网络内部层中的一些基本信息。 批量归一化充当一个正则化器，这意味着我们可以训练网络而无需退出层。
 
 在批处理规范化中，我们将规范化应用于所有隐藏层，而不是仅将其应用于输入层。
 
@@ -558,7 +558,7 @@ The benefits of batch normalization are as follows:
 
 
 
-如上一节所述，批量归一化仅通过利用来自该批量的信息来对一批样本进行归一化。 实例规范化是一种略有不同的方法。 在实例归一化中，我们仅通过利用来自该特征图的信息来归一化每个特征图。 实例规范化由 Dmitry Ulyanov 和 Andrea Vedaldi 在标题为*的论文中介绍了实例规范化：快速风格化*的缺失成分，[可通过以下链接获得](https://arxiv.org/pdf/1607.08022.pdf)。
+如上一节所述，批量归一化仅通过利用来自该批量的信息来对一批样本进行归一化。 实例规范化是一种略有不同的方法。 在实例归一化中，我们仅通过利用来自该特征图的信息来归一化每个特征图。 实例规范化由 Dmitry Ulyanov 和 Andrea Vedaldi 在标题为《实例规范化：用于快速风格化的缺失成分》的论文中介绍，[可通过以下链接获得](https://arxiv.org/pdf/1607.08022.pdf)。
 
 
 

new/gan-proj/2.md

@@ -66,11 +66,11 @@
 
 *   **卷积层**：5
 *   **过滤器**： 512，256，128 和 64，1
-*   **内核大小**：`4 x 4 x 4`， `4 x 4 x 4`， `4 x 4 x 4`， `4 x 4 x 4`， `4 x 4 x 4`
+*   **核大小**：`4 x 4 x 4`， `4 x 4 x 4`， `4 x 4 x 4`， `4 x 4 x 4`， `4 x 4 x 4`
 *   **步幅**：1、2、2、2、2 或`(1, 1), (2, 2), (2, 2), (2, 2), (2, 2)`
 *   **批量标准化**：是，是，是，是，否
 *   **激活**：ReLU， ReLU， ReLU， ReLU，Sigmoid
-*   **汇聚层**：否，否，否，否，否
+*   **池化层**：否，否，否，否，否
 *   **线性层**：否，否，否，否，否
 
 网络的输入和输出如下：
@@ -98,11 +98,11 @@
 
 *   **3D 卷积层**：5
 *   **通道**：64、128、256、512、1
-*   **内核大小**：4、4、4、4、4、4
+*   **核大小**：4、4、4、4、4、4
 *   **大步前进**：2、2、2、2、1
 *   **激活**：LReLU，LReLU，LReLU，LReLU，Sigmoid
 *   **批量标准化**：是，是，是，是，无
-*   **汇聚层**：否，否，否，否，否
+*   **池化层**：否，否，否，否，否
 *   **线性层**：否，否，否，否，否
 
 网络的输入和输出如下：

new/gan-proj/3.md

@@ -364,7 +364,7 @@ input_layer = Input(shape=(64, 64, 3))
 
 2.  接下来，添加第一个卷积块，其中包含具有激活函数的 2D 卷积层，具有以下配置：
     *   **过滤器**：`32`
-    *   **内核大小**：`5`
+    *   **核大小**：`5`
     *   **大步前进**：`2`
     *   **填充**：``same``
     *   **激活**：`LeakyReLU`，其中`alpha`等于`0.2`：
@@ -375,7 +375,7 @@ input_layer = Input(shape=(64, 64, 3))
 
 3.  接下来，再添加三个卷积块，其中每个都包含一个 2D 卷积层，然后是一个批处理归一化层和一个激活函数，具有以下配置：
     *   **过滤器**：`64`，`128`，`256`
-    *   **内核大小**：`5`，`5`，`5`
+    *   **核大小**：`5`，`5`，`5`
     *   **跨越**：`2`，`2`，`2`
     *   **填充**：`same`，`same`，``same``
     *   **批量归一化**：每个卷积层后面都有一个批量归一化层
@@ -539,7 +539,7 @@ x = Reshape((8, 8, 256))(x)
 6.  接下来，添加一个升采样模块，该模块包含一个升采样层，其后是一个具有以下配置的 2D 卷积层和一个批归一化层：
     *   **上采样大小**：`(2, 2)`
     *   **过滤器**：`128`
-    *   **内核大小**：`5`
+    *   **核大小**：`5`
     *   **填充**：`same`
     *   **批量规范化**：是，`momentum`等于`0.8`
     *   **激活**：`LeakyReLU`，其中`alpha`等于`0.2`：
@@ -647,7 +647,7 @@ label_input = Input(shape=label_shape)
 
 2.  接下来，添加具有以下配置的二维卷积块（Conv2D + 激活函数）：
     *   **过滤器** = `64`
-    *   **内核大小**：`3`
+    *   **核大小**：`3`
     *   **大步前进**：`2`
     *   **填充**：`same`
     *   **激活**：`LeakyReLU`，其中`alpha`等于`0.2`：
@@ -684,7 +684,7 @@ x = concatenate([x, label_input1], axis=3)
 
 5.  添加具有以下配置的卷积块（2D 卷积层 + 批处理归一化 + 激活函数）：
     *   **过滤器**：`128`
-    *   **内核大小**：`3`
+    *   **核大小**：`3`
     *   **大步前进**：`2`
     *   **填充**：`same`
     *   **批量标准化**：是

new/gan-proj/4.md

@@ -424,7 +424,7 @@ gen_model.add(UpSampling2D(size=(2, 2)))
 
 2D 上采样层 将张量 的行和列分别以[0]和[1]的大小重复 。
 
-8.  接下来，在第二个 2D 卷积层上添加 `64` 过滤器和，将`(5, 5)` 的**内核大小** `tanh` 作为激活函数：
+8.  接下来，在第二个 2D 卷积层上添加 `64` 过滤器和，将`(5, 5)` 的**核大小** `tanh` 作为激活函数：
 
 ```py
 gen_model.add(Conv2D(64, (5, 5), padding='same'))
@@ -437,7 +437,7 @@ gen_model.add(Activation('tanh'))
 gen_model.add(UpSampling2D(size=(2, 2))) 
 ```
 
-10.  最后，在第三个 2D 卷积层上添加三个**过滤器**，**内核大小**`(5, 5)` ，然后是`tanh`作为激活函数：
+10.  最后，在第三个 2D 卷积层上添加三个**过滤器**，**核大小**`(5, 5)` ，然后是`tanh`作为激活函数：
 
 ```py
 gen_model.add(Conv2D(3, (5, 5), padding='same'))
@@ -490,7 +490,7 @@ def get_generator():
 如 DCGAN 的架构中所述，判别器网络具有三个 2D 卷积层，每个层均具有激活函数，后跟两个最大合并层。 网络的尾部包含两个完全连接的（密集）层，用作分类层。 首先，让我们看一下判别器网络中的不同层：
 
 *   所有卷积层都具有`LeakyReLU`作为激活函数，其`alpha`值为 0.2
-*   卷积层分别具有 128、256 和 512 个滤波器。 它们的内核大小分别为`(5, 5)`，`(3, 3)`和`(3, 3)`。
+*   卷积层分别具有 128、256 和 512 个滤波器。 它们的核大小分别为`(5, 5)`，`(3, 3)`和`(3, 3)`。
 *   在卷积层之后，我们有一个展开层，它将输入平坦化为一维张量。
 *   此后，网络具有两个密集层，分别具有 1,024 个神经元和一个神经元。
 *   第一密集层具有`LeakyReLU`作为激活函数，而第二层具有乙状结肠作为激活函数。 乙状结肠激活用于二进制分类。 我们正在训练辨别器网络，以区分真实图像还是伪图像。
@@ -505,7 +505,7 @@ dis_model = Sequential()
 
 2.  添加一个 2D 卷积层，该层采用形状为`(64, 64, 3)`的输入图像。 该层的超参数如下。 另外，添加具有`0.2`的`alpha`值的`LeakyReLU`作为激活函数：
     *   **过滤器：** 128
-    *   **内核大小：** `(5, 5)`
+    *   **核大小：** `(5, 5)`
     *   **填充：** 相同：
 
 ```py
@@ -524,7 +524,7 @@ dis_model.add(MaxPooling2D(pool_size=(2, 2)))
 
 4.  接下来，添加具有以下配置的另一个 2D 卷积层：
     *   **过滤器**：256
-    *   **内核大小** ：`(3, 3)`
+    *   **核大小** ：`(3, 3)`
     *   **激活函数**： `LeakyReLU`，具有`alpha` 0.2
     *   **2D 最大池中的池大小**：`(2, 2)`
 
@@ -538,7 +538,7 @@ dis_model.add(MaxPooling2D(pool_size=(2, 2)))
 
 5.  接下来，添加具有以下配置的第三个 2D 卷积层：
     *   **过滤器**： 512
-    *   **内核大小**：`(3, 3)`
+    *   **核大小**：`(3, 3)`
     *   **激活函数**：`LeakyReLU`，带有`alpha` 0.2
     *   **2D 最大池中的池大小**：`(2, 2)`
 

new/gan-proj/5.md

@@ -353,7 +353,7 @@ input_layer = Input(shape=input_shape)
 3.  接下来，如下所示添加残差前块（2D 卷积层）：
     配置：
     *   **过滤器**：`64`
-    *   **内核大小**：`9`
+    *   **核大小**：`9`
     *   **大步前进**：`1`
     *   **填充**：`same`
     *   **激活**：`relu:`
@@ -399,7 +399,7 @@ for i in range(residual_blocks - 1):
 6.  接下来，添加后残差块（2D 卷积层，然后是批处理归一化层），如下所示：
     配置：
     *   **过滤器**：`64`
-    *   **内核大小**：`3`
+    *   **核大小**：`3`
     *   **大步前进**：``1``
     *   **填充**：`same`
     *   **批量归一化**：是（动量为 0.8）：
@@ -419,7 +419,7 @@ gen3 = Add()([gen2, gen1])
     配置：
     *   **上采样大小**：`2`
     *   **文件管理器**：`256`
-    *   **内核大小**：`3`
+    *   **核大小**：`3`
     *   **大步前进**：`1`
     *   **填充**：`same`
     *   **激活**：`PReLU:`
@@ -434,7 +434,7 @@ gen4 = Activation('relu')(gen4)
     配置：
     *   **上采样大小**：  `2`
     *   **文件管理器**：  `256`
-    *   **内核大小**：  `3`
+    *   **核大小**：  `3`
     *   **大步前进**：  `1`
     *   **填充**：  `same`
     *   **激活**：  `PReLU:`
@@ -448,7 +448,7 @@ gen5 = Activation('relu')(gen5)
 10.  最后，添加输出卷积层：
     配置：
     *   **过滤器**：`3`（等于通道数）
-    *   **内核大小**：`9`
+    *   **核大小**：`9`
     *   **大步前进**：`1`
     *   **填充**：`same`
     *   **激活**：`tanh:`
@@ -546,7 +546,7 @@ input_layer = Input(shape=input_shape)
 3.  接下来，添加一个卷积块，如下所示：
     配置：
     *   **过滤器**：`64`
-    *   **内核大小**：`3`
+    *   **核大小**：`3`
     *   **大步前进**：`1`
     *   **填充**：`same`
     *   **激活**：`LeakyReLU`，`alpha`等于 0.2：
@@ -559,7 +559,7 @@ dis1 = LeakyReLU(alpha=leakyrelu_alpha)(dis1)
 4.  接下来，添加另外七个卷积块，如下所示：
     配置：
     *   **过滤器**：`64`，`128`，`128`，`256`，`256`，`512`，`512`
-    *   **内核大小**：`3`，`3`，`3`，`3`，`3`，`3`，`3`
+    *   **核大小**：`3`，`3`，`3`，`3`，`3`，`3`，`3`
     *   **跨越**：`2`，`1`，`2`，`1`，`2`，`1`，`2`
     *   每个卷积层的**填充**：`same`
     *   **激活**：`LealyReLU`，每个卷积层的`alpha`等于 0.2：

new/gan-proj/6.md

@@ -658,7 +658,7 @@ input_layer = Input(shape=(64, 64, 3))
 
 2.  接下来，添加具有以下参数的二维卷积层：
     *   **过滤器** = `64`
-    *   **内核大小** = `(4, 4)`
+    *   **核大小** = `(4, 4)`
     *   **大步前进** = `2`
     *   **填充** = `'same'`
     *   **使用偏差** = `False`
@@ -673,7 +673,7 @@ stage1_dis = LeakyReLU(alpha=0.2)(stage1_dis)
 
 3.  之后，添加两个卷积层，每个卷积层之后是一个批处理归一化层和一个`LeakyReLU`激活函数，具有以下参数：
     *   **过滤器：** `128`
-    *   **内核大小：** `(4, 4)`
+    *   **核大小：** `(4, 4)`
     *   **大步前进** = `2`
     *   **填充** = `'same'`
     *   **使用偏差** = `False`
@@ -687,7 +687,7 @@ x = LeakyReLU(alpha=0.2)(x)
 
 4.  接下来，再添加一个 2D 卷积层，然后添加批处理规范化层和`LeakyReLU`激活函数，并具有以下参数：
     *   **过滤器：** `256`
-    *   **内核大小：** `(4, 4)`
+    *   **核大小：** `(4, 4)`
     *   **大步前进** = `2`
     *   **填充** = `'same'`
     *   **使用偏差** = `False`
@@ -701,7 +701,7 @@ x = LeakyReLU(alpha=0.2)(x)
 
 5.  之后，再添加一个 2D 卷积层，然后添加批处理规范化层和 LeakyReLU 激活函数，并具有以下参数：
     *   **过滤器：** `512`
-    *   **内核大小：** `(4, 4)`
+    *   **核大小：** `(4, 4)`
     *   **大步前进** = `2`
     *   **填充** = `'same'`
     *   **使用偏差** = `False`
@@ -727,7 +727,7 @@ merged_input = concatenate([x, input_layer2])
 
 8.  之后，添加另一个 2D 卷积层，然后添加批处理归一化层，并使用以下参数将`LeakyReLU`作为激活函数：
     *   **过滤器** = `512`
-    *   **内核大小** = `1`
+    *   **核大小** = `1`
     *   **大步前进** = `1`
     *   **填充** = `'same'`
     *   **批量标准化** =是
@@ -886,7 +886,7 @@ def build_adversarial_model(gen_model, dis_model):
 1.  首先创建第一个下采样块。 该块包含一个以`ReLU`作为激活函数的 2D 卷积层。 在应用 2D 卷积之前，请在各侧用零填充输入。 该块中不同层的配置如下：
     *   **填充大小：** `(1, 1)`
     *   **过滤器：** `128`
-    *   **内核大小：** `(3, 3)`
+    *   **核大小：** `(3, 3)`
     *   **大步走：** ``1``
     *   **激活：** `ReLU`
 
@@ -899,7 +899,7 @@ x = ReLU()(x)
 2.  接下来，添加具有以下配置的第二个卷积块：
     *   **填充大小：** `(1, 1)`
     *   **过滤器：** `256`
-    *   **内核大小：** `(4, 4)`
+    *   **核大小：** `(4, 4)`
     *   **大步走过：** `2`
     *   **批量标准化：**是
     *   **激活：** `ReLU`
@@ -914,7 +914,7 @@ x = ReLU()(x)
 3.  之后，添加另一个具有以下配置的卷积块：
     *   **填充大小：** `(1, 1)`
     *   **过滤器：** `512`
-    *   **内核大小：** `(4, 4)`
+    *   **核大小：** `(4, 4)`
     *   **大步走过：** `2`
     *   **批量标准化：** 是
     *   **激活：** `ReLU`
@@ -978,7 +978,7 @@ def residual_block(input):
 2.  接下来，添加具有以下超参数的 2D 卷积块：
     *   **填充大小：** `(1, 1)`
     *   **过滤器：** `512`
-    *   **内核大小：** `(3, 3)`
+    *   **核大小：** `(3, 3)`
     *   **大步走过：** `1`
     *   **批量归一化：** `Yes`
     *   **激活：** `ReLU`
@@ -1016,7 +1016,7 @@ x = residual_block(x)
 1.  首先，添加一个包含 2D 上采样层，2D 卷积层，批归一化和激活函数的上采样块。 块中使用的不同参数如下：
     *   **上采样大小：** `(2, 2)`
     *   **过滤器：** `512`
-    *   **内核大小：** `3`
+    *   **核大小：** `3`
     *   **填充：** `"same"`
     *   **大步走：** `1`
     *   **批量标准化：** `Yes`

new/gan-proj/8.md

@@ -104,19 +104,19 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章，“使用条件 GA
 | 第一个 2D 上采样层 | `size=(2, 2)` | `(1, 1, 512)` | `(2, 2, 512)` |
 | 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 1, padding="same"` | `(2, 2, 512)` | `(2, 2, 512)` |
 | 批量归一化层 | 没有 | `(2, 2, 512)` | `(2, 2, 512)` |
-| 辍学层 | 辍学= 0.5 | `(2, 2, 512)` | `(2, 2, 512)` |
+| 丢弃层 | 丢弃= 0.5 | `(2, 2, 512)` | `(2, 2, 512)` |
 | 级联层（编码器网络中的第 7 个卷积层） | `axis=3` | `(2, 2, 512)` | `(2, 2, 1024)` |
 | 激活层 | `activation="relu"` | `(2, 2, 1024)` | `(2, 2, 1024)` |
 | 第二个 2D 上采样层 | `size=(2, 2)` | `(2, 2, 1024)` | `(4, 4, 1024)` |
 | 2D 卷积层 | `filter= 1024, kernel_size = 4, stride= 1, padding="same"` | `(4, 4, 1024)` | `(4, 4, 1024)` |
 | 批量归一化层 | 没有 | `(4, 4, 1024)` | `(4, 4, 1024)` |
-| 辍学层 | 辍学= 0.5 | `(4, 4, 1024)` | `(4, 4, 1024)` |
+| 丢弃层 | 丢弃= 0.5 | `(4, 4, 1024)` | `(4, 4, 1024)` |
 | 级联层（编码器网络中的第 6 个卷积层） | `axis=3` | `(4, 4, 1024)` | `(4, 4, 1536)` |
 | 激活层 | `activation="relu"` | `(4, 4, 1536)` | `(4, 4, 1536)` |
 | 第三个 2D 上采样层 | `size=(2, 2)` | `(4, 4, 1536)` | `(8, 8, 1536)` |
 | 2D 卷积层 | `filter= 1024, kernel_size = 4, stride= 1, padding="same"` | `(8, 8, 1536)` | `(8, 8, 1024)` |
 | 批量归一化层 | 没有 | `(8, 8, 1024)` | `(8, 8, 1024)` |
-| 辍学层 | 辍学= 0.5 | `(8, 8, 1024)` | `(8, 8, 1024)` |
+| 丢弃层 | 丢弃= 0.5 | `(8, 8, 1024)` | `(8, 8, 1024)` |
 | 级联层（编码器网络中的第 5 个卷积层） | `axis=3` | `(8, 8, 1024)` | `(8, 8, 1536)` |
 | 激活层 | `activation="relu"` | `(8, 8, 1536)` | `(8, 8, 1536)` |
 | 第四个 2D 上采样层 | `size=(2, 2)` | `(8, 8, 1536)` | `(16, 16, 1536)` |

new/handson-unsup-learn-py/06.md

@@ -10,7 +10,7 @@
 
 *   概率密度函数及其基本性质简介
 *   直方图及其局限性
-*   **内核密度估计**（**KDE**）
+*   **核密度估计**（**KDE**）
 *   带宽选择标准
 *   异常检测的单变量示例
 *   使用 KDD Cup 99 数据集的 HTTP 攻击异常检测示例
@@ -192,7 +192,7 @@ P(48.84 < x < 51.58) = 0.13 (13.43%)
 
 
 
-# 内核密度估计（KDE）
+# 核密度估计（KDE）
 
 
 
@@ -254,7 +254,7 @@ Epanechnikov 核
 
 
 
-指数内核是一个非常高峰的内核，其通用表达式如下：
+指数核是一个非常高峰的内核，其通用表达式如下：
 
 ![](img/00116f24-e19c-42be-b5cd-868d44bcd7c3.png)
 
@@ -304,7 +304,7 @@ Epanechnikov 核
 
 在这一点上，自然会问为什么不为每个查询使用整个数据集而不是 k-NN 方法？ 答案很简单，它基于这样的假设：可以使用局部行为轻松地插值以`x[j]`计算的密度函数的值（即，对于多变量 分布，以`x[j]`为中心的球和*远点*对估计没有影响。 因此，我们可以将计算限制为`X`的较小子集，避免包含接近零的贡献。
 
-在讨论如何确定最佳带宽之前，让我们展示一下先前定义的数据集的密度估计（使用 scikit-learn）。 由于我们没有任何特定的先验知识，因此我们将使用具有不同带宽（0.1、0.5 和 1.5）的高斯内核。 所有其他参数均保留为其默认值。 但是，`KernelDensity`类允许设置度量（默认为`metric='euclidean'`），数据结构（默认为`algorithm='auto'`，它根据维度在球树和 kd 树之间执行自动选择），以及 绝对公差和相对公差（分别为 0 和 10^(-8) ）。 在许多情况下，无需更改默认值。 但是，对于具有特定功能的超大型数据集，例如，更改`leaf_size`参数以提高性能可能会有所帮助（如 第 2 章 中讨论的 ， “聚类基础知识”）。 此外，默认度量标准不能满足所有任务的要求（例如：标准文档显示了一个基于 Haversine 距离的示例，在使用纬度和经度时可以使用该示例）。 在其他情况下，最好使用超立方体而不是球（曼哈顿距离的情况就是这样）。
+在讨论如何确定最佳带宽之前，让我们展示一下先前定义的数据集的密度估计（使用 scikit-learn）。 由于我们没有任何特定的先验知识，因此我们将使用具有不同带宽（0.1、0.5 和 1.5）的高斯核。 所有其他参数均保留为其默认值。 但是，`KernelDensity`类允许设置度量（默认为`metric='euclidean'`），数据结构（默认为`algorithm='auto'`，它根据维度在球树和 kd 树之间执行自动选择），以及 绝对公差和相对公差（分别为 0 和 10^(-8) ）。 在许多情况下，无需更改默认值。 但是，对于具有特定功能的超大型数据集，例如，更改`leaf_size`参数以提高性能可能会有所帮助（如 第 2 章 中讨论的 ， “聚类基础知识”）。 此外，默认度量标准不能满足所有任务的要求（例如：标准文档显示了一个基于 Haversine 距离的示例，在使用纬度和经度时可以使用该示例）。 在其他情况下，最好使用超立方体而不是球（曼哈顿距离的情况就是这样）。
 
 让我们首先实例化类并拟合模型：
 
@@ -390,7 +390,7 @@ kd_exponential.fit(ages.reshape(-1, 1))
 
 带宽等于 2.0 的密度估计，高斯核（上），Epanechnikov 核（中）和指数核（下）
 
-不出所料，Epanechnikov 和指数核都比高斯核振荡（因为当`h`较小时，它们倾向于更趋于峰值）； 但是，很明显，中心图肯定是最准确的（就 MISE 而言）。 以前使用高斯核和 *h = 0.5* 时已经获得了相似的结果，但是在那种情况下，振荡极为不规则。 如所解释的， Epanechnikov 内核在值达到带宽边界时具有非常强的不连续趋势。 通过查看估计的极端现象可以立即理解该现象，该估计值几乎垂直下降到零。 相反， *h = 2* 的高斯估计似乎非常平滑，并且无法捕获 50 到 60 年之间的变化。 指数内核也发生了同样的情况，它也显示出其独特的行为：极端尖刺的极端。 在下面的示例中，我们将使用 Epanechnikov 内核； 但是，我邀请读者也检查带宽不同的高斯滤波器的结果。 这种选择有一个精确的理由（没有充分的理由就不能丢弃）：我们认为数据集是详尽无遗的，并且我们希望对克服自然极端的所有样本进行惩罚。 在所有其他情况下，可以选择非常小的残差概率。 但是，必须考虑每个特定目标做出这样的选择。
+不出所料，Epanechnikov 和指数核都比高斯核振荡（因为当`h`较小时，它们倾向于更趋于峰值）； 但是，很明显，中心图肯定是最准确的（就 MISE 而言）。 以前使用高斯核和 *h = 0.5* 时已经获得了相似的结果，但是在那种情况下，振荡极为不规则。 如所解释的， Epanechnikov 内核在值达到带宽边界时具有非常强的不连续趋势。 通过查看估计的极端现象可以立即理解该现象，该估计值几乎垂直下降到零。 相反， *h = 2* 的高斯估计似乎非常平滑，并且无法捕获 50 到 60 年之间的变化。 指数核也发生了同样的情况，它也显示出其独特的行为：极端尖刺的极端。 在下面的示例中，我们将使用 Epanechnikov 内核； 但是，我邀请读者也检查带宽不同的高斯滤波器的结果。 这种选择有一个精确的理由（没有充分的理由就不能丢弃）：我们认为数据集是详尽无遗的，并且我们希望对克服自然极端的所有样本进行惩罚。 在所有其他情况下，可以选择非常小的残差概率。 但是，必须考虑每个特定目标做出这样的选择。
 
 
 

new/intel-mobi-proj-tf/08.md

@@ -41,7 +41,7 @@ LSTM 只是解决 RNN 已知梯度消失问题的一种 RNN，我们在第 6 章
 三种常用技术可以使 LSTM 模型表现更好：
 
 *   堆叠 LSTM 层并增加层中神经元的数量：如果不产生过度拟合，通常这将导致功能更强大，更准确的网络模型。 如果还没有，那么您绝对应该玩 [TensorFlow Playground](http://playground.tensorflow.org)来体验一下。
-*   使用辍学处理过度拟合。 删除意味着随机删除层中的隐藏单元和输入单元。
+*   使用丢弃处理过度拟合。 删除意味着随机删除层中的隐藏单元和输入单元。
 *   使用双向 RNN 在两个方向（常规方向和反向方向）处理每个输入序列，希望检测出可能被常规单向 RNN 忽略的模式。
 
 所有这些技术已经实现，并且可以在 TensorFlow 和 Keras API 中轻松访问。
@@ -522,7 +522,7 @@ plt.show()
 
 图 8.2：使用 Keras 双向和堆叠 LSTM 层进行股价预测
 
-很容易在堆栈中添加更多 LSTM 层，或者使用诸如学习率和辍学率以及许多恒定设置之类的超参数。 但是，对于使用`pred_len`和`shift_pred`的不同设置，正确率的差异还没有发现。 也许我们现在应该对接近 60% 的正确率感到满意，并看看如何在 iOS 和 Android 上使用 TensorFlow 和 Keras 训练的模型-我们可以在以后继续尝试改进模型，但是 了解使用 TensorFlow 和 Keras 训练的 RNN 模型是否会遇到任何问题将非常有价值。
+很容易在堆栈中添加更多 LSTM 层，或者使用诸如学习率和丢弃率以及许多恒定设置之类的超参数。 但是，对于使用`pred_len`和`shift_pred`的不同设置，正确率的差异还没有发现。 也许我们现在应该对接近 60% 的正确率感到满意，并看看如何在 iOS 和 Android 上使用 TensorFlow 和 Keras 训练的模型-我们可以在以后继续尝试改进模型，但是 了解使用 TensorFlow 和 Keras 训练的 RNN 模型是否会遇到任何问题将非常有价值。
 
 正如 FrançoisChollet 指出的那样，“深度学习更多的是艺术而不是科学……每个问题都是独特的，您将不得不尝试并经验地评估不同的策略。目前尚无理论可以提前准确地告诉您应该做什么。 以最佳方式解决问题。您必须尝试并进行迭代。” 希望我们为您使用 TensorFlow 和 Keras API 改善股票价格预测模型提供了一个很好的起点。