2021-01-02 15:37:21

6052ed1d · wizardforcel · 25e61286 · 6052ed1d · 6052ed1d · 6052ed1d
19 changed file
--- a/new/adv-dl-tf2-keras/06.md
+++ b/new/adv-dl-tf2-keras/06.md
@@ -674,11 +674,11 @@ def train(models, data, params):

 图 6.2.1：在名人脸生成的背景下 StackedGAN 的基本思想。 假设有一个假设的深层编码器网络可以对名人脸进行分类，那么 StackedGAN 可以简单地反转编码器的过程

-*编码器*网络是由一堆简单的编码器组成的，*编码器* <sub>i</sub> ，其中 *i = 0…n-1*`n`功能。 每个编码器都提取某些面部特征。 例如，*编码器* <sub>0</sub> 可能是发型特征的编码器，*特征* <sub>1</sub> 。 所有简单的编码器都有助于使整个*编码器*执行正确的预测。
+*编码器*网络是由一堆简单的编码器组成的，`Encoder[i]`，其中`i = 0 … n-1`对应`n`个特征。 每个编码器都提取某些面部特征。 例如，`Encoder[0]`可能是发型特征的编码器，`Feature[1]`。 所有简单的编码器都有助于使整个*编码器*执行正确的预测。

-StackedGAN 背后的想法是，如果我们想构建一个可生成假名人面孔的 GAN，则只需将*编码器*反转即可。 StackedGAN 由一堆更简单的 GAN 组成，GAN <sub>i</sub> *，其中 i = 0…n-1* 与`n`特征相对应。 每个 GAN <sub>i</sub> 学会反转其相应编码器*编码器* <sub>i</sub> 的过程。 例如，GAN <sub>0</sub> 从假发型特征生成假名人脸，这是*编码器* <sub>0</sub> 处理的逆过程。
+StackedGAN 背后的想法是，如果我们想构建一个可生成假名人面孔的 GAN，则只需将*编码器*反转即可。 StackedGAN 由一堆更简单的 GAN 组成，`GAN[i]`，其中`i = 0 … n-1`与`n`个特征相对应。 每个`GAN[i]`学会反转其相应编码器`Encoder[i]`的过程。 例如，`GAN[0]`从假发型特征生成假名人脸，这是`Encoder[0]`处理的逆过程。

-每个 GAN <sub>i</sub> 使用潜码`z[i]`，以调节其发电机输出。 例如，潜在代码`z[0]`可以将发型从卷曲更改为波浪形。 GAN 的堆栈也可以用作合成假名人面孔的对象，从而完成整个*编码器*的逆过程。 每个 GAN <sub>i</sub> ，`z[i]`的潜在代码都可以用来更改假名人面孔的特定属性。
+每个`GAN[i]`使用潜码`z[i]`，以调节其发电机输出。 例如，潜在代码`z[0]`可以将发型从卷曲更改为波浪形。 GAN 的堆栈也可以用作合成假名人面孔的对象，从而完成整个*编码器*的逆过程。 每个`GAN[i]`，`z[i]`的潜在代码都可以用来更改假名人面孔的特定属性。

 有了 StackedGAN 的工作原理的关键思想，让我们继续下一节，看看如何在`tf.keras`中实现它。

@@ -690,7 +690,7 @@ StackedGAN 的详细网络模型可以在“图 6.2.2”中看到。 为简洁

 ![](img/B14853_06_09.png)

-图 6.2.2：StackedGAN 包含编码器和 GAN 的堆栈。 对编码器进行预训练以执行分类。 *生成器* <sub>1</sub> ，`G[1]`学会合成`f`<sub>1f</sub> 功能 假标签`y`<sub>f，</sub>和潜在代码`z`<sub>1f</sub> 。 *生成器* <sub>0</sub> ，`G[0]`均使用这两个伪特征`f`<sub>1f 生成伪图像</sub> 和潜在代码`z`<sub>0f</sub>
+图 6.2.2：StackedGAN 包含编码器和 GAN 的堆栈。 对编码器进行预训练以执行分类。 `Generator[1]`，`G[1]`学会合成`f`<sub>1f</sub> 功能 假标签`y`<sub>f，</sub>和潜在代码`z`<sub>1f</sub> 。 `Generator[0]`，`G[0]`均使用这两个伪特征`f`<sub>1f 生成伪图像</sub> 和潜在代码`z`<sub>0f</sub>

 StackedGAN 以*编码器*开头。 它可能是训练有素的分类器，可以预测正确的标签。 可以将中间特征向量`f`<sub>1r</sub> 用于 GAN 训练。 对于 MNIST，我们可以使用基于 CNN 的分类器，类似于在“第 1 章”， *Keras 引入高级深度学习*中讨论的分类器。

@@ -700,7 +700,7 @@ StackedGAN 以*编码器*开头。 它可能是训练有素的分类器，可以

 图 6.2.3：StackedGAN 中的编码器是一个基于 CNN 的简单分类器

-“列表 6.2.1”显示了上图的`tf.keras`代码。 它与“第 1 章”，*用 Keras* 引入高级深度学习中的基于 CNN 的分类器相似，不同之处在于，我们使用`Dense`层来提取`256-dim` 特征。 有两个输出模型，*编码器* <sub>0</sub> 和*编码器* <sub>1</sub> 。 两者都将用于训练 StackedGAN。
+“列表 6.2.1”显示了上图的`tf.keras`代码。 它与“第 1 章”，*用 Keras* 引入高级深度学习中的基于 CNN 的分类器相似，不同之处在于，我们使用`Dense`层来提取`256-dim` 特征。 有两个输出模型，`Encoder[0]`和`Encoder[1]`。 两者都将用于训练 StackedGAN。

 “列表 6.2.1”：`stackedgan-mnist-6.2.1.py`

@@ -766,18 +766,17 @@ def build_encoder(inputs, num_labels=10, feature1_dim=256):
    return enc0, enc1 
 ```

-*编码器* <sub>0</sub> 输出`f`<sub>1r</sub> 是我们想要的`256-dim`特征向量*生成器* 1 学习合成。 可以将用作*编码器* <sub>0</sub> ，`E[0]`的辅助输出。 训练整个*编码器*以对 MNIST 数字进行分类，即`x[r]`。 正确的标签*和* <sub>r</sub> <sub>和</sub>由*编码器* <sub>1</sub> ，`E`预测 <sub>1</sub> 。 在此过程中，学习了的中间特征集`f`<sub>1r</sub> ，可用于 Generator0 训练。 当针对该编码器训练 GAN 时，下标`r`用于强调和区分真实数据与伪数据。
+`Encoder[0]`输出`f[1r]`是我们想要的`256`维特征向量*生成器* 1 学习合成。 可以将用作`Encoder[0]`，`E[0]`的辅助输出。 训练整个*编码器*以对 MNIST 数字进行分类，即`x[r]`。 正确的标签*和* <sub>r</sub> <sub>和</sub>由`Encoder[1]`，`E[1]`。 在此过程中，学习了的中间特征集`f[1r]`，可用于`Generator[0]`训练。 当针对该编码器训练 GAN 时，下标`r`用于强调和区分真实数据与伪数据。

-假设*编码器*输入（`x[r]`）中间特征（`f`<sub>1r</sub> ）和标签（`y[r]`），每个 GAN 都采用通常的区分-对抗方式进行训练。 损耗函数由“表 6.2.1”中的“公式 6.2.1”至“公式 6.2.5”给出。“公式 6.2.1”和“公式 6.2.2”是通用 GAN 的常见损耗函数。 StackedGAN 具有两个附加损失函数，即**有条件**和**熵**。
+假设*编码器*输入（`x[r]`）中间特征（`f[1r]`）和标签（`y[r]`），每个 GAN 都采用通常的区分-对抗方式进行训练。 损耗函数由“表 6.2.1”中的“公式 6.2.1”至“公式 6.2.5”给出。“公式 6.2.1”和“公式 6.2.2”是通用 GAN 的常见损耗函数。 StackedGAN 具有两个附加损失函数，即**有条件**和**熵**。

-<colgroup><col> <col> <col></colgroup> 
 | **网络** | **损失函数** | **编号** |
 | GAN | ![](img/B14853_06_030.png)![](img/B14853_06_031.png) | 4.1.14.1.5 |
 | 堆叠式 | ![](img/B14853_06_032.png)![](img/B14853_06_033.png)![](img/B14853_06_034.png)![](img/B14853_06_035.png)![](img/B14853_06_036.png)其中![](img/B14853_06_037.png)是权重， *i =编码器和 GAN ID* | 6.2.16.2.26.2.36.2.46.2.5 |

-表 6.2.1：GAN 和 StackedGAN 的损失函数之间的比较。 *〜p* <sub>数据</sub>表示从相应的编码器数据（输入，特征或输出）采样
+表 6.2.1：GAN 和 StackedGAN 的损失函数之间的比较。 `~p_data`表示从相应的编码器数据（输入，特征或输出）采样

-条件“公式 6.2.3”中的损失函数![](img/B14853_06_038.png)确保发生器不会忽略输入`f`<sub>i + 1</sub> ， 当从输入噪声代码`z[i]`合成输出`f[i]`时。 编码器*编码器* <sub>i</sub> 必须能够通过反转发生器的过程*发生器* <sub>i</sub> 来恢复发生器输入。 ]。 通过 *L2* 或欧几里德距离（**均方误差**（**MSE**））来测量发电机输入和使用编码器恢复的输入之间的差异。
+条件“公式 6.2.3”中的损失函数![](img/B14853_06_038.png)确保发生器不会忽略输入`f[i + 1]`， 当从输入噪声代码`z[i]`合成输出`f[i]`时。 编码器`Encoder[i]`必须能够通过反转发生器的过程`Generator[i]`来恢复发生器输入。 通过`L2`或欧几里德距离（**均方误差**（**MSE**））来测量发电机输入和使用编码器恢复的输入之间的差异。

 “图 6.2.4”显示了![](img/B14853_06_039.png)计算所涉及的网络元素：

@@ -880,7 +879,7 @@ def build_generator(latent_codes, image_size, feature1_dim=256):

 图 6.2.8：Keras 中的 StackedGAN 鉴别器模型

-我们提供函数来构建*鉴别器* <sub>0</sub> 和*鉴别器* <sub>1</sub> （`dis0`和`dis1`）。 `dis0`鉴别器类似于 GAN 鉴别器，除了特征向量输入和辅助网络`Q[0]`，其恢复`z`<sub>0 [</sub> 。 `gan.py`中的 builder 函数用于创建`dis0`：
+我们提供函数来构建`Discriminator[0]`和`Discriminator[1]`（`dis0`和`dis1`）。 `dis0`鉴别器类似于 GAN 鉴别器，除了特征向量输入和辅助网络`Q[0]`，其恢复`z[0]`。 `gan.py`中的 builder 函数用于创建`dis0`：

 ```py
 dis0 = gan.discriminator(inputs, num_codes=z_dim) 
@@ -1107,13 +1106,13 @@ def build_and_train_models():
    train(models, data, params) 
 ```

-最后，训练功能与典型的 GAN 训练相似，不同之处在于我们一次只训练一个 GAN（即 *GAN* <sub>1</sub> 然后是 *GAN* <sub>0</sub> ）。 代码显示在“列表 6.2.5”中。 值得注意的是，训练顺序为：
+最后，训练功能与典型的 GAN 训练相似，不同之处在于我们一次只训练一个 GAN（即`GAN[0]`然后是`GAN[0]`）。 代码显示在“列表 6.2.5”中。 值得注意的是，训练顺序为：

-1.  *鉴别器* <sub>1</sub> 和`Q[1]`网络通过最小化鉴别器和熵损失
-2.  *鉴别器* <sub>0</sub> 和`Q[0]`网络通过最小化鉴别器和熵损失
-3.  *对抗性* <sub>1</sub> 网络通过最小化对抗性，熵和条件损失
+1.  `Discriminator[1]`和`Q[1]`网络通过最小化鉴别器和熵损失
+2.  `Discriminator[0]`和`Q[0]`网络通过最小化鉴别器和熵损失
+3.  `Adversarial[1]`网络通过最小化对抗性，熵和条件损失

-1.  *对抗性* <sub>0</sub> 网络通过最小化对抗性，熵和条件损失
+1.  `Adversarial[0]`网络通过最小化对抗性，熵和条件损失

 “列表 6.2.5”：`stackedgan-mnist-6.2.1.py`

@@ -1302,7 +1301,7 @@ def train(models, data, params):

 ## StackedGAN 的发电机输出

-在对 StackedGAN 进行 10,000 步训练之后，*生成器* <sub>0</sub> 和*生成器* <sub>1</sub> 模型被保存在文件中。 *生成器* <sub>0</sub> 和*生成器* <sub>1</sub> 堆叠在一起可以合成以标签和噪声代码`z`为条件的伪造图像 <sub>0</sub> 和`z[1]`。
+在对 StackedGAN 进行 10,000 步训练之后，`Generator[0]`和`Generator[1]`模型被保存在文件中。 `Generator[0]`和`Generator[1]`堆叠在一起可以合成以标签和噪声代码`z[0]`和`z[1]`为条件的伪造图像。

 StackedGAN 生成器可以通过以下方式进行定性验证：


--- a/new/adv-dl-tf2-keras/07.md
+++ b/new/adv-dl-tf2-keras/07.md
@@ -187,9 +187,9 @@ CycleGAN 的总损耗变为：

 图 7.1.10：在 Keras 中实现正向循环发生器`G`。 产生器是包括编码器和解码器的 U 网络[7]。

-在 U-Net 结构中，编码器层的输出`e`<sub>ni</sub> 与解码器层的输出`d[i]`，其中`n`= 4 是编码器/解码器的层数，`i`= 1、2 和 3 是共享信息的层号。
+在 U-Net 结构中，编码器层的输出`e[ni]`与解码器层的输出`d[i]`，其中`n = 4`是编码器/解码器的层数，`i = 1, 2, 3`是共享信息的层号。

-我们应该注意，尽管该示例使用`n`= 4，但输入/输出尺寸较大的问题可能需要更深的编码器/解码器层。 通过 U-Net 结构，可以在编码器和解码器之间自由传输功能级别的信息。
+我们应该注意，尽管该示例使用`n = 4`，但输入/输出尺寸较大的问题可能需要更深的编码器/解码器层。 通过 U-Net 结构，可以在编码器和解码器之间自由传输功能级别的信息。

 编码器层由`Instance Normalization(IN)-LeakyReLU-Conv2D`组成，而解码器层由`IN-ReLU-Conv2D`组成。 编码器/解码器层的实现如清单 7.1.1 所示，而生成器的实现如清单 7.1.2 的*所示。*

@@ -369,7 +369,7 @@ CycleGAN 的鉴别器类似于香草 GAN 鉴别器。 输入图像被下采样

 ![](img/B14853_07_12.png)

-图 7.1.12：目标标识符 D <sub>y</sub> 在`tf.keras`中的实现。 PatchGAN 鉴别器显示在右侧
+图 7.1.12：目标标识符`D[y]`在`tf.keras`中的实现。 PatchGAN 鉴别器显示在右侧

 由于输出图像只有 32 x 32 RGB 时较小，因此表示该图像是真实的单个标量就足够了。 但是，当使用 PatchGAN 时，我们也会评估结果。“列表 7.1.3”显示了鉴别器的函数构建器：

@@ -449,7 +449,7 @@ def build_discriminator(input_shape,
 return discriminator 
 ```

-使用生成器和鉴别器生成器，我们现在可以构建 CycleGAN。“列表 7.1.4”显示了构建器功能。 与上一节中的讨论一致，实例化了两个生成器`g_source = F`和`g_target = G`以及两个鉴别器`d_source = D<sub>x</sub>`和`d_target = D<sub>y</sub>`。 正向循环为![](img/B14853_07_036.png) `reco_source = g_source(g_target(source_input))`。反向循环为![](img/B14853_07_037.png) `reco_target = g_target(g_source (target_input))`。
+使用生成器和鉴别器生成器，我们现在可以构建 CycleGAN。“列表 7.1.4”显示了构建器功能。 与上一节中的讨论一致，实例化了两个生成器`g_source = F`和`g_target = G`以及两个鉴别器`d_source = D[x]`和`d_target = D[y]`。 正向循环为![](img/B14853_07_036.png) `reco_source = g_source(g_target(source_input))`。反向循环为![](img/B14853_07_037.png) `reco_target = g_target(g_source (target_input))`。

 对抗模型的输入是源数据和目标数据，而输出是![](img/B14853_07_007.png)和![](img/B14853_07_039.png)的输出以及重构的输入![](img/B14853_07_040.png)和![](img/B14853_07_002.png)。 在本示例中，由于由于灰度图像和彩色图像中通道数之间的差异，因此未使用身份网络。 对于 GAN 和循环一致性损失，我们分别使用建议的![](img/B14853_07_042.png)和![](img/B14853_07_043.png)损失权重。 与前几章中的 GAN 相似，我们使用 RMSprop 作为判别器的优化器，其学习率为 2e-4，衰减率为 6e-8。 对抗的学习率和衰退率是鉴别器的一半。


--- a/new/adv-dl-tf2-keras/09.md
+++ b/new/adv-dl-tf2-keras/09.md
@@ -37,16 +37,16 @@ RL 已经存在了几十年。 但是，除了简单的世界模型之外，RL 

 为简单起见，我们将假定为*确定性*环境，在该环境中，给定状态下的某个动作将始终导致已知的下一个状态和奖励。 在本章的后面部分，我们将研究如何考虑随机性。 在时间步`t`时：

-*   环境处于状态空间![](img/14853_09_001.png)的状态下，状态为 <sub>t</sub> ，该状态可以是离散的也可以是连续的。 起始状态为 s <sub>0</sub> ，而终止状态为 s <sub>T</sub> 。
+*   环境处于状态空间![](img/14853_09_001.png)的状态下，状态`s[0]`，该状态可以是离散的也可以是连续的。 起始状态为`s[0]`，而终止状态为`s[T]`。
 *   代理通过遵循策略![](img/14853_09_003.png)从操作空间![](img/14853_09_002.png)采取操作，即<sub>和</sub>。 ![](img/14853_09_004.png)可以是离散的或连续的。
-*   环境使用状态转换动力学![](img/14853_09_005.png)转换为新状态，即 <sub>t</sub> <sub>+1</sub> 。 下一个状态仅取决于当前状态和操作。 代理不知道![](img/14853_09_006.png)。
-*   代理使用奖励函数接收标量奖励，r <sub>t</sub> <sub>+1</sub> =`R`（s <sub>t</sub> ， <sub>t</sub> ），以及![](img/14853_09_007.png)。 奖励仅取决于当前状态和操作。 代理不知道![](img/14853_09_008.png)。
+*   环境使用状态转换动力学![](img/14853_09_005.png)转换为新状态，`$1[$2]`<sub>+1</sub> 。 下一个状态仅取决于当前状态和操作。 代理不知道![](img/14853_09_006.png)。
+*   代理使用奖励函数接收标量奖励，`r[t]`<sub>+1</sub> =`R`（`s[t]`， <sub>t</sub> ），以及![](img/14853_09_007.png)。 奖励仅取决于当前状态和操作。 代理不知道![](img/14853_09_008.png)。
 *   将来的奖励折现为![](img/14853_09_009.png)，其中![](img/14853_09_010.png)和`k`是未来的时间步长。
 *   *地平线*，`H`是完成从[ <sub>0</sub> 到 s <sub>T 的一集所需的时间步长`T`</sub> 。

 该环境可以是完全或部分可观察的。 后者也称为**部分可观察的 MDP** 或 **POMDP** 。 在大多数情况下，完全观察环境是不现实的。 为了提高的可观察性，当前的观测值也考虑了过去的观测值。 状态包括对环境的足够观察，以使政策决定采取哪种措施。 回忆图 9.1.1 的*，这可能是汽水罐相对于机器人抓手的三维位置，如机器人摄像头所估计的那样。*

-每当环境转换到新状态时，代理都会收到标量奖励 r <sub>t</sub> <sub>+1</sub> 。 在“图 9.1.1”中，每当机器人靠近汽水罐时，奖励可能为+1；当机器人离汽水罐更远时，奖励为-1；当机器人关闭夹具并成功捡起苏打时，奖励为+100。 能够。 代理的目标是学习一种最佳策略![](img/14853_09_011.png)，该策略可使所有状态的收益最大化：
+每当环境转换到新状态时，代理都会收到标量奖励`r[t]`<sub>+1</sub> 。 在“图 9.1.1”中，每当机器人靠近汽水罐时，奖励可能为+1；当机器人离汽水罐更远时，奖励为-1；当机器人关闭夹具并成功捡起苏打时，奖励为+100。 能够。 代理的目标是学习一种最佳策略![](img/14853_09_011.png)，该策略可使所有状态的收益最大化：

 ![](img/14853_09_012.png) (Equation 9.1.1)

@@ -64,7 +64,7 @@ RL 已经存在了几十年。 但是，除了简单的世界模型之外，RL 

 ![](img/14853_09_023.png) (Equation 9.1.4)

-如果 MDP 是偶发的，则当代理到达终端状态 s <sub>T</sub> 时，状态将重置为 s <sub>0</sub> 。 如果`T`是有限的，则我们的水平范围是有限的。 否则，视野是无限的。 在“图 9.1.1”中，如果 MDP 是情景*情节*，则在收集苏打罐后，机器人可能会寻找另一个苏打罐来拾取，并且 RL 问题重发。
+如果 MDP 是偶发的，则当代理到达终端状态`s[T]`时，状态将重置为`s[0]`。 如果`T`是有限的，则我们的水平范围是有限的。 否则，视野是无限的。 在“图 9.1.1”中，如果 MDP 是情景*情节*，则在收集苏打罐后，机器人可能会寻找另一个苏打罐来拾取，并且 RL 问题重发。

 因此，RL 的主要目标是找到一种使每个州的价值最大化的政策。 在下一部分中，我们将介绍可用于最大化价值函数的策略学习算法。


--- a/new/adv-dl-tf2-keras/11.md
+++ b/new/adv-dl-tf2-keras/11.md
@@ -284,7 +284,7 @@ def centroid2minmax(boxes):

 ![](img/B14853_11_08.png)

-图 11.3.1 IoU 等于 Left）相交区域除以 Right）候选锚点框 A <sub>1</sub> 与对象边界框 B <sub>0</sub> 之间的并集面积 ]。
+图 11.3.1 IoU 等于 Left）相交区域除以 Right）候选锚点框`A[1]`与对象边界框`B[0]`之间的并集面积 ]。

 我们删除了该等式的下标。 对于给定的对象边界框`B[i]`，对于所有锚点框`A[j]`，地面真值锚点框[`A`<sub>j（gt）</sub>是具有最大 IoU 的一个：

@@ -716,7 +716,7 @@ def focal_loss_categorical(y_true, y_pred):

 在基础网络之后可以应用其他特征提取模块。 每个特征提取器块都是`Conv2D(strides=2)-BN-ELU`的形式。 在特征提取块之后，特征图的大小减半，并且过滤器的数量增加一倍。 例如，基本网络之后的第一个特征提取器块具有 20 x 15 x 2`n`<sub>过滤器</sub>特征图。 根据该特征图，使用卷积层进行`n[2]`类和`n[2]`偏移量预测。`n[2]`= 20 x 15 x 4 = 1,200

-可以继续添加具有类和偏移量预测变量的特征提取块的过程。 在前面的部分中，对于 640 x 480 的图像，最大可达 2 x 1 x 2 <sup>5</sup>`n`<sub>滤镜</sub>特征图产生`n[6]`类和`n[6]`抵消了其中 n <sub>6</sub> = 2 x 1 x 4 = 8 的预测。 ]到 6 层特征提取和预测块。 在第 6 <sup>个</sup>块之后，一个 640 x 480 图像的锚点地图预测总数为 9,648。
+可以继续添加具有类和偏移量预测变量的特征提取块的过程。 在前面的部分中，对于 640 x 480 的图像，最大可达 2 x 1 x 2 <sup>5</sup>`n`<sub>滤镜</sub>特征图产生`n[6]`类和`n[6]`抵消了其中`n[6]`= 2 x 1 x 4 = 8 的预测。 ]到 6 层特征提取和预测块。 在第 6 <sup>个</sup>块之后，一个 640 x 480 图像的锚点地图预测总数为 9,648。

 在前面的部分中，锚定框的比例因子大小按降序排列：


--- a/new/handson-ai-gcp/03.md
+++ b/new/handson-ai-gcp/03.md
@@ -254,7 +254,7 @@ def predict_json(project, model, instances, version=None):

 ![](img/e6c8acfb-13ae-4537-88c1-af8c800b0746.png)

-在此用户项目矩阵中，行代表用户，每一列都是项目，每个单元格都是用户评分。 共有 j + 1 个用户和 n + 1 个项目。 在此， *<sub>jn</sub>* 是 *i <sub>n</sub>* 的用户 *u <sub>j</sub>* 分数。 *A <sub>jn</sub>* 可以在 1 到 5 之间。有时，如果矩阵是用户 *u <sub>i</sub>* 是否看着对象[HTG20 无论是否 <sub>j</sub> ， *A <sub>jn</sub>* 也可以是二进制的。 在这种情况下， *A <sub>jn</sub>* 为 0 或 1。在我们的情况下，我们将 *A <sub>jn</sub>* 视为 1 到 5 分 。 该矩阵是非常稀疏的矩阵，这意味着其中的许多单元都是空的。
+在此用户项目矩阵中，行代表用户，每一列都是项目，每个单元格都是用户评分。 共有 j + 1 个用户和 n + 1 个项目。 在此， *<sub>jn</sub>* 是 *`i[n]`* 的用户 *`u[j]`* 分数。 *A <sub>jn</sub>* 可以在 1 到 5 之间。有时，如果矩阵是用户 *`u[i]`* 是否看着对象[HTG20 无论是`i[n]`， *A <sub>jn</sub>* 也可以是二进制的。 在这种情况下， *A <sub>jn</sub>* 为 0 或 1。在我们的情况下，我们将 *A <sub>jn</sub>* 视为 1 到 5 分 。 该矩阵是非常稀疏的矩阵，这意味着其中的许多单元都是空的。

 由于项目很多，因此单个用户不可能对所有项目进行评分。 在实际情况下，单个用户甚至不会给最低的项目评分。 这就是为什么此矩阵中约有 99％的单元空着。 空单元格可以表示为**而不是数字**（**NaN**）。 例如，假设 n 为 1000 万，m 为 20,000。 因此 n * m 为 20 ^ 10M，这是一个非常大的数字。 如果用户平均给 5 项评分，则评分总数为 5 * 1 千万= 5 *10⁶。 这被称为矩阵的**的** **奇偶性。 矩阵稀疏度的公式如下：


--- a/new/handson-dl-arch-py/1.md
+++ b/new/handson-dl-arch-py/1.md
@@ -114,7 +114,7 @@ ANN 由两个组件构建：节点和权重。 节点扮演神经元的角色，

 圆圈表示将标量`x`作为输入并在将其与权重`w`相乘后输出`a`的神经元。 在此，将`b`称为偏置。 在方程式中增加了偏置，以提供针对特定输入范围移动输出的功能。 一旦我们通过激活函数，偏见的作用将变得更加清晰。

-现在，假设神经元不仅接受单个标量输入，还接受多个输入。 输入可以称为向量（例如`P`）。 然后，`P`可以写成一组标量输入 *p <sub>1</sub>* <sub>，</sub>`p`<sub>`2`</sub> <sub>，</sub>`p`<sub>`3`，</sub> ....， *p <sub>n</sub>* 和每个输入也将具有权重向量（例如 *W = w <sub>1，</sub> w <sub>2，</sub> w <sub>3，</sub> [ <sub>...</sub> w <sub>n</sub>* ），这将用于激活神经元。 以下矩阵代表`P`和`W`向量：
+现在，假设神经元不仅接受单个标量输入，还接受多个输入。 输入可以称为向量（例如`P`）。 然后，`P`可以写成一组标量输入 *`p[1]`* <sub>，</sub>`p`<sub>`2`</sub> <sub>，</sub>`p`<sub>`3`，</sub> ....， *`p[n]`* 和每个输入也将具有权重向量（例如 *W = w <sub>1，</sub> w <sub>2，</sub> w <sub>3，</sub> [ <sub>...</sub>`w[n]`* ），这将用于激活神经元。 以下矩阵代表`P`和`W`向量：

 ![](img/1f5224a5-58e7-4b78-a07c-2db3e3dab03e.png) ![](img/9bdc844e-2c5f-4fcf-a8b2-0ae365befe92.png)


--- a/new/handson-dl-arch-py/2.md
+++ b/new/handson-dl-arch-py/2.md
@@ -57,7 +57,7 @@ DFN 中存在的权重值负责进行预测。 任何深度网络都具有如此

 # 均方误差（MSE）

-让我们假设我们的数据集中有`n`个样本。 这意味着我们将具有`n`个预测值（ *y <sub>1，...，</sub> y <sub>i，...，</sub> y <sub>n</sub>* ）和`n`对应的期望值（![](img/e653a15c-2e34-4100-aac3-504f856cb54f.png)）。 均方由以下公式定义：
+让我们假设我们的数据集中有`n`个样本。 这意味着我们将具有`n`个预测值（ *y <sub>1，...，</sub> y <sub>i，...，</sub>`y[n]`* ）和`n`对应的期望值（![](img/e653a15c-2e34-4100-aac3-504f856cb54f.png)）。 均方由以下公式定义：

 ![](img/2adae1ac-d004-4f9c-8400-7ca5f53fbdb2.png)

@@ -111,7 +111,7 @@ DFN 中存在的权重值负责进行预测。 任何深度网络都具有如此

 # 批次梯度下降

-让我们说 *w <sub>新</sub>* 是一批梯度下降之后经过更新的权重集合，而`w`是旧的权重集合。 权重根据以下规则进行更新：
+让我们说 *`$1[$2]`* 是一批梯度下降之后经过更新的权重集合，而`w`是旧的权重集合。 权重根据以下规则进行更新：

 ![](img/1bcc1e26-889f-410e-a2c0-2eba6ca9e647.png)

@@ -147,7 +147,7 @@ DFN 中存在的权重值负责进行预测。 任何深度网络都具有如此

 类似地，链规则可以扩展为`n`具有互变量的不同函数。

-在转到该算法之前，我们将看到将要使用的符号。 *w <sub>jk</sub>* <sup>`l`</sup> 将用来表示从`k`<sup>*th 起的重量连接 *（l-1）<sup>第</sup>* 层的*</sup> 神经元与`j`<sup>*th* 神经元`1`<sup>*第*</sup> 层。 对于偏差， *b <sub>j</sub>* <sup>`l`</sup> 将用于 *j <sup>th</sup>* 神经元`l`<sup>*第*</sup> 层。 对于激活功能， *a <sub>j</sub>* <sup>`l`</sup> 用于表示 *j <sup>th</sup>* 的激活`l`<sup>*th*</sup> 层中的神经元。 该符号易于理解。 上标表示层数，而下标表示层的神经元。</sup>
+在转到该算法之前，我们将看到将要使用的符号。 *w <sub>jk</sub>* <sup>`l`</sup> 将用来表示从`k`<sup>*th 起的重量连接 *（l-1）<sup>第</sup>* 层的*</sup> 神经元与`j`<sup>*th* 神经元`1`<sup>*第*</sup> 层。 对于偏差， *`b[j]`* <sup>`l`</sup> 将用于 *j <sup>th</sup>* 神经元`l`<sup>*第*</sup> 层。 对于激活功能， *`a[j]`* <sup>`l`</sup> 用于表示 *j <sup>th</sup>* 的激活`l`<sup>*th*</sup> 层中的神经元。 该符号易于理解。 上标表示层数，而下标表示层的神经元。</sup>

 对于`l`<sup>*th*</sup> 层，输出可以用以下等式表示，其中 *l <sup>th</sup> 的输入*层是*（l-1）* <sup>*th*</sup> 层的激活输出， *a <sup>l-1</sup> = ![](img/7193fa37-d0bd-4671-a38c-beafba0cc8a7.png)（z <sup>l-1</sup> ），* ![](img/2090cbcb-7542-4c6c-a5da-11b0ead2b874.png)代表激活功能：


--- a/new/handson-dl-arch-py/3.md
+++ b/new/handson-dl-arch-py/3.md
@@ -28,7 +28,7 @@ RBM 是一种生成型随机神经网络。 通过说生成式，它表明网络

 ![](img/7e117abf-04cc-407c-b57b-1683118b2ea8.png)

-通常，RBM 由一个输入层组成，该输入层通常称为可见层（**v <sub>1</sub>** ， **v2** ， **v3** ， **v4** 和一个隐藏层（**h <sub>1</sub>** ， **h2** ，`h`[HTG18 例如，] 3 ，`h``4`。 RBM 模型由与可见层和隐藏层之间的连接相关的权重 *W = {* ![](img/c025997f-d7cf-4dd4-af22-951256ebeee8.png) *}* 以及偏差 *a = [ ![](img/48726e5d-90ac-4c3b-be13-9f3ddfe1db4c.png)* 用于可见层，偏置 *b = ![](img/1a0d6ec3-c9b8-41fc-bbf5-f0e6aa8a39a5.png)* 用于隐藏层。
+通常，RBM 由一个输入层组成，该输入层通常称为可见层（**`v[1]`** ， **v2** ， **v3** ， **v4** 和一个隐藏层（**`h[1]`** ， **h2** ，`h`[HTG18 例如，] 3 ，`h``4`。 RBM 模型由与可见层和隐藏层之间的连接相关的权重 *W = {* ![](img/c025997f-d7cf-4dd4-af22-951256ebeee8.png) *}* 以及偏差 *a = [ ![](img/48726e5d-90ac-4c3b-be13-9f3ddfe1db4c.png)* 用于可见层，偏置 *b = ![](img/1a0d6ec3-c9b8-41fc-bbf5-f0e6aa8a39a5.png)* 用于隐藏层。

 RBM 中显然没有输出层，因此学习与前馈网络中的学习有很大不同，如下所示：

@@ -205,7 +205,7 @@ DBN 也有许多有趣的应用程序，例如：
 ...     return tf.cast(distribution.sample(), tf.float32)
 ```

-现在我们能够计算吉布斯采样前后的可见输入和条件概率 *P（h | v）*，我们可以计算梯度，包括![](img/672584aa-4b9b-4feb-9717-4b072ab2f22a.png) *，Δa= v <sub>0</sub> -v <sub> k </sub>* 和*Δb= P（h | v <sup>（0）</sup>）-P（h | v <sup>（k）</sup> ）*，如下所示：
+现在我们能够计算吉布斯采样前后的可见输入和条件概率 *P（h | v）*，我们可以计算梯度，包括![](img/672584aa-4b9b-4feb-9717-4b072ab2f22a.png) *，Δa=`v[0]`-v <sub> k </sub>* 和*Δb= P（h | v <sup>（0）</sup>）-P（h | v <sup>（k）</sup> ）*，如下所示：

 ```py
 >>> def _compute_gradients(self, v0, prob_h_v0, vk, prob_h_vk):
@@ -1194,7 +1194,7 @@ DAE 通常用于神经网络预训练，其中提取的鲁棒表示形式用作

 # 压缩自编码器

-我们将学习的最后一种自编码器是压缩自编码器。 它们与稀疏兄弟相似，因为它们增加了惩罚项以学习更强大的表示形式。 但是，惩罚项更为复杂，可以如下推导，其中 *h <sub>j</sub>* 是 *j <sup>th</sup>* 单位 隐藏层的输出，`W`是编码器的权重， *W <sub>ij</sub>* 是连接 *i <sup>th</sup> 的权重* 输入单元，以及 *j <sup>th</sup>* 隐藏单元：
+我们将学习的最后一种自编码器是压缩自编码器。 它们与稀疏兄弟相似，因为它们增加了惩罚项以学习更强大的表示形式。 但是，惩罚项更为复杂，可以如下推导，其中 *`h[j]`* 是 *j <sup>th</sup>* 单位 隐藏层的输出，`W`是编码器的权重， *W <sub>ij</sub>* 是连接 *i <sup>th</sup> 的权重* 输入单元，以及 *j <sup>th</sup>* 隐藏单元：

 ![](img/3819616b-4468-43f3-b392-72d7523ae417.png)


--- a/new/handson-dl-arch-py/4.md
+++ b/new/handson-dl-arch-py/4.md
@@ -598,7 +598,7 @@ YOLO 中使用的损失函数可分为四个部分：

 图片出自原始论文，“您只看一次”：统一的实时对象检测

-损失函数中的第一项采用所有`B`边界框预测变量的边界框位置差的平方和。 第二项的功能相同，但宽度和高度相同。 您会注意到额外的平方根。 这组作者说，大边界框中的小偏差比小边界框中的小偏差要小。 对术语进行平方根运算有助于我们降低对较大值的敏感度。 我们还预测了置信度分数 *C <sub>i</sub>* ，以及边界框（预测边界框时模型的置信度）。 损失函数中的第三项与置信度得分有关。 损失函数中的最后一项是关于将对象分类为不同类别的。
+损失函数中的第一项采用所有`B`边界框预测变量的边界框位置差的平方和。 第二项的功能相同，但宽度和高度相同。 您会注意到额外的平方根。 这组作者说，大边界框中的小偏差比小边界框中的小偏差要小。 对术语进行平方根运算有助于我们降低对较大值的敏感度。 我们还预测了置信度分数 *`C[i]`* ，以及边界框（预测边界框时模型的置信度）。 损失函数中的第三项与置信度得分有关。 损失函数中的最后一项是关于将对象分类为不同类别的。

 尽管 YOLO 极大地简化了对象检测体系结构并能够实时进行预测，但是也存在某些缺点。 该模型不会提取不同比例的特征，因此对于不同大小和比例的对象不具有鲁棒性。 该模型还难以检测组合在一起的较小尺寸的对象。 接下来，我们将研究另一种基于回归的对象检测架构，即**单发多框检测器**（**SSD**），该架构可弥补 YOLO 的缺点。

@@ -621,7 +621,7 @@ YOLO 中使用的损失函数可分为四个部分：

 第一个特征图集是从 VGG 16 体系结构的第 23 层提取的，大小为 38 x 38 x 512（此处 512 是过滤器的深度或数量）。 第二组要素图的大小为 19 x 19 x 1,024，适用于捕获稍大的对象。 进一步的特征图集将尺寸减小到 10 x 10 x 512、5 x 5 x 256、3 x 3 x 256，最后减小到 1 x 1 x 256。

-为了进行预测，SSD 在提取的特征图上使用 3 x 3 x`d`（`d`表示过滤器的深度）卷积内核。 对于特征图上的每个点，3 x 3 内核输出边界框偏移量和类分数。 SSD 为功能图中的每个点分配了默认框。 3 x 3 卷积的工作是从覆盖对象的默认边界框预测四个偏移值。 除偏移量外，它还可以预测类别的`c`类别分数。 如果我们在每个位置都有`m`x`n`尺寸特征图，并且在每个位置都有`k`默认边界框，则从该层做出的预测总数将为*（c + 4）xkxmxn* 。 每个位置的默认框数通常为 4 到 6。 这些默认边界框的比例和大小由网络中最低和最高要素图的比例决定。 假设我们有`m`个特征图； 然后，默认边界框的比例（ *s <sub>k</sub>* ）由以下公式给出：
+为了进行预测，SSD 在提取的特征图上使用 3 x 3 x`d`（`d`表示过滤器的深度）卷积内核。 对于特征图上的每个点，3 x 3 内核输出边界框偏移量和类分数。 SSD 为功能图中的每个点分配了默认框。 3 x 3 卷积的工作是从覆盖对象的默认边界框预测四个偏移值。 除偏移量外，它还可以预测类别的`c`类别分数。 如果我们在每个位置都有`m`x`n`尺寸特征图，并且在每个位置都有`k`默认边界框，则从该层做出的预测总数将为*（c + 4）xkxmxn* 。 每个位置的默认框数通常为 4 到 6。 这些默认边界框的比例和大小由网络中最低和最高要素图的比例决定。 假设我们有`m`个特征图； 然后，默认边界框的比例（ *`s[k]`* ）由以下公式给出：

 ![](img/93c36209-1288-4964-b35e-b1a8b03d31fa.png)


--- a/new/handson-dl-arch-py/6.md
+++ b/new/handson-dl-arch-py/6.md
@@ -620,14 +620,14 @@ DJIA 由 30 只大型和重要股票（例如 Apple，IBM，GE 和 Goldman Sachs

 接下来，我们需要从原始时间序列构造顺序输入，以便提供 RNN 模型，这与我们在文本生成中所做的类似。 回想一下，在“多对一”架构中，该模型采用一个序列，并经过序列中的所有时间步长后产生一个输出。 在我们的案例中，我们可以将过去`T`天的价格序列提供给 RNN 模型，并输出第二天的价格。

-将价格时间序列表示为 *x <sub>1</sub> ，x <sub>2</sub> 。 。 。 。，x <sub>n</sub>* （N = 4276），并以`T`= 5 为例。 通过这样做，我们可以创建训练样本，如下所示：
+将价格时间序列表示为 *`x[1]`，`x[2]`。 。 。 。，`x[n]`* （N = 4276），并以`T`= 5 为例。 通过这样做，我们可以创建训练样本，如下所示：

 | **输入** | **输出** |
-| *{x <sub>1</sub> ，x <sub>2</sub> ，x <sub>3</sub> ，x <sub>4</sub> ，x <sub>5</sub> }* | *x <sub>6</sub>* |
-| *{x <sub>2</sub> ，x <sub>3</sub> ，x <sub>4</sub> ，x <sub>5</sub> ，x <sub>6</sub> }* | *x <sub>7</sub>* |
-| *{x <sub>3</sub> ，x <sub>4</sub> ，x <sub>5</sub> ，x <sub>6</sub> ，x <sub>7</sub> }* | *x <sub>8</sub>* |
+| *{`x[1]`，`x[2]`，`x[3]`，`x[4]`，`x[5]`}* | *`x[6]`* |
+| *{`x[2]`，`x[3]`，`x[4]`，`x[5]`，`x[6]`}* | *`x[7]`* |
+| *{`x[3]`，`x[4]`，`x[5]`，`x[6]`，`x[7]`}* | *`x[8]`* |
 | ...... | ... |
-| *{x <sub>n-1</sub> ，x <sub>N-4</sub> ，x <sub>N-3</sub> ，x <sub>N-2</sub> ，x <sub>N-1</sub> }* | *x <sub>n</sub>* |
+| *{x <sub>n-1</sub> ，x <sub>N-4</sub> ，x <sub>N-3</sub> ，x <sub>N-2</sub> ，x <sub>N-1</sub> }* | *`x[n]`* |

 在这里，我们通过回顾前 5 个交易日（一周）来预测第二天的价格。 我们还在网络中对其进行了描述：


--- a/new/handson-dl-arch-py/8.md
+++ b/new/handson-dl-arch-py/8.md
@@ -39,7 +39,7 @@

 在我们的常规深度学习模型中，包括权重 *`w`* 和偏差 *`b`* 的参数是通过**最大似然估计**优化的 （**MLE**）：

-*w = argmax <sub>w</sub> logP（x，y | w）*
+*w = argma`x[w]`logP（x，y | w）*

 训练模型后，参数的每个系数（例如![](img/70cea0c9-e117-425b-b461-abf4d08ab1d1.png)）都是标量，例如 *w <sub> 1 </sub> = 1* ， *w <sub> 2 </sub> = 3* 。

@@ -51,7 +51,7 @@

 估计参数的分布等效于参数的最大后验估计（MAP）：

-*w = argmax <sub>w</sub> logP（w | x，y）*
+*w = argma`x[w]`logP（w | x，y）*

 根据贝叶斯规则，可以如下计算`P`（ *w | x，y* ）：


--- a/new/master-cv-tf-2x/10.md
+++ b/new/master-cv-tf-2x/10.md
@@ -650,9 +650,9 @@ Luca Bertinetto，Jack Valmadre，Joao F. Henriques，Andrea Vedaldi 和 Philip

 ![](img/c5197e16-6f1d-47e0-875c-e2e789f29750.png)

-在该图中，网络的输出是功能图。 通过 CNN（ *f <sub>θ</sub>* ）重复该过程两次，一次分别进行测试（`x`）和训练（`z`）。 图像，生成两个相互关联的特征图，如下所示：
+在该图中，网络的输出是功能图。 通过 CNN（ *`$1[$2]`* ）重复该过程两次，一次分别进行测试（`x`）和训练（`z`）。 图像，生成两个相互关联的特征图，如下所示：

-*g <sub>θ</sub>（z，x）= f <sub>θ</sub>（z）* f <sub>θ</sub>（x）*
+*`$1[$2]`（z，x）=`$1[$2]`（z）*`$1[$2]`（x）*

 跟踪开始如下：


--- a/new/master-cv-tf-2x/2.md
+++ b/new/master-cv-tf-2x/2.md
@@ -20,9 +20,9 @@ LBP 是一种灰度图像阈值操作，用于基于不同的模式对图像进
 LBP 模式生成的主要步骤如下：

 1.  将 RGB 图像 A 转换为灰度图像 G。
-2.  对于图像 G 中每个具有强度 I <sub>c</sub> （x，y）的像素，选择`P`相邻点（p <sub>0</sub> ，p <sub>1</sub> .. p <sub>P-1</sub> ），其半径[I <sub>0</sub> ，I <sub>1</sub> .. I <sub>P-1</sub> ）具有相应的强度。`R`。 半径以像素为单位定义为两个像素之间的差。 像素和相邻点代表图像 G 的滑动窗口 W。对于半径 R = 1，P 变为 8，如下所示。
+2.  对于图像 G 中每个具有强度`I[c]`（x，y）的像素，选择`P`相邻点（`p[0]`，`p[1]`.. p <sub>P-1</sub> ），其半径[`I[0]`，`I[1]`.. I <sub>P-1</sub> ）具有相应的强度。`R`。 半径以像素为单位定义为两个像素之间的差。 像素和相邻点代表图像 G 的滑动窗口 W。对于半径 R = 1，P 变为 8，如下所示。

-滑动窗口 W <sub>0</sub> 用![](img/da8626a4-00d9-4c10-8f2c-bc2209a48071.png)表示为数组。 在这里，点 0 到 P-1 代表围绕中心像素 c 的 P 个点的强度：
+滑动窗口`W[0]`用![](img/da8626a4-00d9-4c10-8f2c-bc2209a48071.png)表示为数组。 在这里，点 0 到 P-1 代表围绕中心像素 c 的 P 个点的强度：

 ![](img/3c396842-2d8a-4e8d-a972-a44ad6f954ae.png)

@@ -32,7 +32,7 @@ LBP 模式生成的主要步骤如下：

 3.  计算相邻像素和中心像素之间的强度差，并删除第一个值 0。该数组可以表示如下：

-*W <sub>1</sub> 〜[I <sub>0</sub> -I <sub>c</sub> ，I <sub>1</sub> -I <sub>c</sub> ，。 .I <sub>P-1</sub> -I <sub>c</sub> ]*
+*`W[1]`〜[`I[0]`-`I[c]`，`I[1]`-`I[c]`，。 .I <sub>P-1</sub> -`I[c]`]*

 4.  现在，对图像进行阈值处理。 为此，如果强度差小于 0，则将值分配为 0；如果强度差大于 0，则将值分配为 1，如以下等式所示：

@@ -40,13 +40,13 @@ LBP 模式生成的主要步骤如下：

 应用阈值函数`f`之后的差数组如下：

-*W <sub>2</sub> = [f（I <sub>0</sub> -I <sub>c</sub> ），f（I <sub>1</sub> -I <sub>c</sub> ），.. f（I <sub>P-1</sub> -I <sub>c</sub> ）*
+*`W[2]`= [f（`I[0]`-`I[c]`），f（`I[1]`-`I[c]`），.. f（I <sub>P-1</sub> -`I[c]`）*

 例如，假设第一个差异小于 0 且第二个和最后一个差异大于 0，则数组可以表示如下：

-*W <sub>2</sub> = [0，1，... 1]*
+*`W[2]`= [0，1，... 1]*

-5.  将差数组 W <sub>2</sub> 乘以二项式权重 2 <sup>p</sup> ，将二进制数组 W <sub>2</sub> 转换为表示十进制数组 W <sub>的 LBP 代码 ] 3：</sub>
+5.  将差数组`W[2]`乘以二项式权重 2 <sup>p</sup> ，将二进制数组`W[2]`转换为表示十进制数组 W <sub>的 LBP 代码 ] 3：</sub>

 ![](img/671d8a02-d3ae-47a5-9bcf-4d71d14e6201.png)

@@ -67,11 +67,11 @@ LBP 模式生成的主要步骤如下：

 # 了解 LBP 直方图

-LBP 阵列 W <sub>3</sub> 以直方图形式表示如下：
+LBP 阵列`W[3]`以直方图形式表示如下：

-*W <sub>4</sub> =直方图（W <sub>3</sub> ，bins = P，范围= W <sub>3</sub> （min）至 W <sub>3</sub> （ max））*
+*`W[4]`=直方图（`W[3]`，bins = P，范围=`W[3]`（min）至`W[3]`（ max））*

-*对训练后的图像和测试图像重复上一节中的步骤 1* 至`5`，以创建图像的 LBP 直方图（W <sub>列</sub>，W [HTG6 测试），每个都包含 P 个 bin，然后使用直方图比较方法对其进行比较。
+*对训练后的图像和测试图像重复上一节中的步骤 1* 至`5`，以创建图像的 LBP 直方图（`$1[$2]`，W [HTG6 测试），每个都包含 P 个 bin，然后使用直方图比较方法对其进行比较。

 # 直方图比较方法


--- a/new/master-cv-tf-2x/3.md
+++ b/new/master-cv-tf-2x/3.md
@@ -68,15 +68,15 @@ Haar 级联分类器算法基于这样的思想，即人脸的图像在脸部的

 ![](img/df105f20-916c-4f3f-806e-543e3028a89a.png)

-*   **强分类器**：最终的强分类器`h`（`x`）具有最小的错误， *E <sub>t</sub>* ，并由以下给出：
+*   **强分类器**：最终的强分类器`h`（`x`）具有最小的错误， *`E[t]`* ，并由以下给出：

 ![](img/9f117f11-bcad-449e-acf3-dff0ebdb8ca3.png)

-在此，*α <sub>t</sub>* = log（ *1 /β <sub>t</sub>* ）和*β <sub>t</sub>* = *E <sub>t</sub>* /（`1`- *E <sub>t</sub>* ）：
+在此，*`E[t]`* = log（ *1 /`E[t]`* ）和*`E[t]`* = *`E[t]`* /（`1`- *`E[t]`* ）：

 ![](img/8a29038f-21d3-4a3e-8bd2-e6308d0fddb0.png)

-权重*（W <sub>t</sub> ）*初始化如下：
+权重*（`W[t]`）*初始化如下：

 ![](img/470d13b0-b7f2-4b31-8a67-1145f8bda64a.png)


--- a/new/master-cv-tf-2x/4.md
+++ b/new/master-cv-tf-2x/4.md
@@ -66,7 +66,7 @@ CNN 的图像过滤和处理方法包括执行多种操作，所有这些操作

 ![](img/fc5f1a96-b2c9-4318-8352-a2daea8a7234.png)

-上图显示了如何使用 3 x 3 过滤器（边缘检测器）在宽度减小和深度增加（从 3 到 32）方面转换 7 x 7 图像的图形的一部分。 内核（ *f <sub>i</sub>* ）中 27 个（3 x 3 x 3）单元中的每一个都乘以输入（ *A <sub>i</sub>* ）。 然后，将这些值与**整流线性单位**（**ReLU**）激活函数（ *b <sub>i</sub>* ）相加在一起 单个元素（`Z`），如以下等式所示：
+上图显示了如何使用 3 x 3 过滤器（边缘检测器）在宽度减小和深度增加（从 3 到 32）方面转换 7 x 7 图像的图形的一部分。 内核（ *`f[i]`* ）中 27 个（3 x 3 x 3）单元中的每一个都乘以输入（ *`A[i]`* ）。 然后，将这些值与**整流线性单位**（**ReLU**）激活函数（ *`b[i]`* ）相加在一起 单个元素（`Z`），如以下等式所示：

 ![](img/f7b861f9-ab93-4a27-aecc-567fe346bf5e.png)

@@ -220,12 +220,12 @@ Softmax 是在 CNN 的最后一层中使用的激活功能。 它由以下等式
 CNN 具有许多不同的参数。 训练 CNN 模型需要许多输入图像并执行处理，这可能非常耗时。 如果选择的参数不是最佳参数，则必须再次重复整个过程。 这就是为什么理解每个参数的功能及其相互关系很重要的原因：这样可以在运行 CNN 之前优化其值，以最大程度地减少重复运行。 CNN 的参数如下：

 *   图像尺寸=（ *n x n* ）
-*   滤镜= *（f <sub>h</sub> ，f <sub>w</sub> ），f <sub>h</sub>* =应用于图像高度的滤镜， *f <sub>w</sub>* =应用于图像宽度的滤镜
-*   过滤器数量= *n <sub>f</sub>*
+*   滤镜= *（`f[h]`，`f[w]`），`f[h]`* =应用于图像高度的滤镜， *`f[w]`* =应用于图像宽度的滤镜
+*   过滤器数量= *`n[f]`*
 *   填充=`p`
 *   步幅=`s`
 *   输出大小 *=* *{（n + 2p-f）/ s +1} x {（n + 2p-f）/ s +1}*
-*   参数数量 *=* *（f <sub>h</sub> x f <sub>w</sub> + 1）x n <sub>f</sub>*
+*   参数数量 *=* *（`f[h]`x`f[w]`+ 1）x`n[f]`*

 关键任务是选择上述参数（滤波器大小（`f`），滤波器数量（**nf**），步幅（`s`），填充 CNN 每一层的值（`p`），激活（`a`）和偏差。 下表显示了各种 CNN 参数的功能图：


--- a/new/master-cv-tf-2x/5.md
+++ b/new/master-cv-tf-2x/5.md
@@ -562,7 +562,7 @@ GNN 层汇总了来自其邻居的特征信息，并应用 ReLU 激活，合并

 ![](img/f78efdeb-68ff-4fc8-8d52-7f73d20f4c20.png)

-代理以某种状态（ *s <sub>t</sub>* ）启动，观察一系列观察结果，采取行动（ *a <sub>t</sub>* ）并接收 一份奖励。
+代理以某种状态（ *`s[t]`* ）启动，观察一系列观察结果，采取行动（ *`a[t]`* ）并接收 一份奖励。

 最大化以下累积值函数，以在`Q`-学习方法中找到所需的输出：


--- a/new/master-cv-tf-2x/8.md
+++ b/new/master-cv-tf-2x/8.md
@@ -214,7 +214,7 @@ cv.destroyAllWindows()
    5.  VGG19 中的卷积层具有特征提取功能，而全连接层执行分类任务。 如果没有顶层，则网络将仅具有顶层五个卷积层。 从前面的章节中我们知道，初始层传达原始图像的输入像素，而最终层捕捉图像的定义特征和图案。
    6.  这样，图像的内容就由中间特征图表示–在这种情况下，这是第五个卷积块。

-gram 矩阵是向量 G = I <sub>i</sub> <sup>T</sup> I <sub>j</sub> 的内积的矩阵。 在此，I <sub>i</sub> 和 I <sub>j</sub> 是原始图像和样式图像的特征向量。 内积代表向量的协方差，代表相关性。 这可以用样式来表示。
+gram 矩阵是向量 G =`I[i]`<sup>T</sup>`I[j]`的内积的矩阵。 在此，`I[i]`和`I[j]`是原始图像和样式图像的特征向量。 内积代表向量的协方差，代表相关性。 这可以用样式来表示。

 以下代码输入一个 VGG 模型，并从该模型中提取样式和内容层：


--- a/new/master-cv-tf-2x/9.md
+++ b/new/master-cv-tf-2x/9.md
@@ -27,7 +27,7 @@ OpenPose 是第一个针对图像或视频中的多个人的开源实时二维

 ![](img/2046a738-43a7-4f9b-9500-f98202f7a431.png)

-*   OpenPose 网络将特征图作为输入，并由 CNN 的两个阶段组成：第一阶段使用 T <sub>p</sub> 编号预测**部分相似性字段**（**PAF**） 迭代次数，而第二阶段则以 T <sub>c</sub> 迭代次数预测置信度图。 由于以下两个关键指标，2018 年提出的 OpenPose 模型是对 2017 年提出的早期模型的总体改进：
+*   OpenPose 网络将特征图作为输入，并由 CNN 的两个阶段组成：第一阶段使用`T[p]`编号预测**部分相似性字段**（**PAF**） 迭代次数，而第二阶段则以`T[c]`迭代次数预测置信度图。 由于以下两个关键指标，2018 年提出的 OpenPose 模型是对 2017 年提出的早期模型的总体改进：
 *   通过先计算 PAF，再计算置信度图，可将计算时间减少一半。 这不同于两者的同时计算以及用 3 x 3 卷积代替 7 x 7 卷积。
 *   改进的 PAF 估计（2018 年论文）通过增加神经网络的深度来改善常规 PAF（2017 年）的置信度图，从而提高了准确率。
 *   在下一阶段中，将前一阶段的预测与原始图像特征`F`合并在一起，以为图像中的所有人产生二维关键点预测。 在估计的预测，地面真实特征图和 PAF 之间的每个阶段的末尾都应用了损失函数。 重复此过程几次迭代，从而得到最新的特征图和 PAF 检测。

--- a/new/mobi-dl-tflite/07.md
+++ b/new/mobi-dl-tflite/07.md
@@ -523,11 +523,11 @@ for i in range(len(notes)-n_prev):
    y.append(notes[i+n_prev])
 ```

-我们已将其转换为一个集合，其中每个样本都带有未来的 20 个音符，并且在数据集的末尾具有过去的 20 个音符。这可以通过以下方式进行：如果我们有 5 个样本，例如 M <sub>1</sub> ，M <sub>2</sub> ，M <sub>3</sub> ，M <sub>4</sub> 和 M <sub>5</sub> ，然后我们将它们安排在 配对 2（类似于我们的 20），如下所示：
+我们已将其转换为一个集合，其中每个样本都带有未来的 20 个音符，并且在数据集的末尾具有过去的 20 个音符。这可以通过以下方式进行：如果我们有 5 个样本，例如`M[1]`，`M[2]`，`M[3]`，`M[4]`和`M[5]`，然后我们将它们安排在 配对 2（类似于我们的 20），如下所示：

-*   M <sub>1</sub> M <sub>2</sub>
-*   M <sub>2</sub> M <sub>3</sub>
-*   M <sub>3</sub> M <sub>4</sub> ，依此类推
+*  `M[1]``M[2]`
+*  `M[2]``M[3]`
+*  `M[3]``M[4]`，依此类推

 5.  现在，我们将使用 Keras 创建 LSTM 模型，如以下代码所示：