精华内容
下载资源
问答
  • Meta Learning技术 MAML

    2020-04-10 01:41:03
    Meta Learning 最常被用来解决少样本(Few-Shot)的问题,在这边我们介绍一篇经典的论文 Model-Agnostic Meta-Learning(MAML)。由题目可知他是一种「与模型无关的」元学习,亦即这种方法可以匹配任何使用梯度下降...

    Learning to learn——Meta learning

    Meta Learning 最常被用来解决少样本(Few-Shot)的问题,在这边我们介绍一篇经典的论文 Model-Agnostic Meta-Learning(MAML)。由题目可知他是一种「与模型无关的」元学习,亦即这种方法可以匹配任何使用梯度下降算法(Gradient Descent)训练​​的模型,并能应用于各种不同的学习问题,如分类、回归和强化学习等。

    MAML算法的目的

    在 MAML 中,其目标在于一次看过多种任务(task),并希望可以学到一个可以找到所有任务「本质」的模型。举例来说,我们小的时候学会宝特瓶可以一手握着瓶身,另一手将瓶盖转开;而当我们接触到一个装糖果的玻璃罐时,我们察觉玻璃罐与保特瓶相似的本质,因而有办法套用既往的知识快速的移转到新的任务上,而MAML便是在学这个过程,在遍览多种任务后,学习一组对任务敏感的参数,当新任务进来时能快速的将先验知识移转到新任务中。
    相对于deep learning在一个task(任务)中通过对样本的学习以对新样本做出判断,元学习的目标可以看做是将task视作样本,通过对多个task的学习,以使元模型(meta-learner)能够对新的task做出快速而准确的学习。具体来说,就是训练能"对特定的task产生特定的高效学习算法的算法"。至于MAML,则是尝试训练一个最简单的算法——参数初始化。MAML希望训练一组初始化参数,通过在初始参数的基础上进行一或多步的梯度调整,来达到仅用少量数据就能快速适应新task的目的。当我们通过MAML得到了一组蛮不错的参数,之后在类似的任务中,这组参数将会提供很好的模型初始迭代点。

    算法步骤

    在这里插入图片描述

    1. Sample batch size of tasks:首先会从meta-training里面筛选一个batch size的training data。
    2. Evaluate gradient and compute adapted parameter:对 training data 中每一个 task 以及其对应的 label 计算属于每个 Task 的 gradient 与更新后的 model 参数。
    3. Update the model:当有了每个task 利用training data of meta-train得到的新模型参数后,可以利用test data of meta-train验证,并且加总所有任务的loss,对原本模型参数微分并真正的更新一次参数。
      如何评估一组初始化参数的好坏呢?最直觉的想法自然是用它和task的训练集来训练模型,看最后得到的正确率和所需要的迭代次数。但是一般的深度模型训练常常要花费几万次的迭代来得到一个可靠的解,尽管我们可以像RNN的BPTT算法一样把这几万次的过程中每一步的参数对应的梯度都考虑进去,进而更新初始化参数,但是这个过程需要的时间和空间开销都大得惊人,我们有一种更高效的方式,就是只进行一次参数更新,用这时的参数来计算误差,更新初始化参数。
      解这样的优化问题,得到的将是一个"在所有任务上,经过一次梯度下降更新后,total loss最小的初始化参数"。尽管我们不能说这是一个最好的初始化参数,但是我们可以相信这个参数将会帮助我们训练更多的类似task。
      具体到代码实现,考虑到task可能非常多,则是一般采取每次随机抽取一个task,把参数代入模型,迭代更新一次;更新到第二次时,用这个Δ直接更新我们的初始化参数。
      这里使用了一种近似,设初始参数为Φ,则单次更新后的模型参数为
      θ=ΦαL1Φ θ=Φ-\alpha \frac{\partial {L_1}}{\partial {Φ}}
      其中L1是第一次计算loss时的损失函数(损失函数会随着参数变化而变化)。当计算第二次更新时,我们要计算这时的Φ关于Loss2的导数,涉及到二阶导数,为了快速计算,我们直接用
      L2Φ=L2θθΦ=L2θ(12LΦ2)L2θ \frac{\partial {L_2}}{\partial {Φ}} = \frac{\partial {L_2}}{\partial {θ}} \frac{\partial {θ}}{\partial {Φ}}= \frac{\partial {L_2}}{\partial {θ}} (1-\frac{\partial ^2{L}}{\partial {Φ}^2}) \approx \frac{\partial {L_2}}{\partial {θ}}
      的一阶近似扔掉二阶导数,这样计算就变得简单很多,每次我们只需要把初始参数(Meta)用于模型初始化,在训练集上训练一次更新参数,然后在计算第二次导数时,把这个导数拿出来用于更新我们的初始参数(Meta).

    代码实现

    论文上给出了一组非常简单的训练任务集,我们要实现的就是生成 a∗sin(x+b) 的数据集,其中a,b可以调整以得到多种相似但不相同的任务。a,b 的范围是(0,1.5) (0,2π),每个数据集有10个点。在这些数据集中,训练一个最契合所有任务的初始化值。
    (先调包,我可懒得自己写梯度下降)

    import torch
    import torch.nn as nn
    import torch.utils.data as data
    import torch.nn.functional as F
    import numpy as np
    from tqdm import tqdm
    import copy
    import matplotlib.pyplot as plt
    

    然后我们设计一个函数产生我们需要的数据集,通过随机产生a和b,就能获得多组不同的tasks。我们这里设置每个任务的数据size为10

    device = 'cpu'
    def meta_task_data(seed = 0, a_range=[0.1, 5], b_range = [0, 2*np.pi], task_num = 100,
                       n_sample = 10, sample_range = [-5, 5], plot = False):
        np.random.seed = seed
        a_s = np.random.uniform(low = a_range[0], high = a_range[1], size = task_num)
        b_s = np.random.uniform(low = b_range[0], high = b_range[1], size = task_num)
        total_x = []
        total_y = []
        label = []
        for t in range(task_num):
            x = np.random.uniform(low = sample_range[0], high = sample_range[1], size = n_sample)
            total_x.append(x)
            total_y.append( a_s[t]*np.sin(x+b_s[t]) )
            label.append('{:.3}*sin(x+{:.3})'.format(a_s[t], b_s[t]))
        if plot:
            plot_x = [np.linspace(-5, 5, 1000)]
            plot_y = []
            for t in range(task_num):
                plot_y.append( a_s[t]*np.sin(plot_x+b_s[t]) ) 
            return total_x, total_y, plot_x, plot_y, label
        else:
            return total_x, total_y, label
    
    bsz = 1
    train_x, train_y, train_label = meta_task_data() 
    train_x = torch.Tensor(train_x).unsqueeze(-1) # add one dim
    train_y = torch.Tensor(train_y).unsqueeze(-1)
    train_dataset = data.TensorDataset(train_x, train_y)
    train_loader = data.DataLoader(dataset=train_dataset, batch_size=bsz, shuffle=False)
    
    test_x, test_y, plot_x, plot_y, test_label = meta_task_data(task_num=1, n_sample = 10, plot=True)  
    test_x = torch.Tensor(test_x).unsqueeze(-1) # add one dim
    test_y = torch.Tensor(test_y).unsqueeze(-1) # add one dim
    plot_x = torch.Tensor(plot_x).unsqueeze(-1) # add one dim
    test_dataset = data.TensorDataset(test_x, test_y)
    test_loader = data.DataLoader(dataset=test_dataset, batch_size=bsz, shuffle=False)  
    

    有了上面的推导,实现起来也并不困难。我们知道了只需要用第二次梯度下降的更新直接应用到meta上,就可以另外找一个变量把meta存起来,每次要用就用它初始化模型。在第一次和第二次更新参数时,把参数记录下来取差值,直接加到meta上,就这么简单。
    在此之前还要先定义模型,我们定义1-50-50-1的全连接网用来处理上面的所有任务。

    # 定义模型,输入输出为1维,双隐层,隐层单元50个
    
    class net(nn.Module):
        def __init__(self):
            super(net, self).__init__()
            self.fc1 = nn.Linear(1, 50) 
            self.sig1 = nn.Sigmoid()
            self.fc2 = nn.Linear(50, 50)
            self.sig2 = nn.Sigmoid()
            self.fc3 = nn.Linear(50, 1)
        
        def forward(self, x):
            out = self.fc1(x)
            out = self.sig1(out)
            out = self.fc2(out)
            out = self.sig2(out)
            out = self.fc3(out)
            return out
    

    为了更方便地进行张量加减,我这里把meta用一个一维的张量表示;如此,我们要额外定义从一维张量生成模型,以及从模型获得一维张量的函数。

    def model_to_array(model):
        '''
        这个函数把所有模型参数一字排开,输出一个1维的tensor
        '''
        s_dict = model.state_dict()
        return torch.cat(
            (
            s_dict['fc1.weight'].view(-1),
            s_dict['fc1.bias'].view(-1),
            s_dict['fc2.weight'].view(-1),
            s_dict['fc2.bias'].view(-1),
            s_dict['fc3.weight'].view(-1),
            s_dict['fc3.bias'].view(-1))
        )
    
    def array_to_model(model,arr):
        '''
        这个函数把1维的tensor的数据写回model的dict中
        '''
        indice = 0
        s_dict = model.state_dict()
        for name,param in s_dict.items():
            length = torch.prod(torch.tensor(param.shape))
            s_dict[name] = arr[indice:indice+length].view(param.shape)
            indice += length
        model.load_state_dict(s_dict)
    

    开始训练,我们把所有的tasks过5000个epoch,使用随机梯度下降,更新meta和更新模型参数的学习率都设为0.01

    model = net() # 正式的模型,用于在各个task上测试
    protortype_prarms = model_to_array(model) # 我们要更新的原型参数,也就是MAML要训练的参数
    
    EPOCH = 5000
    Prototype_LR = 0.01
    Training_LR = 0.01
    optimizer = torch.optim.SGD(model.parameters(), lr=Training_LR)
    proto_optimizer = torch.optim.SGD(model.parameters(), lr=Prototype_LR)
    loss_func = nn.MSELoss()
    
    for epoch in range(EPOCH):
        total_loss = 0
        total_times = 0
        for step, (X,y) in enumerate(train_loader):
            X = X.view(10,1)
            y = y.view(10,1)
            # 把prototype的参数导入模型,作为初始化
            array_to_model(model,protortype_prarms)
            # 先计算一次,更新一次参数
            yhat = model(X)
            loss = loss_func(yhat,y)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            params_first_step = model_to_array(model)
            
            # 然后做第二次计算,再更新一次参数,把这次更新的差值用于更新原型参数
            yhat = model(X)
            loss = loss_func(yhat,y)
            total_loss += loss.item()
            proto_optimizer.zero_grad()
            loss.backward()
            proto_optimizer.step()
            params_second_step = model_to_array(model)
            
            total_times += 1
            
            # 计算差值,更新protortype_prarms
            protortype_prarms += params_second_step
            protortype_prarms -= params_first_step
        if (epoch+1)%20==0:
            print("Epoch %d, loss:%.2f"%(epoch+1,total_loss/total_times))
    

    我们可以画图来看一看meta的参数有没有发挥作用

    # 我们可以用两张图来看一看meta的参数有没有发挥作用
    optimizer = torch.optim.SGD(model.parameters(), lr=Training_LR)
    
    fig = plt.figure(figsize = [9.6,7.2])
    ax = plt.subplot(111)
    plot_x1 = plot_x.squeeze().numpy()
    ax.scatter(test_x.numpy().squeeze(), test_y.numpy().squeeze())
    ax.plot(plot_x1, plot_y[0].squeeze(),label = 'origin')
    # 丢入without train的model看一看
    plot_y_without_train = model(plot_x.view(1000,1))
    ax.plot(plot_x1, plot_y_without_train.detach().numpy().squeeze(),label = 'meta')
    # train一个step,再观察输出
    yhat = model(test_x[0])
    loss = loss_func(yhat,test_y[0])
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    plot_y_with_one_step = model(plot_x.view(1000,1))
    ax.plot(plot_x1, plot_y_with_one_step.detach().numpy().squeeze(),label = '1 step')
    # train 10个step,再观察输出
    for step in range(10):
        yhat = model(test_x[0])
        loss = loss_func(yhat,test_y[0])
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    plot_y_with_ten_step = model(plot_x.view(1000,1))
    ax.plot(plot_x1, plot_y_with_ten_step.detach().numpy().squeeze(),label = '10 step')
    ax.legend()
    

    在这里插入图片描述
    初始化后的函数已经有点正弦函数的样子了,只需要再train一个step,就能让数据点和网络输出相当接近,如果train10个epoch,就基本完全收敛在所有的数据点上。这是一般的参数初始化完全无法做到的,这就是meta学习到的知识。
    更直观的,我们画出normal的初始化和meta的初始化的loss图。
    在这里插入图片描述
    在类似的任务上有更快的收敛速度,就是meta-learning的力量。

    小结

    懒得写了,有人看记得点个赞呗

    展开全文
  • meta learning 第二章

    2019-01-17 09:56:52
    meta learning 第二章,算是比较系统的meta learning 教材,基本上介绍了什么是元学习。
  • 文章目录介绍Meta Learning概念Meta Learning的三板斧第一板第二板第三板Meta Learning实例:OmniglotTechniques TodayMAMLMAML vs transfer learningMAML的trickMAML Toy ExampleWarning of MathMAML – Real ...

    介绍

    元学习Meta learning = 学习如何去学习Learn to learn
    和Life-long方法有所不一样:

    方法 区别
    Life-long one model for all the tasks
    Meta How to learn a new model

    在这里插入图片描述
    从过去的任务中学习到一些经验,在新的任务上学得更快(不是更好)
    在这里插入图片描述

    公式输入请参考:在线Latex公式

    Meta Learning概念

    机器学习:用Training Data训练由我们设计的Learning Algorithm,得到一个最优算法ff^*,可以用来完成相应的任务(猫狗识别)

    在这里插入图片描述
    也就是:Machine Learning ≈ 根据数据找一个函数 f 的能力
    在这里插入图片描述

    原学习:用DtrainD_{train}训练由我们设计的F,可以得到一个完成相应任务的ff^*,怎么感觉和上面没什么区别?
    在这里插入图片描述
    其实不一样,Meta Learning≈ 根据数据找一个找一个函数 f 的函数 F 的能力。
    在这里插入图片描述
    机器学习中是知道函数f,而是训练函数f的参数;
    绪论里面的图:
    在这里插入图片描述
    元学习是不知道函数f,而是训练函数F找到f(含参数)。
    把上图中的function 代换为 F就变成了元学习
    在这里插入图片描述

    Meta Learning的三板斧

    第一板

    • Define a set of learning algorithm
    以基于GD优化的算法为例,下图中的每一步的gradient gg其实不一样
    在这里插入图片描述
    对于上图中有很多东西都是我们人来定义的,具体看下图中红色框框,网络构建是我们定义的,初始值是我们定义的,定义的lr不一样,更新的结果也不一样。
    红框中如果我们定义不同的东西,实际上就是不同的算法。我们的想法是让机器来帮助我们设计这些东西。
    在这里插入图片描述

    第二板

    Defining the goodness of a function F
    在机器学习中衡量一个函数f的好坏是用一组testing data来进行测试,那么要知道一个生成函数的函数F的好坏当然是要准备一把函数来进行测试咯。
    在这里插入图片描述
    在这里插入图片描述
    从这里可以看到机器学习和元学习在数据上有所不一样:
    机器学习的数据:
    在这里插入图片描述
    元学习的数据:
    在这里插入图片描述
    这里要说明:

    1. 由于元学习有多个任务,每个任务如果有很多数据,那么训练时间会很长很长,因此,元学习中每个任务的数据不会很多,所以元学习也叫few-shot learning,为了和机器学习区分开,训练和测试数据分别叫Support set和Query set。
    2. 和机器学习一样,当我们的元学习中的训练任务很多的时候,我们可以将其中一部分切出来作为验证任务:validation tasks。
    3. 元学习中的testing task可以和training task一样,也可以不一样。

    第三板

    • Defining the goodness of a function FF
    完成了N个任务后,可以计算F的loss
    L(F)=n=1NlnL(F)=\sum_{n=1}^Nl^n
    我们就是要找到一个FF^*,使得L最小。
    F=argminFL(F)F^*=arg\underset{F}{\text{min}}L(F)
    找到之后:
    在这里插入图片描述

    Meta Learning实例:Omniglot

    https://github.com/brendenlake/omniglot
    • 1623 characters,部分字符:
    在这里插入图片描述
    • Each has 20 examples
    在这里插入图片描述
    把这个学习过程看做是:N-ways K-shot classification,意思是 In each training and test tasks, there are N classes, each has K examples.
    例如:20 ways 1 shot就是有20个类别,每个类别只有一个example。
    在这里插入图片描述
    具体做法:
    • Split your characters into training and testing characters
    • Sample N training characters, sample K examples from each sampled characters → one training task
    • Sample N testing characters, sample K examples from each sampled characters → one testing task

    Techniques Today

    • MAML
    • Chelsea Finn, Pieter Abbeel, and Sergey Levine, “Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks”, ICML, 2017
    在这里插入图片描述

    • Reptile
    • Alex Nichol, Joshua Achiam, John Schulman, On FirstOrder Meta-Learning Algorithms, arXiv, 2018
    在这里插入图片描述

    MAML

    MAML主要是关注初始化参数ϕ\phi的选择(所有task的Network Structure都是一样的)。其损失函数为:
    L(ϕ)=n=1Nln(θ^n)L(\phi)=\sum_{n=1}^Nl^n(\hat\theta^n)
    其中:
    θ^n\hat\theta^n: model learned from task n, θ^n\hat\theta^n depends on ϕ\phi
    ln(θ^n)l^n(\hat\theta^n):loss of task n on the testing set of task n


    这里补充下后面一节中助教的讲解:
    MAML的框架是两层的循环嵌套,外面这层是更新MAML模型的参数ϕ\phi,然后里面这层是更新任务的参数θ^n\hat\theta^n,当然这个内部循环只更新一次(实际是两次)。


    在这里插入图片描述
    使用Gradient Descent来最小化L(ϕ)L(\phi)
    ϕϕηϕL(ϕ)\phi\leftarrow\phi-\eta\triangledown_{\phi}L(\phi)
    这里要和transfer learning中的pre-train model的损失函数进行区分:
    L(ϕ)=n=1Nln(ϕ)L(\phi)=\sum_{n=1}^Nl^n(\phi)
    可以看到transfer learning是用现有的模型去计算Loss(看模型的当前表现)
    而MAML是用ϕ\phi训练之后的模型来计算Loss(看模型潜力)
    用图形来表示二者的区别吧

    MAML vs transfer learning

    对于transfer learning,我们寻找在所有task都最好的ϕ\phi,但并不能保证把ϕ\phi拿去训练以后会得到最好的θn\theta^n,例如下图中ϕ\phi在task 2上得到最好的结果,但是拿到task 1上却只能得到一个局部最小值。
    在这里插入图片描述
    对于MAML,我们不在意 ϕ\phi 在 training task 上表现如何,我们在意用 ϕ\phi 训练出来的θn\theta^n
    表现如何,例如下图中的ϕ\phi,在task 1和task 2上目前表现并不是最好的,但是在task 1上,如果顺着左边的黑色箭头梯度下降,最终可以得到θ^1\hat \theta^1;在task 2上,如果顺着右边的黑色箭头梯度下降,最终可以得到θ^2\hat \theta^2。这两个都是最好的结果。
    在这里插入图片描述

    MAML的trick

    在这里插入图片描述
    在上面讲的MAML更新参数的过程中,一般只会更新一次:
    θ^=ϕϵϕl(ϕ)\hat \theta=\phi-\epsilon\triangledown_{\phi}l(\phi)
    原因如下:
    • Fast … Fast … Fast …更新次数少,速度就快,因为MAML跑一轮需要几个小时。
    • Good to truly train a model with one step. 就用一次更新就可以达到最佳作为目标来训练。
    • When using the algorithm, still update many times.实作的时候在测试过程中可以更新个几次,没毛病。
    • Few-shot learning has limited data.MAML对应的数据比较少,多次更新容易过拟合。

    MAML Toy Example

    Each task:
    • 给定一个正弦函数 y=asin(x+b)y=a\text{sin}(x+b)作为target function;
    • 从正弦函数中采样K个点作为样本;
    • 用这K个样本来估计target function。
    在这里插入图片描述
    Model Pre-training做出的结果如下图所示:由于Model Pre-training是在所有task都最好的初始化ϕ\phi,这里所有的正弦函数叠起来就是一条直线,所以它初始就是直线。
    在这里插入图片描述
    MAML的结果就很不错:
    在这里插入图片描述

    Warning of Math

    先把手上的公式整理出来,GD更新公式为:
    ϕϕηϕL(ϕ)(1)\phi\leftarrow\phi-\eta\triangledown_{\phi}L(\phi)\tag1
    其中损失函数为每个任务的ll累加
    L(ϕ)=n=1Nln(θ^n)(2)L(\phi)=\sum_{n=1}^Nl^n(\hat\theta^n)\tag2
    其中参数θ^n\hat\theta^n的计算公式为一步更新:
    θ^=ϕϵϕl(ϕ)(3)\hat \theta=\phi-\epsilon\triangledown_{\phi}l(\phi)\tag3

    先来整理计算公式1中的梯度优化项,把公式2代入公式1的梯度优化项中,并且把梯度放到求和函数里面去:
    ϕL(ϕ)=ϕn=1Nln(θ^n)=n=1Nϕln(θ^n)\triangledown_{\phi}L(\phi)=\triangledown_{\phi}\sum_{n=1}^Nl^n(\hat\theta^n)=\sum_{n=1}^N\triangledown_{\phi}l^n(\hat\theta^n)
    下面来看梯度ϕl(θ^)\triangledown_{\phi}l(\hat\theta)的求法,实际上是对每一项求偏导:
    ϕl(θ^)=[l(θ^)/ϕ1l(θ^)/ϕ2l(θ^)/ϕi]\triangledown_{\phi}l(\hat\theta)=\begin{bmatrix}\partial l(\hat\theta)/\partial \phi_1 \\ \partial l(\hat\theta)/\partial \phi_2 \\ \vdots \\ \partial l(\hat\theta)/\partial \phi_i \\ \vdots \end{bmatrix}
    初始化参数ϕi\phi_i是通过很多个θ^\hat\theta来影响l(θ^)l(\hat\theta)
    在这里插入图片描述
    根据链式法则:
    l(θ^)ϕi=jl(θ^)θ^jθ^jϕi(4)\cfrac{\partial l(\hat\theta)}{\partial \phi_i}=\sum_j\cfrac{\partial l(\hat\theta)}{\partial \hat\theta_j}\cfrac{\partial \hat\theta_j}{\partial \phi_i}\tag4
    上式中l(θ^)θ^j\cfrac{\partial l(\hat\theta)}{\partial \hat\theta_j}很好计算,根据损失函数l的形式直接求即可,例如l如果是交叉熵,就用交叉熵求偏导即可。重点来看后面这项:θ^jϕi\cfrac{\partial \hat\theta_j}{\partial \phi_i}
    根据公式3可知,θ^\hat\theta是一个向量,所以我们可以找其中一个分量:θ^j\hat\theta_j,由公式3可得:
    θ^j=ϕjϵϕjl(ϕ)=ϕjϵl(ϕ)ϕj(5)\hat\theta_j=\phi_j-\epsilon\triangledown_{\phi_j}l(\phi)=\phi_j-\epsilon\cfrac{\partial l(\phi)}{\partial\phi_j}\tag5
    对公式5中求ϕi\phi_i的偏导:
    iji\neq j
    θ^jϕi=ϵl(ϕ)ϕiϕj\cfrac{\partial \hat\theta_j}{\partial \phi_i}=-\epsilon\cfrac{\partial l(\phi)}{\partial\phi_i\partial\phi_j}
    i=ji= j
    θ^jϕi=1ϵl(ϕ)ϕiϕj\cfrac{\partial \hat\theta_j}{\partial \phi_i}=1-\epsilon\cfrac{\partial l(\phi)}{\partial\phi_i\partial\phi_j}
    算二次偏导很麻烦,原论文提出忽略二次偏导项:
    iji\neq j
    θ^jϕi=ϵl(ϕ)ϕiϕj0(6)\cfrac{\partial \hat\theta_j}{\partial \phi_i}=-\epsilon\cfrac{\partial l(\phi)}{\partial\phi_i\partial\phi_j}\approx 0\tag6
    i=ji= j
    θ^jϕi=1ϵl(ϕ)ϕiϕj1(7)\cfrac{\partial \hat\theta_j}{\partial \phi_i}=1-\epsilon\cfrac{\partial l(\phi)}{\partial\phi_i\partial\phi_j}\approx 1\tag7
    把公式6和公式7代入公式4,由于当iji\neq j时,θ^jϕi=0\cfrac{\partial \hat\theta_j}{\partial \phi_i}=0,所以求和的时候只用考虑i=ji= j的情况,即公式4可以写为:
    l(θ^)ϕi=jl(θ^)θ^jθ^jϕil(θ^)θ^i(8)\cfrac{\partial l(\hat\theta)}{\partial \phi_i}=\sum_j\cfrac{\partial l(\hat\theta)}{\partial \hat\theta_j}\cfrac{\partial \hat\theta_j}{\partial \phi_i}\approx\cfrac{\partial l(\hat\theta)}{\partial \hat\theta_i}\tag8
    利用公式8的估计,梯度矩阵就变成了:
    ϕl(θ^)=[l(θ^)/ϕ1l(θ^)/ϕ2l(θ^)/ϕi]=[l(θ^)/θ^1l(θ^)/θ^2l(θ^)/θ^i]=θ^l(θ^)\triangledown_{\phi}l(\hat\theta)=\begin{bmatrix}\partial l(\hat\theta)/\partial \phi_1 \\ \partial l(\hat\theta)/\partial \phi_2 \\ \vdots \\ \partial l(\hat\theta)/\partial \phi_i \\ \vdots \end{bmatrix}=\begin{bmatrix}\partial l(\hat\theta)/\partial \hat\theta_1 \\ \partial l(\hat\theta)/\partial \hat\theta_2 \\ \vdots \\ \partial l(\hat\theta)/\partial \hat\theta_i \\ \vdots \end{bmatrix}=\triangledown_{\hat\theta}l(\hat\theta)
    最后我们的梯度优化项就变成了:
    ϕL(ϕ)=ϕn=1Nln(θ^n)=n=1Nϕln(θ^n)=n=1Nθ^nln(θ^n)\triangledown_{\phi}L(\phi)=\triangledown_{\phi}\sum_{n=1}^Nl^n(\hat\theta^n)=\sum_{n=1}^N\triangledown_{\phi}l^n(\hat\theta^n)=\sum_{n=1}^N\triangledown_{\hat\theta^n}l^n(\hat\theta^n)

    MAML – Real Implementation

    先要有一个初始化参数,然后把一个任务task看做是一个sample,当然可以用多个任务组成mini-batch,然后做GD,这里不用batch,而是用SGD:
    在这里插入图片描述
    先取一个任务m(Sample a training task m),然后更新参数得到θ^m\hat\theta^m
    在这里插入图片描述
    虽然说好只更新一次,但是这里还是更新两次:
    在这里插入图片描述
    这里我们计算θ^m\hat\theta^m的偏导,取其方向作为ϕ0\phi^0的梯度更新方向:
    在这里插入图片描述
    这里需要注意,同向的绿色和蓝色箭头不一定等长,因为LR可能不一样。
    然后取一个任务n(Sample a training task n)同样用ϕ1\phi^1计算出θ^n\hat\theta^n以及θ^n\hat\theta^n的下一次梯度方向
    在这里插入图片描述
    取其方向作为ϕ1\phi^1的梯度更新方向:
    这里需要注意,同向的黄色和蓝色箭头不一定等长,因为LR可能不一样。
    在这里插入图片描述
    再次对比transfer learning的Model Pre-training在实现上和MAML有什么不一样:
    现有一个初始化参数:
    在这里插入图片描述
    然后计算θ^m\hat\theta^m
    在这里插入图片描述
    然后沿着绿色箭头更新ϕ0\phi^0
    在这里插入图片描述
    然后不断重复:
    在这里插入图片描述

    MAML 应用:Translation

    Meta-Learning for Low-Resource Neural Machine Translation
    18 training tasks: 18 different languages translating to English
    2 validation tasks: 2 different languages translating to English
    实验结果中用的是BLEU来做评估,横轴是数据量,当然数据量越大效果越好。
    Baseline是多任务学习。
    先看验证集结果,罗马语翻译为英文
    在这里插入图片描述
    测试任务结果,法语翻译英文
    在这里插入图片描述

    Reptile(简单介绍)

    https://openai.com/blog/reptile/
    现有初始化参数ϕ0\phi^0
    在这里插入图片描述
    取一个任务m(Sample a training task m),Reptile没有规定只能更新一次参数,因此:
    在这里插入图片描述
    ϕ0\phi^0θ^m\hat\theta^m方向就是ϕ0\phi^0更新的方向:
    在这里插入图片描述
    计算出ϕ1\phi^1后,取一个任务n(Sample a training task n)同样用ϕ1\phi^1计算出θ^n\hat\theta^n并更新多次,取ϕ1\phi^1θ^n\hat\theta^n的方向作为ϕ1\phi^1的更新方向:
    在这里插入图片描述
    把pre-train,MAML,Reptile都放在一起看下有什么区别:
    下面g1g_1是pre-train的更新方向
    g2g_2是MAML的更新方向
    g1+g2g_1+g_2是Reptile的更新方向,当然还可以更新更多次
    在这里插入图片描述

    实验结果比较:
    在这里插入图片描述
    MAML和Reptile其实不分上下,但是最下面那个蓝色是Transfer learning。

    More about Meta Learning

    上面讲的MAML和Reptile都是关于用Meta Learning来找初始化参数这个事情,那我们在介绍Meta Learning的时候还有很多红色框框,这些也是可以用Meta Learning来进行研究如何学习的。
    不过弹幕提示:只有初始化参数这里可以用GD
    下图是用network来设计Architecture & Activation,以及如何更新参数。
    在这里插入图片描述
    下面套娃预警:
    We learn the initialization parameter ϕ\phi by gradient descent.
    What is the initialization parameter ϕ0\phi^0 for initialization parameter ϕ\phi?
    在这里插入图片描述
    How about learning algorithm beyond gradient descent?
    在这里插入图片描述

    展开全文
  • Meta Dialogue Policy Learning》 作者:微软2020 介绍: 研究任务型对话中DP组件的few shot问题与新领域迁移。 提出了DTQN以利用跨domains的low-level共享信号(如动作、槽位)。 把DTQN嵌入到一个meta-Learning...

    《Meta Dialogue Policy Learning》

    作者:微软2020

    介绍:

    • 研究任务型对话中DP组件的few shot问题与新领域迁移。
    • 提出了DTQN以利用跨domains的low-level共享信号(如动作、槽位)。
    • 把DTQN嵌入到一个meta-Learning框架,引入了Meta-DTQN。

    注意现在这个论文还在under review,所以源码就别想了,不过可以去ConvLab上搜下试试。

    Introduction

    多领域问答:复杂的系统比如Siri,通常包含thousands of task domains。总之,新领域迁移,或者few-shot,是一大问题。

    DP = POL = 对话策略管理 = 给定state和user-goal,输出next-step-action。

    由于对话会跨越多轮,DP通常需要使用强化学习。

    传统方法在算法层面内在地无法实现向新领域的迁移。

    我们提出了一个思想,即there is often shareable low-level information between different domains.它们可以在上下文表示与agent策略选择上构成相似性。提出了一个基于DQN的强化学习算法,DTQN,hierarchically model cross-domain relations at domain-level, act-level and slot-level。

    【按:这里所谓的信息,就是两个领域拥有same-name的act和slot。至于3-level层级建模,说穿了,就是多利用底层的低维信息。】

    元学习框架:元学习框架MAML用于adapt models to new tasks with a small number of data。过去的元学习框架主要都是NLG以及监督学习,POL以及强化学习的则少很多,而这就是本文的第二个创新点。作者基于MAML元学习框架进行魔改,引入了很多trick如dual-replay机制,warm-up RBS机制等等,使得其胜任了任务型对话POL的task。

    【按: meta-learning即元学习,也可以称为“learning to learn”。常见的深度学习模型,目的是学习一个用于预测的数学模型。而元学习面向的不是学习的结果,而是学习的过程。其学习的不是一个直接用于预测的数学模型,而是学习“如何更快更好地学习一个数学模型”。 了解元学习框架需要多看参考文献,这里不赘述了。】

    P.S. 作者在论文内多次提到附录,但是论文里根本没有附录,怎么回事?

    2 参考文献

    No. 类型 内容 重要性
    1 早期RL与策略对话的结合 Model-based RL 3
    2 基于multi-hot的POL temporal control。对话任务的完成需要的回合会越来越多。 2
    3 基于multi-hot的POL Bbq-networks 2
    4 基于multi-hot的POL ConvLab。这里的multi-hot state向量包括6个基本特征类,例如request和inform。 4
    5 早期RL Playing atari 0
    6 Meta-learning框架 Model-Agnostic Meta-Learning (MAML) framework。can applies to any optimizable system. 4
    7 Meta-learning框架 off-policy meta-reinforcement learning 2
    8 Meta-learning框架用于NLG The domain adaptive dialog generation method (DAML)。It places the state encoder and response generator into the MAML framework to learn general features across multiple tasks 2
    9 早期RL Meta-supervised-learning 0
    10 MultiWoz 数据集 1
    11 基于人工规则的POL - 1
    12 早期RL RL的科普扫盲 0
    13 早期RL 2015年 0
    14 早期RL与策略对话的结合 Sample efficient on-line learning of optimal dialogue policies with kalman temporal differences. 1
    15 层级POL subgoal discovery for hierarchical dialogue policy learning 1
    16 Meta-learning框架 finding an effective prior as initialization for new task learning 1
    17 Meta-learning框架 by a meta-learner to optimize the model which can quickly adapt to new domains 3
    18 早期RL DQN 1
    19 早期RL与策略对话的结合 Replay Buffer Spiking (RBS) 2

    RL扫盲的,太老的POL都不用管了。核心就是要了解基于MultiWOZ数据集做POL的基本程式,以及如何与RL结合。

    一些参考:

    https://www.zhihu.com/question/57159315

    https://zhuanlan.zhihu.com/p/57864886

    3 Problem Formulation

    3.1 Reinforced Dialogue Agent

    RL用于POL,则Reward rr measures the degree of success of a dialogue。例如在ConvLab中,reward与对话轮数L有关。

    RL内有state(envrioument, oveservation),有act。用于POL,state就是对话状态s,act就是系统动作a。Q函数就是Q(s, a)

    给定s,agent根据ϵ\epsilon-greedy策略选择a。这里和DQN就很像了,比如replay buffer也有。最终loss也是均方误差。

    3.2 Environment and Domain

    用户模拟器:首先,模拟器具化一个对话目标goal,然后,agent努力完成这个目标。目标可能涉及1到多个domains。

    We split all domains into source domains and target domains to fit the meta-learning scenario。

    【按:即是source domain用于training,target domain用于adaptation。而不是把全部领域都一股脑地训练,那样还怎么表现模型的跨领域迁移能力对吧】

    3.3 State Representation

    在这里插入图片描述

    左:传统DQN系统。

    缺陷:

    (1)6个multi-hot特征向量彼此相对隔绝,缺乏内部联系的考虑。(state信息不共享)

    (2)来自不同domain的act是独立建模的回归类。(action信息不共享)

    总结就是action与state信息可以也应该跨领域共享。

    右:DTQN

    jointly optimizes the policy network and domain knowledge representations.

    Framework

    本节介绍核心创新点。4.1节介绍我们提出的DTQN强化学习算法。4.2节介绍我们如何将其用于元学习框架。

    4.1 DTQN

    system action space:A

    dialogue state space:S

    把state与actions层级分解为4个嵌入子空间:

    领域空间D,动作空间C,槽位空间O,值空间V。

    原来的state与actions则通过这4个子空间嵌入的联合编码获得。

    【按:说的很绕。其实,就是指利用domain,slot,value,act的词向量,来构建system action 与dialogue state 的嵌入特征向量。由于数据集里system action 与dialogue state都是结构化的domain,slot,value,act实例的组合,所以就等于system action 与dialogue state的嵌入空间降维到了更加线性无关的子空间。】

    (1)state encoder

    过去已定义好的dialogue state特征类,我们保留。
    在这里插入图片描述

    【按:这里不太懂。依图看,6个feature对应6个act?inform,request,thank,bye,greet,booking?】

    H=6H=6类对话状态特征向量用如下方法转化成最终该dialog state的向量:
    s=ReLU(Ws[s1,s2,...,sH]) s=\bold {ReLU}(W_s[s_1,s_2,...,s_H])
    shs_hh[1,H]h\in[1,H])是每一个特征类的特征向量,H个拼起来,用线性层映射到ss,其是一个长度为dsd_s的向量。

    【按:每个domain都有自己特有的act特征集?这里需要翻引用的文献才能明白。】

    接下来的问题就是怎么计算shs_h

    注意每个shs_h都包含了Dh|D_h|个domain-specific特征。将第hh个特征类的特征向量shs_h的第ii个(i[1,Dh]i\in[1,|D_h|])domain-specific组成部分记为s^h,i\hat s_{h,i},包含了该act-domain的信息,全部本体内的槽值对信息,以及标志domain是否active的二值信息(concat)
    s^h,i=[dh,i,avg(ov),uh,i] \hat s_{h,i}=[d_{h,i}, \bold{avg}(o \odot v),u_{h,i}]

    sh=1/Dhi=1Dh(Residual(s^h,i)) s_h=1/|D_h| ·\sum^{|D_h|}_{i=1}(\bold{Residual}(\hat s_{h,i}))

    把针对每个领域的特有特征加和求平均,作为最终第hh个特征类的特征向量。

    (2)action encoder

    传统DQN仅编码dialogue states。

    而我们则用一个action encoder显式地建模system actions

    对每一个act aa,定义包含这个act的所有领域构成集合为DaD_a

    其中第ll个domain(l[1,Da]l\in[1, |D_a|])的特征定义为
    a^l=[dl,cl,avg(o)] \hat a_{l}=[d_l, c_l, \bold {avg}(o)]
    即领域的嵌入向量;动作嵌入向量;全部槽位嵌入向量的平均——三者拼接。
    a=1/Dhl=1Dh(Residual(a^l)) a=1/|D_h| ·\sum^{|D_h|}_{l=1}(\bold{Residual}(\hat a_l))
    定义上式为最终的该system action的特征向量。

    是一个长度为dad_a的向量。

    【按:state encoders与action encoders的嵌入表是共享的】

    一共有A|A|个这种act向量。将全部act的特征向量堆叠为一个矩阵ARA×daA\in R^{|A| \times d_a}

    (4)Q-values

    上面得到dialogue states空间的特征向量sRdss\in R^{d_s},又得到了dialogue actions空间每一个act的特征向量aRdaa\in R^{d_a},用一个双线性张量积将两个向量乘起来,得到一个标量:
    v=1daaWqs v = \frac {1}{\sqrt{d_a}}aW_qs
    它就是当前对话状态情况下,系统动作为a对应的Q值。

    4.2 Meta Reinforcement Learning with Dual Replay

    伪代码如下:

    在这里插入图片描述

    policy network:QQ

    target network:QQ'

    训练时:

    外循环:取样K个dialogue goal作训练用task

    内循环:for k in range(K):

    • agent基于task tkt_k与环境交互,收集轨迹,存在一个replay buffer MtrM_{tr}里。
    • MtrM_{tr}中采样,得到一minibatch个该任务的实验对象:BtrtkB^{t_k}_{tr}
    • 用DQN经典Loss公式,计算损失函数
    • 更新一次参数θQ(k)\theta_{Q}^{(k)} from θQ\theta_{Q}
    • 根据更新后的网络参数,agent再与环境交互,取得轨迹BevtkB_{ev}^{t_k}

    在这里插入图片描述

    • 这一步逐渐特殊。论理,应当把根据BevtkB_{ev}^{t_k}计算的task eval loss用于更新θQ\theta_Q。但是,这种on-policy学习,在初始阶段会遭受sparse rewards的问题。为什么会稀疏呢?因为跨领域对话场景下,一则要探索的state-action空间非常大,二则完成任务的回合数会非常多,三则前两个问题在未来随着新领域集成到系统里会变得越来越严重。因此,agent就容易过拟合on-policy data,掉入决策空间的局部最小点。故,作者提出了一个dual-replay framework以支持有效的off-poliicy学习。即,Apart from the main replay buffer MtrM_{tr} for meta-training, we construct a task evaluation memory MevM_{ev}。说穿了,就是训练阶段的task与估计阶段的task分开存储。【按:这一段是重点,以后细化】
    • 另外,我们还利用了一个imitation learning的变体,**Replay Buffer Spiking (RBS)**来warm up学习过程。在开始实验前,先拿一批数据以基于规则的方法对buffer做初始化。这样能让从MevM_{ev}采用得到的BevtkB_{ev}^{t_k}是混合了on-policy与off-policy数据。然后,根据BevtkB_{ev}^{t_k}计算的task eval loss用于更新θQ\theta_Q

    在这里插入图片描述

    测试时

    for an unseen domain, we adopt a similar off-policy approach for meta-adaptation.

    这种train-test consistency(训练-测试一致性)规避了the known difficulty in on-policy meta-adaptation with off-policy meta-training

    事实上,传统的MAML-RL框架,可以视作我们的dual-replay结构的一个特例(set the task evaluation memory MevM_{ev} to Bevtk|B^{t_k} _{ev}|

    Experiment

    5.1 Setup

    数据集:multiwoz2.0

    基本模式:training-and-adaptation

    • source domain:attraction, restaurant, taxi and hospital for training
    • target domain:hotel, train and police for adaptation

    我们设置了两种实验环境:

    • single-domain:agents are trained and tested with only single-domain dialogue goals
    • composite-domain:for each task in meta-training, we first select a seed domain dd^* and then sample domain composition which contains dd^*. The trained model is then adapted and evaluated in various domain compositions containing dd^*.

    【按:原始数据集内以数据dial(goal)为单位,有些dial仅涉及1个domain,有些dial则涉及两到三个。总共本体里有7种domain。单领域环境很简单。组合领域环境则根据seed domain的选取衍生多种子环境。】

    系统:DQN + DTQN两种RL算法,分有无RBS和有无dual replay来做消融实验。few shot上,选取1000个数据。

    实施细节:所有agent都在ConvLab上开发。batch_size=16,training_replay_buffer.size() = evaluation_replay_buffer.size() = 50000。在训练阶段,前1000个episode对buffer初始化。在adapt阶段,single-domain为10个episode;composite-domain为前50个episode。

    5.2 Evaluation Results


    在这里插入图片描述

    5.2.1 Few-shot Models

    No. 系统
    1 DQN-1K
    2 DTQN-1K

    both models are trained from scratch with the 1,000 frames in the target domains.

    DQN-1K在向Hotel迁移时完全失败了。而DTQN-1K全面胜利。

    5.2.2 Adaptive Models

    No. 系统 说明 单领域 多领域
    1 VANILLADQN DQN没有RBS 最差
    2 DQN 标准baseline,使用binary state representations 次差
    3 DTQN 我们的模型(没有使用元学习框架) 次好
    4 META-DTQN-SR 我们的模型(使用元学习框架,没有dual replay机制)(5的single replay版本) 一般
    5 META-DTQN 我们的模型 最好 最好

    由表1:在单领域方面,META-DTQN虽然最好,但优势不明显,因为单领域比较简单,DTQN也能handle。

    由表2:组合领域方面,DTQN在hotel上几乎失败。在train上还算成功,因为train与taxi相似度较高。META-DTQN全面胜利。

    由表3:表3就是单纯的POL性能,不管adaptive能力了。这个情况下,META-DTQN和DTQN都很好。反而META-DTQN-SR还不如DQN,这是因为single replay设置使得它过拟合了。所以,如果没有dual replay机制,宁可不要元学习框架。

    Effects of dual replay:

    [

    composite-domain情况下,DTQN更易遭受initial reward sparsity的影响,这 时候dual replay机制的作用就更明显。

    图2:控制task eval memory的size Mev|M_{ev}|的增大,从Mev|M_{ev}| = batch size Bevtk|B_{ev}^{t_k}| = 16开始。size<5000时,训练loss在warm-up阶段结束后,会迅速下降,即过拟合确实是存在的,导致success rate无法提升。size > 5000时,success rate得以正常提升,说明增大size对帮助模型逃离局部最小点是有效的。

    Effects of adaptation data size

    在这里插入图片描述

    接下来研究adaptation data on target domains的size对agent性能的影响。

    图3:size从100增到2500,性能逐次提升。注意到,既然1个episode包含大约10个frames(samples),而我们在前50个episodes使用RBS,这意味着当size<500时,仅off-policy经历能够影响到agent。换言之,其实agent的adaptation能力主要提升自size - 500个on-policy数据,这再次印证了我们模型具有极强adaptation能力

    Conclusion

    略。

    展开全文
  • 首先,我们先从Meta Learning的概念说起。 原始的机器学习的流程被认为是下面这这样的: 也就是我们根据我们先验知识设计网络架构和参数初始化方法,从Training Data 中得到参数的梯度,使用一阶条件调整参数。 ...

    整理自

    Frank Tian 回答

    首先,我们先从Meta Learning的概念说起。

    原始的机器学习的流程被认为是下面这这样的:

    也就是我们根据我们先验知识设计网络架构和参数初始化方法,从Training Data 中得到参数的梯度,使用一阶条件调整参数。

    因为网络架构已经是提前设计好的,我们学习的最终输出其实就是参数

    图中红框内的都是人类之前设计好的,Meta Learning 的目标就是学习这些是如何设计的。

    Meta Learning的任务是输入,现阶段成熟的方法一般默认这些任务是同类的。例如图像分类。

    输入的训练集可以是十个图像分类任务,这些任务有自己的训练集和测试集,但是我们在这里称为 Support SetQuery Set

    而测试集可以是两个额外的任务,当然他们也有自己的Support set 和 Query set。

    Machine Learning 的训练和测试数据如下:

    Meta Learning 的训练和测试数据如下:

    在 Machine Learning 中我们定义损失函数为 l=L(f)l = L(f) , ff 表示这个模型,损失函数 LL 是一个泛函,通常我们用测试数据经过模型的输出原来的label的差异作为损失函数的估计。

    而Meta Learning中,我们用这些 ll 的和,估计Meta Learning的损失:

    L(F)=i=0NlnL(F) = \sum_{i=0}^{N} l^n

    在Meta Learning中,我们常用Omniglot作为数据集训练,Omniglot有1623个characters,每个character有20个examples

    characters如下:

    而examples指的是同样一个character经过不同的人写出来的结果:

    Mate Learning的任务被称为N-ways K-shot classification,N指的是有多少个类别,K指的是每个类别有多少个sample。

    Meta Learning常常和Few-shot Learning一起出现,Few-shot Learning指的是样本特别少的Machine Learning。

    例如一个20-ways 1-shot classification,就是一共有20个类别,每个类别只有一个训练样本。往往这样的问题用传统的Machine Learning是很难解决的。20-ways 1-shot classification的一个例子如下:

    Support set:

    Query set:

    MAML就是一种决定如何初始化参数的方法。

    它默认要求了不同任务的网络模型是一样的,更确切的说,它没有“根据训练集生成初始化参数”的能力,它对所有任务的初始化参数是相同的。

    也就是说,它其实是找到了对于所有的任务,最好的一种参数初始化的方法。并让所有任务都按照这种方法进行参数初始化。

    这当然要求模型的结构是相同的了,不然根本没有办法使用同样的参数。

    我们设初始化的参数为 ϕ\phi,每个任务的模型一开始的参数都是 ϕ\phi,经过训练后,参数就会变成 θ^n\hat{\theta}^n ,而用 ln(θ^n)l^n(\hat{\theta}^n)表示每个任务的损失

    那么,对于这个Meta Learning而言,整体的损失函数应该是 ϕ\phi 的函数:
    L(ϕ)=n=1Nln(θ^n)L(\phi) = \sum_{n=1}^{N} l^n(\hat{\theta}^n)

    当然如果我们把 ϕ\phi 看作参数, LL 就是函数,把 ϕ\phi 看作函数, LL 就是泛函,不过问题不大。而对于单一的一个任务而言,ϕ\phi 被视为超参数

    回忆一下我们之所以能很有效的调节参数,而没办法高效的调节超参数,就是因为我们没办法计算超参数的梯度,而MAML则是基于一些假设,使我们可以计算 ϕ\phi 的梯度

    一旦我们可以计算 ϕ\phi 的梯度,就可以直接更新 ϕ\phi
    ϕ[ϕηϕL(ϕ)] \phi \leftarrow [\phi - \eta\bigtriangledown_{\phi } L(\phi ) ]
    而所谓的假设即是:每次训练只进行一次梯度下降

    这个假设听起来不可思议,但是却也有一定的道理,首先我们只是在Meta Learning的过程中只进行一次参数下降,而真正学习到了很好的 ϕ\phi 之后自然可以进行多次梯度下降。

    只考虑一次梯度下将的原因有:

    • Meta Learning会很多 ;
    • 如果能让模型只经过一次梯度下降就性能优秀,当然很好 ;
    • Few-shotlearning的数据有限,多次梯度下降很容易过拟合 ;
    • 刚才说的可以在实际应用中多次梯度下降.

    如果只经历了一次梯度下降,模型最后的参数就会变成:
    θ^=θϵϕl(ϕ) \hat{\theta} = \theta - \epsilon\bigtriangledown_{\phi }l(\phi )

    当然因为 ll 的不同,最后不同任务的 θ^\hat{\theta} 也会不一样,准确来说应该是:
    θ^n=θϵϕln(ϕ) \hat{\theta}^n = \theta - \epsilon\bigtriangledown_{\phi }l^n(\phi )

    现在我们已经有 L(ϕ)=n=1Nln(θ^n)L(\phi) = \sum_{n=1}^{N} l^n(\hat{\theta}^n),下一步就是计算 θ\theta 关于 LL 的梯度。

    我们有:

    ϕL(ϕ)=ϕi=1Nln(θ^n)=n=1Nϕln(θ^n)\bigtriangledown_{\phi}L(\phi) = \bigtriangledown_{\phi}\sum_{i=1}^{N} l^n(\hat{\theta}^n)=\sum_{n=1}^{N}\bigtriangledown_{\phi} l^n(\hat{\theta}^n)

    现在的问题是如何求 ϕln(θ^n)\bigtriangledown_{\phi} l^n(\hat{\theta}^n) ,略去上标 nn,有:

    ϕl(θ^)=[l(θ^)ϕ1l(θ^)ϕ2l(θ^)ϕi]\bigtriangledown_{\phi} l(\hat{\theta})=\left[ \begin{matrix} \frac{\partial l(\hat{\theta})}{\partial \phi_1}\\ \frac{\partial l(\hat{\theta})}{\partial \phi_2}\\ {\vdots}\\ \frac{\partial l(\hat{\theta})}{\partial \phi_i}\\ {\vdots} \end{matrix} \right]

    注意 llθ\theta 的函数,而 θ\theta 又和每一个 ϕi\phi_i 有关,因此有:

    l(θ^)ϕi=jl(θ^)θ^jl(θ^j)ϕi \frac{\partial l(\hat{\theta})}{\partial \phi_i} = \sum_{j}\frac{\partial l(\hat{\theta})}{\partial \hat{\theta}_j} \frac{\partial l(\hat \theta_j)}{\partial \phi_i}
    也就是说,每一个 ϕi\phi_i 通过影响不同的 θi\theta_i,从而影响到 ll

    llθ\theta 的关系是很直接的,我们可以直接求 l(θ^)θ^j\frac{\partial l(\hat{\theta})}{\partial \hat{\theta}_j} ,现在的问题是怎么求 l(θ^j)ϕi\frac{\partial l(\hat \theta_j)}{\partial \phi_i}

    注意 ϕ\phiθ\theta 的关系也是显然的:
    θ^=ϕϵϕl(ϕ)\hat \theta = \phi - \epsilon \nabla_{\phi}l(\phi)

    把向量的形式展开:
    θ^j=ϕjϵl(ϕ)ϕj\hat \theta_j = \phi_j - \epsilon \frac{\partial l(\phi)}{\partial \phi_j}

    我们考虑 iji \neq j
    (θ^j)ϕi=ϵl2(ϕ)ϕiϕj\frac{\partial (\hat \theta_j)}{\partial \phi_i} = - \epsilon \frac{\partial l^2(\phi)}{\partial \phi_i \partial \phi_j}

    而当 i=ji = j
    (θ^j)ϕi=1ϵl2(ϕ)ϕiϕi\frac{\partial (\hat \theta_j)}{\partial \phi_i} = 1 - \epsilon \frac{\partial l^2(\phi)}{\partial \phi_i \partial \phi_i}

    当然到此为止已经把梯度计算出来了,但是在MAML的论文中其实做了简化,它直接不计算二阶条件
    (θ^j)ϕi=ϵl2(ϕ)ϕiϕj0\frac{\partial (\hat \theta_j)}{\partial \phi_i} = - \epsilon \frac{\partial l^2(\phi)}{\partial \phi_i \partial \phi_j} \approx 0

    (θ^j)ϕi=1ϵl2(ϕ)ϕiϕi1\frac{\partial (\hat \theta_j)}{\partial \phi_i} = 1 - \epsilon \frac{\partial l^2(\phi)}{\partial \phi_i \partial \phi_i} \approx 1
    那么原来的偏导近似为:
    l(θ^)ϕi=jl(θ^)θ^jl(θ^j)ϕil(θ^)θ^i \frac{\partial l(\hat{\theta})}{\partial \phi_i} = \sum_{j}\frac{\partial l(\hat{\theta})}{\partial \hat{\theta}_j} \frac{\partial l(\hat \theta_j)}{\partial \phi_i} \approx \frac{\partial l(\hat{\theta})}{\partial \hat{\theta}_i}
    整个梯度就可以近似为:
    ϕl(θ^)=[l(θ^)ϕ1l(θ^)ϕ2l(θ^)ϕi][l(θ^)θ^1l(θ^)θ^2l(θ^)θ^i]=θ^l(θ^)\bigtriangledown_{\phi} l(\hat{\theta})=\left[ \begin{matrix} \frac{\partial l(\hat{\theta})}{\partial \phi_1}\\ \frac{\partial l(\hat{\theta})}{\partial \phi_2}\\ {\vdots}\\ \frac{\partial l(\hat{\theta})}{\partial \phi_i}\\ {\vdots} \end{matrix} \right] \approx \begin{bmatrix} \frac{\partial l(\hat{\theta})}{\partial \hat\theta_1}\\ \frac{\partial l(\hat{\theta})}{\partial \hat\theta_2}\\ {\vdots}\\ \frac{\partial l(\hat{\theta})}{\partial \hat\theta_i}\\ {\vdots} \end{bmatrix} = \nabla_{\hat\theta}l(\hat\theta)
    那么整个MAML的过程其实就很简单了:

    ϕ0\phi^0 开始,先用一个batch的任务训练(这里任务就相当于数据了),假设只用了一个任务,即任务m

    那么先用 ϕ0\phi^0 作为初始化参数,用task m的数据作为训练集,梯度下降一次,得到了θ^m\hat{\theta}^m ,这是已经训练好的模型了(我们假设只梯度下降一次)。

    然后我们要得到模型关于 θ^m\hat{\theta}^m 的梯度信息,那就再求一次梯度,但是我们就不用这个梯度对 θ\theta 梯度下降了,而是对 ϕ\phi 梯度下降。

    不停的计算不同的task的梯度,对 ϕ\phi 进行更新,就得到了最终的 ϕ\phi

    这就是MAML的思想。


    参考:

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

    展开全文
  • Meta-Q-Learning

    2020-09-27 16:38:57
    Meta-Q-Learning如有错误,欢迎指正摘要Introductionbackground 如有错误,欢迎指正 本文翻译为机翻,仅作初步了解学习使用,需要...介绍了元强化学习(Meta-Q-Learning,MQL)的一种新的off-policy算法Meta-RL。MQL建
  • 本文介绍我最近学习的两个 Meta Learning 的算法:MAML 和 Reptile。原始论文分别见:Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks 和 Reptile: a Scalable Metalearning Algorithm 。文章...
  • 转载:https://zhuanlan.zhihu.com/p/32270990 1 前言 2017年马上就要过去了,在这一年中,肯定很多搞深度学习的知友都会看到Meta Learning/ Learning to Learn 这个词。是的,它今年很火。在NIPS上,被Oriol...
  • 一、介绍 现有的基于元学习、度量学习的小样本学习方法在处理diverse domains和various classes上存在局限。元学习训练一个meta learner预测具有相同结构,但针对不同任务网络的权重。度量学习针对不同任务学习一个...
  • MAML在学术界已经是非常重要的模型了,论文Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks自2017年发表至今已经收获了400+的引用。由于当前网上关于MAML的中文介绍少之又少,可能很多小伙伴对...
  • 写在前面:迄今为止,本文应该是网上介绍【元学习(Meta-Learning)】最通俗易懂的文章了( 保命),主要目的是想对自己对于元学习的内容和问题进行总结,同时为想要学习Meta-Learning的同学提供一下简单的入门。...
  • Model-Agnostic Meta-Learning (MAML)模型介绍及算法详解: https://zhuanlan.zhihu.com/p/57864886
  • 强化学习在展现其强大学习能力的同时也深受其自身特性的困扰:系统的脆弱性和对超参数的依赖性。这一点在现今的复杂深度强化学习系统...打算最近介绍一个系列,今天先来说说这篇2003年的《Meta-learning in Reinforc...
  • 一个介绍Meta-Learning的Tutorial,重点说Meta-RL的基本方法。大致分以下三类:Black-Block Based、Optimization Based、Inference Based。
  • 本文提出了一种新的学习方法——元...具体来说,“meta”是指训练多个任务,“transfer”是通过学习每个任务的DNN权值的缩放和变换函数来实现的。此外,我们还介绍了作为一种有效的MTL学习课程的困难任务元批处理方案。
  • 最近meta learning很火,比如MAML等都是和神经网络相结合,而高斯过程在实际场景中有广泛的应用,但是高斯过程的计算复杂度很高,特别是需要多个数据点进行初始化,如果能和meta learning结合,减少初始化的数据点,...
  • 核心思想   本文提出一种基于参数优化的小样本学习算法(MetaNAS)。本文最重要的改进就是将神经...为了实现这一想法,作者将经典的NAS算法DARTS和小样本学习算法Reptile进行了结合,为了方便大家理解,我们首先介绍
  • 介绍联邦学习、元学习、联邦元学习以及他们的必要性、原理、方法、例子等内容
  • 总述: 这篇文章貌似就是把end2end模式的dialogue system套了一层maml的更新方式,然后在few-shot领域上的效果比之前赵天成的ZSDG效果要好。... 首先介绍一下maml的主要思想:maml就是说有多个domain的数据a1,a2,a3...
  • Online Meta-Learning2019||论文阅读

    千次阅读 2019-05-24 22:00:54
    元学习论文总结||小样本学习论文总结 2017-2019年计算机视觉...先简单介绍在线学习的概念: 在线学习算法的特点是:每来一个训练样本,就用该样本产生的loss和梯度对模型迭代一次,一个一个数据地进行训练,因此...
  • 一、介绍 作者使用元学习的方法,通过构建gallery encoder和probe encoder使得gallery image图片能够根据其余gallery images提取特征,probe image能够根据gallery iamges提取特征,达到了很好的效果,few-shot的...
  • 元学习—基于元学习的上下文快速适应(Fast Context Adaptation via Meta-Learning) 1 介绍 机器学习中的快速适应指的是使用少量的数据在之前未见的任务上进行快速的学习。原则上,可以利用之前的一些相关的任务所...
  • 元学习论文总结||小样本学习论文总结 2017-2019年计算机视觉顶会文章收录 AAAI2017-2019 ...文章之前多用遗传算法解决元学习问题,本文介绍如何应用梯度下降法解决循环网络结构的元学习模型。基于先前关于“固定...
  • 前几天读了18年的这篇文章《Camel: Content-Aware and Meta-path Augmented Metric Learning for Author Identification 》,将自己的阅读笔记分享给大家,共同学习共同进步! 这篇文章主要介绍的是作者识别...
  • 介绍3. 模型3.1 模型架构3.1.1 注意力机制内核3.1.2 完全上下文 embedding3.2 训练策略4. 其他5. 论文链接 1. 摘要 文章提出了一种概念上简单、灵活、通用的框架用于 few-shot learning 问题。few-shot learning ...
  • 介绍2. 背景2.1 少样本学习:2.2 原型网络3 半监督少样本学习3.1 半监督原型网络:3.1.1 soft k-means 原型网络:3.1.2 soft k-means 和干扰项簇的原型网络:3.1.3 soft k-means 和 masking 的原型网络:4. 其他5. ...
  • 最近在读few-shot Learning 的论文,这个Tired ImageNet可以说是...tired ImageNet是在2018年的论文 META-LEARNING FOR SEMI-SUPERVISED FEW-SHOT CLASSIFICATION 中提出来的一个数据集,根据作者的介绍,这个数据集是
  • Chelsea finn's Stanford CS330 class on multi-task and meta-learning - 2020斯坦福大学多任务与元学习教程CS330 Brief introduction and slides 简介与ppt资料 Brief introduction in Chinese PPT (English)...
  • 这篇文章主要介绍的是作者识别(author identification)问题。作者识别问题是指基于某个T时间之前的所有论文(paper)和它们的作者(author),以及所属机构(organization),或者发表会议(venue)这些已知...

空空如也

空空如也

1 2 3 4
收藏数 71
精华内容 28
关键字:

learningmeta介绍