2020-12-20 19:38:28

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

@@ -407,7 +407,7 @@ CIFAR 数据集是机器学习数据集，其中包含按不同类别组织的
 
 ###### 使用看不见的数据测试网络性能
 
-在浏览器中访问[网站](http://mnist-demo.herokuapp.com/)并在 **0** 和**之间绘制一个数字 9** 在指定的白框中：
+在浏览器中访问[网站](http://mnist-demo.herokuapp.com/)并在`0`和**之间绘制一个数字 9** 在指定的白框中：
 
 ![Testing Network Performance with Unseen Data](img/image01_06.jpg)
 
@@ -417,7 +417,7 @@ CIFAR 数据集是机器学习数据集，其中包含按不同类别组织的
 
 [来源](https://github.com/ShafeenTejani/mnist-demo)。
 
-在应用程序中，您可以看到两个神经网络的结果。 我们训练过的那个在左边（称为 CNN）。 它能正确分类所有手写数字吗？ 尝试在指定区域的边缘绘制编号。 例如，尝试在该区域的右边缘附近绘制数字 **1** ：
+在应用程序中，您可以看到两个神经网络的结果。 我们训练过的那个在左边（称为 CNN）。 它能正确分类所有手写数字吗？ 尝试在指定区域的边缘绘制编号。 例如，尝试在该区域的右边缘附近绘制数字`1`：
 
 ![Testing Network Performance with Unseen Data](img/image01_07.jpg)
 
@@ -425,7 +425,7 @@ CIFAR 数据集是机器学习数据集，其中包含按不同类别组织的
 
 ### 注意
 
-在此示例中，我们看到在绘图区域的右侧绘制了数字 **1** 。 在两个网络中，此数字为 **1** 的概率为 **0** 。
+在此示例中，我们看到在绘图区域的右侧绘制了数字`1`。 在两个网络中，此数字为`1`的概率为`0`。
 
 MNIST 数据集在图像边缘不包含数字。 因此，两个网络都没有为位于该区域的像素分配相关值。 如果我们将它们拉近指定区域的中心，则这两个网络都将更好地正确分类数字。 这表明神经网络只能像用于训练它们的数据一样强大。 如果用于训练的数据与我们试图预测的数据完全不同，则该网络很可能会产生令人失望的结果。
 

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

@@ -20,7 +20,7 @@
 
 # 元学习和少拍
 
-从较少的数据点中学习称为**少镜头学习**或 **k** **-镜头学习**，其中 *k* 表示每个数据点的数量 数据集中的类。 假设我们正在对猫和狗进行图像分类。 如果我们正好有一只狗和一只猫的图像，那么它被称为**单次学习**，也就是说，我们每个班级仅从一个数据点开始学习。 如果我们有 10 张狗的图像和 10 张猫的图像，则称为 10 次学习。 因此， *k-* 镜头学习中的 *k* 意味着每个班级都有许多数据点。 还有**零击学习**，每个班级没有任何数据点。 等待。 什么？ 根本没有数据点时，我们如何学习？ 在这种情况下，我们将没有数据点，但是将获得有关每个类的元信息，并且将从元信息中学习。 由于我们的数据集中有两个类别，即狗和猫，因此可以将其称为双向学习 *k* -shot learning； 因此 *n* -way 表示我们在数据集中拥有的类的数量。
+从较少的数据点中学习称为**少镜头学习**或`k`**-镜头学习**，其中 *k* 表示每个数据点的数量 数据集中的类。 假设我们正在对猫和狗进行图像分类。 如果我们正好有一只狗和一只猫的图像，那么它被称为**单次学习**，也就是说，我们每个班级仅从一个数据点开始学习。 如果我们有 10 张狗的图像和 10 张猫的图像，则称为 10 次学习。 因此， *k-* 镜头学习中的 *k* 意味着每个班级都有许多数据点。 还有**零击学习**，每个班级没有任何数据点。 等待。 什么？ 根本没有数据点时，我们如何学习？ 在这种情况下，我们将没有数据点，但是将获得有关每个类的元信息，并且将从元信息中学习。 由于我们的数据集中有两个类别，即狗和猫，因此可以将其称为双向学习 *k* -shot learning； 因此 *n* -way 表示我们在数据集中拥有的类的数量。
 
 为了使我们的模型从一些数据点中学习，我们将以相同的方式对其进行训练。 因此，当我们有一个数据集 *D* 时，我们从数据集中存在的每个类中采样一些数据点，并将其称为**支持集。** 同样，我们从每个类中采样一些不同的数据点，并将其称为**查询集。** 因此，我们使用支持集训练模型，并使用查询集进行测试。 我们以**情节形式**训练模型-也就是说，在每个情节中，我们从数据集中 *D* 中采样一些数据点，准备支持集和查询集，然后进行训练 在支持集上并在查询集上进行测试。 因此，在一系列情节中，我们的模型将学习如何从较小的数据集中学习。 我们将在接下来的章节中对此进行更详细的探讨。
 

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

@@ -14,9 +14,9 @@
 
 连体网络是神经网络的一种特殊类型，它是最简单且使用最广泛的单发学习算法之一。 正如我们在上一章中学到的，单次学习是一种技术，其中我们每个班级仅从一个训练示例中学习。 因此，在每个类别中没有很多数据点的应用程序中主要使用连体网络。 例如，假设我们要为我们的组织建立一个人脸识别模型，并且在组织中有大约 500 个人在工作。 如果我们想从头开始使用**卷积神经网络**（ **CNN** ）建立人脸识别模型，那么我们需要这 500 人中的许多人来训练网络并获得良好的图像 准确性。 但是显然，我们不会为这 500 个人提供很多图像，因此除非有足够的数据点，否则使用 CNN 或任何深度学习算法构建模型都是不可行的。 因此，在这种情况下，我们可以求助于复杂的单次学习算法，例如连体网络，该算法可以从更少的数据点进行学习。
 
-但是，连体网络如何工作？ 连体网络基本上由两个对称的神经网络组成，它们共享相同的权重和结构，并且都使用能量函数 **E** 最终结合在一起。 我们的连体网络的目标是了解两个输入值是相似还是相异。 假设我们有两个图像 **X <sub>1</sub>** 和 **X2** ，我们想了解两个图像是相似还是相异。
+但是，连体网络如何工作？ 连体网络基本上由两个对称的神经网络组成，它们共享相同的权重和结构，并且都使用能量函数`E`最终结合在一起。 我们的连体网络的目标是了解两个输入值是相似还是相异。 假设我们有两个图像 **X <sub>1</sub>** 和`X2`，我们想了解两个图像是相似还是相异。
 
-如下图所示，我们将图像 **X <sub>1</sub>** 馈送到**网络** **A** 和图像 **X <sub>2</sub>** 到另一个**网络 B** 。 这两个网络的作用是为输入图像生成嵌入（特征向量）。 因此，我们可以使用任何可以嵌入我们的网络。 由于我们的输入是图像，因此我们可以使用卷积网络来生成嵌入，即用于提取特征。 请记住，CNN 在这里的作用仅仅是提取特征而不是进行分类。 我们知道这些网络应该具有相同的权重和架构，如果我们的**网络 A** 是三层 CNN，那么我们的**网络 B** 也应该是三层 CNN，我们 这两个网络必须使用相同的权重集。 因此，**网络 A** 和**网络 B** 将为我们提供输入图像 **X <sub>1</sub>** 和 **X <sub>的嵌入 2</sub>** 。 然后，我们会将这些嵌入信息提供给能量函数，从而告诉我们两个输入的相似程度。 能量函数基本上是任何相似性度量，例如欧几里得距离和余弦相似性。
+如下图所示，我们将图像 **X <sub>1</sub>** 馈送到**网络**`A`和图像 **X <sub>2</sub>** 到另一个**网络 B** 。 这两个网络的作用是为输入图像生成嵌入（特征向量）。 因此，我们可以使用任何可以嵌入我们的网络。 由于我们的输入是图像，因此我们可以使用卷积网络来生成嵌入，即用于提取特征。 请记住，CNN 在这里的作用仅仅是提取特征而不是进行分类。 我们知道这些网络应该具有相同的权重和架构，如果我们的**网络 A** 是三层 CNN，那么我们的**网络 B** 也应该是三层 CNN，我们 这两个网络必须使用相同的权重集。 因此，**网络 A** 和**网络 B** 将为我们提供输入图像 **X <sub>1</sub>** 和 **X <sub>的嵌入 2</sub>** 。 然后，我们会将这些嵌入信息提供给能量函数，从而告诉我们两个输入的相似程度。 能量函数基本上是任何相似性度量，例如欧几里得距离和余弦相似性。
 
 ![](img/a7f1a41e-4291-4bec-87dd-fa6bc1d0c00b.png)
 
@@ -28,13 +28,13 @@
 
 ![](img/5b9384ce-2640-4df1-8d41-f668a5da1b79.png)
 
-如上图所示，连体网络由两个相同的网络组成，它们共享相同的权重和架构。 假设我们有两个输入， **X <sub>1</sub>** 和 **X <sub>2</sub>** 。 我们将输入 **X <sub>1</sub>** 馈送到**网络 A** ，即 **f <sub>w</sub> （X <sub>1</sub> ）**，然后将输入的 **X <sub>2</sub>** 馈送到**网络 B** ，即 **f <sub>w</sub> （ X <sub>2</sub> ）**。 您会注意到，这两个网络的权重相同 **w** ，它们将为我们的输入 **X <sub>1</sub>** 和 **X 生成嵌入 <sub>2</sub>** 。 然后，我们将这些嵌入提供给能量函数 **E** ，这将使我们在两个输入之间具有相似性。
+如上图所示，连体网络由两个相同的网络组成，它们共享相同的权重和架构。 假设我们有两个输入， **X <sub>1</sub>** 和 **X <sub>2</sub>** 。 我们将输入 **X <sub>1</sub>** 馈送到**网络 A** ，即 **f <sub>w</sub> （X <sub>1</sub> ）**，然后将输入的 **X <sub>2</sub>** 馈送到**网络 B** ，即 **f <sub>w</sub> （ X <sub>2</sub> ）**。 您会注意到，这两个网络的权重相同`w`，它们将为我们的输入 **X <sub>1</sub>** 和 **X 生成嵌入 <sub>2</sub>** 。 然后，我们将这些嵌入提供给能量函数`E`，这将使我们在两个输入之间具有相似性。
 
 可以表示为：
 
 ![](img/bec7e4fe-5f04-4f09-8d62-0c2aac4e48fb.png)
 
-假设我们使用欧几里得距离作为能量函数，那么如果 **X <sub>1</sub>** 和 **X <sub>2</sub>** 相似。 如果输入值不相同，则 **E** 的值将很大。
+假设我们使用欧几里得距离作为能量函数，那么如果 **X <sub>1</sub>** 和 **X <sub>2</sub>** 相似。 如果输入值不相同，则`E`的值将很大。
 
 假设您有两个句子，句子 1 和句子 2。我们将句子 1 馈送到**网络 A** ，将句子 2 馈送到**网络 B** 。 假设我们的**网络 A** 和**网络 B** 都是 LSTM 网络，它们共享相同的权重。 因此，**网络 A** 和**网络 B** 将分别为句子 1 和句子 2 生成单词嵌入。 然后，我们将这些嵌入提供给能量函数，从而为我们提供两个句子之间的相似度得分。 但是我们如何训练我们的连体网络呢？ 数据应该如何？ 有哪些功能和标签？ 我们的目标功能是什么？
 
@@ -48,7 +48,7 @@
 
 ![](img/7aff44fc-ed83-4b1e-ba16-fc5457ef9b7d.png)
 
-在前面的公式中， **Y** 的值是真实的标签，如果两个输入值相似，则为 **1** ；如果两个输入值为 **0** 是不同的， **E** 是我们的能量函数，可以是任何距离度量。 术语**边距**用于保持约束，也就是说，当两个输入值互不相同时，并且如果它们的距离大于边距，则不会造成损失。
+在前面的公式中，`Y`的值是真实的标签，如果两个输入值相似，则为`1`；如果两个输入值为`0`是不同的，`E`是我们的能量函数，可以是任何距离度量。 术语**边距**用于保持约束，也就是说，当两个输入值互不相同时，并且如果它们的距离大于边距，则不会造成损失。
 
 # 连体网络的应用
 

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

@@ -396,7 +396,7 @@ for epoch in range(num_epochs):
 
 因此，编码器，以及为输入生成嵌入，还返回协方差矩阵。 我们使用协方差矩阵的对角线或半径分量。 同样，我们使用逆协方差矩阵代替直接使用协方差矩阵。
 
-但是将协方差矩阵与嵌入一起使用有什么用？ 如前所述，它在数据点周围添加了置信区域，在嘈杂的数据中非常有用。 看下图。 假设我们有两个类， **A** 和 **B** 。 黑点表示数据点的嵌入，黑点周围的圆圈表示协方差矩阵。 大的虚线圆表示一个类的整体协方差矩阵。 中间的星星表示类的原型。 如您所见，在嵌入周围有这个协方差矩阵，这给了我们围绕数据点和类原型的置信度区域：
+但是将协方差矩阵与嵌入一起使用有什么用？ 如前所述，它在数据点周围添加了置信区域，在嘈杂的数据中非常有用。 看下图。 假设我们有两个类，`A`和`B`。 黑点表示数据点的嵌入，黑点周围的圆圈表示协方差矩阵。 大的虚线圆表示一个类的整体协方差矩阵。 中间的星星表示类的原型。 如您所见，在嵌入周围有这个协方差矩阵，这给了我们围绕数据点和类原型的置信度区域：
 
 ![](img/298373d7-0231-43e2-b6bc-62d7b850e5c0.png)
 

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

@@ -487,7 +487,7 @@ Sampling Next Batch of Tasks
 *   ![](img/e10a87b0-5a1d-4ee6-8de6-7fc97eb299bd.png)是输入图像
 *   ![](img/474889d5-2f98-4cfb-a696-b748d045b14f.png)是相对于我们输入图像的损耗梯度
 
-如您在下图中所看到的，我们有一个输入图像 **x** ，并且通过将损失相对于我们的图像的梯度符号添加到实际图像中，我们得到了对抗图像。
+如您在下图中所看到的，我们有一个输入图像`x`，并且通过将损失相对于我们的图像的梯度符号添加到实际图像中，我们得到了对抗图像。
 
 ![](img/b7ca263c-ad08-4ec5-beda-3687f8209093.png)
 

new/handson-rl-py/03.md

@@ -273,23 +273,23 @@ MDP 由五个重要元素表示：
 
 让我们通过手动逐步执行值迭代来直观地理解它。
 
-考虑此处显示的网格。 让我们说我们处于状态 **A** ，我们的目标是在不访问状态 **B** 的情况下达到状态 **C** ，我们有两个动作，0-左/右 和 1-上/下：
+考虑此处显示的网格。 让我们说我们处于状态`A`，我们的目标是在不访问状态`B`的情况下达到状态`C`，我们有两个动作，0-左/右 和 1-上/下：
 
 ![](img/00077.gif)
 
-您能想到这里的最佳政策吗？ 此处的最佳策略是告诉我们在 **A** 状态下执行操作 1 的策略，这样我们就可以访问 **C** 而无需访问 **B** 。 我们如何找到这个最佳政策？ 现在让我们看看：
+您能想到这里的最佳政策吗？ 此处的最佳策略是告诉我们在`A`状态下执行操作 1 的策略，这样我们就可以访问`C`而无需访问`B`。 我们如何找到这个最佳政策？ 现在让我们看看：
 
-初始化随机值函数，即所有状态的随机值。 让我们将 **0** 分配给所有状态：
+初始化随机值函数，即所有状态的随机值。 让我们将`0`分配给所有状态：
 
 ![](img/00078.gif)
 
 让我们计算所有状态动作对的 *Q* 值。
 
-Q 值告诉我们每个状态下一个动作的值。 首先，让我们计算状态 *A* 的 *Q* 值。 调用 *Q* 函数的方程式。 为了进行计算，我们需要过渡和奖励概率。 让我们考虑状态 **A** 的转移和奖励概率，如下所示：
+Q 值告诉我们每个状态下一个动作的值。 首先，让我们计算状态 *A* 的 *Q* 值。 调用 *Q* 函数的方程式。 为了进行计算，我们需要过渡和奖励概率。 让我们考虑状态`A`的转移和奖励概率，如下所示：
 
 ![](img/00079.gif)
 
-状态 **A** 的 Q 函数可以计算如下：
+状态`A`的 Q 函数可以计算如下：
 
 *Q（s，a）=转移概率*（奖励概率+伽玛* next_state 的值）*
 
@@ -343,7 +343,7 @@ Q（A，0）= -0.1
 
 ![](img/00087.gif)
 
-从此 *Q* 函数中，我们选择每种状态下具有最大值的动作。 在状态 **A** 下，我们为操作 1 设置了最大值，这是我们的最佳策略。 因此，如果我们在状态 **A** 中执行动作 1，则无​​需访问 **B** 就可以达到 **C** 。
+从此 *Q* 函数中，我们选择每种状态下具有最大值的动作。 在状态`A`下，我们为操作 1 设置了最大值，这是我们的最佳策略。 因此，如果我们在状态`A`中执行动作 1，则无​​需访问`B`就可以达到`C`。
 
 # 策略迭代
 
@@ -419,19 +419,19 @@ policy_iteration():
 
 看上图：
 
-*   **S** 是起始位置（原点）
-*   **F** 是您可以漫步的冰冻湖
-*   **H** 是孔，您必须非常小心
-*   **G** 是目标（办公室）
+*`S`是起始位置（原点）
+*`F`是您可以漫步的冰冻湖
+*`H`是孔，您必须非常小心
+*`G`是目标（办公室）
 
-好的，现在让我们代替您使用我们的代理来找到到达办公室的正确方法。 该代理的目标是找到从 **S** 到 **G** 的最佳路径，而不会陷入 **H** 的陷阱。 代理商如何做到这一点？ 如果代理正确地在冰冻的湖面上行走，我们给+1 分作为奖励，如果代理正确落入洞中，则给 0 分，以便代理确定正确的行动。 代理现在将尝试找到最佳策略。 最优政策意味着采取正确的道路，这将最大化代理商的报酬。 如果代理人正在使报酬最大化，则显然代理人正在学习跳过漏洞并到达目的地。
+好的，现在让我们代替您使用我们的代理来找到到达办公室的正确方法。 该代理的目标是找到从`S`到`G`的最佳路径，而不会陷入`H`的陷阱。 代理商如何做到这一点？ 如果代理正确地在冰冻的湖面上行走，我们给+1 分作为奖励，如果代理正确落入洞中，则给 0 分，以便代理确定正确的行动。 代理现在将尝试找到最佳策略。 最优政策意味着采取正确的道路，这将最大化代理商的报酬。 如果代理人正在使报酬最大化，则显然代理人正在学习跳过漏洞并到达目的地。
 
 我们可以将问题建模为我们先前研究的 MDP。 MDP 包含以下内容：
 
 *   **状态**：状态集。 在这里，我们有 16 个州（网格中的每个小方框）。
 *   **动作**：所有可能动作的集合（左，右，上，下；这是我们的代理商在冰冻湖面环境中可以采取的所有四种可能动作）。
-*   **转移概率**：通过执行动作*和*从一种状态（ **F** ）转换为另一种状态（ **H** ）的概率。
-*   **奖励概率**：这是从一种状态（ **F** ）迁移到另一种状态（ **H** ）时获得奖励的概率。 执行*和*动作。
+*   **转移概率**：通过执行动作*和*从一种状态（`F`）转换为另一种状态（`H`）的概率。
+*   **奖励概率**：这是从一种状态（`F`）迁移到另一种状态（`H`）时获得奖励的概率。 执行*和*动作。
 
 现在我们的目标是解决 MDP。 解决 MDP 意味着寻找最佳策略。 现在，我们介​​绍三个特殊功能：
 

new/handson-rl-py/04.md

@@ -501,7 +501,7 @@ plot_blackjack(value, axes[0], axes[1])
 
 但是，这里出现了探索的问题。如果我们还没有处于状态状态值，我们如何知道状态状态值？ 如果我们不采取所有可能的措施探索所有州，我们可能会错过丰厚的回报。
 
-假设在二十一点游戏中，我们处于纸牌总数为 20 的状态。如果我们仅尝试 **h** **它**动作，我们将获得负数奖励，我们将学习 处于不佳状态。但是，如果我们尝试**站立**动作，我们将获得积极的回报，这实际上是最好的状态。因此，每次进入此特定状态 ，我们站立而不是受到打击。 为了让我们知道哪个是最佳操作，我们必须探索每种状态下的所有可能操作以找到最佳值。 我们应该怎么做？
+假设在二十一点游戏中，我们处于纸牌总数为 20 的状态。如果我们仅尝试`h`**它**动作，我们将获得负数奖励，我们将学习 处于不佳状态。但是，如果我们尝试**站立**动作，我们将获得积极的回报，这实际上是最好的状态。因此，每次进入此特定状态 ，我们站立而不是受到打击。 为了让我们知道哪个是最佳操作，我们必须探索每种状态下的所有可能操作以找到最佳值。 我们应该怎么做？
 
 让我介绍一个名为**的新概念蒙特卡洛** **探索开始**，这意味着对于每个情节，我们都将随机状态作为初始状态开始并执行操作。 因此，如果我们有大量的情节，我们可能会以所有可能的动作覆盖所有州。 它也称为 **MC-ES** 算法。
 

new/handson-rl-py/05.md

@@ -38,7 +38,7 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo
 
 ![](img/00116.jpeg)
 
-让我们将学习率（α）视为 *0.1* ，将折现率（![](img/00117.jpeg)）视为 *0.5* ； 我们知道状态**（1,1）**的值（如 *v（s）*中的值）为 0，而下一个状态**（1,2）的值** 与 *V（s）*一样，也是 **0** 。 我们获得的奖励*（r）*为-0.3。 我们将其替换为 TD 规则，如下所示：
+让我们将学习率（α）视为 *0.1* ，将折现率（![](img/00117.jpeg)）视为 *0.5* ； 我们知道状态**（1,1）**的值（如 *v（s）*中的值）为 0，而下一个状态**（1,2）的值** 与 *V（s）*一样，也是`0`。 我们获得的奖励*（r）*为-0.3。 我们将其替换为 TD 规则，如下所示：
 
 *V（s）= 0 + 0.1 [-0.3 + 0.5（0）-0]*
 
@@ -60,7 +60,7 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo
 
 ![](img/00119.jpeg)
 
-现在我们处于*（s）* **（1,3）**状态； 假设我们要采取行动了。 我们再次回到该状态*（s'）* **（1,2）**，我们将获得奖励*（r）* *-0.3* 。 此处，状态**（1,3）**的值为 **0** ，下一个状态**（1,2）**的值为 **-0.03 值表中的**。
+现在我们处于*（s）* **（1,3）**状态； 假设我们要采取行动了。 我们再次回到该状态*（s'）* **（1,2）**，我们将获得奖励*（r）* *-0.3* 。 此处，状态**（1,3）**的值为`0`，下一个状态**（1,2）**的值为 **-0.03 值表中的**。
 
 现在我们可以更新状态**（1,3）**的值，如下所示：
 
@@ -174,7 +174,7 @@ TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo
 
 为了演示该问题，我们假设代理是驱动程序。 有四个地点，代理商必须在一个地点接客并在另一地点下车。 座席将获得+20 积分作为成功下车的奖励，而每走一步便获得-1 积分。 该代理商还将因非法取送丢掉-10 分。 因此，我们代理商的目标是学会在短时间内在正确的位置上落客而不增加非法乘客。
 
-这里显示的环境中，字母（ **R** ， **G** ， **Y** ， **B** ）代表不同的位置，并且是一个小矩形 是驾驶出租车的代理商：
+这里显示的环境中，字母（`R`，`G`，`Y`，`B`）代表不同的位置，并且是一个小矩形 是驾驶出租车的代理商：
 
 ![](img/00131.gif)
 

new/handson-rl-py/07.md

@@ -79,7 +79,7 @@
 
 ![](img/00170.gif)
 
-假设我们有两个输入， **x <sub class="calibre24">1</sub>** 和 **x <sub class="calibre24">2</sub>** ，我们必须预测输出 **y** ]。 由于我们有两个输入，因此输入层中的神经元数将为两个。 现在，这些输入将乘以权重，然后添加偏差并将结果值传播到将应用激活函数的隐藏层。 因此，首先我们需要初始化权重矩阵。 在现实世界中，我们不知道哪个输入真正重要，因此需要权重较高才能计算输出。 因此，我们将随机初始化权重和偏差值。 我们可以将输入层和隐藏层之间的权重和偏差分别表示为 *w <sub class="calibre24">xh</sub>* 和 *b <sub class="calibre24">h</sub>* 。 权重矩阵的尺寸如何？ 权重矩阵的尺寸必须为 *[当前层中的神经元数量*下一层中的神经元数量]* 。 这是为什么？ 因为这是基本的矩阵乘法规则。 要乘以任意两个矩阵 AB，矩阵 A 中的列数必须等于矩阵 B 中的行数。因此，权重矩阵 *w <sub class="calibre24">xh</sub>* 的尺寸应为 *[输入层中的神经元数量*隐藏层中的神经元数量]，*，即 *2 x 4* ：
+假设我们有两个输入， **x <sub class="calibre24">1</sub>** 和 **x <sub class="calibre24">2</sub>** ，我们必须预测输出`y`]。 由于我们有两个输入，因此输入层中的神经元数将为两个。 现在，这些输入将乘以权重，然后添加偏差并将结果值传播到将应用激活函数的隐藏层。 因此，首先我们需要初始化权重矩阵。 在现实世界中，我们不知道哪个输入真正重要，因此需要权重较高才能计算输出。 因此，我们将随机初始化权重和偏差值。 我们可以将输入层和隐藏层之间的权重和偏差分别表示为 *w <sub class="calibre24">xh</sub>* 和 *b <sub class="calibre24">h</sub>* 。 权重矩阵的尺寸如何？ 权重矩阵的尺寸必须为 *[当前层中的神经元数量*下一层中的神经元数量]* 。 这是为什么？ 因为这是基本的矩阵乘法规则。 要乘以任意两个矩阵 AB，矩阵 A 中的列数必须等于矩阵 B 中的行数。因此，权重矩阵 *w <sub class="calibre24">xh</sub>* 的尺寸应为 *[输入层中的神经元数量*隐藏层中的神经元数量]，*，即 *2 x 4* ：
 
 ![](img/00171.jpeg)
 
@@ -407,9 +407,9 @@ RNN 是一种特殊类型的神经网络，广泛应用于顺序数据。 换句
 
 在上图中：
 
-*   **U** 代表隐藏状态权重矩阵的输入
-*   **W** 代表隐藏状态到隐藏状态权重矩阵
-*   **V** 表示隐藏到输出状态的权重矩阵
+*`U`代表隐藏状态权重矩阵的输入
+*`W`代表隐藏状态到隐藏状态权重矩阵
+*`V`表示隐藏到输出状态的权重矩阵
 
 因此，在前向传递中，我们计算以下内容：
 
@@ -435,7 +435,7 @@ RNN 是一种特殊类型的神经网络，广泛应用于顺序数据。 换句
 
 ![](img/00221.gif)
 
-在上图中， **L <sub class="calibre24">1</sub>** ， **L <sub class="calibre24">2</sub>** 和 **L <sub class="calibre24">3</sub>** 是每个时间步的损失。 现在，我们需要在每个时间步长计算相对于我们的权重矩阵 **U** ， **V** 和 **W** 的损耗梯度。 就像我们之前通过对每个时间步长求和来计算总损耗一样，我们用每个时间步长的梯度之和来更新权重矩阵：
+在上图中， **L <sub class="calibre24">1</sub>** ， **L <sub class="calibre24">2</sub>** 和 **L <sub class="calibre24">3</sub>** 是每个时间步的损失。 现在，我们需要在每个时间步长计算相对于我们的权重矩阵`U`，`V`和`W`的损耗梯度。 就像我们之前通过对每个时间步长求和来计算总损耗一样，我们用每个时间步长的梯度之和来更新权重矩阵：
 
 ![](img/00222.jpeg)
 
@@ -766,7 +766,7 @@ CNN 通常包含三个主要层：
 
 ![](img/00232.jpeg)
 
-因此，过滤器负责通过执行卷积运算从实际图像中提取特征。 将有多个过滤器用于提取生成特征图的图像的不同特征。 特征图的深度是我们使用的过滤器的数量。 如果我们使用 5 个滤镜提取特征并生成 5 个特征图，则特征图的深度为 **5** ，如下所示：
+因此，过滤器负责通过执行卷积运算从实际图像中提取特征。 将有多个过滤器用于提取生成特征图的图像的不同特征。 特征图的深度是我们使用的过滤器的数量。 如果我们使用 5 个滤镜提取特征并生成 5 个特征图，则特征图的深度为`5`，如下所示：
 
 ![](img/00233.gif)
 

new/handson-rl-py/11.md

@@ -9,7 +9,7 @@
 *   政策梯度
 *   使用政策梯度的月球着陆器
 *   深度确定性政策梯度
-*   使用 **d** **深度确定性策略梯度**（ **DDPG** ）摆动
+*   使用`d`**深度确定性策略梯度**（ **DDPG** ）摆动
 *   信任区域政策优化
 *   近端政策优化
 

new/handson-rl-py/13.md

@@ -102,7 +102,7 @@ MAXQ 值函数分解是 HRL 中最常用的算法之一。 让我们看看 MAXQ
 
 总共有四个地点，代理商必须在一个地点接客并在另一地点下车。 座席将获得+20 积分作为成功下车的奖励，而每走一步便获得-1 积分。 该代理商还将因非法取送丢掉-10 分。 因此，我们代理商的目标是学会在短时间内在正确的位置上落客而不增加非法乘客。
 
-接下来显示的是环境，其中的字母（ **R** ， **G** ， **Y** ， **B** ）代表不同的位置， 黄色矩形是由我们的代理商驾驶的出租车：
+接下来显示的是环境，其中的字母（`R`，`G`，`Y`，`B`）代表不同的位置， 黄色矩形是由我们的代理商驾驶的出租车：
 
 ![](img/00436.gif)
 

new/intel-proj-py/01.md

@@ -120,7 +120,7 @@
 
 ![](img/ff09283d-c4ae-42d3-8b20-5c6cb9523899.png)
 
-tanh 激活功能输出的值在[ **-1** ， **1** ]范围内，如下图所示：
+tanh 激活功能输出的值在[ **-1** ，`1`]范围内，如下图所示：
 
 ![](img/58f98f0c-6a81-4acc-bafb-9b0f683ad9c9.png)
 
@@ -488,7 +488,7 @@ Figure 1.14: GAN architecture
 
 图 1.18：使用预训练的 VGG 16 网络进行迁移学习
 
-以 **x** 表示的输入图像被馈送到**预训练的 VGG 16** 网络，以及 **4096** 维输出特征向量 **x'**， *是从最后一个完全连接的层中提取的。 提取的特征 **x'**以及相应的类别标签 **y** 用于训练简单的分类网络，从而减少解决问题所需的数据。*
+以`x`表示的输入图像被馈送到**预训练的 VGG 16** 网络，以及`4096`维输出特征向量 **x'**， *是从最后一个完全连接的层中提取的。 提取的特征 **x'**以及相应的类别标签`y`用于训练简单的分类网络，从而减少解决问题所需的数据。*
 
 我们将通过使用第 2 章，“迁移学习”中的迁移学习来解决医疗保健领域中的图像分类问题。
 

new/intel-proj-py/02.md

@@ -54,11 +54,11 @@
 
 在医疗保健中，糖尿病性视网膜病变的检测通常是一个手动过程，需要受过训练的医师检查彩色眼底视网膜图像。 这导致诊断过程的延迟，通常导致延迟的治疗。 作为我们项目的一部分，我们将建立一个强大的人工智能系统，该系统可以拍摄视网膜的彩色眼底图像，并对糖尿病性视网膜病变的视网膜状况进行严重性分类。 我们将视网膜图像分类的不同条件如下：
 
-*   **0** ：无糖尿病性视网膜病变
-*   **1** ：轻度糖尿病性视网膜病变
-*   **2** ：中度糖尿病性视网膜病变
-*   **3** ：严重的糖尿病视网膜病变
-*   **4** ：糖尿病性视网膜增生病
+*`0`：无糖尿病性视网膜病变
+*`1`：轻度糖尿病性视网膜病变
+*`2`：中度糖尿病性视网膜病变
+*`3`：严重的糖尿病视网膜病变
+*`4`：糖尿病性视网膜增生病
 
 # 糖尿病视网膜病变数据集
 

new/intel-proj-py/05.md

@@ -690,7 +690,7 @@ Epoch 99 is done. Saving the model ...
 
 图 5.7 训练期间的损失概况
 
-从前面的图表（*图 5.7* ）可以看出，损耗减少在最初的几个时期中较高，然后在时期 **80** 处逐渐减小。 在下一节中，我们将说明该模型在为看不见的视频生成字幕时的性能。
+从前面的图表（*图 5.7* ）可以看出，损耗减少在最初的几个时期中较高，然后在时期`80`处逐渐减小。 在下一节中，我们将说明该模型在为看不见的视频生成字幕时的性能。
 
 # 用看不见的测试视频推断
 

new/intel-proj-py/06.md

@@ -363,7 +363,7 @@ RBM 的参数是可见层单位 *i* 与隐藏层单位之间的广义权重连
 
 我们应该首先遇到的一个问题是如何处理 RBM 中的等级，因为等级本质上是有序的，而 RBM 则针对二进制数据。 可以将等级视为二进制数据，表示等级的单位数量等于每个等级的唯一值的数量。 例如：在评级系统中，等级从 1 到 5 不等，并且将有 5 个二进制单位，其中与等级相对应的 1 个单位设置为 1，其余单位设置为 0。 RBM 可见的单位将是为用户提供给不同电影的等级。 如所讨论的，每个等级将以二进制表示，并且对于每个可见单元，来自所有二进制可见单元的权重连接都与电影等级相对应。 由于每个用户将为一组不同的电影评分，因此每个用户的输入将不同。 但是，从电影分级单位到隐藏单位的重量连接对于所有用户而言都是通用的。
 
-下图所示（*图 6.8a* 和*图 6.8b* ）是**用户 A** 和**用户 B** 的 RBM 视图。 **用户** **A** 和**用户 B** 为一组不同的电影评分。 但是，正如我们所看到的，每个用户到每部电影中隐藏单元的权重连接都相同。 关于**用户 A** 的 RBM 等级如下：
+下图所示（*图 6.8a* 和*图 6.8b* ）是**用户 A** 和**用户 B** 的 RBM 视图。 **用户**`A`和**用户 B** 为一组不同的电影评分。 但是，正如我们所看到的，每个用户到每部电影中隐藏单元的权重连接都相同。 关于**用户 A** 的 RBM 等级如下：
 
 ![](img/430c8607-253c-4471-8fdd-cf581201fc71.jpg)
 

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

@@ -39,7 +39,7 @@
 
 ![](img/2fedfc25-71ae-4f2f-a64c-488eb2c170a9.png)
 
-假设我们有 1 到 10 的人口，可以认为是原始人口数据。 要获得引导程序样本，我们需要从原始数据中抽取 10 个样本进行替换。 假设您戴着帽子，用 10 张卡片写下了 10 个数字； 对于样本的第一个元素，您从帽子上随机拿出一张卡片并将其写下来，然后将卡片放回帽子中，此过程一直进行到获得 10 个元素为止。 这是您的引导程序示例。 如您在前面的示例中所见，在引导程序样本中， **9** 重复了三次。
+假设我们有 1 到 10 的人口，可以认为是原始人口数据。 要获得引导程序样本，我们需要从原始数据中抽取 10 个样本进行替换。 假设您戴着帽子，用 10 张卡片写下了 10 个数字； 对于样本的第一个元素，您从帽子上随机拿出一张卡片并将其写下来，然后将卡片放回帽子中，此过程一直进行到获得 10 个元素为止。 这是您的引导程序示例。 如您在前面的示例中所见，在引导程序样本中，`9`重复了三次。
 
 用替换对数字进行重采样可以提高真实总体数据的准确性。 它还有助于理解重采样过程中涉及的各种差异和特征，从而提高其准确性。
 

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

@@ -25,7 +25,7 @@
 
 ![](img/5fc96b69-e4fa-497c-9c96-25fc7005239d.png)
 
-您可以删除超过 x％的样本中所有为 0 或 1 的虚拟特征，或者可以为这些特征的方差建立最小阈值。 现在，可以使用前面的公式获得这些特征的方差，其中 **p** 是您的虚拟特征中 **1** 的数量或比例。 我们将在 Jupyter Notebook 中查看其工作原理。
+您可以删除超过 x％的样本中所有为 0 或 1 的虚拟特征，或者可以为这些特征的方差建立最小阈值。 现在，可以使用前面的公式获得这些特征的方差，其中`p`是您的虚拟特征中`1`的数量或比例。 我们将在 Jupyter Notebook 中查看其工作原理。
 
 # 统计确定重要特征
 
@@ -365,19 +365,19 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 ![](img/4dcab463-bc46-4047-9f46-8d6b362ce700.png)
 
-假设目标（ **y** ）是机器学习的基础假设，并且功能与目标之间的关系由一个函数给出。 由于在大多数情况下，我们认为特征与目标之间的关系存在一定的随机性，因此我们在此处添加了一个噪声项，该噪声项将始终存在于现实中。 这是机器学习中的基本假设。
+假设目标（`y`）是机器学习的基础假设，并且功能与目标之间的关系由一个函数给出。 由于在大多数情况下，我们认为特征与目标之间的关系存在一定的随机性，因此我们在此处添加了一个噪声项，该噪声项将始终存在于现实中。 这是机器学习中的基本假设。
 
 在模型中，我们尝试在执行特征工程，调整参数等时通过使用实际函数来近似理论函数：
 
 ![](img/86502f63-aa51-40f7-8605-e6feaecaf2c3.png)
 
-因此，我们的预测是将这些近似值应用于概念或理论 **f** 的结果。 我们在机器学习中所做的所有事情都是通过训练模型来尝试近似 **f** 函数。
+因此，我们的预测是将这些近似值应用于概念或理论`f`的结果。 我们在机器学习中所做的所有事情都是通过训练模型来尝试近似`f`函数。
 
-训练模型意味着近似该功能。 可以从数学上显示预期误差（可以定义为实际 **y** 与预测的 **y** 之差）可以分解为两个项。 一个术语称为**可减少的误差**，另一术语称为**不可减少的误差**，如以下屏幕截图所示：
+训练模型意味着近似该功能。 可以从数学上显示预期误差（可以定义为实际`y`与预测的`y`之差）可以分解为两个项。 一个术语称为**可减少的误差**，另一术语称为**不可减少的误差**，如以下屏幕截图所示：
 
 ![](img/ba4c0671-5d52-4204-806c-85b9c4ecfcd9.png)
 
-现在，**不可约误差**项是该随机项的方差。 您对此词没有任何控制权。 总会有一个不可减少的错误成分。 因此，您的模型总是会出错； 无论您拥有多少个特征和数据点，您的模型都不能总是 100％正确的。 我们必须尝试使用​​更好和更复杂的方法来执行特征工程，并尝试将我们的估计近似为真实函数。 仅仅因为您使用的是更复杂的模型或您有更多的数据，您的模型就不会是完美的，并且您将无法准确预测 **y** 是什么，因为几乎所有过程都存在随机性 与您一起工作。 这是一个非常有趣的部分的结尾。
+现在，**不可约误差**项是该随机项的方差。 您对此词没有任何控制权。 总会有一个不可减少的错误成分。 因此，您的模型总是会出错； 无论您拥有多少个特征和数据点，您的模型都不能总是 100％正确的。 我们必须尝试使用​​更好和更复杂的方法来执行特征工程，并尝试将我们的估计近似为真实函数。 仅仅因为您使用的是更复杂的模型或您有更多的数据，您的模型就不会是完美的，并且您将无法准确预测`y`是什么，因为几乎所有过程都存在随机性 与您一起工作。 这是一个非常有趣的部分的结尾。
 
 # 概要
 

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

@@ -37,13 +37,13 @@
 
 ![](img/7938be7f-8c64-4cdd-9d93-b6ba65e4d5a6.png)
 
-如您所见，我们有相同的表格。 如果权重之和乘以特征 **-b** 的值实际上大于 **0** ，则我们预测 **1** ，否则，我们预测 **0 [** 。 假设所有特征都在同一尺度上，权重将代表每个特征在做出决策时的重要性。 因此，我们知道对于这个特殊问题，所有功能的比例都非常不同。 例如，年龄与帐单金额的比例不同，但是假设您将所有功能设置为相似的比例。 您可以将 **w** 变量视为权重，它们是决策时每个功能最重要的部分。
+如您所见，我们有相同的表格。 如果权重之和乘以特征 **-b** 的值实际上大于`0`，则我们预测`1`，否则，我们预测 **0 [** 。 假设所有特征都在同一尺度上，权重将代表每个特征在做出决策时的重要性。 因此，我们知道对于这个特殊问题，所有功能的比例都非常不同。 例如，年龄与帐单金额的比例不同，但是假设您将所有功能设置为相似的比例。 您可以将`w`变量视为权重，它们是决策时每个功能最重要的部分。
 
 以下屏幕截图显示了可视化此感知器的另一种方法：
 
 ![](img/bd6b7f5e-ef5e-4f6e-aac0-a65a57a01b6b.png)
 
-因此，您具有阈值或偏差 **b** 的值，并且具有 **Age** ， **x1** 和**的值 帐单金额**， **x2** 。 因此，这三个值进入一个运算，然后得到输出。 现在，我们可以对感知器进行一些修改，这就是添加所谓的**激活函数**。 激活功能是任何可以获取运算结果并使用 **f** 功能对输入值进行某种转换的功能。 因此，激活函数的输入是来自运算的结果数量，然后在应用激活函数 **f** 之后，我们将获得以下输出：
+因此，您具有阈值或偏差`b`的值，并且具有 **Age** ，`x1`和**的值 帐单金额**，`x2`。 因此，这三个值进入一个运算，然后得到输出。 现在，我们可以对感知器进行一些修改，这就是添加所谓的**激活函数**。 激活功能是任何可以获取运算结果并使用`f`功能对输入值进行某种转换的功能。 因此，激活函数的输入是来自运算的结果数量，然后在应用激活函数`f`之后，我们将获得以下输出：
 
 ![](img/b2e13ce5-8226-4536-a9c6-c425619c50d0.png)
 
@@ -75,7 +75,7 @@
 
 ![](img/d0c4a68a-1a43-4bc2-96a2-719ca85c0389.png)
 
-这是一种更紧凑的可视化方式，但实际上是同一网络。 因此，我们为每个观察结果添加了一个不变的特征 **1** ，而不是具有三个偏差。 **1** 的值乘以不同的偏差，并作为对我们隐藏层中神经元的输入。 **x1** 的值乘以一定的权重，并作为下一个神经元的输入， **x2** 的值也是如此。 然后，将隐藏层中神经元的结果用作我们网络中最后一个感知器的输入，这是总输出。
+这是一种更紧凑的可视化方式，但实际上是同一网络。 因此，我们为每个观察结果添加了一个不变的特征`1`，而不是具有三个偏差。`1`的值乘以不同的偏差，并作为对我们隐藏层中神经元的输入。`x1`的值乘以一定的权重，并作为下一个神经元的输入，`x2`的值也是如此。 然后，将隐藏层中神经元的结果用作我们网络中最后一个感知器的输入，这是总输出。
 
 # 深度神经网络模型的要素
 
@@ -209,11 +209,11 @@ pip install --ignore-installed --upgrade tensorflow
 1.  定义计算图
 2.  运行计算图
 
-让我们尝试通过一个非常简单的示例来理解这个概念。 假设您有一个带有两个变量的函数， **x** 和 **y** ，如以下屏幕截图所示：
+让我们尝试通过一个非常简单的示例来理解这个概念。 假设您有一个带有两个变量的函数，`x`和`y`，如以下屏幕截图所示：
 
 ![](img/5212c92e-d91d-4024-ac39-d753f31f3926.png)
 
-当您传递 **x** 和 **y** 的值 **3** 和 2 时，我们将使用上述公式来计算或构建此函数的实际值的计算图 ] 分别：
+当您传递`x`和`y`的值`3`和 2 时，我们将使用上述公式来计算或构建此函数的实际值的计算图 ] 分别：
 
 ![](img/4127c2a0-3c52-4a52-85a3-f1f9e63d87cf.png)
 
@@ -221,7 +221,7 @@ pip install --ignore-installed --upgrade tensorflow
 
 ![](img/ef618ce1-282e-41fd-9b3f-55b6317130f4.png)
 
-在前面的屏幕截图中，我们看到了通过计算图流到图中不同节点的值。 因此，在第一个节点中，将值 **3** 分配给 **x** ，在另一个节点中，将值 **2** 分配给 **y [** 。 现在， **x** 的值流到一个运算节点，在该运算节点上平方，该节点的结果流到另一个运算，在运算上与 **y** 的值相乘。 我们还有另一个节点，其中 **y** 的值乘以 **4** 。 **x** 和 **y** 乘法节点的结果以及 **y** 乘法节点的结果流到最终节点，即加法节点，这使我们 最终输出 **26** 。 因此，这基本上就是 TensorFlow 的工作方式。 节点之间流动的是张量。
+在前面的屏幕截图中，我们看到了通过计算图流到图中不同节点的值。 因此，在第一个节点中，将值`3`分配给`x`，在另一个节点中，将值`2`分配给 **y [** 。 现在，`x`的值流到一个运算节点，在该运算节点上平方，该节点的结果流到另一个运算，在运算上与`y`的值相乘。 我们还有另一个节点，其中`y`的值乘以`4`。`x`和`y`乘法节点的结果以及`y`乘法节点的结果流到最终节点，即加法节点，这使我们 最终输出`26`。 因此，这基本上就是 TensorFlow 的工作方式。 节点之间流动的是张量。
 
 我们在 TensorFlow 中使用以下其他对象：