2020-12-25 20:47:12

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

@@ -11,17 +11,17 @@
 
 # 梯度协议作为优化
 
-梯度一致性算法是一种有趣且最近引入的算法，可作为元学习算法的增强功​​能。 在 MAML 和 Reptile 中，我们尝试找到一个更好的模型参数，该参数可在多个相关任务中推广，以便我们可以使用更少的数据点快速学习。 如果我们回顾前面几章中学到的知识，就会发现我们随机初始化了模型参数，然后从任务分布![](img/f31ea39c-34ba-4674-8cdc-c84a89c8bd4d.png)中抽取了一批随机任务![](img/6a76c328-6ece-4221-b362-dfb12c664952.png)进行了采样。 对于每个采样任务![](img/6a76c328-6ece-4221-b362-dfb12c664952.png)，我们通过计算梯度将损失降到最低，并获得更新的参数![](img/dd9ec7a2-16b0-4c48-a13e-9ce398fdff63.png)，这形成了我们的内部循环：
+梯度一致性算法是一种有趣且最近引入的算法，可作为元学习算法的增强功​​能。 在 MAML 和 Reptile 中，我们尝试找到一个更好的模型参数，该参数可在多个相关任务中推广，以便我们可以使用更少的数据点快速学习。 如果我们回顾前面几章中学到的知识，就会发现我们随机初始化了模型参数，然后从任务分布`p(T)`中抽取了一批随机任务`T[i]`进行了采样。 对于每个采样任务`T[i]`，我们通过计算梯度将损失降到最低，并获得更新的参数`θ'[i]`，这形成了我们的内部循环：
 
 ![](img/93324229-a8df-4cb6-aead-090e6ebb7a0a.png)
 
-在为每个采样任务计算出最佳参数之后，我们执行元优化-也就是说，我们通过计算一组新任务中的损失来执行元优化，并通过针对最佳参数`θ'[i]`计算梯度来最大程度地减少损失， 我们在内部循环中获得的，并更新了初始模型参数![](img/14c754a4-f3d5-4a53-a06a-af325718e358.png)：
+在为每个采样任务计算出最佳参数之后，我们执行元优化-也就是说，我们通过计算一组新任务中的损失来执行元优化，并通过针对最佳参数`θ'[i]`计算梯度来最大程度地减少损失， 我们在内部循环中获得的，并更新了初始模型参数`θ`：
 
 ![](img/a32ed07f-28bb-476b-847f-5093fde1a90a.png)
 
-前面的方程式实际上是什么？ 如果仔细研究这个方程，您会注意到我们只是对各个任务的梯度求平均值，并更新我们的模型参数![](img/8bb0d75d-b140-4443-a8e8-e20254ac0fde.png)，这意味着所有任务在更新我们的模型参数方面均做出同等贡献。
+前面的方程式实际上是什么？ 如果仔细研究这个方程，您会注意到我们只是对各个任务的梯度求平均值，并更新我们的模型参数`θ`，这意味着所有任务在更新我们的模型参数方面均做出同等贡献。
 
-但是，这怎么了？ 假设我们已经采样了四个任务，并且三个任务在一个方向上具有梯度更新，但是一个任务在一个方向上与其他任务完全不同的梯度更新。 由于所有任务的坡度对更新模型参数的贡献均相等，因此这种分歧可能会对更新模型的初始参数产生严重影响。 如下图所示，与其他任务相比，从![](img/2e11ca1e-7bf4-41db-84eb-73ebcf3636cc.png)到![](img/3581a639-ffaa-4682-bf53-55d8c30f6648.png)的所有任务在一个方向上具有梯度，但是任务![](img/13ead245-2815-4417-b18c-15718a4312ff.png)在完全不同的方向上具有梯度：
+但是，这怎么了？ 假设我们已经采样了四个任务，并且三个任务在一个方向上具有梯度更新，但是一个任务在一个方向上与其他任务完全不同的梯度更新。 由于所有任务的坡度对更新模型参数的贡献均相等，因此这种分歧可能会对更新模型的初始参数产生严重影响。 如下图所示，与其他任务相比，从`T[1]`到`T[3]`的所有任务在一个方向上具有梯度，但是任务`T[4]`在完全不同的方向上具有梯度：
 
 ![](img/54e133c3-30ae-49e2-bd8a-74eba5711ce0.png)
 
@@ -47,9 +47,9 @@
 
 ![](img/bf3a2201-8469-4802-8e8b-1a77b6c35ad8.png)
 
-假设我们抽样了一批任务。 然后，对于批量中的每个任务，我们对`k`个数据点进行采样，计算损失，更新梯度，并找到每个任务的最佳参数`θ'[i]`。 与此同时，我们还将每个任务的梯度更新向量存储在![](img/d3270793-e1ed-4c1b-9cf5-0749201fb690.png)中。 可以计算为![](img/885389fb-9c2a-4a41-9600-270f46c23850.png)。
+假设我们抽样了一批任务。 然后，对于批量中的每个任务，我们对`k`个数据点进行采样，计算损失，更新梯度，并找到每个任务的最佳参数`θ'[i]`。 与此同时，我们还将每个任务的梯度更新向量存储在`g[i]`中。 可以计算为`g[i] = θ - θ'[i]`。
 
-因此，![](img/db1dd637-56c6-490d-85ef-047f78be9815.png)任务的权重是![](img/af4e2919-4e2b-47f7-9060-12e4f5b1b242.png)和![](img/6c387c39-bc77-4e18-88f0-48060009e4d3.png)的内积之和除以归一化因子。 归一化因子与![](img/d2497d95-29c0-40d4-8073-ccda9852f5d2.png)和![](img/a7fa1fc1-556f-40dd-af23-15f759a7dca7.png)的内积成正比。
+因此，第`i`个任务的权重是`g[i]`和`g[j]`的内积之和除以归一化因子。 归一化因子与`g[i]`和`g_avg`的内积成正比。
 
 通过查看以下代码，让我们更好地理解如何精确计算这些权重：
 
@@ -78,25 +78,27 @@ for i in range(num_tasks):
 
 现在，让我们看一下梯度协议的工作原理：
 
-1.  假设我们有一个由参数![](img/8d358d29-40fc-4658-99ec-8dce07ffed4e.png)参数化的模型![](img/bfb72f9a-40a2-4714-af50-7413e94d75c5.png)和任务![](img/cee73716-a0c5-4331-8c95-8008acc3de5d.png)上的分布。 首先，我们随机初始化模型参数![](img/903a7361-1e91-4fe0-bb13-768777903a48.png)。
-2.  我们从任务分布中![](img/30fb6037-d542-4092-9f74-8a1f4e026b43.png)采样了一些任务![](img/ecdf7adc-d6ac-4ae0-ae47-b1117c642370.png)。 假设我们采样了两个任务，然后是![](img/2b20fb20-d4ea-4a02-be86-be16c4afa37b.png)。
-3.  **内循环**：对于任务（![](img/9004a396-a086-42e6-8cca-5a2212f0fbef.png)）中的每个任务（![](img/ec769f15-277c-41ad-98f3-673c370b9c8a.png)），我们对`k`个数据点进行采样，并准备训练和测试数据集：
+1.  假设我们有一个由参数`θ`参数化的模型`f`和任务上的分布`p(T)`。 首先，我们随机初始化模型参数`θ`。
+2.  我们从任务分布`T ~ p(T)`中采样了一些任务`T[i]`。 假设我们采样了两个任务，然后是`T`。
+3.  **内循环**：对于任务（`T`）中的每个任务（`T[i]`），我们对`k`个数据点进行采样，并准备训练和测试数据集：
 
 ![](img/b66a819c-dc38-44e0-a336-69e7b76ed4f0.png)
 
 ![](img/ea7d1848-6a67-49fa-be6d-75bb9373c18b.png)
 
-我们使用梯度下降来计算损耗并使![](img/cf4419e2-a8d6-4dac-8d7d-2ad60a97e533.png)上的损耗最小，并获得最佳参数`θ'[i]`-![](img/7abdf4a0-5254-4785-9a28-55793af3f6e0.png)。
+我们使用梯度下降来计算损耗并使`D_train[i]`上的损耗最小，并获得最佳参数`θ'[i]`：
 
-与此同时，我们还将梯度更新向量存储为：![](img/931d62e5-10ae-41ee-bac0-841f7c7237e0.png)。
+![](img/7abdf4a0-5254-4785-9a28-55793af3f6e0.png)。
 
-因此，对于每个任务，我们对`k`个数据点进行采样，并最大程度地减少训练集![](img/cf4419e2-a8d6-4dac-8d7d-2ad60a97e533.png)上的损失，并获得最佳参数`θ'[i]`。 当我们采样两个任务时，我们将有两个最佳参数`θ'[i]`，并且我们将为这两个任务中的每一个都有一个梯度更新向量![](img/11b42fa8-3a92-4824-ac83-286a7a62a445.png)。
+与此同时，我们还将梯度更新向量存储为：`g[i] = θ - θ'[i]`。
+
+因此，对于每个任务，我们对`k`个数据点进行采样，并最大程度地减少训练集`D_train[i]`上的损失，并获得最佳参数`θ'[i]`。 当我们采样两个任务时，我们将有两个最佳参数`θ'[i]`，并且我们将为这两个任务中的每一个都有一个梯度更新向量`g = {(θ - θ'[1]), (θ - θ'[2])}`。
 
 4.  **外循环**：现在，在执行元优化之前，我们将按以下方式计算权重：
 
 ![](img/a735063f-a419-46f8-bd00-d06a0e7df3d0.png)
 
-在计算权重之后，我们现在通过将权重与梯度相关联来执行元优化。 通过计算相对于上一步中获得的参数的梯度，并将梯度与权重相乘，我们将![](img/f76662f9-e4c4-4f0c-be32-a0a204d1e754.png)中的损失最小化。
+在计算权重之后，我们现在通过将权重与梯度相关联来执行元优化。 通过计算相对于上一步中获得的参数的梯度，并将梯度与权重相乘，我们将`D_test[i]`中的损失最小化。
 
 如果我们的元学习算法是 MAML，则更新公式如下：
 
@@ -209,7 +211,7 @@ class GradientAgreement_MAML(object):
             for i in range(self.num_tasks):
 ```
 
-我们对`k`个数据点进行采样，并准备我们的火车组![](img/5de96cd5-ee46-4140-9dc7-cfe42401d367.png)：
+我们对`k`个数据点进行采样，并准备我们的训练集`D_train[i]`：
 
 ```py
                 XTrain, YTrain = sample_points(self.num_samples)
@@ -223,7 +225,7 @@ class GradientAgreement_MAML(object):
                 YHat = self.sigmoid(a)
 ```
 
-我们使用梯度下降![](img/bb49d618-c397-4d52-a896-0dd6bc9e9f4d.png)计算损耗并使损耗最小化：
+我们使用梯度下降`θ'[i] = θ - αᐁ[θ]L[T[i]](f[θ])`计算损耗并使损耗最小化：
 
 ```py
                 #since we're performing classification, we use cross entropy loss as our loss function
@@ -237,13 +239,15 @@ class GradientAgreement_MAML(object):
 
 ```
 
-我们将梯度更新存储在`g`和![](img/b10b1009-342f-471c-b58c-0cb416808e2d.png)中：
+我们将梯度更新存储在`g`和`g[i] = θ - θ'`中：
 
 ```py
                 self.g.append(self.theta-self.theta_[i])
 ```
 
-现在，我们计算权重![](img/64a42b94-e7e4-4fe5-9e7d-ac423eeb8963.png)：
+现在，我们计算权重：
+
+![](img/64a42b94-e7e4-4fe5-9e7d-ac423eeb8963.png)
 
 ```py
             normalization_factor = 0
@@ -269,7 +273,7 @@ class GradientAgreement_MAML(object):
             weighted_gradient = np.zeros(self.theta.shape)
 ```
 
-对于任务数量，我们对`k`个数据点进行采样，并准备测试集![](img/594ea09a-7bac-45ee-a809-9421fd932510.png)：
+对于任务数量，我们对`k`个数据点进行采样，并准备测试集`D_test[i]`：
 
 ```py
             for i in range(self.num_tasks):
@@ -292,7 +296,9 @@ class GradientAgreement_MAML(object):
                 meta_gradient = np.matmul(XTest.T, (YPred - YTest)) / self.num_samples
 ```
 
-将权重乘以计算出的元梯度，并使用![](img/60dee51c-592a-4c55-822a-ff7c5711ff9d.png)更新![](img/161dd888-c43d-481c-ac1d-9c9064e97e35.png)的值：
+将权重乘以计算出的元梯度，并使用这个更新`θ`的值：
+
+![](img/60dee51c-592a-4c55-822a-ff7c5711ff9d.png)
 
 ```py
                 weighted_gradient += np.sum(w[i]*meta_gradient)
@@ -469,7 +475,7 @@ Sampling Next Batch of Tasks
 
 # 概要
 
-在本章中，我们学习了梯度一致性算法。 我们已经看到了梯度一致性算法如何使用加权梯度来找到更好的初始模型参数![](img/53f63aef-c6c4-45ed-8e0d-744bd090430f.png)。 我们还看到了这些权重如何与任务梯度的内积和采样批次任务中所有任务的梯度平均值的乘积成正比。 我们还探讨了如何将梯度一致性算法与 MAML 和 Reptile 算法结合使用。 之后，我们看到了如何使用梯度一致性算法在分类任务中找到最佳参数`θ'[i]`。
+在本章中，我们学习了梯度一致性算法。 我们已经看到了梯度一致性算法如何使用加权梯度来找到更好的初始模型参数`θ`。 我们还看到了这些权重如何与任务梯度的内积和采样批次任务中所有任务的梯度平均值的乘积成正比。 我们还探讨了如何将梯度一致性算法与 MAML 和 Reptile 算法结合使用。 之后，我们看到了如何使用梯度一致性算法在分类任务中找到最佳参数`θ'[i]`。
 
 在下一章中，我们将了解元学习的最新进展，例如与任务无关的元学习，在概念空间中学习以及元模仿学习。