meta learning
概述
元学习是基于不同的但是相似的一系列任务的学习。
元学习是关于学习的学习，即:学习到的内容是如何更好的学习，是一种通过一些列不同但是相似的任务，去学习到其内在的通用的技巧。
例子：如果是骑自行车，电瓶车、摩托车。我们现在有一个负责教授别人学这三种车的教练。当然这个教练肯定已经掌握了这三种车的诈尸方式。刚开始的时候这个新教练按部就班的教授学员分别学这三种车。学员学的就比较慢。时间在新教练的脸庞留下了足迹，新教练变成了老司机。他经过多年的经验总结，学会了如何faster and better（更好更快）去让菜鸟变成秋名山常客。他的方法很简单：不再按部就班的教授如何诈尸这三种车，而是去教这三种车的通用技巧：如何保持两个*的平衡、如何在保持平衡的同时去一把把把把住，并切改变方向。然后再去根据自行车去单独教蹬*，电瓶车教握把旋转控制速度，摩托车教如何踩离合给油门。
这里三种车，具有共同的特征联系即满足related tasks。学会自行车、电瓶车、摩托车是三个不同的任务，但是这三个不同的任务并不是完全不同，而是具有某些相似性。注意：这是元学习的任务要满足的条件！
普通的深度学习或者机器学习、强化学习都是针对特定任务而言，即：给定一个具体任务的数据集，然后将数据集划分为训练集和测试集抑或验证集。然后设计一个algorithm model，之后先使用验证集实验该模型大概能否完成该任务以及相关的超参数的设置，若不能完成该任务，则需要继续改变或重新设计一个algorithm model（包括重设超参数）。若判断模型能满足该任务，则使用训练集进行模型参数的求解，最好使用测试集进行最好的结果把关。其中验证集非必须，普遍做法都是直接不要验证集，只划分训练集和测试集，直接在训练集完成超参数和algorithm model的迭代。注意这里的训练集和测试集验证集的样本都是一条条的数据记录：标签+特征项输入。
元学习也需要数据进行求解。元学习的数据集的个体是一个个不同但是相似的任务。每一个任务都是由一条条记录构成。元学习中，用于训练的任务集称为support set，用于最好把关元学习的任务集称为query set。
例如：task1：猫狗识别；task2：蛇和蜥蜴识别；task3：男女识别；task4：橙子橘子识别；task5：真假钞识别。等等。这些任务的共同联系是都是图形的二分类任务。当然任务之间的难度系数不同。划分task1，task2，task3作为support set，task4，task5作为query set。
元学习主要有三个大的分支：metric，model，optimization三种。
metric顾名思义：就是学习一种度量方式，该种度量方式能区别任务的不同类别。
model更多的是偏向于设计一个具有更高效更持久的记忆机制，可以想象成super cool的LSTM，longer and stronger than LSTM。
optimization则是寻求模型的参数的初始化或者求解过程的最优化。
meta learning & zero/one/few shot learning
meta learning
元学习是关于学习的学习，其落脚点在于学到一系列的学习的技巧，当new relate task上具体应用的时候，能够只经过很快的再次训练，就能够很好的在该任务上表现出不错的效果。
元学习一半包含两个过程，
过程一：通过系列的relate tasks元学习算法模型学习到其通用的技巧，技巧可以表现为模型的参数、参数优化方法、模型结构等。
过程二：在遇到新的相关的/类似的任务时，将过程一获得的技巧在该任务上落实，使用该任务的样本只经过少量的训练就能够解决任务。
zero/one/few shot learning
少样本学习本质上是关于一个特定任务的学习，其落脚点在于如何仅仅使用尽量少的样本，就能使面对的任务得到不错的解决。其仍然是一个面向task的传统深度学习算法思想。
metric based
其核心思想类似于近邻算法(例如K-NN和K-means)和核密度估计。一组已知标签 y y y的预测概率是支撑集样本标签的加权和，而这个“权”是由一个计算两个样本相似度的函数 k θ k_{\theta} kθ得出的：
P ( y ∣ x , S ) = ∑ ( x i , y i ) ∈ S k θ ( x , x i ) y i P(y|x,S)=\sum_{(x_i,y_i)\in S}k_{\theta}(x,x_i)y_i P(y∣x,S)=(xi,yi)∈S∑kθ(x,xi)yi
学习一个好的 k k k对它的成功至关重要，它旨在学习对象的度量和距离函数，好的度量概念是依赖于问题的，它应该能表示任务空间中的输入之间的关系，以此来完成任务。下面介绍的经典模型很好地学习了输入数据的嵌入向量并用它们设计合适的内核函数。
Siamese Neural Network
Koch，Zemel和Salakhutdinov在2015年提出了一种使用孪生神经网络进行one-shot图像分类的方法。 首先，对孪生网络进行训练来判断两个输入图像是否在同一类别中。 它输出两个图像属于同一类别的概率。 然后，在测试期间，孪生神经网络会处理测试图像与支撑集中的每个图像所组成的图像对。 最终预测是概率最高的支撑图像的类别。
网络结构如上图所示：network A和B是两个完全一样的东西，共享参数。可以将A和B视作一个映射函数 f f f，变量是 x x x，参数是 θ \theta θ，则： f e a t u r e = f θ ( x ) feature=f_{\theta}(x) feature=fθ(x)
energy function是一种能够衡量两个输入变量的距离的函数，例如欧式距离，余弦距离等。其实就是另一个函数，其为二元函数，设为 d i s t a n c e = E ( x 1 , x 2 ) distance=E(x_1,x_2) distance=E(x1,x2)，当 x 1 x_1 x1和 x 2 x_2 x2是具有同一个类别标签，则distance最小化，否则最大化。由此可以看出，此网络适用于分类任务。
当network A 和network B相同时，将此网络称为Siamese network。
当network A 和network B 不同时，将该网络称为pseudo-Siamese network。
Siamese network和pseudo-Siamese network适S用的场景有：human action recognition, scene change detection, and machine translation.
孪生神经网络用于处理两个输入"比较类似"的情况。伪孪生神经网络适用于处理两个输入"有一定差别"的情况。比如，我们要计算两个句子或者词汇的语义相似度，使用Siamese network比较适合；如果验证标题与正文的描述是否一致（标题和正文长度差别很大），或者文字是否描述了一幅图片（一个是图片，一个是文字），就应该使用pseudo-Siamese network。也就是说，要根据具体的应用，判断应该使用哪一种结构，哪一种Loss。
孪生网络更适用于verification tasks，或者是one-shot learning相关的任务。
Convolutional Siamese Neural Network
卷积孪生神经网络就是其网络结构AB都使用卷积神经网络，如下图。
-
首先，卷积孪生神经网络通过包含两个卷积层的嵌入函数 f θ f_{\theta} fθ将两个图像编码为特征向量。
-
两个嵌入向量的L1距离表示为 ∣ f θ ( x i ) − f θ ( x j ) ∣ |f_{\theta}(x_i)-f_{\theta}(x_j)| ∣fθ(xi)−fθ(xj)∣
-
通过线性前馈层和sigmoid将距离转换为概率P，这个概率表示两张图像是否属于同一类
-
损失使用交叉熵，因为标签是二分类的。
p ( x i , x j ) = σ ( W ∣ f θ ( x i ) − f θ ( x j ) ∣ ) p(x_i,x_j)=\sigma(W|f_{\theta}(x_i)-f_{\theta}(x_j)|) p(xi,xj)=σ(W∣fθ(xi)−fθ(xj)∣)
L ( B ) = ∑ ( x i , x j , y i , y j ) ∈ B 1 y i = y j log p ( x i , x j ) + ( 1 − 1 y i = y j ) log ( 1 − p ( x i , x j ) ) \mathcal{L}(B)=\sum_{(x_i,x_j,y_i,y_j)\in B}\mathbf{1}_{y_i=y_j}\log p(x_i,x_j)+(1-\mathbf{1}_{y_i=y_j})\log(1-p(x_i,x_j)) L(B)=(xi,xj,yi,yj)∈B∑1yi=yjlogp(xi,xj)+(1−1yi=yj)log(1−p(xi,xj))
- 给定支撑集 S S S和测试图像 x x x，最终预测类为 c ^ s ( x ) = c ( a r g m a x x i ∈ S P ( x , x i ) ) \hat{c}_s(x)=c(arg \underset{x_i\in S}{max}P(x,x_i)) c^s(x)=c(argxi∈SmaxP(x,xi))，其中 c ( x ) c(x) c(x)是图像x的类标签， c ^ ( . ) \hat{c}(.) c^(.)是预测标签。
Matching networks
匹配网络有两个主要的创新点，一是给网络增加了一个外部记忆，二是设计了一种新的训练策略，就是让训练过程与测试过程匹配。传统的方式是训练与测试分开进行，而这个匹配网络提出了episode的概念，即每个episode包含一个支撑集和一个测试集，测试的时候也同样如此。就比如训练时候以暹罗猫和金毛犬作为支撑集，给一张哈士奇做测试集来训练网络，那么测试的时候则相似，以熊和鸟作为支撑集，以鹦鹉作测试集，来判断鹦鹉是不是鸟。
结合论文中的叙述，对任意给定的(小)支撑集 S = { x i , y i } i = 1 k S=\left\{x_i,y_i\right\}_{i=1}^k S={xi,yi}i=1k( k k k表示k-shot)，去学习一个分类器 c s c_s cs，这个分类器定义了给定一个测试样例 x \mathbf{x} x后，输出标签 y y y上的概率分布。和其他基于度量的模型类似，分类器的输出被定义为由attention核 a ( x , x i ) a(x,x_i) a(x,xi)加权的支撑样本的标签的总和，这个核应当与 x x x和 x i x_i xi之间的相似度成比例。网络结构图如下。
c S ( x ) = P ( y ∣ x , S ) = ∑ i = 1 k a ( x , x i ) y i , where S = { ( x i , y i ) } i = 1 k c_S(\mathbf{x}) = P(y \vert \mathbf{x}, S) = \sum_{i=1}^k a(\mathbf{x}, \mathbf{x}_i) y_i \text{, where }S=\{(\mathbf{x}_i, y_i)\}_{i=1}^k cS(x)=P(y∣x,S)=i=1∑ka(x,xi)yi, where S={(xi,yi)}i=1k
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u4VbDzzo-1606979628004)(https://s1.ax1x.com/2020/04/12/GLjkGt.png)]
attention核取决于两个嵌入函数 f f f和 g g g，分别对测试样本和支撑样本进行编码，两个数据点之间的attention权值为其嵌入向量之间的余弦相似度，并用Softmax进行归一化。
a ( x , x i ) = exp ( cos ( f ( x ) , g ( x i ) ) ) ∑ j = 1 k exp ( cos ( f ( x ) , g ( x j ) ) ) a(\mathbf{x},\mathbf{x}_i)=\frac{\exp(\cos(f(\mathbf{x}),g(\mathbf{x}_i)))}{\sum_{j=1}^k\exp(\cos(f(\mathbf{x}),g(\mathbf{x}_j)))} a(x,xi)=∑j=1kexp(cos(f(x),g(xj)))exp(cos(f(x),g(xi)))
模型结构
在所有这些模型中，通常完全可微的神经注意机制被定义为访问(或读取)存储有用信息以解决手头任务的记忆矩阵。它的典型应用包括机器翻译、语音识别或问题回答。更一般地说，这些架构模型 P ( B ∣ A ) P(B\vert A) P(B∣A)，其中A、B可以是一个序列(如seq2seq模型)，或者一个集合。
作者的贡献是在set-to-set框架中解决一次性学习的问题。关键在于，经过训练的匹配网络能够为未观察到的类生成合理的测试标签，而不需要对网络进行任何更改。更准确地说，是将一个有 k k k个带标签样本的(小)支撑集 S = { ( x i , y i ) } i = 1 k S=\left\{(x_i,y_i)\right\}_{i=1}^k S={(xi,yi)}i=1k映射到分类器 c S ( x ^ ) c_S(\hat{x}) cS(x^)上，给这个分类器一个 x ^ \hat x x^能够定义输出 y ^ \hat y y^上的概率分布。将 S → c S ( x ^ ) S\rightarrow c_S(\hat x) S→cS(x^)映射为 P ( x ^ ∣ y ^ , S ) P(\hat x\vert\hat y,S) P(x^∣y^,S)，其中 P P P是由神经网络参数化的。因此，当给一个新的支撑集 S ′ S' S′来进行one-shot学习时，我们只需使用 P P P定义的参数神经网络对每个测试示例 x ^ \hat x x^的标签 y ^ \hat y y^做出预测，即 P ( y ^ ∣ x ^ , S ′ ) P(\hat y\vert\hat x,S') P(y^∣x^,S′)。一般来说，对于给定的不知其类别的样例 x ^ \hat x x^，预测的类与支撑集 S S S的关系是： arg max y P ( y ∣ x ^ , S ) \arg\max_yP(y\vert\hat x,S) argmaxyP(y∣x^,S)
模型在其最简单的形式下预测 y ^ \hat y y^如下：
y ^ = ∑ i = 1 k a ( x ^ , x i ) y i ( 1 ) \hat y=\sum_{i=1}^ka(\hat x,x_i)y_i \ \ \ \ \ \ \ \ (1) y^=i=1∑ka(x^,xi)yi (1)
其中 x i x_i xi， y i y_i yi是来自支撑集 S S S的样本和标签， a a a是我们下面要讨论的注意力机制。注意，公式(1)本质上把新类的输出描述为支撑集中的标签的线性组合。当注意机制 a a a是 X × X X\times X X×X上的核时，则(1)类似于核密度估计(KDE)。如果根据某种距离度量，距 x ^ \hat x x^最远的 x i x_i xi的注意机制 b b b为零，否则为一个适当的常数，则公式(1)等于“ k − b k-b k−b”个近邻。因此公式(1)既包含KDE算法也包含kNN算法。(1)的另一种观点是， a a a充当注意力机制， y i y_i yi充当与相应 x i x_i xi绑定的记忆。在这种情况下，我们可以把它理解为一种特殊的联想记忆，即给定一个输入，我们“指出”它在支撑集中相应的样本，然后检索这个样本的标签，从而知道它属于什么类。然而，与其他注意记忆机制[[2]](D Bahdanau, K Cho, and Y Bengio. Neural machine translation by jointly learning to align and translate. ICLR, 2014.)不同，公式(1)本质上是非参数的：随着支撑集大小的增长，所使用的内存也在增长。因此，分类器 c S ( x ^ ) c_S(\hat x) cS(x^)定义的功能形式非常灵活，可以轻松地适应任何新的支持集。
Attention核
公式1依赖于选择注意机制 a ( . , . ) a(.,.) a(.,.)，该机制完全指定了分类。这种方式最简单的形式是在余弦距离 c c c上使用Softmax，即 a ( x ^ , x i ) = e c ( f ( x ^ ) , g ( x i ) ) / ∑ j = 1 k e c ( f ( x ^ ) , g ( x j ) ) a(\hat x,x_i)={e^{c(f(\hat x),g(x_i))}}/{\sum_{j=1}^ke^{c(f(\hat x),g(x_j))}} a(x^,xi)=ec(f(x^),g(xi))/∑j=1kec(f(x^),g(xj))，其中嵌入函数 f f f和 g g g是嵌入 x ^ \hat x x^和 x i x_i xi的适当神经网络(有可能 f = g f=g f=g)。在实验中，其中 f f f和 g g g被分别参数化为用于图像任务的深度卷积网络（如VGG [22]或Inception [24]）或用于语言任务的简单形式的词向量。
可以注意到，虽然与度量学习有关，但是由公式(1)定义的分类器和它还是有区别的。对于给定的支撑集 S S S和样本来对 x ^ \hat x x^分类，足够使 x ^ \hat x x^与 ( x ′ , y ′ ) ∈ S (x',y')\in S (x′,y′)∈S充分一致，从而使 y ′ = y y'=y y′=y并与剩余的不一致。这种损失还与近邻成分分析(NCA)[18]，三重态损失[9]或大余量最近邻[28]等方法有关。
但是，我们尝试优化的目标与multi-way,one-shot分类完全一致，因此我们希望它的性能要优于同类模型。另外，loss是简单且可微的，因此人们可以以“端到端”的方式找到最佳参数。
Full Context Embeddings
作者模型的主要新颖之处在于重新解释一个经过充分研究的框架(带有外部记忆的神经网络)以进行one-shot学习。与度量学习密切相关，嵌入函数 f f f和 g g g充当特征空间 X X X的提升，以通过公式(1)中描述的分类函数实现最大的准确性。
尽管分类策略完全取决于通过 P ( . ∣ x ^ , S ) P(.\vert\hat x,S) P(.∣x^,S)的整个支撑集，但是将余弦相似度应用于“参与”，“点”或仅计算最近邻的嵌入从某种意义上说都是短视的，每个元素 x i x_i xi独立于支撑集 S S S中的其他元素而被 g ( x i ) g(x_i) g(xi)嵌入。
作者提出通过一个函数来嵌入集合的元素，该函数除 x i x_i xi外还以完整的集合 S S S作为输入，即 g g g变为 g ( x i , S ) g(x_i,S) g(xi,S)。因此， g g g作为整个支持集 S S S的函数，可以修改嵌入 x i x_i xi的方式。当某些元素 x j x_j xj非常接近 x i x_i xi时可能会有用，在这种情况下，更改我们嵌入 x i x_i xi的函数可能会有所帮助。我们使用双向LSTM[8]在支持集 S S S的全局中对 x i x_i xi进行编码，并将其视为一个序列。
第二个问题可以通过一个LSTM来解决，这个LSTM的read-attention在整个集合 S S S上，它的输入等于 x x x： f ( x ^ , S ) = attLSTM ( f ′ ( x ^ ) , g ( S ) , K ) f(\hat x,S)=\text{attLSTM}(f'(\hat x),g(S),K) f(x^,S)=attLSTM(f′(x^),g(S),K)其中 f ′ ( x ^ ) f'(\hat x) f′(x^)是输入到LSTM的特征(例如可以从CNN得到)。 K K K是LSTM的固定unrolling步，而 g ( S ) g(S) g(S)是我们由 g g g嵌入的集合。这允许模型潜在地忽略支撑集S中的某些元素，并为注意力计算增加“深度”(有关更多详细信息，请参见附录)。
训练策略
在前一小节我们描述匹配网络将支撑集映射到一个分类函数， S → c ( x ^ ) S\rightarrow c(\hat x) S→c(x^)。我们通过对由attention增强的set-to-set范式的修改来实现这一点，结果映射的形式为 P θ ( . ∣ x ^ , S ) P_{\theta}(.\vert\hat x,S) Pθ(.∣x^,S)， θ \theta θ是模型的参数(即前面叙述的嵌入函数 f f f和 g g g)。
更具体地说，将任务 T T T定义为关于可能的标签集 L L L上的分布。通常，我们认为 T T T可以对多个类别(例如5个)的所有数据集进行统一加权，每个类别包含一些样本(例如最多5个)。在这种情况下，从任务 T T T采样的标签集 L L L( L ∼ T L\sim T L∼T)通常具有5~25个样本。
为了形成一个“episode”来计算梯度并更新模型，首先从 T T T中采样 L L L(例如， L L L可能是标签集{cats，dogs})。然后，我们使用 L L L来采样支撑集 S S S和批次 B B B(即 S S S和 B B B都是被标记为猫和狗的样本)。然后训练匹配网络来最小化预测 B B B中样本类别的误差。这是元学习的一种形式，训练过程中会明确地学习如何从给定的支撑集中学习如何最大程度地减少批次损失。 更确切地说，匹配网络的训练目标如下：
θ = arg max θ E L ∼ T [ E S ∼ L , B ∼ L [ ∑ ( x , y ) ∈ B L log P θ ( y ∣ x , S ) ] ] ( 2 ) \theta = \arg\max_\theta \mathbb{E}_{L\sim T}[ \mathbb{E}_{S\sim L,B \sim L} [\sum_{(x, y)\in B^L} \log P_\theta(y\vert x, S)]]\ \ \ \ \ \ (2) θ=argθmaxEL∼T[ES∼L,B∼L[(x,y)∈BL∑logPθ(y∣x,S)]] (2)
用公式(2)训练 θ \theta θ产生了一个模型，该模型在从新的标签的不同分布中采样 S ′ ∼ T ′ S'\sim T' S′∼T′时效果很好。至关重要的是，由于其非参数性质，模型不需要对从未见过的类进行任何微调。但也很显然，当 T ′ T' T′与我们学习 θ \theta θ的 T T T偏离很大时，该模型将无法工作。
Prototypical networks
原型网络属于元学习中基于度量的网络，它的原理是学习一个度量空间，在这个空间中，分类这一任务表现为计算各个类的原型表示(prototype representation)之间的距离。论文中提到，针对few-shot learning这一任务，他们是通过解决过拟合这一思路来提高最终的网络表现。原型网络解决问题的思想是基于每个类都存在一个嵌入点，这个点就是这个类的原型表示，而属于这个点的样本会聚集在这个点的周围，以此来完成分类。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9ljMwGr5-1606979628007)(https://s1.ax1x.com/2020/04/07/G6NbAe.png)]
为了做到这一点，作者使用神经网络学习输入到嵌入空间的非线性映射，并以类的原型作为其在嵌入空间中的支撑集的平均值。之后就可以通过简单的寻找离嵌入查询点最近的类原型来完成分类。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B2BbNFEC-1606979628009)(https://s1.ax1x.com/2020/04/12/GLOh0H.png)]
同时，作者将原型网络与聚类相关联，以证明在以Bregman散度计算距离(例如平方欧几里得距离)时，将类均值用作原型是合理的。作者认为这一点很重要，因为在他们的实验中，欧几里得距离就比余弦相似度管用。
原型网络的数学表示
符号记法 在few-shot分类任务中，给定一个含有 N N N个带标签样本的数据集 S = { ( x 1 , y 1 ) , … , ( x N , y N ) } S=\left\{ (\mathbf{x}_1, y_1),\dots,(\mathbf{x}_N, y_N)\right\} S={(x1,y1),…,(xN,yN)}，每个 x i ∈ R D \mathbf{x}_i\in\mathbb{R}^D xi∈RD都是样本的 D D D维特征向量，而 y i ∈ { 1 , … , K } y_i\in\left\{1,\dots,K\right\} yi∈{1,…,K}是其对应的标签， S k S_k Sk表示标记为 k k k类的样本集。
模型 原型网络通过一个具有可学习参数
ϕ
\phi
ϕ的嵌入函数
f
ϕ
:
R
D
→
R
M
f_{\phi}:\mathbb{R}^D\rightarrow\mathbb{R}^M
fϕ:RD→RM来计算每个类的
M
M
M维表示
c
k
∈
R
M
\mathbf{c}_k\in\mathbb{R}^M
ck∈RM或者原型。每个原型为所属类内嵌支撑点的均值向量:
c
k
=
1
∣
S
k
∣
∑
(
x
i
,
y
i
)
∈
S
k
f
ϕ
(
x
i
)
\mathbf{c}_k=\frac{1}{\left|S_k\right|}\sum_{(\mathbf{x}_i,y_i)\in S_k}{f_{\phi}(\mathbf{x}_i)}
ck=∣Sk∣1(xi,yi)∈Sk∑fϕ(xi)
给定距离函数 d : R M × R M → [ 0 , + ∞ ) d:\mathbb{R}^M\times\mathbb{R}^M\rightarrow[0,+\infty) d:RM×RM→[0,+∞)，原型网络基于softmax到嵌入空间中原型的距离来产生查询点 x \mathbf{x} x的类分布：
p ϕ ( y = k ∣ x ) = e x p ( − d ( f ϕ ( x ) , c k ) ) ∑ k ′ e x p ( − d ( f ϕ ( x ) , c k ′ ) ) p_{\phi}(y=k|\mathbf{x})=\frac{exp(-d(f_{\phi}(\mathbf{x}),\mathbf{c}_k))}{\sum\nolimits_{k'}{exp(-d(f_{\phi}(\mathbf{x}),\mathbf{c}_{k'}))}} pϕ(y=k∣x)=∑k′exp(−d(fϕ(x),ck′))exp(−d(fϕ(x),ck))
学习过程是通过SGD最小化真实类别 k k k的负对数概率 J ( ϕ ) = − log p ϕ ( y = k ∣ x ) J(\phi)=-\log p_{\phi}(y=k|\mathbf{x}) J(ϕ)=−logpϕ(y=k∣x)进行的。训练episode是通过从训练集中随机选择一个类的子集，然后在每个类中选择一个样本子集作为支撑集，其余的子集作为query点来形成的。对训练片段计算损失的伪代码如下：
算法1：原型网络训练片段损失的计算
N N N表示训练集中的样本数， K K K表示训练集中类的数量， N C ≤ K N_C\leq K NC≤K是每个片段中类的数量， N S N_S NS是每个类中support样本的数量， N Q N_Q NQ是每个类中query样本的数量。 R a n d o m S a m p l e ( S , N ) \mathsf{RandomSample}(S,N) RandomSample(S,N)表示从集合 S S S中随机选择的 N N N个元素的集合。
输入: 训练集 D = { ( x 1 , y 1 ) , … , ( x N , y N ) } ， y i ∈ { 1 , … , K } \mathcal{D}=\left\{(\mathbf{x}_1,y_1),\dots,(\mathbf{x}_N,y_N)\right\}，y_i\in \left\{1,\dots,K\right\} D={(x1,y1),…,(xN,yN)}，yi∈{1,…,K}， D k \mathcal{D}_k Dk表示 D \mathcal{D} D的子集，其中包含所有 y i = k y_i=k yi=k的元素 ( x i , y i ) (\mathbf{x}_i,y_i) (xi,yi)。
输出: 一个随机生成的训练episode的损失 J J J
V ← R a n d o m S a m p l e ( { 1 , … , K } , N C ) V\gets \mathsf{RandomSample}(\left\{1,\dots,K\right\},N_C) V←RandomSample({1,…,K},NC) # 选择episode的类索引
for $ k\in \left{1,\dots,N_C\right}$ do
S k ← R a n d o m S a m p l e ( D V k , N S ) S_k\gets \mathsf{RandomSample}(\mathcal{D}_{V_k},N_S) Sk←RandomSample(DVk,NS) # 选择support样本
Q k ← R a n d o m S a m p l e ( D V k \ S k , N Q ) Q_k\gets \mathsf{RandomSample}(\mathcal{D}_{V_k}\backslash S_k,N_Q) Qk←RandomSample(DVk\Sk,NQ) # 选择query样本
c k ← 1 N C ∑ ( x i , y i ) ∈ S k f ϕ ( x i ) \mathbf{c}_k\gets \frac{1}{N_C}\sum_{(\mathbf{x}_i,y_i)\in S_k}f_{\phi}(\mathbf{x}_i) ck←NC1∑(xi,yi)∈Skfϕ(xi) # 从support样本中计算原型
end for
J ← 0 J\gets 0 J←0 # 初始化权重
for k ∈ { 1 , … , N C } k\in \left\{1,\dots,N_C\right\} k∈{1,…,NC} do
for ( x , y ) ∈ Q k (\mathbf{x},y)\in Q_k (x,y)∈Qk do
J ← J + 1 N C N Q [ d ( f ϕ ( x ) , c k ) + log ∑ k ′ exp ( − d ( f ϕ ( x ) , c k ) ) ] J\gets J+\frac{1}{N_CN_Q}[d(f_{\phi}(\mathbf{x}),\mathbf{c}_k)+\log\sum_{k'}\exp(-d(f_{\phi}(\mathbf{x}),\mathbf{c}_k))] J←J+NCNQ1[d(fϕ(x),ck)+logk′∑exp(−d(fϕ(x),ck))]
end for
end for
与匹配网络(Matching Networks)的比较
在few-shot任务中，原型网络与匹配网络不同；而在one-shot任务中，它们是等价的。在给定支撑集的情况下，匹配网络产生一个加权最近邻分类器，而在使用平方欧氏距离(squared Euclidean distance)的情况下，原型网络产生一个线性分类器。在one-shot学习中， c k = x k \mathbf{c}_k=\mathbf{x}_k ck=xk是因为每个类中只有一个支撑点，此时原型网络和匹配网络等价。
一个问题是，每个类使用多个原型而不是一个是否有意义呢？如果每个类的原型数量是固定的且大于1，则这将需要一种分区方案来进一步将类中的支撑点聚类。然而，这需要一个独立的分区阶段，该阶段与权值更新是解耦的，而作者的方法使用普通的梯度下降方法使得学习很容易。
设计选择
距离度量 匹配网络使用余弦距离。但是，对于原型网络和匹配网络来说任何距离都是允许的，作者发现使用平方欧氏距离可以极大地改善两者的结果。作者推测这主要是由于余弦距离不是布雷格曼散度。
episode组成 在匹配网络中使用的一种构造片段的简单方法是，为每个类别选择 N C N_C NC类和 N S N_S NS支持点，以匹配测试时的预期情况。也就是说，如果我们期望在测试时执行5-way分类和1-shot学习，那么训练集可以由 N C = 5 ， N S = 1 N_C = 5，N_S = 1 NC=5，NS=1组成。然而，我们发现使用比测试时更高的 N C N_C NC(或“way”)进行训练是非常有益的。在作者的实验中，根据保留的验证集调整训练 N C N_C NC。另一个需要考虑的是是否在训练和测试时匹配 N S N_S NS(或“shot”)。对于原型网络，作者发现使用相同的“shot”数字进行训练和测试会有很好的效果。
实验
对于few-shot学习，作者利用Ravi和Larochelle [1]提出的分束方法，在Omniglot和ILSVRC-2012的mini-ImageNet版本上进行实验。在加州理工学院UCSD鸟数据集(CUB-200 2011)的2011版本上执行zero-shot学习实验。
Omniglot few-shot分类
Omniglot是一个从50个字母中收集到的1623个手写字符的数据集。每个字符都有20个例子，每个例子都是由不同的人绘制的。作者采用了匹配网络中的方法，通过将灰度图像调整为28×28，并以90度的倍数旋转增加字符的类。作者使用1200个字符类加上旋转后的进行训练(总共4800个类)，其余的类包括旋转后的类进行测试。其嵌入结构由4个卷积块组成，每个块包含一个64-filter的3×3卷积，batch-normalization层，ReLU层和一个2×2最大池化层。当应用于28×28的Omniglot图像时，这种结构产生了64维的输出空间。作者使用相同的编码器来嵌入support点和query点。所有模型都经过Adam优化的SGD训练。初始学习率为0.001，每经过2000个片段将其减半。除了batch-normalization没使用其他正则化。
作者在1-shot和5-shot场景里使用欧式距离对原型网络进行训练，训练片段中包含60个类，每个类有5个query点。同时作者发现将“training-shot”与“test-shot”匹配是有利的，并且每个训练片段使用更多的类(高级“way”)而不是更少。作者最后计算了从测试集随机生成的1000个片段的平均分类准确率。结果如下：
Gaussian prototypical network
这是一个基于原型网络的few-shot分类模型。简单来讲，原型网络学习了一个图片和其嵌入向量的映射关系，然后将嵌入向量聚类进行分类，而作者的网络的编码器的一部分输出被解释成了一个用于估计嵌入点的置信区间，并作为一个高斯协方差矩阵表达出来，接着作者的网络在嵌入空间上构建了一个直接的类内距离标尺，使用独立的数据点的不确定性作为权重。换句话讲，网络将每张图片都映射为一个嵌入向量和一个图片质量的估计值，然后用高斯协方差矩阵来预测、表征一个置信区间。
作者还发现该网络和原型网络有同样多的参数，但是效果却好了很多，在Omniglot数据集上取得了SOTA的表现。此外，作者还进行了训练集上的人工下采样，从而使得表现再次提升，进而说明该模型在不太均匀的、噪声比较大的数据集上可能表现会更好一点，这也更接近现实世界中的应用情形。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C5lVaRLx-1606979628012)(https://s1.ax1x.com/2020/04/12/GLXzrD.png)]
Relation networks
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JQ4rnAT8-1606979628014)(https://s1.ax1x.com/2020/04/12/GLjMIs.png)]
这个网络和孪生网络很像，但又有一丢丢不同：
-
该“关系”不是由特征空间中简单地L1距离捕获的，而是由CNN分类器 g ϕ g_{\phi} gϕ预测的。一对输入 x i \mathbf{x}_i xi和 x j \mathbf{x}_j xj之间地关系分数为 r i j = g ϕ ( [ x i , x j ] ) r_{ij} = g_\phi([\mathbf{x}_i, \mathbf{x}_j]) rij=gϕ([xi,xj])，这里的方括号表示“连接”(concatenation)
-
目标函数是MSE损失而不是交叉熵，因为在概念上，关系网络更关注去预测关系分数，而不是二分类。
L ( B ) = ∑ ( x i , x j , y i , y j ) ∈ B ( r i j − 1 y i = y j ) 2 \mathcal{L}(B) = \sum_{(\mathbf{x}_i, \mathbf{x}_j, y_i, y_j)\in B} (r_{ij} - \mathbf{1}_{y_i=y_j})^2 L(B)=(xi,xj,yi,yj)∈B∑(rij−1yi=yj)2
model based
Neural Turing Machines （NTM）
Memory-Augmented Neural Networks （MANN）
MANN是NTM的改进版本，其主要改变是写入头的寻址方式引入了最近最少使用原则。
Meta Networks
翻译自lilianwen博客：博客地址
它是一种元学习模型，其架构和训练过程旨在于任务之间快速进行泛化。
快速权值(Fast Weights)
MetaNet的快速泛化有赖于“快速权值”。一般情况下，神经网络中的权值是通过目标函数中的随机梯度下降来更新的，但它的速度很慢。一种更快的学习方法是利用一个神经网络预测另一个神经网络的参数，这样生成的权值称之为快速权值。而基于SGD的权值称为慢权值。
在MetaNet中，损失梯度信息作为元信息来填充学习快速权重的模型。神经网络中使用快慢权值相结合的方式进行预测。
图1. 在MLP中结合了快慢权值，其中 ⨁ \bigoplus ⨁表示对应元素相加。
模型组件(Model Components)
MetaNet的关键组件：
- 一个由 θ \theta θ参数化的嵌入函数 f θ f_{\theta} fθ 将原始输入编码为特征向量，与孪生神经网络相似，对这些向量进行训练可判断两个输入是否属于同一类。
- 由权重 ϕ \phi ϕ参数化的基本学习器模型 g ϕ g_{\phi} gϕ完成了实际的学习任务，即直接预测输入样本的类别。
到此时，这看起来就像个关系网络。但此外，MetaNet显式地对两个函数的快速权重进行建模，然后将它们聚合回到模型中。因此我们需要另外两个函数分别输出 f f f和 g g g的快速权值。
- F ω F_{\omega} Fω：用 ω \omega ω参数化的LSTM，用于学习嵌入函数 f f f的快速权重 θ + {\theta}^+ θ+。它以 f f f 的嵌入损失作为验证任务的输入梯度。
- G ν G_{\nu} Gν：由 ν \nu ν 参数化的神经网络，从基本学习器 g g g 的损失梯度学习快速权重 ϕ + {\phi}^+ ϕ+。在MetaNet中，学习器的损失梯度被视为任务的元信息。
MetaNet如何训练？
训练数据包含多对数据集：支撑集 S = { x i ′ , y i ′ } i = 1 k S=\left\{ x_{i}', y_{i}' \right\}_{i=1}^{k} S={xi′,yi′}i=1k ，测试集 U = { x i , y i } i = 1 L U=\left\{x_i, y_i \right\}_{i=1}^L U={xi,yi}i=1L
先说一下，有四个网络和四组参数要学习→ { ϕ , θ , ω , ν } \left\{ \phi , \theta , \omega , \nu \right\} {ϕ,θ,ω,ν}
图2. MetaNet结构
训练过程：
- 在支撑集 S S S的每一步时刻 t t t采样一对随机输入 ( x i ′ , y i ′ ) ( x_{i}' , y_{i}') (xi′,yi′)和 ( x j ′ , y j ) ( x_{j}',y_{j}) (xj′,yj)。使 x ( t , 1 ) = x i ′ , x ( t , 2 ) = x j ′ x_{\left( t,1 \right)}=x_{i}',x_{\left( t,2 \right)}=x_{j}' x(t,1)=xi′,x(t,2)=xj′
for t = 1 , … , K t=1,\dots ,K t=1,…,K：
- 计算表征学习(representation learning)的损失，即验证任务的交叉熵 L t e m b = 1 y i ′ = y j ′ l o g P t + ( 1 − 1 y i ′ = y j ′ ) l o g ( 1 − P t ) \mathcal{L}^{emb}_{t}=\mathbf{1}_{y_{i}'=y_{j}'}logP_{t}+(1-\mathbf{1}_{y_{i}'=y_{j}'})log(1-P_{t}) Ltemb=1yi′=yj′logPt+(1−1yi′=yj′)log(1−Pt)，其中 P t = σ ( W ∣ f θ ( x ( t , 1 ) ) − f θ ( x ( t , 2 ) ) ∣ ) P_t = \sigma(\mathbf{W}\vert f_\theta(\mathbf{x}_{(t,1)}) - f_\theta(\mathbf{x}_{(t,2)})\vert) Pt=σ(W∣fθ(x(t,1))−fθ(x(t,2))∣)
-
计算task-level快速权重： θ + = F ω ( ∇ θ L 1 e m b , … , L T e m b ) \theta^+=F_{\omega}(\nabla_{\theta}\mathcal{L}_{1}^{emb},\dots,\mathcal{L}_{T}^{emb}) θ+=Fω(∇θL1emb,…,LTemb)
-
接下来通过支撑集 S S S中的示例计算示例级快速权重。同时用习得的表征来更新记忆。
for i = 1 , … , K i=1,\dots,K i=1,…,K：
基础学习器输出一个概率分布： P ( y ^ i ∣ x i ) = g ϕ ( x i ) P(\hat{y}_i \vert x_i) = g_\phi(x_i) P(y^i∣xi)=gϕ(xi)，损失函数可以是交叉熵或MSE： L i t a s k = y i ′ log g ϕ ( x i ′ ) + ( 1 − y i ′ ) log ( 1 − g ϕ ( x i ′ ) ) \mathcal{L}^{task}_i = y'_i \log g_{\phi}(x'_i) + (1- y'_i) \log (1 - g_\phi(x'_i)) Litask=yi′loggϕ(xi′)+(1−yi′)log(1−gϕ(xi′))
提取任务的元信息(损失梯度)并计算示例级快速权重： ϕ i + = G v ( ∇ ϕ L i t a s k ) \phi_i^+=G_v(\nabla_\phi\mathcal{L}^{task}_i) ϕi+=Gv(∇ϕLitask)
- 之后将 ϕ i + \phi_i^+ ϕi+存到"值"存储器 M \mathbf{M} M的第 i i i个位置。
使用慢速和快速权重将支撑样本编码为特定于任务的输入表示形式： r i ′ = f θ , θ + ( x i ′ ) r'_i = f_{\theta, \theta^+}(x'_i) ri′=fθ,θ+(xi′)
- 之后将 r i ′ r'_i ri′存到"键"存储器 R \mathbf{R} R的第 i i i个位置
- 最后，使用测试集 U = { x i , y i } i = 1 L U=\left\{ x_i,y_i \right\}_{i=1}^L U={xi,yi}i=1L构造训练损失。从 L t r a i n = 0 \mathcal{L}_{train}=0 Ltrain=0开始：
for j = 1 , … , K j=1,\dots,K j=1,…,K：
将测试样本编码为特定于任务的输入表示： r j = f θ , θ + ( x j ) r_j = f_{\theta, \theta^+}(x_j) rj=fθ,θ+(xj)
快速权重是通过关注内存 R \mathbf{R} R中支撑集样本的表示来计算的。attention功能可以*选择，MetaNet这里选择余弦相似度：
a j = c o s i n e ( R , r j ) = [ r 1 ′ ⋅ r j ∥ r 1 ′ ∥ ⋅ ∥ r j ∥ , … , r N ′ ⋅ r j ∥ r N ′ ∥ ⋅ ∥ r j ∥ ] a_j=cosine(\mathbf{R},r_j)=[\frac{r'_1\cdot r_j}{\|r'_1\|\cdot\|r_j\|},\dots,\frac{r'_N\cdot r_j}{\|r'_N\|\cdot\|r_j\|}] aj=cosine(R,rj)=[∥r1′∥⋅∥rj∥r1′⋅rj,…,∥rN′∥⋅∥rj∥rN′⋅rj]
ϕ j + = s o f t m a x ( a j ) ⊤ M \phi_j^+=softmax(a_j)^{\top} \mathbf{M} ϕj+=softmax(aj)⊤M
更新训练损失： L t r a i n ← L t r a i n + L t a s k ( g ϕ , ϕ + ( x i ) , y i ) \mathcal{L}_{train}\gets \mathcal{L}_{train}+\mathcal{L}^{task}(g_{\phi,\phi^+}(x_i),y_i) Ltrain←Ltrain+Ltask(gϕ,ϕ+(xi),yi)
- 使用 L t r a i n \mathcal{L}_{train} Ltrain更新所有参数 { ϕ , θ , ω , ν } \left\{\phi,\theta,\omega,\nu \right\} {ϕ,θ,ω,ν}
optimization based
LSTM Meta-Learner
Meta Learning by gradient descent by gradient descent
引言：
In a few-shot learning setting, gradient descent fails abruptly due to very few data points. Gradient descent optimization requires more data points to reach the convergence and minimize loss.
在传统的深度学习模型中，都会使用大量的样本基于梯度下降算法对模型的参数进行训练，使其收敛、模型的误差最小化。但是在few-shot learning中，往往是给定一个任务，但是该任务只有非常少量的训练样本。例如要做一个类似cifar100的图片分类任务，但是每个类别只提供了5个样本。
显然我们很难再使用传统的深度学习那一套方法：设计一个特征提取和组合的结构，之后对接上一个全连接结构，最后使用一个Softmax层输出每个类别的概率。三个部分作为一个整体，以便能进行端到端的训练。
因为我们没有足够多的训练样本去使上述的一个典型的三个部分的模型结构参数收敛。当然可以做数据增强，但是样本的数量依旧远远达不到能使模型收敛的量。
梯度下降 和 LSTM
KaTeX parse error: No such environment: align at position 8: \begin{̲a̲l̲i̲g̲n̲}̲ Gradient \quad…
由公式可以看出梯度下降是LSTM隐状态的ct的更新简化版本。
所以可以用LSTM当作优化器，去训练模型的参数θ。LSTM的输出是更新之后的θ。
M为任务的模型Model 参数是θ，LSTM的是模型R，参数是Φ={c,h}。
算法过程如下：
Φ_0 <----random init, Φ={c,h}
for d=1...n:
D_train, D_test <----random sample from dataset D
θ_0 = C_0
for t=1...T:
X_t,Y_t <---random sample batch from D_train
Loss_t = L(M(X_t; θ_t-1), Y_t)
c_t <--- R((dLoss_t/dθ_t, Loss_t), Φ_d-1)
θ_t = c_t
end for
X, Y <---D_test
Loss_test = L(M(X; θ_T), Y)
update Φ_d using dLoss_test/dθ_t
end for
summary
Meta Learning by gradient descent by gradient descent使用了LSTM作为参数优化器，其包含两个子模型，一个是用于解决针对任务的模型，另一个是LSTM网络。任务模块传给LSTM的输入是损失和损失关于其自身的梯度。LSTM输出的是任务模块更新之后的参数。
显然整个结构有两个参数，一个是任务模块的参数，其在LSTM内负责更新，这里没有直接使用梯度下降策略。另一个是LSTM本身的参数，即4个权重矩阵及其偏置。LSTM的参数学习是通过梯度下降策略完成，具体指定的梯度下降对象是测试集上的损失：任务模块使用训练集一次内循环更新完成之后的参数，应用到测试集上计算测试集的损失，该损失用于梯度更新LSTM的参数。以此完成整个结构的一次训练。
meta learning by gradient descent by gradient descent 是关于一个特定任务的学习，即：其操作对象是一个特定的任务，而不是一些列相关的任务集。整个模型训练完成之后，真正部署需要保留的仅仅是任务模块及其参数。
注意：该方法的操作对象不是一系列关联任务，而是单个任务。本质上依旧是针对任务的深度学习。
该方法的主要思想是使用一种非梯度下降方式去更新任务的参数，这种参数更新的策略是自动学习得到。其尝试学习的是一种自适应的参数更新方法，是关于参数更新方法的学习。
更多详细了解参阅：https://blog.csdn.net/senius/article/details/84483329
（MAML）Model Agnostic Meta Learning
思想
MAML的思想是企图找到一些列相似任务的比较好的一个初始化的参数状态。其操作对象是一个个具有联系的任务。显然这些任务的网络结构是共享的，参数shape是一致的。
算法
传统的深度学习参数更新是一步完成的即：
θ
=
θ
−
α
∇
θ
L
o
s
s
(
f
θ
(
x
)
,
y
)
\theta = \theta-\alpha\nabla_\theta Loss(f_\theta(x),y)
θ=θ−α∇θLoss(fθ(x),y)
MAML的参数更新是两步完成：
KaTeX parse error: No such environment: align at position 8: \begin{̲a̲l̲i̲g̲n̲}̲ \\model\ :&f \…
算法的具体内容：
使用
MAML的输出是一个能解决相似性任务的模型，和该模型的一个初始化状态。将得到的MAML具体应用到一个特定的相似性任务时，仅使用少量的样本进行训练即可。
注意点：训练和测试classes和每个类的样本数要对应。
Reptile
reptile是在MAML的基础进行改进的，MAML是两步调整一次cross tasks parameter，而reptile是多步之后调整一次cross tasks parameter，区别见下图。
算法
Adversarial meta learning
思想
Adversarial meta learning的思想是以提高网络的鲁棒性为重点，对给定的每个样本，生成样本的一个adversarial样本。原来的样本称为origin input，生成的称为adversarial input，ad input的label和origin是同一个。即：一个样本（origin_x, y）生成一个（ad_x, y）。
之后将两个样本分别输入到网络进行训练。训练的方法使用的是MAML的思想。
Fast Gradient Sign Method（FGSM ）
ADML
网络参数为θ，分别对原始输入图像和假的图像独立使用θ进行同MAML的计算过程，并且分别求出两个gradient，然后分别对θ进行累计更新。
$ θ=θ-β(\nabla_\theta origin+\nabla_\theta adv) $
最后得到的是网络的参数θ，用以初始化相似任务的网络参数。实际使用该网络和参数对特定任务应用时，只需要在train set训练即可。FGSM和AMDL可以不需要使用。
CAML
思想
同样以MAML为基础，与MAML不同的是，MAML在每个新任务上会更新所有的参数，而CAML将模型的参数分成了两部分，一部分是context parameters，作为模型的额外输入使其适应于单独的任务；另一部分是shared parameters，在任务间共享并通过元学习训练过程优化。CAML在每个新任务上只更新模型的context部分的参数，这样可以在使用更大的网络情况下避免在单一任务上过拟合，并且可以节省内存。
为了使模型在新任务上快速学习，通常只进行几步梯度下降，这时候MAML内循环实际上变成了一个任务识别问题，而不是学习如何去解决整个任务。因此，如果模型中跨任务变化的部分是模型的额外输入，并且独立于其他输入，那么就足够解决问题了。
模型的额外输入，也就是context parameters ϕ \phi ϕ，可以被看做是调整模型行为的task embedding或者是condition。 ϕ \phi ϕ在元学习过程的内循环中更新，其余的参数 θ \theta θ在外循环中更新，这可以使CAML优化过程更加明确，在任务间优化任务独立参数 θ \theta θ，同时保证任务特异的参数 ϕ \phi ϕ可以快速地适应新任务。
task solver和task embedding分离有几个优点：
- 这两部分的大小可以根据任务进行合适的调整，使得在使用更深的网络进行训练时能够在内循环不会对某个任务过拟合（MAML在使用更深的网络时会过拟合）
- 模型设计和结构选择也从这种分离中受益，因为对于许多实际问题，我们事先知道任务之间在哪些方面不同，因此也知道 ϕ \phi ϕ的容量
- 由于只对 ϕ \phi ϕ求高阶导，避免了在神经网络对weights和biases的操作
- 由于不用像MAML一样在内层循环时复制参数，减少了写内存的次数，加快了训练过程
算法
注意：第4行： D i t r a i n D_i^{train} Ditrain和 D i t e s t D_i^{test} Ditest的是由同一个testi划分而得到。
第6行 learn task-specific parameters $\phi_i $ via one gradient update
计算的 ϕ i \phi_i ϕi是需要保存下来的。即 l i s t ϕ = { ϕ 1 , ϕ 2 , . . . , ϕ i } list_\phi=\{\phi_1,\phi_2,...,\phi_i \} listϕ={ϕ1,ϕ2,...,ϕi}
ϕ \phi ϕ是特定任务 t a s k i task_i taski相关的参数，task是如上图的Actual image和Adversial image分类。
具体细节
神经网络的 h l h^l hl层的输出与 ϕ \phi ϕ（在每一步adaption之前都被初始化为0）进行拼接， ϕ \phi ϕ在内循环和训练过程中被更新； θ \theta θ只在外循环中被更新并且在任务间共享，所以在测试中固定。通过将 ϕ \phi ϕ初始化为0，网络和 ϕ \phi ϕ相关联的参数不会影响adaptation前的输出。在第一次adaptation之后，他们将被用于调整网络剩余的部分以解决新的任务。
分两种情况
一：当全连接网络时，输入层x是一维向量， ϕ \phi ϕ也是一维一维向量，直接与x进行拼接即可。
二：当输入层x是二维或三维矩阵
卷积网络，使用FiLM的feature-wise linear modulation方法，对feature map进行变换，给定
ϕ
\phi
ϕ和卷积层输出的M个feature map
{
h
i
}
i
=
1
M
\{h_i\}_{i=1}^M
{hi}i=1M
F
i
L
M
(
h
i
)
=
γ
i
h
i
+
β
FiLM(h_i)=γ_ih_i+β
FiLM(hi)=γihi+β
γ , β γ,β γ,β都是context parameter的函数，使用全连接层 [ γ , β ] = ∑ k = 1 K θ k , i ( l , ϕ ) ϕ 0 , k + b [γ,β]=∑^K_{k=1}θ^{(l,ϕ)}_{k,i}ϕ_{0,k}+b [γ,β]=∑k=1Kθk,i(l,ϕ)ϕ0,k+b加上输出的恒等变换。
eg: 例如是RGB图像 s h a p e = [ h e i g h t , w i t h , c h a n n e l s ] shape=[height, with, channels] shape=[height,with,channels]， ϕ \phi ϕ的$ shape=[height, with, n]\ n\in N^+$
使用
网络的参数 θ , ϕ \theta, \phi θ,ϕ 的shape是固定的。训练完成之后，得到的是网络的参数是 θ , ϕ \theta,\phi θ,ϕ,其中 θ \theta θ是数值是网络训练得到的，例如MAML的网络初始化参数，而 ϕ \phi ϕ直接初始化为0即可。得到的网络模型和原始网络一致，注意具体落实应用时，只有一个task，所以模型中内循环 T i , i = 1 T_i,i=1 Ti,i=1。或者直接将 θ , ϕ \theta, \phi θ,ϕ作为一个整体进行参数更新。
Meta-SGD
思想
首次提出将学习率作为参数进行学习。是在MAML的基础上将学习率作为可训练的参数。
一个确定的网络，其参数 θ \theta θ是固定的，即一个确定的网络的参数量是固定的，不包括参数的状态。将学习率作为参数，论文提出：每个参数有一个自身的学习率 α \alpha α。所以学习率参数的shape和网络自身的参数 θ \theta θ是相同的。并且学习率也是以随机的形式进行初始化。论文指出学习率的更新方式和 θ \theta θ的更新方式一致，即: θ = θ − β ⊙ ∇ θ L o s s ( f θ , α ( x ) , y ) α = α − β ⊙ ∇ θ L o s s ( f θ , α ( x ) , y ) \theta=\theta-\beta\odot\nabla_\theta Loss(f_{\theta,\alpha}(x),y)\\\alpha=\alpha-\beta\odot\nabla_\theta Loss(f_{\theta,\alpha}(x),y) θ=θ−β⊙∇θLoss(fθ,α(x),y)α=α−β⊙∇θLoss(fθ,α(x),y)
算法
KaTeX parse error: No such environment: align at position 8: \begin{̲a̲l̲i̲g̲n̲}̲ \\model\ :&f \…
具体使用
同MAML一致，Meta-SGD最后得到的也是模型+参数，参数包括学习率。
Gradient Agreement as an Optimization Objective
思想
梯度一致性也是在MAML的基础上做的改进，其考虑到不同的任务对cross task parameter的梯度方向不同，有些任务梯度方向和整体平均的梯度方向不一致，那么就对该个方向取一个较小的权重，对梯度方向和整体均值的梯度方向一致的取个较大的权重。以此加速模型的参数更新。故此称为梯度一致性作为优化对象。
算法
例如 θ ′ = { θ 1 ′ , θ 2 ′ , θ 3 ′ , θ 4 ′ } \theta^\prime=\{\theta'_1,\theta'_2,\theta'_3,\theta'_4\} θ′={θ1′,θ2′,θ3′,θ4′}，显然 θ 1 ′ , θ 2 ′ , θ 3 ′ , θ 4 ′ \theta'_1,\theta'_2,\theta'_3,\theta'_4 θ1′,θ2′,θ3′,θ4′的均值方法与 θ 4 ′ \theta'_4 θ4′相反，而与 θ 1 ′ , θ 2 ′ , θ 3 ′ \theta'_1,\theta'_2,\theta'_3 θ1′,θ2′,θ3′相同。
θ = θ − β ∑ i w i ∇ θ L o s s T i ( f θ i ′ ) \theta=\theta-\beta\sum_{i}w_i\nabla_\theta Loss_{T_i}(f_{\theta_i' }) θ=θ−β∑iwi∇θLossTi(fθi′)，其中 w i w_i wi是每个任务梯度的权重系数。
例如在reptile算法中的参数更新： θ = θ − β ∑ i w i ( θ i ′ − θ ) \theta=\theta-\beta\sum_{i}w_i(\theta_i'-\theta) θ=θ−β∑iwi(θi′−θ)
参数
w
w
w的计算：
g
:
g
i
=
θ
−
θ
i
′
w
:
w
i
=
∑
j
∈
T
(
g
i
T
g
j
)
∑
k
∈
T
∣
∑
j
∈
T
(
g
k
T
g
j
)
∣
g:g_i=\theta-\theta_i' \\w:w_i=\frac{\sum_{j\in T}(g_i^T g_j)}{\sum_{k\in T}|\sum_{j\in T}(g_k^T g_j)|}
g:gi=θ−θi′w:wi=∑k∈T∣∑j∈T(gkTgj)∣∑j∈T(giTgj)
Task agnostic meta learning (TAML)
思想
考虑到(MAML系列)元学习网络可能对任务具有偏向性。
出发点：模型可能会偏向于某些任务，特别是在元训练阶段抽样的任务。所以模型会在这些任务上容易发生过拟合。如果模型在某些任务发生了偏向，那么元学习模型无法获得一个好的、能在新的任务达到一个好的效果的通用模型状态。
为了克服元学习对任务潜在的偏向性，论文引入了经济学中的一些避免不平等的方法。
算法：
Entropy maximization/reduction：熵是衡量随机性的度量。因此，我们通过允许模型对预测的标签以相同的概率进行随机猜测来最大化熵。
对一个分类任务，可以直接最大化初始模型在不同类别上的熵（Entropy Maximization）来实现对任务的无偏性。
在更新模型参数之前，我们将熵最大化。其次，在更新模型参数后，我们将熵最小化。那么，最小化熵是什么意思？最小化熵意味着我们不在预测标签上添加任何随机性，并且我们允许模型以高置信度预测标签。因此，我们的目标是最大限度地减少每个任务的熵，它可以表示如下：
KaTeX parse error: No such environment: align at position 8: \begin{̲a̲l̲i̲g̲n̲}̲ \\Entropy:&H \…
Inequality minimization
另一方面，对一般任务，比如回归或增强学习任务，我们注意到往往可以通过定义一个损失函数(loss function)或者奖励函数（reward function）来定义和优化这些任务。如果把负损失或者奖励看着是给每个任务的收入（income），我们就可以基于经济学中的度量收入不平等（inequality）的方法来刻画meta-learner 在不同任务的bias。
比如，我们可以用广泛应用的基尼系数来度量元学习在不同任务的偏差，除此之外还有GE指数、Theil指数等。这些不平等度量具有不同的特性，可以聚焦考虑在特定的损失或奖励（收入）区间上任务。同时，这些度量还满足若干性质，使得它们非常适合作为不平等度量。比如对称性、伸缩不变性、非负性、传递原则等等。
通过最小化不平等度量，我们可以得到对不同任务无偏的meta-learner；我们有理由相信，这种无偏性，可以在某种程度上保证这种meta-learner对未来的新任务具有更好的泛化性能。
KaTeX parse error: No such environment: align at position 8: \begin{̲a̲l̲i̲g̲n̲}̲ \\task_i:&\ lo…
Meta imitation learning
介绍
强化学习的具体例子。
Clustering to Automatically Generate Tasks for Unsupervised Model Agnostic Meta Learning （CACTUs）
介绍
聚类思想解决zero-shot learning：先对给定的无标签样本进行聚类，获得类别标签。之后使用MAML或者reptile进行训练。
给定了 D = { x 1 , x 2 , x 3 , … , x n } D=\{x_1,x_2,x_3,…,x_n\} D={x1,x2,x3,…,xn}，使用一个函数，计算样本的embeddings，对embeddings使用k-nn，划分k clusters(partitions)。clusters中对应的embeddings拥有一个共同的类别标签。
任务划分：聚类获得了一共k个clusters，从k个clusters中随机抽取n个clusters，每个cluster无放回的抽取r个样本： { x r } n \{x_r\}_n {xr}n，之后对n个clusters进行one-hot编码，得到label： l n l_n ln
最后定义得到task T： T = { ( x n , r , l n ) ∣ x n , r ∈ { x r } n } T=\{(x_{n,r},l_n)|x_{n,r}\in \{x_r\}_n\} T={(xn,r,ln)∣xn,r∈{xr}n}
ign}
$$
Meta imitation learning
介绍
强化学习的具体例子。
Clustering to Automatically Generate Tasks for Unsupervised Model Agnostic Meta Learning （CACTUs）
介绍
聚类思想解决zero-shot learning：先对给定的无标签样本进行聚类，获得类别标签。之后使用MAML或者reptile进行训练。
给定了 D = { x 1 , x 2 , x 3 , … , x n } D=\{x_1,x_2,x_3,…,x_n\} D={x1,x2,x3,…,xn}，使用一个函数，计算样本的embeddings，对embeddings使用k-nn，划分k clusters(partitions)。clusters中对应的embeddings拥有一个共同的类别标签。
任务划分：聚类获得了一共k个clusters，从k个clusters中随机抽取n个clusters，每个cluster无放回的抽取r个样本： { x r } n \{x_r\}_n {xr}n，之后对n个clusters进行one-hot编码，得到label： l n l_n ln
最后定义得到task T： T = { ( x n , r , l n ) ∣ x n , r ∈ { x r } n } T=\{(x_{n,r},l_n)|x_{n,r}\in \{x_r\}_n\} T={(xn,r,ln)∣xn,r∈{xr}n}