2020-12-26 16:50:07

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

@@ -2,7 +2,7 @@
 
 TensorFlow 是用于机器学习以及最近的深度学习的最受欢迎的架构之一。 本书是将 TensorFlow 和 Keras 模型部署到实际应用程序中的指南。
 
-本书从专门的蓝图开始，说明如何构建可生成预测的应用程序。 随后的每节课程都针对特定类型的模型，例如神经网络，使用 Keras 配置深度学习环境，并着重于三个重要问题，即模型如何工作，如何在示例模型中提高我们的预测准确性以及如何 使用实际应用程序评估和评估其性能。
+本书从专门的蓝图开始，说明如何构建可生成预测的应用程序。 随后的每节课程都针对特定类型的模型，例如神经网络，使用 Keras 配置深度学习环境，并着重于三个重要问题，即模型如何工作，如何在示例模型中提高我们的预测准确性以及如何使用实际应用程序评估其性能。
 
 在本书中，您将学习如何创建一个应用程序，该应用程序可以从深度学习中生成预测。 这项学习之旅从探索神经网络的通用组件及其基本性能开始。 在课程结束时，您将探索使用 TensorFlow 创建的训练有素的神经网络。 在其余的课程中，您将学习建立一个将不同组件组合在一起的深度学习模型，并评估它们在预测中的性能。 最后，我们将能够部署可运行的 Web 应用程序
 
@@ -46,7 +46,7 @@ TensorFlow 是用于机器学习以及最近的深度学习的最受欢迎的架
 
 在本书中，您将找到许多可以区分不同类型信息的文本样式。 以下是这些样式的一些示例，并解释了其含义。
 
-文本，数据库表名称，文件夹名称，文件名，文件扩展名，路径名，虚拟 URL，用户输入和 Twitter 句柄中的代码字显示如下：“ `\`类提供了静态方法来生成自身的实例，例如 作为`()`。”
+文本，数据库表名称，文件夹名称，文件名，文件扩展名，路径名，虚拟 URL，用户输入和 Twitter 句柄中的代码字显示如下：“ `\`类提供了静态方法来生成自身的实例，例如`()`。”
 
 代码块设置如下：
 

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

@@ -129,7 +129,7 @@
 
 蒂莫西·雷维尔（Timothy Revell），[《用于“识别”罪犯的面部识别技术的关注》](https://www.newscientist.com/article/2114900-concerns-as-face-recognition-tech-used-to-identify-criminals/)。
 
-为了使进一步了解学习算法（包括深度学习）中的道德主题，请参阅 [AI Now Institute](https://ainowinstitute.org/) 所做的工作 为了解智能系统的社会意义。
+为了使进一步了解学习算法（包括深度学习）中的道德主题，请参阅 [AI Now Institute](https://ainowinstitute.org/) 为了解智能系统的社会意义所做的工作。
 
 ## 神经网络的通用组件和操作
 
@@ -195,7 +195,7 @@ TensorBoard 是用于探索 TensorFlow 模型的数据可视化套件，并与 T
 
 在使用 Python 创建深度学习模型时，通常开始进行交互工作，慢慢地开发一个模型，最终将其变成结构化的软件。 在此过程中，经常使用以下三个 Python 程序包：Jupyter 笔记本，Pandas 和 NumPy：
 
-*   Jupyter 笔记本 创建使用网络浏览器作为其界面的交互式 Python 会话
+*   Jupyter 笔记本创建交互式 Python 会话，使用网络浏览器作为其界面
 *   Pandas 是用于数据操纵和分析的程序包
 *   NumPy 是，经常用于整形数据和执行数值计算
 
@@ -293,7 +293,7 @@ Michael Heydt 的《学习 Pandas》和 Dan Toomey 的《学习 Jupyter》提供
 
     如果您运行的是 Python 3.6，并且分布式 TensorFlow 滚轮是在其他版本（本例中为 3.5）下编译的，则会显示该消息。 您可以放心地忽略该消息。
 
-    一旦我们确认已安装 Python 3，TensorFlow，Keras，TensorBoard 和`requirements.txt`中概述的软件包，我们就可以继续进行有关如何训练神经网络的演示，然后继续使用这些工具探索受过训练的网络 相同的工具。
+    一旦我们确认已安装 Python 3，TensorFlow，Keras，TensorBoard 和`requirements.txt`中概述的软件包，我们就可以继续进行有关如何训练神经网络的演示，然后继续使用这些工具的相同工具探索受过训练的网络。
 
     ### 注意
 

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

@@ -81,7 +81,7 @@ TensorFlow 团队可使用 TensorFlow Playground 应用程序，以帮助我们
 
 ![Different Loss Functions, Same Architecture](img/image03_01.jpg)
 
-图 1：TensorFlow Playground Web 应用程序 在此可视化中获取神经网络的参数，以直观了解每个参数如何影响模型结果。
+图 1：TensorFlow Playground Web 应用程序在此可视化中获取神经网络的参数，以直观了解每个参数如何影响模型结果。
 
 应用程序帮助我们探索了上一节中讨论的不同问题类别。 当我们选择分类作为问题类型（右上角）时，数据集中的点仅用两种颜色值着色：蓝色或橙色。 选择回归时，点的颜色将在橙色和蓝色之间的一系列颜色值中上色。 在处理分类问题时，网络会根据网络出错了多少个蓝色和橙色来评估其损失函数。 在处理分类问题时，它将检查网络每个点距正确的颜色值的距离，如下图所示：
 
@@ -286,7 +286,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
 这表明我们的预测与实际数据的平均差异约为 399 美元。 这意味着与实际比特币价格相差约 8.4%。
 
-这些结果有助于理解我们的预测。 我们将继续使用`model.evaluate()`方法来跟踪我们的 LSTM 模型的改进情况，但还将在模型的每个版本的完整系列中计算`rmse()`和`mape()`来解释其接近程度 我们将预测比特币价格。
+这些结果有助于理解我们的预测。 我们将继续使用`model.evaluate()`方法来跟踪我们的 LSTM 模型的改进情况，但还将在模型的每个版本的完整系列中计算`rmse()`和`mape()`来解释我们预测的比特币价格的接近程度。
 
 #### 活动 6 –创建积极的培训环境
 
@@ -413,7 +413,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
     ### 注意
 
-    对于 参考解决方案，请使用 `Code/Lesson-3/activity_6` 文件夹。
+    对于参考解决方案，请使用`Code/Lesson-3/activity_6`文件夹。
 
 在本节中，我们学习了如何使用损失函数评估网络。 我们了解到，损失函数是神经网络的关键元素，因为它们在每个时期评估网络的性能，并且是将调整传播回层和节点的起点。 我们还探讨了为什么某些损失函数可能难以解释（例如 MSE）的原因，并开发了使用其他两个函数（RMSE 和 MAPE）的策略来解释 LSTM 模型的预测结果。
 
@@ -444,7 +444,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
 ##### 添加更多节点
 
-图层所需的神经元数量与输入和输出数据的结构方式有关。 例如，如果您要将`4 x 4`像素图像分为两类之一，则可以从一个具有 12 个神经元的隐藏层（每个可用像素一个）和一个只有两个神经元的输出层开始（一个用于 每个预测的课程）。
+图层所需的神经元数量与输入和输出数据的结构方式有关。 例如，如果您要将`4 x 4`像素图像分为两类之一，则可以从一个具有 12 个神经元的隐藏层（每个可用像素一个）和一个只有两个神经元的输出层开始（每个预测类一个）。
 
 通常在添加新层的同时添加新神经元。 然后，可以添加一层具有与前一层相同数量的神经元，或者是前一层的神经元数量的倍数的层。 例如，如果您的第一个隐藏层具有 12 个神经元，则可以尝试添加第二个具有 12、6 或 24 个层的神经元。
 

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

@@ -338,7 +338,7 @@ Docker 使用名为`Dockerfile`的文件来描述如何构建镜像的规则以
 
 `--publish`标志将`localhost`上的端口`5000`绑定到 Docker 容器上的端口`5000`，并且`--detach`在后台将容器作为守护程序运行。
 
-如果您训练了不同的模型，并且想用它代替训练新的模型，则可以更改`docker-compose.yml`上的`MODEL_NAME`环境变量，如代码段 9 所示。该变量应包含 您已经训练并想要使用的模型的文件名（例如`bitcoin_lstm_v1_trained.h5`），它也应该是 Keras 模型。 如果这样做，请确保也将本地目录装载到`/models`文件夹中。 您决定挂载的目录必须具有模型文件。
+如果您训练了不同的模型，并且想用它代替训练新的模型，则可以更改`docker-compose.yml`上的`MODEL_NAME`环境变量，如代码段 9 所示。该变量应包含您已经训练并想要使用的模型的文件名（例如`bitcoin_lstm_v1_trained.h5`），它也应该是 Keras 模型。 如果这样做，请确保也将本地目录装载到`/models`文件夹中。 您决定挂载的目录必须具有模型文件。
 
 `cryptonic`应用程序还包含许多环境变量，这些变量在部署自己的模型时可能会有用：
 

new/handson-dl-img-tf/1.md

@@ -41,7 +41,7 @@ GPU 状态
 
 # 机器学习 Docker 文件
 
-现在，让我们开始准备准备机器学习的 Docker 文件。 在本节中，我们将研究克隆源文件，Docker 所需的基本镜像，安装其他必需的软件包，公开一个卷以便您可以共享您的工作以及公开端口以便您能够 看 Jupyter 笔记本，这是我们将用来探索机器学习的工具。
+现在，让我们开始准备准备机器学习的 Docker 文件。 在本节中，我们将研究克隆源文件，Docker 所需的基本镜像，安装其他必需的软件包，公开一个卷以便您可以共享您的工作以及公开端口以便您能够查看 Jupyter 笔记本，这是我们将用来探索机器学习的工具。
 
 现在，您需要获取这些部分附带的源代码。 前往[这里](https://github.com/wballard/kerasvideo/tree/2018)，您可以在其中快速克隆存储库。 在这里，我们只是使用 GitHub for Windows 作为一种相对快速的方法来克隆该存储库，但是您可以以自己喜欢的任何方式使用 Git。 将这些文件放在哪个目录中都没有关系。 我们只是将它们下载到本地工作目录中。 然后，我们将使用此位置作为开始构建实际 Docker 容器的位置。
 
@@ -111,7 +111,7 @@ Docker 设置窗口
 
 现在，这将弹出一个新窗口，要求您输入密码，以便我们允许 Docker 将共享驱动器映射回我们的 PC，以便可以从容器内看到我们 PC 的硬盘。 该共享位置是我们将要工作和编辑文件的位置，以便我们可以保存我们的工作。
 
-现在我们有了从对话框中复制的命令，我们将继续将其粘贴到命令提示符中，或者您可以在要运行测试容器的位置键入它，以确保 我们的 Docker 安装程序实际上可以看到本地硬盘驱动器：
+现在我们有了从对话框中复制的命令，我们将继续将其粘贴到命令提示符中，或者您可以在要运行测试容器的位置键入它，以确保我们的 Docker 安装程序实际上可以看到本地硬盘驱动器：
 
 ```py
 C:\11519>docker run --rm -v c:/Users:/data alpine ls /data

new/handson-dl-img-tf/2.md

 # 图片资料
 
-在上一章中，我们准备了机器学习工具包，在其中设置了 Keras 和 Docker，以便允许我们运行 Jupyter 笔记本 处理机器学习。
+在上一章中，我们准备了机器学习工具包，在其中设置了 Keras 和 Docker，以便允许我们运行 Jupyter 笔记本来处理机器学习。
 
 在本章中，我们将研究准备供机器学习使用的图像数据，以及将其连接到 Keras 中涉及的步骤。 我们将从了解 MNIST 数字开始。 这些是图像形式的手写字符，我们将在机器学习中有效执行**光学字符识别**（**OCR**）。 然后，我们将讨论张量。 张量听起来像是一个数学词，的确是，但是作为一名程序员，您已经看到了多维数组，因此您实际上已经在使用张量，我将向您展示其等效性。 之后，我们将图像转换为张量。 正如您习惯在计算机上看到图像一样，图像需要一种特殊的编码形式才能与机器学习一起使用。
 
@@ -60,7 +60,7 @@ Python 元组
 
 ![](img/abb0ea3a-4467-4f88-91dd-b4f06affe366.png)
 
-呼叫.shape
+调用`.shape`
 
 这是构成我们的三个张量的三个维度。 它只是一个多维数组。 然后，当然是数据类型，即`dtype`，就像您在 NumPy 多维数组上在这里所说的那样。 您可以看到这些图像存储为`uint8`或 8 位整数，以记录`0`至`255`值。 好吧，我们经常将这种数据类型用于源数据，特别是对于像前一个图像一样的黑白图像。 当我们将其转换为实际的机器学习格式时，我们将使用浮点数。
 
@@ -68,7 +68,7 @@ Python 元组
 
 在上一节中，我们了解了张量是什么。 现在，我们将使用这些知识来准备图像数据作为机器学习的张量。 首先，我们会问一个问题：为什么要使用浮点数据？ 然后，我们将了解样本与样本末尾数据点之间的差异。 最后，我们将规范化数据以用于机器学习。
 
-那么，为什么要浮点数呢？ 好吧，真正的原因是机器学习从根本上讲是一个数学优化问题，当我们使用浮点数时，计算机正在尝试优化一系列数学关系以找到可以预测输出的学习功能。 因此，为机器学习准备数据确实需要将正常的二进制数据（例如图像）重新格式化为一系列浮点数，这不是我们通常在图像处理方面处理图像的方式，但这是必需的 为了让机器学习算法参与其中。
+那么，为什么要浮点数呢？ 好吧，真正的原因是机器学习从根本上讲是一个数学优化问题，当我们使用浮点数时，计算机正在尝试优化一系列数学关系以找到可以预测输出的学习功能。 因此，为机器学习准备数据确实需要将正常的二进制数据（例如图像）重新格式化为一系列浮点数，这不是我们通常在图像处理方面处理图像的方式，但为了让机器学习算法参与其中，这是必需的。
 
 现在，让我们谈谈样本。 按照惯例，样本始终是多维数据数组中的第一维。 在这里，我们有多个样本，因为机器学习从根本上来说是通过查看大量不同样本中的大量不同数据点，然后学习基于此预测结果的函数来进行的。
 
@@ -98,13 +98,13 @@ Python 元组
 
 0 到 9 的预测
 
-因此，为此，我们将使用数据转换技巧。 这种事情称为“单热编码”，在这里您可以获取一系列标签可能性，在这种情况下，将数字`0`至`9`转换为一种位图，其中每个选项都编码为 一列，并且对于每个给定的数据样本，只有一列设置为`1`（因此为一热）：
+因此，为此，我们将使用数据转换技巧。 这种事情称为“单热编码”，在这里您可以获取一系列标签可能性，在这种情况下，将数字`0`至`9`转换为一种位图，其中每个选项都编码为一列，并且对于每个给定的数据样本，只有一列设置为`1`（因此为一热）：
 
 ![](img/d8a1f493-a432-4a27-8247-bfd255324106.png)
 
 一键编码
 
-现在，既查看输入数字（此处为`9`），又查看输出位图，您可以看到第四个索引设置了第九个位，您可以看到我们在此处进行数据准备的工作是 将一个图像作为输入，将另一个图像作为输出。 它们只是被编码为张量（浮点数的多维数组）：
+现在，既查看输入数字（此处为`9`），又查看输出位图，您可以看到第四个索引设置了第九个位，您可以看到我们在此处进行数据准备的工作是将一个图像作为输入，将另一个图像作为输出。 它们只是被编码为张量（浮点数的多维数组）：
 
 ![](img/4775c1e4-c69e-4b7c-9aca-21dc65a8e371.png)
 

new/handson-dl-img-tf/3.md

@@ -153,7 +153,7 @@ Keras 功能模型
 
 最后，我们得出验证数据，也称为测试数据。 实际上，这是用来计算精度的。 在每个时期结束时，对模型进行部分训练，然后通过模型运行测试数据，生成一组试验预测，用于对准确性进行评分。 机器学习涉及大量的人类等待。 我们将继续并跳过每个时代的进度； 在运行这些样本时，您将有很多机会观看这些进度条的增长。
 
-现在，让我们谈谈前面的输出。 随着进度栏的增长，您可以看到其正在运行的示例图像的数量。 但是还有`loss`功能和`metrics`参数； 在这里，我们使用准确性。 因此，`loss`功能会反馈给学习者，这实际上就是机器学习的学习方式; 它试图通过迭代设置模型中的数字参数来使`loss`最小化，以使`loss`编号下降。 那里的准确性，以便您可以了解发生了什么。 在这种情况下，精度表示模型猜测正确数字的频率。 因此，就将其视为一本菜谱而言，分类交叉熵是您实际上一直希望用于此类分类问题的`loss`函数，而`adam`是最明智的默认学习算法 选择; `accuracy`是出色的输出`metrics`，您可以用来查看模型的运行状况。
+现在，让我们谈谈前面的输出。 随着进度栏的增长，您可以看到其正在运行的示例图像的数量。 但是还有`loss`功能和`metrics`参数； 在这里，我们使用准确性。 因此，`loss`功能会反馈给学习者，这实际上就是机器学习的学习方式; 它试图通过迭代设置模型中的数字参数来使`loss`最小化，以使`loss`编号下降。 那里的准确性，以便您可以了解发生了什么。 在这种情况下，精度表示模型猜测正确数字的频率。 因此，就将其视为一本菜谱而言，分类交叉熵是您实际上一直希望用于此类分类问题的`loss`函数，而`adam`是学习算法的最明智的默认选项; `accuracy`是出色的输出`metrics`，您可以用来查看模型的运行状况。
 
 # 超参数
 
@@ -163,13 +163,13 @@ Keras 功能模型
 
 在我们的“模型摘要输出”的屏幕截图中，请注意屏幕截图底部代码中突出显示的部分中可训练参数的数量。 这就是我们的模型`adam`优化器与我们的分类交叉熵`loss`函数一起将在模型内部包含的单个浮点数的数目，以便找到可能的最佳参数值。 因此，此可训练的参数编号是我们的`optimizer`函数学习的唯一编号集合。 但是，此代码和前面的屏幕快照中还有许多其他数字。 这些不可训练的参数呢？ 在我们当前的模型中，有零个不可训练参数。 但是，Keras 中不同种类的图层可能具有恒定值，因此它们将显示为不可训练的。 再次，这只是意味着不需要对其进行培训，并且我们的`optimizer`函数将不会尝试更改其值。
 
-那么，什么是超参数？ 好吧，非常简单，超参数是模型本身之外的值（参数）。 因此，认为超参数最简单的是实际的模型结构。 在这种情况下，我们创建层的次数是一个超参数，层的大小是一个超参数，我们在密集层中选择的`32`单位是一个超参数，`0.1`退出设置是 超参数，甚至激活函数本身（例如，选择`relu`而不是`sigmoid`）都是超参数。 现在您可能在想，“请稍等，我不得不在这里选择很多参数；我以为机器应该在学习”。 它是！ 但是，诀窍在于`optimizer`无法学习我们需要了解的所有知识，以组成一个最佳模型。
+那么，什么是超参数？ 好吧，非常简单，超参数是模型本身之外的值（参数）。 因此，认为超参数最简单的是实际的模型结构。 在这种情况下，我们创建层的次数是一个超参数，层的大小是一个超参数，我们在密集层中选择的`32`单位是一个超参数，`0.1`的丢弃设置是超参数，甚至激活函数本身（例如，选择`relu`而不是`sigmoid`）都是超参数。 现在您可能在想，“请稍等，我不得不在这里选择很多参数；我以为机器应该在学习”。 它是！ 但是，诀窍在于`optimizer`无法学习我们需要了解的所有知识，以组成一个最佳模型。
 
 # 网格搜索
 
 在本节中，我们将探索网格搜索。
 
-我们将讨论有关优化与网格搜索，设置模型生成器功能，设置参数网格以及使用交叉验证进行网格搜索的一些知识，最后，报告网格搜索的结果，以便我们选择最佳的 模型。
+我们将讨论有关优化与网格搜索，设置模型生成器功能，设置参数网格以及使用交叉验证进行网格搜索的一些知识，最后，报告网格搜索的结果，以便我们选择最佳的模型。
 
 那么，为什么从根本上讲这里有两种不同的机器学习活动？ 好吧，优化通过`loss`函数的反馈来求解参数：高度优化。 具体来说，求解器无需尝试每个参数值即可工作。 它使用具有偏导数的数学关系来沿**梯度**移动。 这使它在数学上基本上走下坡路才能找到正确的答案。
 
@@ -185,7 +185,7 @@ Keras 功能模型
 
 现在，让我们集中讨论一个模型生成函数并设想两个超参数。 其中一个将是`dropout`，另一个将是每个密集隐藏层中的单位数。 因此，我们在此处构建一个名为`dense_model`的函数，该函数接受`units`和`dropout`，然后像以前一样计算网络。 但是，而不是使用硬编码的`32`或`0.1`（例如），实际的参数将被传入，这将为我们编译模型，然后将该模型作为输出返回。 这次，我们使用顺序模型。 以前，当我们使用 Keras 功能模型时，我们一层又一层地链接在一起。 对于顺序模型，它更像一个列表：从顺序模型开始，然后逐层添加，直到顺序模型本身为您形成链。 现在是超参数网格。 这是我们指出网格搜索与优化器相比的缺点。 您可以在前面的屏幕截图中看到我们选择的值。 为了使运行更快，我们将做一个时期，并保持`64`图像的恒定`batch_size`，该图像将在`32`，`64`和`128`隐藏单位以及退出之间变化 `0.1`，`0.2`和`0.4`的特征。 这是网格搜索的最大缺点：您将在此处看到的超参数是唯一可以完成的操作-网格搜索不会在两者之间探索超参数值。
 
-现在，我们设置`KerasClassifier`，将其交给我们刚刚创建的模型构建功能，并将`verbose`设置为`0`以隐藏每次 Keras 运行的进度条。 然后，我们设置一个计时器； 我想知道这需要多长时间。 现在，我们设置了带有交叉验证的网格搜索。 对于其估计量，我们给我们提供我们的模型，即我们的`KerasClassifier`包装器和我们的`grid`参数（请参阅前面的超参数），然后说`cv=6`，这意味着将数据（训练数据）分为六个不同 细分，然后交叉验证。 在`5`上进行训练，并使用六分之一进行验证并反复重复此步骤，以搜索最佳的超参数值。 另外，将`verbose`设置为`4`，这样我们就可以看到很多输出。 现在仅 Keras 就运行了很多东西，我们将`fit`函数从我们的`x`训练数据（同样是我们的输入图像）转到我们的`y`训练数据（这些是从零到数字的标签） 九），然后打印出我们最好的结果。 请注意，我们实际上尚未触及我们的测试数据。 我们将在稍后使用它来对网格搜索报告的最佳模型的值进行评分。
+现在，我们设置`KerasClassifier`，将其交给我们刚刚创建的模型构建功能，并将`verbose`设置为`0`以隐藏每次 Keras 运行的进度条。 然后，我们设置一个计时器； 我想知道这需要多长时间。 现在，我们设置了带有交叉验证的网格搜索。 对于其估计量，我们给我们提供我们的模型，即我们的`KerasClassifier`包装器和我们的`grid`参数（请参阅前面的超参数），然后说`cv=6`，这意味着将数据（训练数据）分为六个不同部分，然后交叉验证。 在`5`上进行训练，并使用六分之一进行验证并反复重复此步骤，以搜索最佳的超参数值。 另外，将`verbose`设置为`4`，这样我们就可以看到很多输出。 现在仅 Keras 就运行了很多东西，我们将`fit`函数从我们的`x`训练数据（同样是我们的输入图像）转到我们的`y`训练数据（这些是从零到数字的标签） 九），然后打印出我们最好的结果。 请注意，我们实际上尚未触及我们的测试数据。 我们将在稍后使用它来对网格搜索报告的最佳模型的值进行评分。
 
 现在，我们测试结果。 这是我们使用`argmax`的地方。 再次，这是一个函数，它调查数组并挑选出其中值最大的索引。 实际上，这会将十个单热点编码值的数组转换为一个数字，这将是我们预测的数字。 然后，我们使用将打印出`x`网格的分类报告，该报告向我们显示正确预测数字与被预测的数字总数相比的频率。
 

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

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

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

@@ -12,11 +12,11 @@
 
 # 什么是连体网络？
 
-连体网络是神经网络的一种特殊类型，它是最简单且使用最广泛的单发学习算法之一。 正如我们在上一章中学到的，单次学习是一种技术，其中我们每个班级仅从一个训练示例中学习。 因此，在每个类别中没有很多数据点的应用程序中主要使用连体网络。 例如，假设我们要为我们的组织建立一个人脸识别模型，并且在组织中有大约 500 个人在工作。 如果我们想从头开始使用**卷积神经网络**（**CNN**）建立人脸识别模型，那么我们需要这 500 人中的许多人来训练网络并获得良好的图像 准确性。 但是显然，我们不会为这 500 个人提供很多图像，因此除非有足够的数据点，否则使用 CNN 或任何深度学习算法构建模型都是不可行的。 因此，在这种情况下，我们可以求助于复杂的单次学习算法，例如连体网络，该算法可以从更少的数据点进行学习。
+连体网络是神经网络的一种特殊类型，它是最简单且使用最广泛的单发学习算法之一。 正如我们在上一章中学到的，单次学习是一种技术，其中我们每个班级仅从一个训练示例中学习。 因此，在每个类别中没有很多数据点的应用程序中主要使用连体网络。 例如，假设我们要为我们的组织建立一个人脸识别模型，并且在组织中有大约 500 个人在工作。 如果我们想从头开始使用**卷积神经网络**（**CNN**）建立人脸识别模型，那么我们需要这 500 人中的许多人来训练网络并获得准确性良好的图像。 但是显然，我们不会为这 500 个人提供很多图像，因此除非有足够的数据点，否则使用 CNN 或任何深度学习算法构建模型都是不可行的。 因此，在这种情况下，我们可以求助于复杂的单次学习算法，例如连体网络，该算法可以从更少的数据点进行学习。
 
 但是，连体网络如何工作？ 连体网络基本上由两个对称的神经网络组成，它们共享相同的权重和结构，并且都使用能量函数`E`最终结合在一起。 我们的连体网络的目标是了解两个输入值是相似还是相异。 假设我们有两个图像`X[1]`和`X2`，我们想了解两个图像是相似还是相异。
 
-如下图所示，我们将图像`X[1]`馈送到网络`A`和图像`X[2]`到另一个网络`B`。 这两个网络的作用是为输入图像生成嵌入（特征向量）。 因此，我们可以使用任何可以嵌入我们的网络。 由于我们的输入是图像，因此我们可以使用卷积网络来生成嵌入，即用于提取特征。 请记住，CNN 在这里的作用仅仅是提取特征而不是进行分类。 我们知道这些网络应该具有相同的权重和架构，如果我们的网络`A`是三层 CNN，那么我们的网络`B`也应该是三层 CNN，我们 这两个网络必须使用相同的权重集。 因此，网络`A`和网络`B`将为我们提供输入图像`X[1]`和`X[2]`的嵌入。 然后，我们会将这些嵌入信息提供给能量函数，从而告诉我们两个输入的相似程度。 能量函数基本上是任何相似性度量，例如欧几里得距离和余弦相似性。
+如下图所示，我们将图像`X[1]`馈送到网络`A`和图像`X[2]`到另一个网络`B`。 这两个网络的作用是为输入图像生成嵌入（特征向量）。 因此，我们可以使用任何可以嵌入我们的网络。 由于我们的输入是图像，因此我们可以使用卷积网络来生成嵌入，即用于提取特征。 请记住，CNN 在这里的作用仅仅是提取特征而不是进行分类。 我们知道这些网络应该具有相同的权重和架构，如果我们的网络`A`是三层 CNN，那么我们的网络`B`也应该是三层 CNN，我们这两个网络必须使用相同的权重集。 因此，网络`A`和网络`B`将为我们提供输入图像`X[1]`和`X[2]`的嵌入。 然后，我们会将这些嵌入信息提供给能量函数，从而告诉我们两个输入的相似程度。 能量函数基本上是任何相似性度量，例如欧几里得距离和余弦相似性。
 
 ![](img/a7f1a41e-4291-4bec-87dd-fa6bc1d0c00b.png)
 

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

@@ -410,7 +410,7 @@ class Matching_network():
         self.query_label = tf.placeholder(tf.int32, [None, ])
 ```
 
-假设我们的支持集和查询集包含图片。 在将此原始图像提供给嵌入函数之前，首先，我们将使用卷积网络从图像中提取特征，然后将支持集和查询集的提取特征提供给`g`的嵌入函数 和`f`。
+假设我们的支持集和查询集包含图片。 在将此原始图像提供给嵌入函数之前，首先，我们将使用卷积网络从图像中提取特征，然后将支持集和查询集的提取特征提供给嵌入函数`g`和`f`。
 
 因此，我们将定义一个名为`image_encoder`的函数，该函数用于对图像中的特征进行编码。 我们使用具有最大池化操作的四层卷积网络作为图像编码器：
 

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

@@ -53,7 +53,7 @@ NTM 的重要组成部分如下：
 
 ![](img/a274afdc-2759-43bc-8fe0-c3516401b0ab.png)
 
-如上图所示，我们具有`N`行和`M`列的存储矩阵，大小为`N`的权重向量包含 所有`N`个位置。 执行这两个的线性组合，我们得到长度为`M`的读取向量。
+如上图所示，我们具有`N`行和`M`列的存储矩阵，大小为`N`的权重向量包含所有`N`个位置。 执行这两个的线性组合，我们得到长度为`M`的读取向量。
 
 # 写操作
 

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

@@ -14,7 +14,7 @@
 
 # MAML
 
-MAML 是最近推出且使用最广泛的元学习算法之一，它在元学习研究中创造了重大突破。 元学习是元学习的重点，我们知道，在元学习中，我们从仅包含少量数据点的各种相关任务中学习，并且元学习者会产生一个可以很好地概括新的相关任务的快速学习者 即使训练样本数量较少。
+MAML 是最近推出且使用最广泛的元学习算法之一，它在元学习研究中创造了重大突破。 元学习是元学习的重点，我们知道，在元学习中，我们从仅包含少量数据点的各种相关任务中学习，并且元学习者会产生一个可以很好地概括新的相关任务的快速学习者，即使训练样本数量较少。
 
 MAML 的基本思想是找到一个更好的初始参数，以便具有良好的初始参数，该模型可以以较少的梯度步骤快速学习新任务。
 
@@ -22,7 +22,7 @@ MAML 的基本思想是找到一个更好的初始参数，以便具有良好的
 
 在 MAML 中，我们尝试通过学习类似任务的分布来找到这些最佳权重。 因此，对于新任务，我们不必从随机初始化的权重开始，而是可以从最佳权重开始，这将花费较少的梯度步骤来达到收敛，并且不需要更多的数据点来进行训练。
 
-让我们简单地了解一下 MAML； 假设我们有三个相关任务： `T1, T2, T3`。 首先，我们随机初始化模型参数`θ`。 我们针对任务`T1`训练我们的网络。 然后，我们尝试通过梯度下降使损失`L`最小化。 通过找到最佳参数`θ'[1]`，我们将损失降至最低。 同样，对于任务`T2`和`T3`，我们将以随机初始化的模型参数`θ`开始，并最小化 通过梯度下降找到正确的参数集来降低损耗。 假设`θ'[2]`和`θ'[3]`是任务的最佳参数，分别是`T2`和`T3`。
+让我们简单地了解一下 MAML； 假设我们有三个相关任务： `T1, T2, T3`。 首先，我们随机初始化模型参数`θ`。 我们针对任务`T1`训练我们的网络。 然后，我们尝试通过梯度下降使损失`L`最小化。 通过找到最佳参数`θ'[1]`，我们将损失降至最低。 同样，对于任务`T2`和`T3`，我们将以随机初始化的模型参数`θ`开始，并通过梯度下降找到正确的参数集来最小化损失。 假设`θ'[2]`和`θ'[3]`是任务的最佳参数，分别是`T2`和`T3`。
 
 如下图所示，我们以随机初始化的参数`θ`开始每个任务，并通过为每个任务`T`查找最佳参数`θ'[1]`，`θ'[2]`和`θ'[3]`来使损失最小化。 `T1, T2, T3`分别为：
 
@@ -69,7 +69,7 @@ MAML 的基本思想是找到一个更好的初始参数，以便具有良好的
 
 如果您仔细看一下以前的元更新方程，我们会注意到我们正在更新模型参数`θ`，方法是仅取每个新任务`Ti`的参数`θ'[i]`最佳梯度平均值。
 
-下图显示了 MAML 的总体算法； 我们的算法由两个循环组成：一个内部循环，我们在其中找到每个任务`Ti`的最佳参数`θ'[i]`，一个外部循环，在其中我们更新随机初始化的模型参数 通过计算相对于一组新任务`Ti`中最佳参数`θ'[i]`的梯度来确定`θ`：
+下图显示了 MAML 的总体算法； 我们的算法由两个循环组成：一个内部循环，我们在其中找到每个任务`Ti`的最佳参数`θ'[i]`，一个外部循环，在其中我们通过计算相对于一组新任务`Ti`中最佳参数`θ'[i]`的梯度来确定`θ`，并更新随机初始化的模型参数：
 
 ![](img/a8f748a6-3636-47c9-8118-a26d27fd687f.png)
 
@@ -94,7 +94,7 @@ MAML 非常擅长寻找最佳初始参数，对吗？ 现在，我们将看到
 1.  假设我们有一个由参数θ参数化的模型`f`，并且在任务`p(T)`上有分布。 首先，我们随机初始化模型参数θ。
 2.  我们从任务分布中抽取一些任务`Ti`，即`Ti ~ p(T)`。 假设我们采样了三个任务，然后`T = {T1, T2, T3}`。
 
-3.  **内循环**：对于任务（`T`）中的每个任务（`Ti`），我们对`k`数据进行采样 点并准备我们的训练和测试数据集：
+3.  **内循环**：对于任务（`T`）中的每个任务（`Ti`），我们对`k`个数据点进行采样，并准备我们的训练和测试数据集：
 
 ![](img/037ef61e-e595-4eb7-8fd1-00f6fce23823.png) ![](img/259b87df-9fd2-430a-9a11-1718a717f16f.png)
 
@@ -465,7 +465,7 @@ Sampling Next Batch of Tasks
 
 ![](img/75cd4f0f-ba3e-4a2d-b1f9-6e819e8b8336.png)
 
-但是上一个方程式中发生了什么？ `R(x[y, t])`表示对状态`x`具有作用`a`的奖励 时间`t`和`t = 1`至`H`表示我们的时间步长，其中`H`是地平线-我们的最终时间步长。
+但是上一个方程式中发生了什么？ `R(x[y, t])`表示时间`t`的状态`x`和动作`a`的奖励，`t = 1`至`H`表示我们的时间步长，其中`H`是地平线-我们的最终时间步长。
 
 假设我们有一个由`θ`参数化的模型`f`，也就是`f[θ]()`和任务的分布`p(T)`。 首先，我们用一些随机值初始化参数`θ`。 接下来，我们从任务分布中抽样一些任务`Ti`： `Ti ~ p(T)`。
 
@@ -503,7 +503,7 @@ Sampling Next Batch of Tasks
 
 现在，我们已经了解了什么是对抗性样本以及如何生成对抗性样本，我们将看到如何在元学习中使用这些对抗性样本。 我们使用干净样本和对抗样本训练元学习模型。 但是，需要使用对抗样本训练模型吗？ 它有助于我们找到鲁棒的模型参数`θ`。 干净样本和对抗样本均在算法的内部和外部循环中使用，并且同样有助于更新模型参数。 ADML 使用干净样本和对抗样本之间的这种变化的相关性来获得更好，更健壮的模型参数初始化，从而使我们的参数对对抗样本变得健壮，并且可以很好地推广到新任务。
 
-因此，当我们有任务分布`p(T)`，时，我们从任务分布中采样了一批任务`Ti`，对于每个任务，我们 对`k`个数据点进行采样，并准备我们的训练和测试集。
+因此，当我们有任务分布`p(T)`，时，我们从任务分布中采样了一批任务`Ti`，对于每个任务，我们采样`k`个数据点，并准备我们的训练和测试集。
 
 在 ADML 中，我们将训练集和测试集的干净样本和对抗样本采样为`D_train[clean_i]`，`D_train[adv_i]`，`D_test[clean_i]`，`D_test[adv_i]`。
 
@@ -1025,7 +1025,7 @@ Sampling Next Batch of Tasks
 
 # 反洗钱
 
-我们已经看到了 MAML 如何找到模型的最佳初始参数，从而可以轻松地以较少的梯度步骤将其适应于新任务。 现在，我们将看到一个有趣的 MAML 变体，称为 CAML。 CAML 的概念非常简单，与 MAML 相同。 它还尝试找到更好的初始参数。 我们了解了 MAML 如何使用两个循环。 在内部循环中，MAML 学习特定于任务的参数，并尝试使用梯度下降来最大程度地减少损失，在外部循环中，它更新模型参数以减少跨多个任务的预期损失，以便我们可以使用更新的模型 参数作为相关任务的更好的初始化。
+我们已经看到了 MAML 如何找到模型的最佳初始参数，从而可以轻松地以较少的梯度步骤将其适应于新任务。 现在，我们将看到一个有趣的 MAML 变体，称为 CAML。 CAML 的概念非常简单，与 MAML 相同。 它还尝试找到更好的初始参数。 我们了解了 MAML 如何使用两个循环。 在内部循环中，MAML 学习特定于任务的参数，并尝试使用梯度下降来最大程度地减少损失，在外部循环中，它更新模型参数以减少跨多个任务的预期损失，以便我们可以使用更新的模型参数作为相关任务的更好的初始化。
 
 在 CAML 中，我们对 MAML 算法进行了非常小的调整。 在这里，我们不使用单个模型参数，而是将模型参数分成两个部分：
 
@@ -1043,7 +1043,7 @@ Sampling Next Batch of Tasks
 1.  假设我们有一个由参数θ参数化的模型`f`，并且在任务`p(T)`上有分布。 首先，我们随机初始化模型参数θ。 我们还初始化了上下文参数`∅[0] = 0`。
 2.  现在，我们从任务分布中抽样一些任务`Ti`，即`Ti ~ p(T)`。
 
-3.  **内循环**：对于任务（`T`）中的每个任务（`Ti`），我们对`k`数据进行采样 点并准备我们的训练和测试数据集：
+3.  **内循环**：对于任务（`T`）中的每个任务（`Ti`），我们采样`k`个数据点并准备我们的训练和测试数据集：
 
 ![](img/4e2552d7-1491-4538-abef-5499fce82cf0.png)
 

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

@@ -426,7 +426,7 @@ Sampling Next Batch of Tasks
 
 # 爬虫
 
-Reptile 算法已被 OpenAI 提出作为对 MAML 的改进。 它很容易实现。 我们知道，在 MAML 中，我们可以计算二阶导数，即梯度的梯度。 但是从计算上来说，这不是一个有效的任务。 因此，OpenAI 提出了对 MAML 的改进，称为 Reptile。 Reptile 的算法非常简单。 对一些`n`个任务进行采样，然后运行**随机梯度下降**（**SGD**），以减少每个采样任务的迭代次数，然后沿某个方向更新模型参数 这是所有任务的共同点。 由于我们对每个任务执行的 SGD 迭代次数较少，因此间接暗示我们正在计算损失的二阶导数。 与 MAML 不同，它在计算上很有效，因为我们不直接计算二阶导数也不展开计算图，因此易于实现。
+Reptile 算法已被 OpenAI 提出作为对 MAML 的改进。 它很容易实现。 我们知道，在 MAML 中，我们可以计算二阶导数，即梯度的梯度。 但是从计算上来说，这不是一个有效的任务。 因此，OpenAI 提出了对 MAML 的改进，称为 Reptile。 Reptile 的算法非常简单。 对一些`n`个任务进行采样，然后运行**随机梯度下降**（**SGD**），以减少每个采样任务的迭代次数，然后沿某个方向更新模型参数，这是所有任务的共同点。 由于我们对每个任务执行的 SGD 迭代次数较少，因此间接暗示我们正在计算损失的二阶导数。 与 MAML 不同，它在计算上很有效，因为我们不直接计算二阶导数也不展开计算图，因此易于实现。
 
 假设我们从任务分布中采样了两个任务`T[1]`和`T[2]`，并随机初始化了模型参数`θ`。 首先，我们接受任务`T[1]`并对某些`n`次迭代执行 SGD，并获得最佳参数`θ'[i]`。 然后我们执行下一个任务`T[2]`，迭代执行 SGD `n`次，并获得最佳参数`θ'[i]`。 因此，我们有两个最佳参数集：`θ' = {θ'[1], θ'[2]}`。 现在，我们需要沿更靠近这两个最佳参数的方向移动参数`θ`，如下图所示：
 

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

@@ -187,7 +187,7 @@ MIL 中涉及的步骤如下：
 
 # 学习在概念空间中学习
 
-现在，我们将看到如何使用深度元学习在概念空间中元学习。 首先，我们如何进行元学习？ 我们在每个任务中抽样一批相关任务和一些`k`数据点，并训练我们的元学习者。 我们可以将深度学习的力量与元学习结合起来，而不仅仅是使用我们的原始元学习技术进行培训。 因此，当我们对一批任务以及每个任务中的一些`k`数据点进行采样时，我们将使用深度神经网络学习每个`k`数据点的表示形式，然后 对这些表示进行元学习。
+现在，我们将看到如何使用深度元学习在概念空间中元学习。 首先，我们如何进行元学习？ 我们在每个任务中抽样一批相关任务和一些`k`数据点，并训练我们的元学习者。 我们可以将深度学习的力量与元学习结合起来，而不仅仅是使用我们的原始元学习技术进行培训。 因此，当我们对一批任务以及每个任务中的一些`k`数据点进行采样时，我们将使用深度神经网络学习每个`k`数据点的表示形式，然后对这些表示进行元学习。
 
 我们的框架包含三个组件：
 
@@ -195,9 +195,9 @@ MIL 中涉及的步骤如下：
 *   概念鉴别器
 *   元学习者
 
-概念生成器的作用是提取数据集中每个数据点的特征表示，捕获其高级概念，概念鉴别器的作用是识别和分类由概念生成器生成的概念，而 元学习者学习由概念生成器生成的概念。 先前的所有组件（即概念生成器，概念鉴别器和元学习器）都可以一起学习。 因此，我们通过将元学习与深度学习相集成来改善原始元学习。 我们的概念生成器随着新的传入数据而发展，因此我们可以将我们的框架视为终身学习系统。
+概念生成器的作用是提取数据集中每个数据点的特征表示，捕获其高级概念，概念鉴别器的作用是识别和分类由概念生成器生成的概念，而元学习者学习由概念生成器生成的概念。 先前的所有组件（即概念生成器，概念鉴别器和元学习器）都可以一起学习。 因此，我们通过将元学习与深度学习相集成来改善原始元学习。 我们的概念生成器随着新的传入数据而发展，因此我们可以将我们的框架视为终身学习系统。
 
-但是这里到底发生了什么？ 看下图； 如您所见，我们对一组任务进行采样，并将其提供给概念生成器，该概念生成器将学习概念（即嵌入），然后将这些概念提供给元学习器，后者将学习这些概念并将损失回馈给 概念生成器。 同时，我们还将一些外部数据集提供给概念生成器，概念生成器学习这些输入的概念并将这些概念发送给概念识别器。 概念识别器预测这些概念的标签，计算损失，然后将损失发送回概念生成器。 通过这样做，我们增强了概念生成器概括概念的能力：
+但是这里到底发生了什么？ 看下图； 如您所见，我们对一组任务进行采样，并将其提供给概念生成器，该概念生成器将学习概念（即嵌入），然后将这些概念提供给元学习器，后者将学习这些概念并将损失回馈给概念生成器。 同时，我们还将一些外部数据集提供给概念生成器，概念生成器学习这些输入的概念并将这些概念发送给概念识别器。 概念识别器预测这些概念的标签，计算损失，然后将损失发送回概念生成器。 通过这样做，我们增强了概念生成器概括概念的能力：
 
 ![](img/ab57f770-1198-4573-a9ab-a4e9ba34bb85.png)