深度学习应用篇-元学习[14]：基于优化的元学习-MAML模型、LEO模型、Reptile模型

1.Model-Agnostic Meta-Learning

Model-Agnostic Meta-Learning (MAML)： 与模型无关的元学习，可兼容于任何一种采用梯度下降算法的模型。 MAML 通过少量的数据寻找一个合适的初始值范围，从而改变梯度下降的方向， 找到对任务更加敏感的初始参数， 使得模型能够在有限的数据集上快速拟合，并获得一个不错的效果。 该方法可以用于回归、分类以及强化学习。

该模型的Paddle实现请参考链接：PaddleRec版本

1.1 MAML

MAML 是典型的双层优化结构，其内层和外层的优化方式如下：

1.1.1 MAML 内层优化方式

内层优化涉及到基学习器，从任务分布 $p(T)p(T)$ 中随机采样第 $ii$ 个任务 $T_{i}T\_\{i\}$。任务 $T_{i}T\_\{i\}$ 上，基学习器的目标函数是：

其中，$f_{\varphi }f\_\{\backslash phi\}$ 是基学习器，$\varphi \backslash phi$ 是基学习器参数，$L_{T_i}\left(f_{\varphi }\right)L\_\{T\_\{i\}\}\backslash left(f\_\{\backslash phi\}\backslash right)$ 是基学习器在 $T_{i}T\_\{i\}$ 上的损失。更新基学习器参数：

其中，$\theta \backslash theta$ 是元学习器提供给基学习器的参数初始值 $\varphi =\theta \backslash phi=\backslash theta$，在任务 $T_{i}T\_\{i\}$ 上更新 $NN$ 后 $\varphi ={\theta }_i^{N-1}\backslash phi=\backslash theta\_\{i\}^\{N-1\}$.

1.1.2 MAML 外层优化方式

外层优化涉及到元学习器，将 ${\theta }_i^N\backslash theta\_\{i\}^\{N\}$ 反馈给元学匀器，此时元目标函数是：

元目标函数是所有任务上验证集损失和。更新元学习器参数：

1.2 MAML 算法流程

1. randomly initialize $\theta \backslash theta$
2. while not done do:
3. sample batch of tasks $T_i\sim p(T)T\_i\; \backslash sim\; p(T)$
4. for all $T_{i}T\_i$ do：
   1. evaluate ${\mathrm{\nabla }}_{\varphi }{L}_{T_i}\left(f_{\varphi }\right)\backslash nabla\_\{\backslash phi\}L\_\{T\_\{i\}\}\backslash left(f\_\{\backslash phi\}\backslash right)$ with respect to K examples
   2. compute adapted parameters with gradient descent: ${\theta }_i^N={\theta }_i^{N-1}-\alpha {\left[{\mathrm{\nabla }}_{\varphi }{L}_{T_i}\left(f_{\varphi }\right)\right]}_{\varphi ={\theta }_i^{N-1}}\backslash theta\_\{i\}^\{N\}=\backslash theta\_\{i\}^\{N-1\}\; -\backslash alpha\backslash left[\backslash nabla\_\{\backslash phi\}L\_\{T\_\{i\}\}\backslash left(f\_\{\backslash phi\}\backslash right)\backslash right]\_\{\backslash phi=\backslash theta\_\{i\}^\{N-1\}\}$
5. end for
6. update $\theta \leftarrow \theta -\beta {\sum }_{T_i\sim p(T)}{\mathrm{\nabla }}_{\theta }{\left[L_{T_i}\left(f_{\varphi }\right)\right]}_{\varphi ={\theta }_i^N}\backslash theta\; \backslash leftarrow\; \backslash theta-\backslash beta\; \backslash sum\_\{T\_\{i\}\; \backslash sim\; p(T)\}\; \backslash nabla\_\{\backslash theta\}\backslash left[L\_\{T\_\{i\}\}\backslash left(f\_\{\backslash phi\}\backslash right)\backslash right]\_\{\backslash phi=\backslash theta\_\{i\}^\{N\}\}$
7. end while

MAML 中执行了两次梯度下降 (gradient by gradient)，分别作用在基学习器和元学习器上。图1给出了 MAML 中特定任务参数 ${\theta }_i^{\ast }\backslash theta\_\{i\}^\{*\}$ 和元级参数 $\theta \backslash theta$ 的更新过程。

1.3 MAML 模型结构

MAML 是一种与模型无关的元学习方法，可以适用于任何基于梯度优化的模型结构。

基准模型：4 modules with a 3 $\times \backslash times$ 3 convolutions and 64 filters, followed by batch normalization, a ReLU nonlinearity, and 2 $\times \backslash times$ 2 max-pooling。

1.4 MAML 分类结果

1.5 MAML 的优缺点

优点

• 适用于任何基于梯度优化的模型结构。

• 双层优化结构，提升模型精度和泛化能力，避免过拟合。

缺点

• 存在二阶导数计算

1.6 对 MAML 的探讨

• 每个任务上的基学习器必须是一样的，对于差别很大的任务，最切合任务的基学习器可能会变化，那么就不能用 MAML 来解决这类问题。

• MAML 适用于所有基于随机梯度算法求解的基学习器，这意味着参数都是连续的，无法考虑离散的参数。对于差别较大的任务，往往需要更新网络结构。使用 MAML 无法完成这样的结构更新。

• MAML 使用的损失函数都是可求导的，这样才能使用随机梯度算法来快速优化求解，损失函数中不能有不可求导的奇异点，否则会导致优化求解不稳定。

• MAML 中考虑的新任务都是相似的任务，所以没有对任务进行分类，也没有计算任务之间的距离度量。对每一类任务单独更新其参数初始值，每一类任务的参数初始值不同，这些在 MAML 中都没有考虑。

• 参考文献

[1] Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks.

2.Latent Embedding Optimization

Latent Embedding Optimization (LEO) 学习模型参数的低维潜在嵌入，并在这个低维潜在空间中执行基于优化的元学习，将基于梯度的自适应过程与模型参数的基础高维空间分离。

2.1 LEO

在元学习器中，使用 SGD 最小化任务验证集损失函数， 使得模型的泛化能力最大化，计算元参数，元学习器将元参数输入基础学习器， 继而，基础学习器最小化任务训练集损失函数，快速给出任务上的预测结果。 LEO 结构如图1所示。

图1 LEO 结构图。$D^{\mathrm{t}\mathrm{r}}D^\{\backslash mathrm\{tr\}\}$ 是任务 $\epsilon \backslash varepsilon$ 的 support set， $D^{\mathrm{v}\mathrm{a}\mathrm{l}}D^\{\backslash mathrm\{val\}\}$ 是任务 $\epsilon \backslash varepsilon$ 的 query set， $zz$ 是通过编码器计算的 $NN$ 个类别的类别特征，$f_{\theta }f\_\{\backslash theta\}$ 是基学习器， $\theta \backslash theta$ 是基学习器参数， $L^{\mathrm{t}\mathrm{r}}=f_{\theta }\left(D^{\mathrm{t}\mathrm{r}}\right)L^\{\backslash mathrm\{tr\}\}=f\_\{\backslash theta\}\backslash left(\; D^\{\backslash mathrm\{tr\}\}\backslash right)$, $L^{\mathrm{v}\mathrm{a}\mathrm{l}}=f_{\theta }\left(D^{\mathrm{v}\mathrm{a}\mathrm{l}}\right)L^\{\backslash mathrm\{val\}\}=f\_\{\backslash theta\}\backslash left(\; D^\{\backslash mathrm\{val\}\}\backslash right)$。

LEO 包括基础学习器和元学习器，还包括编码器和解码器。 在基础学习器中，编码器将高维输入数据映射成特征向量， 解码器将输入数据的特征向量映射成输入数据属于各个类别的概率值， 基础学习器使用元学习器提供的元参数进行参数更新，给出数据标注的预测结果。 元学习器为基础学习器的编码器和解码器提供元参数， 元参数包括特征提取模型的参数、编码器的参数、解码器的参数等， 通过最小化所有任务上的泛化误差，更新元参数。

2.2 基础学习器

编码器和解码器都在基础学习器中，用于计算输入数据属于每个类别的概率值， 进而对输入数据进行分类。 元学习器提供编码器和解码器中的参数，基础学习器快速的使用编码器和解码器计算输入数据的分类。 任务训练完成后，基础学习器将每个类别数据的特征向量和任务 $\epsilon \backslash varepsilon$ 的基础学习器参数 ${\mathit{\theta }}_{\epsilon }\backslash boldsymbol\{\backslash theta\}\_\{\backslash varepsilon\}$ 输入元学习器， 元学习器使用这些信息更新元参数。

2.2.1 编码器

编码器模型包括两个主要部分：编码器和关系网络。

编码器 $g_{{\varphi }_e}g\_\{\backslash phi\_\{e\}\}$ ，其中 ${\varphi }_e\backslash phi\_\{e\}$ 是编码器的可训练参数， 其功能是将第 $nn$ 个类别的输入数据映射成第 $nn$ 个类别的特征向量。

关系网络 $g_{{\varphi }_r}g\_\{\backslash phi\_\{r\}\}$ ，其中 ${\varphi }_r\backslash phi\_\{r\}$ 是关系网络的可训练参数， 其功能是计算特征之间的距离。

第 $nn$ 个类别的输入数据的特征记为 $z_{n}z\_\{n\}$ 。 对于输入数据，首先，使用编码器 $g_{{\varphi }_e}g\_\{\backslash phi\_\{e\}\}$ 对属于第 $nn$ 个类别的输入数据进行特征提取； 然后，使用关系网络 $g_{{\varphi }_r}g\_\{\backslash phi\_r\}$ 计算特征之间的距离， 综合考虑训练集中所有样本点之间的距离，计算这些距离的平均值和离散程度； 第 $nn$ 个类别输入数据的特征 $z_{n}z\_\{n\}$ 服从高斯分布， 且高斯分布的期望是这些距离的平均值，高斯分布的方差是这些距离的离散程度， 具体的计算公式如下：

其中，$NN$ 是类别总数， $KK$ 是每个类别的图片总数， $D_n^{\mathrm{t}\mathrm{r}}\{D\}\_\{n\}^\{\backslash mathrm\{tr\}\}$ 是第 $nn$ 个类别的训练数据集。 对于每个类别的输入数据，每个类别下有 $KK$ 张图片， 计算这 $KK$ 张图片和所有已知图片之间的距离。 总共有 $NN$ 个类别，通过编码器的计算，形成所有类别的特征， 记为 $z=(z_1,\cdots ,z_N)z=\backslash left(z\_\{1\},\; \backslash cdots,\; z\_\{N\}\backslash right)$。

2.2.2 解码器

解码器 $g_{{\varphi }_d}g\_\{\backslash phi\_\{d\}\}$ ，其中 ${\varphi }_d\backslash phi\_\{d\}$ 是解码器的可训练参数， 其功能是将每个类别输入数据的特征向量 $z_{n}z\_\{n\}$ 映射成属于每个类别的概率值 ${\mathit{w}}_n\backslash boldsymbol\{w\}\_\{n\}$：

其中，任务 $\epsilon \backslash varepsilon$ 的基础学习器参数记为 ${\theta }_{\epsilon }\backslash theta\_\{\backslash varepsilon\}$， 基础学习器参数由属于每个类别的概率值组成， 记为 ${\theta }_{\epsilon }=(w_1,w_2,\cdots ,w_N)\backslash theta\_\{\backslash varepsilon\}=\backslash left(w\_\{1\},\; w\_\{2\},\; \backslash cdots,\; w\_\{N\}\backslash right)$， 基础学习器参数 ${\mathit{w}}_n\backslash boldsymbol\{w\}\_\{n\}$ 指的是输入数据属于第 $nn$ 个类别的概率值， $g_{{\varphi }_d}g\_\{\backslash phi\_\{d\}\}$ 是从特征向量到基础学习器参数的映射。

2.2.3 基础学习器更新过程

在基础学习器中，任务 $\epsilon \backslash varepsilon$ 的交叉熵损失函数是：

其中，$(x,y)(x,\; y)$ 是任务 $\epsilon \backslash varepsilon$ 训练集 $D_{\epsilon }^{\mathrm{t}\mathrm{r}}D\_\{\backslash varepsilon\}^\{\backslash mathrm\{tr\}\}$ 中的样本点，$f_{{\theta }_{\epsilon }}f\_\{\backslash theta\_\{\backslash varepsilon\}\}$ 是任务 $\epsilon \backslash varepsilon$ 的基础学习器， 最小化任务 $\epsilon \backslash varepsilon$ 的损失函数更新任务专属参数 ${\theta }_{\epsilon }\backslash theta\_\{\backslash varepsilon\}$ 。 在解码器模型中，任务专属参数为 $w_n\sim q(w\mid z_n)w\_\{n\}\; \backslash sim\; q\backslash left(w\; \backslash mid\; z\_\{n\}\backslash right)$， 更新任务专属参数 ${\theta }_{\epsilon }\backslash theta\_\{\backslash varepsilon\}$ 意味着更新特征向量 $z_{n}z\_\{n\}$：

其中，${\mathit{z}}_n^{\mathrm{\prime }}\backslash boldsymbol\{z\}\_\{n\}^\{\backslash prime\}$ 是更新后的特征向量， 对应的是更新后的任务专属参数 ${\mathit{\theta }}_{\epsilon }^{\mathrm{\prime }}\backslash boldsymbol\{\backslash theta\}\_\{\backslash varepsilon\}^\{\backslash prime\}$。 基础学习器使用 ${\theta }_{\epsilon }^{\mathrm{\prime }}\backslash theta\_\{\backslash varepsilon\}^\{\backslash prime\}$ 来预测任务验证集数据的标注， 将任务 $\epsilon \backslash varepsilon$ 的验证集 ${\mathrm{D}}_{\epsilon }^{\mathrm{v}\mathrm{a}\mathrm{l}}\backslash mathrm\{D\}\_\{\backslash varepsilon\}^\{\backslash mathrm\{val\}\}$ 损失函数 $L_{\epsilon }^{\mathrm{v}\mathrm{a}\mathrm{l}}\left(f_{{\theta }_{\epsilon }^{\mathrm{\prime }}}\right)L\_\{\backslash varepsilon\}^\{\backslash mathrm\{val\}\}\backslash left(f\_\{\backslash theta\_\{\backslash varepsilon\}^\{\backslash prime\}\}\backslash right)$ 、 更新后的特征向量 $z_n^{\mathrm{\prime }}z\_\{n\}^\{\backslash prime\}$、 更新后的任务专属参数 ${\theta }_{\epsilon }^{\mathrm{\prime }}\backslash theta\_\{\backslash varepsilon\}^\{\backslash prime\}$ 输入元学习器， 在元学习器中更新元参数。

2.3 元学习器更新过程

在元学习器中，最小化所有任务 $\epsilon \backslash varepsilon$ 的验证集的损失函数的求和， 最小化任务上的模型泛化误差：

其中， $L_{\epsilon }^{\mathrm{v}\mathrm{a}\mathrm{l}}\left(f_{{\theta }_{\epsilon }^{\mathrm{\prime }}}\right)L\_\{\backslash varepsilon\}^\{\backslash mathrm\{val\}\}\backslash left(f\_\{\backslash theta\_\{\backslash varepsilon\}^\{\backslash prime\}\}\backslash right)$ 是任务 $\epsilon \backslash varepsilon$ 验证集的损失函数， 衡量了基础学习器模型的泛化误差，损失函数越小，模型的泛化能力越好。 $p\left(z_n\right)=N(0,I)p\backslash left(z\_\{n\}\backslash right)=N(0,\; I)$ 是高斯分布，$D_{\mathrm{K}\mathrm{L}}\left\{q(z_n\mid D_n^{\mathrm{t}\mathrm{r}})\mathrm{\parallel }p\left(z_n\right)\right\}D\_\{\backslash mathrm\{KL\}\}\backslash left\backslash \{q\backslash left(z\_\{n\}\; \backslash mid\; \{D\}\_\{n\}^\{\backslash mathrm\{tr\}\}\backslash right)\; \backslash |\; p\backslash left(z\_\{n\}\backslash right)\backslash right\backslash \}$ 是近似后验分布 $q(z_n\mid D_n^{\text{tr }})q\backslash left(z\_\{n\}\; \backslash mid\; D\_\{n\}^\{\backslash text\; \{tr\; \}\}\backslash right)$ 与先验分布 $p\left(z_n\right)p\backslash left(z\_\{n\}\backslash right)$ 之间的 KL 距离 (KL-Divergence)， 最小化 $\mathrm{K}\mathrm{L}\backslash mathrm\{KL\}$ 距离可使后验分布 $q(z_n\mid D_n^{\text{tr}})q\backslash left(z\_\{n\}\; \backslash mid\; \{D\}\_\{n\}^\{\backslash text\; \{tr\}\}\backslash right)$ 的估计尽可能准确。 最小化距离 $\parallel s\left(z_n^{\mathrm{\prime }}\right)-z_n\parallel \backslash left\backslash |s\backslash left(z\_\{n\}^\{\backslash prime\}\backslash right)-z\_\{n\}\backslash right\backslash |$ 使得参数初始值 $z_{n}z\_\{n\}$ 和训练完成后的参数更新值 $z_n^{\mathrm{\prime }}z\_\{n\}^\{\backslash prime\}$ 距离最小， 使得参数初始值和参数最终值更接近。 $RR$ 是正则项, 用于调控元参数的复杂程度，避免出现过拟合，正则项 $RR$ 的计算公式如下：

其中， ${\parallel {\varphi }_r\parallel }_2^2\backslash left\backslash |\backslash phi\_\{r\}\backslash right\backslash |\_\{2\}^\{2\}$ 指的是调控元参数的个数和大小， $C_d\{C\}\_\{d\}$ 是参数 ${\varphi }_d\backslash phi\_\{d\}$ 的行和行之间的相关性矩阵， 超参数 ${\lambda }_1,{\lambda }_2>0\backslash lambda\_\{1\},\backslash lambda\_\{2\}>0$， ${\parallel C_d-\mathbb{I}\parallel }_2\backslash left\backslash |C\_\{d\}-\backslash mathbb\{I\}\backslash right\backslash |\_\{2\}$ 使得 $C_{d}C\_\{d\}$ 接近单位矩阵， 使得参数 ${\varphi }_d\backslash phi\_\{d\}$ 的行和行之间的相关性不能太大， 每个类别的特征向量之间的相关性不能太大， 属于每个类别的概率值之间的相关性也不能太大，分类要尽量准确。

2.4 LEO 算法流程

LEO 算法流程

1. randomly initialize ${\varphi }_e,{\varphi }_r,{\varphi }_d\backslash phi\_\{e\},\; \backslash phi\_\{r\},\; \backslash phi\_\{d\}$
2. let $\varphi =\{{\varphi }_e,{\varphi }_r,{\varphi }_d,\alpha \}\backslash phi=\backslash left\backslash \{\backslash phi\_\{e\},\; \backslash phi\_\{r\},\; \backslash phi\_\{d\},\; \backslash alpha\backslash right\backslash \}$
3. while not converged do:
   1. for number of tasks in batch do:
      1. sample task instance ${\mathcal{T}}_i\sim {\mathcal{S}}^{tr}\backslash mathcal\{T\}\_\{i\}\; \backslash sim\; \backslash mathcal\{S\}^\{t\; r\}$
      2. let $({\mathcal{D}}^{tr},{\mathcal{D}}^{val})={\mathcal{T}}_i\backslash left(\backslash mathcal\{D\}^\{t\; r\},\; \backslash mathcal\{D\}^\{v\; a\; l\}\backslash right)=\backslash mathcal\{T\}\_\{i\}$
      3. encode ${\mathcal{D}}^{tr}\backslash mathcal\{D\}^\{t\; r\}$ to z using $g_{{\varphi }_e}g\_\{\backslash phi\_\{e\}\}$ and $g_{{\varphi }_r}g\_\{\backslash phi\_\{r\}\}$
      4. decode $\mathbf{z}\backslash mathbf\{z\}$ to initial params ${\theta }_i\backslash theta\_\{i\}$ using $g_{{\varphi }_d}g\_\{\backslash phi\_\{d\}\}$
      5. initialize ${\mathbf{z}}^{\mathrm{\prime }}=\mathbf{z},{\theta }_i^{\mathrm{\prime }}={\theta }_i\backslash mathbf\{z\}^\{\backslash prime\}=\backslash mathbf\{z\},\; \backslash theta\_\{i\}^\{\backslash prime\}=\backslash theta\_\{i\}$
      6. for number of adaptation steps do:
         1. compute training loss ${\mathcal{L}}_{{\mathcal{T}}_i}^{tr}\left(f_{{\theta }_i^{\mathrm{\prime }}}\right)\backslash mathcal\{L\}\_\{\backslash mathcal\{T\}\_\{i\}\}^\{t\; r\}\backslash left(f\_\{\backslash theta\_\{i\}^\{\backslash prime\}\}\backslash right)$
         2. perform gradient step w.r.t. ${\mathbf{z}}^{\mathrm{\prime }}\backslash mathbf\{z\}^\{\backslash prime\}$:
         3. ${\mathbf{z}}^{\mathrm{\prime }}\leftarrow {\mathbf{z}}^{\mathrm{\prime }}-\alpha {\mathrm{\nabla }}_{{\mathbf{z}}^{\mathrm{\prime }}}{\mathcal{L}}_{{\mathcal{T}}_i}^{tr}\left(f_{{\theta }_i^{\mathrm{\prime }}}\right)\backslash mathbf\{z\}^\{\backslash prime\}\; \backslash leftarrow\; \backslash mathbf\{z\}^\{\backslash prime\}-\backslash alpha\; \backslash nabla\_\{\backslash mathbf\{z\}^\{\backslash prime\}\}\; \backslash mathcal\{L\}\_\{\backslash mathcal\{T\}\_\{i\}\}^\{t\; r\}\backslash left(f\_\{\backslash theta\_\{i\}^\{\backslash prime\}\}\backslash right)$
         4. decode ${\mathbf{z}}^{\mathrm{\prime }}\backslash mathbf\{z\}^\{\backslash prime\}$ to obtain ${\theta }_i^{\mathrm{\prime }}\backslash theta\_\{i\}^\{\backslash prime\}$ using $g_{{\varphi }_d}g\_\{\backslash phi\_\{d\}\}$
      7. end for
      8. compute validation loss ${\mathcal{L}}_{{\mathcal{T}}_i}^{val}\left(f_{{\theta }_i^{\mathrm{\prime }}}\right)\backslash mathcal\{L\}\_\{\backslash mathcal\{T\}\_\{i\}\}^\{v\; a\; l\}\backslash left(f\_\{\backslash theta\_\{i\}^\{\backslash prime\}\}\backslash right)$
   2. end for
   3. perform gradient step w.r.t $\varphi \backslash phi$：$\varphi \leftarrow \varphi -\eta {\mathrm{\nabla }}_{\varphi }{\sum }_{{\mathcal{T}}_i}{\mathcal{L}}_{{\mathcal{T}}_i}^{val}\left(f_{{\theta }_i^{\mathrm{\prime }}}\right)\backslash phi\; \backslash leftarrow\; \backslash phi-\backslash eta\; \backslash nabla\_\{\backslash phi\}\; \backslash sum\_\{\backslash mathcal\{T\}\_\{i\}\}\; \backslash mathcal\{L\}\_\{\backslash mathcal\{T\}\_\{i\}\}^\{v\; a\; l\}\backslash left(f\_\{\backslash theta\_\{i\}^\{\backslash prime\}\}\backslash right)$
4. end while

(1) 初始化元参数：编码器参数 ${\varphi }_e\backslash phi\_\{e\}$、关系网络参数 ${\varphi }_r\backslash phi\_\{r\}$、解码器参数 ${\varphi }_d\backslash phi\_\{d\}$, 在元学习器中更新的元参数包括 $\varphi =\{{\varphi }_e,{\varphi }_r,{\varphi }_d\}\backslash phi=\backslash left\backslash \{\backslash phi\_e,\; \backslash phi\_r,\backslash phi\_d\; \backslash right\backslash \}$。

(2) 使用片段式训练模式， 随机抽取任务 $\epsilon \backslash varepsilon$, $D_{\epsilon }^{\mathrm{t}\mathrm{r}}\{D\}\_\{\backslash varepsilon\}^\{\backslash mathrm\{tr\}\}$ 是任务 $\epsilon \backslash varepsilon$ 的训练集， $D_{\epsilon }^{\mathrm{v}\mathrm{a}\mathrm{l}}\{D\}\_\{\backslash varepsilon\}^\{\backslash mathrm\{val\}\}$ 是任务 $\epsilon \backslash varepsilon$ 的验证集。

(3) 使用编码器 $g_{{\varphi }_e}g\_\{\backslash phi\_\{e\}\}$ 和关系网络 $g_{{\varphi }_r}g\_\{\backslash phi\_\{r\}\}$ 将任务 $\epsilon \backslash varepsilon$ 的训练集 $D_{\epsilon }^{\mathrm{t}\mathrm{r}}D\_\{\backslash varepsilon\}^\{\backslash mathrm\{tr\}\}$ 编码成特征向量 $zz$， 使用 解码器 $g_{{\varphi }_d}g\_\{\backslash phi\_\{d\}\}$ 从特征向量映射到任务 $\epsilon \backslash varepsilon$ 的基础学习器参数 ${\theta }_{\epsilon }\{\backslash theta\}\_\{\backslash varepsilon\}$， 基础学习器参数指的是输入数据属于每个类别的概率值向量； 计算任务 $\epsilon \backslash varepsilon$ 的训练集的损失函数 $L_{\epsilon }^{\mathrm{t}\mathrm{r}}\left(f_{{\theta }_{\epsilon }}\right)L\_\{\backslash varepsilon\}^\{\backslash mathrm\{tr\}\}\backslash left(f\_\{\backslash theta\_\{\backslash varepsilon\}\}\backslash right)$， 最小化任务 $\epsilon \backslash varepsilon$ 的损失函数，更新每个类别的特征向量：

使用解码器 $g_{{\varphi }_d}g\_\{\backslash phi\_\{d\}\}$ 从更新后的特征向量映射到更新后的任务 $\epsilon \backslash varepsilon$ 的基础学习器参数 ${\theta }_{\epsilon }^{\mathrm{\prime }}\{\backslash theta\}\_\{\backslash varepsilon\}^\{\backslash prime\}$； 计算任务 $\epsilon \backslash varepsilon$ 的验证集的损失函数 $L_{\epsilon }^{\text{val}}\left(f_{{\theta }_s^{\mathrm{\prime }}}\right)L\_\{\backslash varepsilon\}^\{\backslash text\; \{val\}\}\backslash left(f\_\{\backslash theta\_\{s\}^\{\backslash prime\}\}\backslash right)$； 基础学习器将更新后的参数和验证集损失函数值输入元学习器。

(4) 更新元参数, $\varphi \leftarrow \varphi -\eta {\mathrm{\nabla }}_{\varphi }{\sum }_{\epsilon }{L}_{\epsilon }^{\text{val}}\left(f_{{\theta }_{\epsilon }^{\mathrm{\prime }}}\right)\backslash phi\; \backslash leftarrow\; \backslash phi-\backslash eta\; \backslash nabla\_\{\backslash phi\}\; \backslash sum\_\{\backslash varepsilon\}\; L\_\{\backslash varepsilon\}^\{\backslash text\; \{val\}\}\backslash left(f\_\{\backslash theta\_\{\backslash varepsilon\}^\{\backslash prime\}\}\backslash right)$， 最小化所有任务 $\epsilon \backslash varepsilon$ 的验证集的损失和， 将更新后的元参数输人基础学习器，继续处理新的分类任务。

2.5 LEO 模型结构

LEO 是一种与模型无关的元学习，[1] 中给出的各部分模型结构及参数如表1所示。

2.6 LEO 分类结果

2.7 LEO 的优点

• 新任务的初始参数以训练数据为条件，这使得任务特定的适应起点成为可能。 通过将关系网络结合到编码器中，该初始化可以更好地考虑所有输入数据之间的联合关系。

• 通过在低维潜在空间中进行优化，该方法可以更有效地适应模型的行为。 此外，通过允许该过程是随机的，可以表达在少数数据状态中存在的不确定性和模糊性。

• 参考文献 [1] Meta-Learning with Latent Embedding Optimization

3.Reptile

Reptil 是 MAML 的特例、近似和简化，主要解决 MAML 元学习器中出现的高阶导数问题。 因此，Reptil 同样学习网络参数的初始值，并且适用于任何基于梯度的模型结构。

在 MAML 的元学习器中，使用了求导数的算式来更新参数初始值， 导致在计算中出现了任务损失函数的二阶导数。 在 Reptile 的元学习器中，参数初始值更新时， 直接使用了任务上的参数估计值和参数初始值之间的差， 来近似损失函数对参数初始值的导数，进行参数初始值的更新，从而不会出现任务损失函数的二阶导数。

Peptile 有两个版本：Serial Version 和 Batched Version，两者的差异如下：

3.1 Serial Version Reptile

单次更新的 Reptile，每次训练完一个任务的基学习器，就更新一次元学习器中的参数初始值。

(1) 任务上的基学习器记为 $f_{\varphi }f\_\{\backslash phi\}$ ，其中 $\varphi \backslash phi$ 是基学习器中可训练的参数， $\theta \backslash theta$ 是元学习器提供给基学习器的参数初始值。 在任务 $T_{i}T\_\{i\}$ 上，基学习器的损失函数是 $L_{T_i}\left(f_{\varphi }\right)L\_\{T\_\{i\}\}\backslash left(f\_\{\backslash phi\}\backslash right)$ ， 基学习器中的参数经过 $NN$ 次迭代更新得到参数估计值：

(2) 更新元学习器中的参数初始值：

Serial Version Reptile 算法流程

1. initialize $\theta \backslash theta$, the vector of initial parameters
2. for iteration=1, 2, ... do:
   1. sample task $T_{i}T\_i$, corresponding to loss $L_{T_i}L\_\{T\_i\}$ on weight vectors $\theta \backslash theta$
   2. compute ${\theta }_i^N=\mathrm{SGD}(L_{T_i},\theta ,N)\backslash theta\_\{i\}^\{N\}=\backslash operatorname\{SGD\}\backslash left(L\_\{T\_\{i\}\},\; \{\backslash theta\},\; \{N\}\backslash right)$
   3. update $\theta \leftarrow \theta +\epsilon ({\theta }_i^N-\theta )\backslash theta\; \backslash leftarrow\; \backslash theta+\backslash varepsilon\backslash left(\backslash theta\_\{i\}^\{N\}-\backslash theta\backslash right)$
3. end for

3.2 Batched Version Reptile

批次更新的 Reptile，每次训练完多个任务的基学习器之后，才更新一次元学习器中的参数初始值。

(1) 在多个任务上训练基学习器，每个任务从参数初始值开始，迭代更新 $NN$ 次，得到参数估计值。

(2) 更新元学习器中的参数初始值：

其中，$nn$ 是指每次训练完 $nn$ 个任务上的基础学习器后，才更新一次元学习器中的参数初始值。

Batched Version Reptile 算法流程

1. initialize $\theta \backslash theta$
2. for iteration=1, 2, ... do:
   1. sample tasks $T_{1}T\_1$, $T_{2}T\_2$, ... , $T_{n}T\_n$,
   2. for i=1, 2, ... , n do:
      1. compute ${\theta }_i^N=\mathrm{SGD}(L_{T_i},\theta ,N)\backslash theta\_\{i\}^\{N\}=\backslash operatorname\{SGD\}\backslash left(L\_\{T\_\{i\}\},\; \{\backslash theta\},\; \{N\}\backslash right)$
   3. end for
   4. update $\theta \leftarrow \theta +\epsilon \frac{1}{n}{\sum }_{i=1}^n({\theta }_i^N-\theta )\backslash theta\; \backslash leftarrow\; \backslash theta+\backslash varepsilon\; \backslash frac\{1\}\{n\}\; \backslash sum\_\{i=1\}^\{n\}\backslash left(\backslash theta\_\{i\}^\{N\}-\backslash theta\backslash right)$
3. end for

3.3 Reptile 分类结果

更多优质内容请关注公重号：汀丶人工智能

• 参考文献 [1] Reptile: a Scalable Metalearning Algorithm