Lookahead、LazyOptimizer、MaskedAdamOptimizer、AdaBound

最新推荐文章于 2024-06-04 17:46:18 发布
最新推荐文章于 2024-06-04 17:46:18 发布
阅读量2.1k 收藏 9
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37947156/article/details/98208772
版权

AdaBound算法：像Adam一样快，又像SGD一样好的优化器

论文地址：

https://openreview.net/pdf?id=Bkg3g2R9FX

GitHub地址：（Pytorch）

https://github.com/Luolc/AdaBound

GitHub地址：（Tensorflow）

https://github.com/taki0112/AdaBound-Tensorflow

 

SGD的缺点：


SGD现在后期调优时还是经常使用到，但SGD的问题是前期收敛速度慢。SGD前期收敛慢的原因： SGD在更新参数时对各个维度上梯度的放缩是一致的，并且在训练数据分布极不均很时训练效果很差。而因为收敛慢的问题应运而生的自适应优化算法Adam、AdaGrad、RMSprop 等，但这些自适应的优化算法虽然可以在训练早期展现出快速的收敛速度，但其在测试集上的表现却会很快陷入停滞，并最终被 SGD 超过。

Adam等自适应学习率算法缺点：


这就是目前很多大牛任然喜欢SGD的原因。这篇文章对于Adam后期的毛病进行了分析，原因出在自适应方法训练后期不稳定的极端学习率。换句话说，就是自适应学习率训练到后期，学习率出现极端情况，更新参数时有些维度上学习率特别大，有些维度学习率特别小。

 采样参数的学习率，每个单元格包含一个通过对学习率进行数值运算得到的值，颜色越浅代表学习率越小。

我们可以看到，当模型接近收敛时，学习率中有大量的极端值（包含许多小于 0.01 和大于 1000 的情况）。这一现象表明在实际训练中，极端学习率是实际存在的。

发现这个问题怎么解决？如何融合上面两种方法的优点？


那就对自适应学习率加一下限制吧。具体做法是对学习率进行动态裁剪，在这一设置下，在训练早期由于上下界对学习率的影响很小，算法更加接近于 Adam；而随着时间增长裁减区间越来越收紧，模型的学习率逐渐趋于稳定，在末期更加贴近于 SGD。AMSBound 可以对 AMSGrad 采用类似的裁剪得到。

换句话说，Adam和SGD是AdaBound的特殊情况。

在这一设置下，在训练早期由于上下界对学习率的影响很小，算法更加接近于 Adam；而随着时间增长裁减区间越来越收紧，模型的学习率逐渐趋于稳定，在末期更加贴近于 SGD。AMSBound 可以对 AMSGrad 采用类似的裁剪得到。

 

Adam作者大革新， 联合Hinton等人推出全新优化方法Lookahead

论文地址：

https://arxiv.org/abs/1907.08610v1

GitHub地址：（Pytorch）

https://github.com/alphadl/lookahead.pytorch

GitHub地址：（Tensorflow）

https://github.com/Janus-Shiau/lookahead_tensorflow

Lookahead的思路很朴素，准确来说它并不是一个优化器，而是一个使用现有优化器的方案。简单来说它就是下面三个步骤的循环执行：

附：《机器之心的Lookahead的介绍》

LazyAdam、MaskedAdamOptimize

LazyAdam

和图像等领域不同，对 NLU 之类的任务，每个 batch 采样到的词有限，每次更新对 Embedding 的梯度估计都是稀疏的。非 momentum-based 的 Optimizer 每步只会更新采样到的词，而对于所有带动量的优化器（自然也就包括Adam以及带动量的SGD）都存在一个问题：当前batch中没被采样到的词，依然会使用历史动量来更新，这可能导致Embedding层过拟合。具体来说，当一个词的被采样过后，它的Embedding的梯度不为0，这个梯度也会被记录在动量中，实际更新是用动量去更新的；在后面的batch中，假如该词没有被采样到，它的Embedding的梯度为0，但是它的动量并不为0，所以该词还是被更新了。这样一来就算没有被反复采样的词，对应的Embedding也被反复更新了，就导致了过拟合。

所以，一个改进的方案是只有当该词被采样过才更新，这就是LazyOptimizer的基本原理了。

LazyAdam是Adam的变体，可以更有效地处理稀疏更新。原始的Adam算法为每个可训练变量维护两个移动平均累加器，累加器在每一步都会更新**。 而此类为稀疏变量提供了更加懒惰的梯度更新处理，它仅更新当前batch中出现的稀疏变量索引的移动平均累加器，而不是更新所有索引的累加器。 与原始的Adam优化器相比，它可以为某些应用提供模型训练吞吐量的大幅改进。 但是它的语义与原始的Adam算法略有不同，可能会导致不同的实验结果。

在实现上，我们要如何判断一个词有没有被采样过呢？当然终极方法肯定是传入被采样过的词的index了，但这使用上不够友好。我这里使用了一个近似的方法：判断该词的Embedding对应的梯度是否为0，如果为0意味着它“很可能”在当前batch没有被采样到。背后的原理在于，如果它没有被采样到，那么梯度一定为0，如果它被采样到了，那么梯度为0的概率是非常小的，毕竟那么多分量，同时为0的可能性很小，所以这样实现也够用了。

AdamOptimizer源码中函数_apply_sparse和_resource_apply_sparse 主要用在稀疏向量的更新操作上，而具体的实现是在函数_apply_sparse_shared中

LazyAdam的源码：

def _apply_sparse(self, grad, Var):
    beta1_power, beta2_power = self._get_beta_accumulators()
    beta1_power = math_ops.cast(beta1_power, Var.dtype.base_dtype)
    beta2_power = math_ops.cast(beta2_power, Var.dtype.base_dtype)
    lr_t = math_ops.cast(self._lr_t, Var.dtype.base_dtype)
    beta1_t = math_ops.cast(self._beta1_t, Var.dtype.base_dtype)
    beta2_t = math_ops.cast(self._beta2_t, Var.dtype.base_dtype)
    epsilon_t = math_ops.cast(self._epsilon_t, Var.dtype.base_dtype)
    lr = (lr_t * math_ops.sqrt(1 - beta2_power) / (1 - beta1_power))

    # \\(m := beta1 * m + (1 - beta1) * g_t\\)
    m = self.get_slot(Var, "m")
    m_t = state_ops.scatter_update(m, grad.indices,
                                   beta1_t * array_ops.gather(m, grad.indices) +
                                   (1 - beta1_t) * grad.Values,
                                   use_locking=self._use_locking)#一阶动量

    # \\(V := beta2 * V + (1 - beta2) * (g_t * g_t)\\)
    V = self.get_slot(Var, "V")
    V_t = state_ops.scatter_update(V, grad.indices,
                                   beta2_t * array_ops.gather(V, grad.indices) +
                                   (1 - beta2_t) * math_ops.square(grad.Values),
                                   use_locking=self._use_locking) #二阶动量

    # \\(Variable -= learning_rate * m_t / (epsilon_t + sqrt(V_t))\\)
    m_t_slice = array_ops.gather(m_t, grad.indices)
    V_t_slice = array_ops.gather(V_t, grad.indices)
    denominator_slice = math_ops.sqrt(V_t_slice) + epsilon_t
    Var_update = state_ops.scatter_sub(Var, grad.indices,
                                       lr * m_t_slice / denominator_slice,
                                       use_locking=self._use_locking)
    return control_flow_ops.group(Var_update, m_t, V_t)

可以看出公式与Adam都相同，不同的是每次迭代根据当前batch的indices来对一阶动量和二阶动量进行更新。

Madam

from tensorflow.python.ops import array_ops
from tensorflow.python.training import adam
from tensorflow.python.framework import ops
from tensorflow.python.ops import control_flow_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import resource_variable_ops
from tensorflow.python.ops import state_ops
from tensorflow.python.ops import variable_scope
from tensorflow.python.training import optimizer

class MaskedAdamOptimizer(adam.AdamOptimizer):
    def _apply_sparse_shared(self, grad, var, indices, scatter_add):
        beta1_power, beta2_power = self._get_beta_accumulators()
        beta1_power = math_ops.cast(beta1_power, var.dtype.base_dtype)
        beta2_power = math_ops.cast(beta2_power, var.dtype.base_dtype)
        lr_t = math_ops.cast(self._lr_t, var.dtype.base_dtype)
        beta1_t = math_ops.cast(self._beta1_t, var.dtype.base_dtype)
        beta2_t = math_ops.cast(self._beta2_t, var.dtype.base_dtype)
        epsilon_t = math_ops.cast(self._epsilon_t, var.dtype.base_dtype)
        lr = (lr_t * math_ops.sqrt(1 - beta2_power) / (1 - beta1_power))
        # m_t = beta1 * m + (1 - beta1) * g_t
        m = self.get_slot(var, "m")
        m_scaled_g_values = grad * (1 - beta1_t)
        m_t = state_ops.assign(m, m * beta1_t,
                               use_locking=self._use_locking)
        with ops.control_dependencies([m_t]):
            m_t = scatter_add(m, indices, m_scaled_g_values)
        # v_t = beta2 * v + (1 - beta2) * (g_t * g_t)
        v = self.get_slot(var, "v")
        v_scaled_g_values = (grad * grad) * (1 - beta2_t)
        v_t = state_ops.assign(v, v * beta2_t, use_locking=self._use_locking)
        with ops.control_dependencies([v_t]):
            v_t = scatter_add(v, indices, v_scaled_g_values)
        gather_m_t = array_ops.gather(m_t, indices)
        gather_v_t = array_ops.gather(v_t, indices)
        gather_v_sqrt = math_ops.sqrt(gather_v_t)
        var_update = scatter_add(var, indices, -lr * gather_m_t / (gather_v_sqrt + epsilon_t))
        return control_flow_ops.group(*[var_update, m_t, v_t])

两者在计算移动平均累加器时（一阶动量和二阶动量）有所不同：

LazyAdam：

m_t = state_ops.scatter_update(m, grad.indices,
                                   beta1_t * array_ops.gather(m, grad.indices) +
                                   (1 - beta1_t) * grad.Values,
                                   use_locking=self._use_locking)

Madam：

m_scaled_g_Values = grad * (1 - beta1_t)
        m_t = state_ops.assign(m, m * beta1_t,
                               use_locking=self._use_locking)  
        with ops.control_dependencies([m_t]):
            m_t = scatter_add(m, indices, m_scaled_g_Values)

Madam其实是介于Lazy Adam和 Adam之间的一种方法，其与Lazy Adam唯一的不同在于对一阶动量m和二阶动量 V 进行 decay 的操作，Madam是全部都要 decay，即当前batch没有采样到的变量所对应的之前动量的累积值也要考虑。 而LazyAdam 是只 decay 采样到的embedding。（在计算指数加权平均时，LazyAdam只对当前采样到的变量之前的平均值进行累加，没有采样到的样本不累加，而Madam要全部累加）。

LazyAdam存在的一个问题是当梯度为0时不更新对应的m和v。实际上当其他权重改变时m和v应该更新。Madam应该是解决了这个问题所以性能变得更好。

为了更形象的说明它们的差异，通过一个假设的例子来说明，用一阶动量来举例：


参考文章：https://kexue.fm/archives/6869

sliderSun
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
keras优化算法_Keras实现两个优化器：Lookahead和LazyOptimizer
weixin_39541600的博客
12-19 399
最近用Keras实现了两个优化器，也算是有点实现技巧，遂放在一起写篇文章简介一下(如果只有一个的话我就不写了)。这两个优化器的名字都挺有意思的，一个是look ahead(往前看？)，一个是lazy(偷懒？)，难道是两个完全不同的优化思路么？非也非也～只能说发明者们起名字太有创意了。Lookahead#首先登场的是Lookahead优化器，它源于论文《Lookahead Optimizer: k ...
Keras实现两个优化器：Lookahead和LazyOptimizer
岁月如歌
07-30 1055
转载一篇苏神的文章： https://kexue.fm/archives/6869
Adam optimizer的原理
最新发布
smartcat2010的博客
06-04 256
可把E这个机制，视为自适应学习率。对梯度太大的w，把收敛速度拉得慢一些；梯度太小的w，把收敛速度拉的快一些；（太快了，怕出事故，拉慢些；太慢了，要助力，拉快些）E[gt^2]: 梯度平方的带权Moving average；在之前保持的正确的方向上，加速收敛；vt: mementum(冲量)
77、Spark SQL之核心源码深度剖析（DataFrame lazy特性、Optimizer优化策略等）
ZJ__ZFH的博客
01-02 1468
入口，org.apache.spark.sql包下的SQLContext类 首先看sql()方法 看sql()方法之前，先看下SQLConf protected[sql] lazy val conf: SQLConf = new SQLConf /** * 如果要给Spark SQL设置一些参数，那么要使用SQLContext.setConf()方法，底层是会将配置信息放入SQLC...
优化方法总结以及Adam存在的问题(SGD, Momentum, AdaDelta, Adam, AdamW，LazyAdam)
热门推荐
糖葫芦君的博客
05-29 3万+
文章目录优化方法概述整体框架SGDMomentum理解指数加权平均偏差修正AdaGradAdaDelta/RMSPropAdam(Adaptive Moment Estimation)Adam+L2 regularizationL2 regularization与Weight decay学习率衰减局部最优 优化方法概述 模型优化方法的选择直接关系到最终模型的性能。有时候效果不好，未必是特征的问题或...
深度学习使用的优化器
玉洁的博客
05-05 1331
优化器总结 1、sgd 针对每个训练样本进行参数更新，执行速度块，参数波动大。改进：每个batch进行参数更新，减少波动，更加稳定 # 梯度下降法 x += - learning_rate * dx 问题：容易产生震荡，且容易被困在鞍点，迟迟不能到达全局最优值 2、Adgrad 累积平方梯度，保证每次学习率的每次更新，解决了SGD中学习率不能自适应调整的问题。缺点： 对于训练深度神经网络模型而言，从训练开始时累积平方梯度值会越来越大，会导致学习率过早和过量的减少，从而导致迭代后期收敛及其缓慢
4 bit carry lookahead adder
04-13
This is a verilog code.It's function is 4 bit carry lookahead adder.
lookahead:先行优化器的实现
05-27
lookahead : optimizer = Lookahead ( optimizer , la_steps = args . la_steps , la_alpha = args . la_alpha ) 在TensorFlow中： optimizer = # {any optimizer} e.g. tf.train.AdamOptimizerif args . lookahead...
32位加法器 lookahead算法 verilog
08-14
32位加法器 lookahead算法 verilog 先实现4位，再实现4*8=32位
Python-lookahead优化器的Keras实现
08-11
"Python-lookahead优化器的Keras实现"就是一个这样的尝试，它引入了lookahead优化策略来改善模型的收敛速度和性能。 Lookahead优化器是一种结合了快速适应（如Adam）和慢速步长调整（如SGD with momentum）的策略。...
keras2.3.1定义RAdam、Lookahead
12-21
import keras import keras.backend as K ...class RAdam(keras.optimizers.Optimizer): """RAdam optimizer. # Arguments learning_rate: float >= 0.... beta_1: float, 0 < beta < 1.... bet
ADABOUND算法，究竟是颠覆Adam算法的成果还是只是一种小技巧?
qq_43597090的博客
05-09 1392
这两年，随着adam算法的缺陷被科学家发现，很多研究人员开始对adam进行了改进。其中中国的两位本科学霸开发出来了AdaBound算法，受到了国内媒体的关注。我是之前看到一篇 拳打Adam，脚踩Sgd的新闻，才了解到这个AdaBound算法。当时颇为震惊，因为Adam和Sgd算法都是深度学习界赫赫有名的算法。所以抱着好奇的想法看了看这篇论文，依然有一些疑问，希望能和大家一起交流学习。 Adam算法 作为深度学习界的自适应优化算法，Adam算法可谓是威名赫赫，它赋予了神经网络在更新每个参数的时候都能自适应的
优化算法：《Lookahead Optimizer: k steps forward, 1 step back》
Mingx9527
08-13 5231
《Lookahead Optimizer: k steps forward, 1 step back》   作者：Michael R. Zhang， James Lucas，Geoffrey Hinton，Jimmy Ba（adam作者）   来源：多伦多大学   论文地址：https://arxiv.org/abs/1907.08610v1   Pytorch实现：https://github...
深度学习调参tricks总结！
小白学视觉
08-16 349
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达 作者：山竹小果，来源：NewBeeNLP寻找合适的学习率(learning rate)学习率是一个非常非常重要的超参数，这个参数呢，面对不同规模、不同batch-size、不同优化方式、不同数据集，其最合适的值都是不确定的，我们无法光凭经验来准确地确定lr的值，我们唯一可以做的，就是在训练中不断寻找最合适当前状态的学习率。比如...
keras自定义loss的两个例子
小马哥的博客
09-01 1457
Lookahead和LazyOptimizer和AccumOptimizer 转自： Lookahead LazyOptimizer Keras实现两个优化器 用时间换取效果：Keras梯度累积优化器 AccumOptimizer keras inject#497 keras/optimizers.py lookahead用法: model.compile(optimizer=Adam(1e-3)...
模型优化方法总结
weixin_41744192的博客
08-20 9700
模型优化方法总结1. 梯度下降法SGD2. 动量法Momentum3. RMSpropAdamAdamWLookahead，RAdam?LazyAdam参考资料 模型优化方法的选择直接关系到最终模型的性能。有时候效果不好，未必是特征的问题或者模型设计的问题，很可能是优化算法的问题，而且好的优化算法还能够帮助加速训练模型。 深度学习模型的发展进程： SGD -> SGDM ->NAG -> AdaGrad -> AdaDelta -> Adam -> Nadam 1.整体框
radam+lookahead optimizer
paradoxgao的博客
04-21 363
radam+lookahead optimizertorch 中 optimizer的类lookahead 源码解析radams 源码解析 torch 中 optimizer的类 optimizer的类中的link optimizer详解 主要说明optimizer里面的param_groups这个属性，param_group是一个list，在里面存放着字典 dict，dict中的key包括下面的几个部分: lookahead 源码解析 lookahead 使用的是向前k步，然后倒退一步，这可以理解为
ffmpeg sync_lookahead
07-16
FFmpeg中的sync_lookahead是一个编码器选项，用于指定编码器的预测帧数。它决定了在进行编码之前，编码器将在输入帧序列中查看多少个未来帧。较大的sync_lookahead值可以提高编码质量，但会增加编码延迟。 请注意，sync_lookahead选项并不适用于所有编码器，只有一些特定的编码器支持它。它通常用于视频编码器，例如x264和x265。你可以通过设置该选项的值来调整编码器的行为，具体的取值范围和默认值可能因编码器而异。 例如，要将sync_lookahead设置为4，你可以使用以下命令： ffmpeg -i input.mp4 -c:v libx264 -x264-params sync-lookahead=4 output.mp4 这个命令将使用libx264编码器，并将sync_lookahead设置为4。你可以根据自己的需求调整这个值，并选择适合你的场景的最佳设置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值