手把手 | OpenAI开发可拓展元学习算法Reptile,能快速学习(附代码)

简介:

在OpenAI, 我们开发了一种简易的元学习算法,称为Reptile。它通过对任务进行重复采样,利用随机梯度下降法,并将初始参数更新为在该任务上学习的最终参数。

其性能可以和MAML(model-agnostic meta-learning,由伯克利AI研究所研发的一种应用广泛的元学习算法)相媲美,操作简便且计算效率更高。

MAML元学习算法:

http://bair.berkeley.edu/blog/2017/07/18/learning-to-learn/

元学习是学习如何学习的过程。此算法接受大量各种的任务进行训练,每项任务都是一个学习问题,然后产生一个快速的学习器,并且能够通过少量的样本进行泛化。

一个深入研究的元学习问题是小样本分类(few-shot classification),其中每项任务都是一个分类问题,学习器在每个类别下只能看到1到5个输入-输出样本(input-output examples),然后就要给新输入的样本进行分类。

下面是应用了Reptile算法的单样本分类(1-shot classification)的互动演示,大家可以尝试一下。

601fe0a17f3e2b9b60a5a6cdfd9f7568e963d8fa

尝试单击“Edit All”按钮,绘制三个不同的形状或符号,然后在右侧的输入区中绘制其中一个,并查看Reptile如何对它进行分类。前三张图是标记样本,每图定义一个类别。最后一张图代表未知样本,Reptile要输出此图属于每个类别的概率。

Reptile的工作原理

像MAML一样,Reptile试图初始化神经网络的参数,以便通过新任务产生的少量数据来对网络进行微调。

但是,当MAML借助梯度下降算法的计算图来展开和区分时,Reptile只是以标准方法在每个任务中执行随机梯度下降(stochastic gradient descent, SGD)算法,并不展开计算图或者计算二阶导数。这使得Reptile比MAML需要更少的计算和内存。示例代码如下:

20b1b34904b609f3047e0f8f85deb9b2ecd46ede

 

初始化Φ,初始参数向量

对于迭代1,2,3……执行

随机抽样任务T

在任务T上执行k>1步的SGD,输入参数Φ,输出参数w

更新:Φ←Φ+ϵ(w−Φ)

结束

返回Φ

最后一步中,我们可以将Φ−W作为梯度,并将其插入像这篇论文里https://arxiv.org/abs/1412.6980Adam这样更为先进的优化器中作为替代方案。

首先令人惊讶的是,这种方法完全有效。如果k=1,这个算法就相当于 “联合训练”(joint training)——对多项任务的混合体执行SGD。虽然在某些情况下,联合训练可以学习到有用的初始化,但当零样本学习(zero-shot learning)不可能实现时(比如,当输出标签是随机排列时),联合训练就几乎无法学习得到结果。

Reptile要求k>1,也就是说,参数更新要依赖于损失函数的高阶导数实现,此时算法的表现和k=1(联合训练)时是完全不同的。

为了分析Reptile的工作原理,我们使用泰勒级数(Taylor series)来逼近参数更新。Reptile的更新将同一任务中不同小批量的梯度内积(inner product)最大化,从而提高了的泛化能力。

这一发现可能超出了元学习领域的指导意义,比如可以用来解释SGD的泛化性质。进一步分析表明,Reptile和MAML的更新过程很相近,都包括两个不同权重的项。

泰勒级数:

https://en.wikipedia.org/wiki/Taylor_series

在我们的实验中,展示了Reptile和MAML在Omniglot和Mini-ImageNet基准测试中对少量样本分类时产生相似的性能,由于更新具有较小的方差,因此Reptile也可以更快的收敛到解决方案。

Omniglot:

https://github.com/brendenlake/omniglot

Mini-ImageNet:

https://arxiv.org/abs/1606.04080

我们对Reptile的分析表明,通过不同的SGD梯度组合,可以获得大量不同的算法。在下图中,假设针对每一任务中不同小批量执行k步SGD,得出的梯度分别为g1,g2,…,gk。

下图显示了在 Omniglot 上由梯度之和作为元梯度而绘制出的学习曲线。g2对应一阶MAML,也就是原先MAML论文中提出的算法。由于方差缩减,纳入更多梯度明显会加速学习过程。需要注意的是,仅仅使用g1(对应k=1)并不会给这个任务带来改进,因为零样本学习的性能无法得到改善。

29078431915cd074ed17ddcf1b18595abee66f62

X坐标:外循环迭代次数

Y坐标:Omniglot对比5种方式的

5次分类的准确度

算法实现

我们在GitHub上提供了Reptile的算法实现,它使用TensorFlow来完成相关计算,并包含用于在Omniglot和Mini-ImageNet上小样本分类实验的代码。我们还发布了一个较小的JavaScript实现,对TensorFlow预先训练好的模型进行了微调。文章开头的互动演示也是借助JavaScript完成的。

GitHub:

https://github.com/openai/supervised-reptile

较小的JavaScript实现:

https://github.com/openai/supervised-reptile/tree/master/web

最后,展示一个小样本回归(few-shot regression)的简单示例,用以预测10(x,y)对的随机正弦波。该示例基于PyTorch实现,代码如下:

 

import numpy as np

import torch

from torch import nn, autograd as ag

import matplotlib.pyplot as plt

from copy import deepcopy



seed = 0

plot = True

innerstepsize = 0.02 # stepsize in inner SGD

innerepochs = 1 # number of epochs of each inner SGD

outerstepsize0 = 0.1 # stepsize of outer optimization, i.e., meta-optimization

niterations = 30000 # number of outer updates; each iteration we sample one task and update on it



rng = np.random.RandomState(seed)

torch.manual_seed(seed)



# Define task distribution

x_all = np.linspace(-5, 5, 50)[:,None] # All of the x points

ntrain = 10 # Size of training minibatches

def gen_task():

"Generate classification problem"

phase = rng.uniform(low=0, high=2*np.pi)

ampl = rng.uniform(0.1, 5)

f_randomsine = lambda x : np.sin(x + phase) * ampl

return f_randomsine



# Define model. Reptile paper uses ReLU, but Tanh gives slightly better results

model = nn.Sequential(

nn.Linear(1, 64),

nn.Tanh(),

nn.Linear(64, 64),

nn.Tanh(),

nn.Linear(64, 1),

)



def totorch(x):

return ag.Variable(torch.Tensor(x))



def train_on_batch(x, y):

x = totorch(x)

y = totorch(y)

model.zero_grad()

ypred = model(x)

loss = (ypred - y).pow(2).mean()

loss.backward()

for param in model.parameters():

param.data -= innerstepsize * param.grad.data



def predict(x):

x = totorch(x)

return model(x).data.numpy()



# Choose a fixed task and minibatch for visualization

f_plot = gen_task()

xtrain_plot = x_all[rng.choice(len(x_all), size=ntrain)]



# Reptile training loop

for iteration in range(niterations):

weights_before = deepcopy(model.state_dict())

# Generate task

f = gen_task()

y_all = f(x_all)

# Do SGD on this task

inds = rng.permutation(len(x_all))

for _ in range(innerepochs):

for start in range(0, len(x_all), ntrain):

mbinds = inds[start:start+ntrain]

train_on_batch(x_all[mbinds], y_all[mbinds])

# Interpolate between current weights and trained weights from this task

# I.e. (weights_before - weights_after) is the meta-gradient

weights_after = model.state_dict()

outerstepsize = outerstepsize0 * (1 - iteration / niterations) # linear schedule

model.load_state_dict({name :

weights_before[name] + (weights_after[name] - weights_before[name]) * outerstepsize

for name in weights_before})



# Periodically plot the results on a particular task and minibatch

if plot and iteration==0 or (iteration+1) % 1000 == 0:

plt.cla()

f = f_plot

weights_before = deepcopy(model.state_dict()) # save snapshot before evaluation

plt.plot(x_all, predict(x_all), label="pred after 0", color=(0,0,1))

for inneriter in range(32):

train_on_batch(xtrain_plot, f(xtrain_plot))

if (inneriter+1) % 8 == 0:

frac = (inneriter+1) / 32

plt.plot(x_all, predict(x_all), label="pred after %i"%(inneriter+1), color=(frac, 0, 1-frac))

plt.plot(x_all, f(x_all), label="true", color=(0,1,0))

lossval = np.square(predict(x_all) - f(x_all)).mean()

plt.plot(xtrain_plot, f(xtrain_plot), "x", label="train", color="k")

plt.ylim(-4,4)

plt.legend(loc="lower right")

plt.pause(0.01)

model.load_state_dict(weights_before) # restore from snapshot

print(f"-----------------------------")

print(f"iteration {iteration+1}")

print(f"loss on plotted curve {lossval:.3f}") # would be better to average loss over a set of examples, but this is optimized for brevity




原文发布时间为:2018-04-11

本文作者:文摘菌

本文来自云栖社区合作伙伴“大数据文摘”,了解相关信息可以关注“大数据文摘”。

相关文章
|
13天前
|
算法 JavaScript 前端开发
第一个算法项目 | JS实现并查集迷宫算法Demo学习
本文是关于使用JavaScript实现并查集迷宫算法的中国象棋demo的学习记录,包括项目运行方法、知识点梳理、代码赏析以及相关CSS样式表文件的介绍。
第一个算法项目 | JS实现并查集迷宫算法Demo学习
|
17天前
|
XML JavaScript 前端开发
学习react基础(1)_虚拟dom、diff算法、函数和class创建组件
本文介绍了React的核心概念,包括虚拟DOM、Diff算法以及如何通过函数和类创建React组件。
16 2
|
2月前
|
机器学习/深度学习 人工智能 资源调度
【博士每天一篇文献-算法】连续学习算法之HAT: Overcoming catastrophic forgetting with hard attention to the task
本文介绍了一种名为Hard Attention to the Task (HAT)的连续学习算法,通过学习几乎二值的注意力向量来克服灾难性遗忘问题,同时不影响当前任务的学习,并通过实验验证了其在减少遗忘方面的有效性。
54 12
|
2月前
|
算法 Java
掌握算法学习之字符串经典用法
文章总结了字符串在算法领域的经典用法,特别是通过双指针法来实现字符串的反转操作,并提供了LeetCode上相关题目的Java代码实现,强调了掌握这些技巧对于提升算法思维的重要性。
|
2月前
|
算法 NoSQL 中间件
go语言后端开发学习(六) ——基于雪花算法生成用户ID
本文介绍了分布式ID生成中的Snowflake(雪花)算法。为解决用户ID安全性与唯一性问题,Snowflake算法生成的ID具备全局唯一性、递增性、高可用性和高性能性等特点。64位ID由符号位(固定为0)、41位时间戳、10位标识位(含数据中心与机器ID)及12位序列号组成。面对ID重复风险,可通过预分配、动态或统一分配标识位解决。Go语言实现示例展示了如何使用第三方包`sonyflake`生成ID,确保不同节点产生的ID始终唯一。
go语言后端开发学习(六) ——基于雪花算法生成用户ID
|
2月前
|
存储 机器学习/深度学习 算法
【博士每天一篇文献-算法】连续学习算法之RWalk:Riemannian Walk for Incremental Learning Understanding
RWalk算法是一种增量学习框架,通过结合EWC++和修改版的Path Integral算法,并采用不同的采样策略存储先前任务的代表性子集,以量化和平衡遗忘和固执,实现在学习新任务的同时保留旧任务的知识。
77 3
|
27天前
|
机器学习/深度学习 人工智能 UED
OpenAI o1模型:AI通用复杂推理的新篇章
OpenAI发布了其最新的AI模型——o1,这款模型以其独特的复杂推理能力和全新的训练方式,引起了业界的广泛关注。今天,我们就来深入剖析o1模型的特点、背后的原理,以及一些有趣的八卦信息。
254 73
|
1月前
|
人工智能 Serverless API
一键服务化:从魔搭开源模型到OpenAI API服务
在多样化大模型的背后,OpenAI得益于在领域的先发优势,其API接口今天也成为了业界的一个事实标准。
一键服务化:从魔搭开源模型到OpenAI API服务
|
21天前
|
搜索推荐 算法
模型小,还高效!港大最新推荐系统EasyRec:零样本文本推荐能力超越OpenAI、Bert
【9月更文挑战第21天】香港大学研究者开发了一种名为EasyRec的新推荐系统,利用语言模型的强大文本理解和生成能力,解决了传统推荐算法在零样本学习场景中的局限。EasyRec通过文本-行为对齐框架,结合对比学习和协同语言模型调优,提升了推荐准确性。实验表明,EasyRec在多个真实世界数据集上的表现优于现有模型,但其性能依赖高质量文本数据且计算复杂度较高。论文详见:http://arxiv.org/abs/2408.08821
38 7
|
1月前
|
机器学习/深度学习 人工智能 供应链
【通义】AI视界|OpenAI的“草莓”模型预计两周内上线!像人类一样思考!
本文介绍了近期科技领域的五大亮点:OpenAI即将推出的新一代AI模型“草莓”,具备高级推理能力;亚马逊测试AI技术加速有声读物生产,通过语音克隆提高效率;Kimi API新增联网搜索功能,拓宽信息来源;顺丰发布物流行业专用大语言模型“丰语”,提升工作效率;钉钉推出“AI班级群”功能,改善家校沟通体验。更多详情,请访问[通义官网]。