LookAhead优化器方法

最新推荐文章于 2023-09-23 16:44:49 发布
最新推荐文章于 2023-09-23 16:44:49 发布
阅读量1.2k 收藏
点赞数 1
分类专栏： 深度学习函数学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/znevegiveup1/article/details/118487101
版权

SGD优化器：1.自适应学习率方法，如AdaGrad和Adam优化器方法
2.加速训练方式，如Nesterov momentum优化器的方法。
Lookahead优化器算法通过预先(look ahead)由另外一个优化器生成的"快速权重"序列来选择搜索方向。
look ahead优化器对应的行走路线蓝色实线为本来应该走的fast path的路线，紫色的线为直接到达的slow path路线，这里画出本来应该去走的路线和现在使用了lookahead优化器方法之后去走的路线。

对应的走势可以看出来，常规的梯度下降优化器的优化方向为图中的红色箭头所示，而使用了lookahead之后的优化方向为图中的黑色箭头所示，可以看出使用了lookahead优化器之后，明显优化的方向离最优值点更近了，因此论文中指出，使用Lookahead优化器可以优化对应的梯度下降方向。

唐僧爱吃唐僧肉
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Keras实现两个优化器：Lookahead和LazyOptimizer
qq_25104905的博客
08-31 457
Keras实现两个优化器：Lookahead和LazyOptimizer By苏剑林|2019-07-30|2232位读者| 最近用Keras实现了两个优化器，也算是有点实现技巧，遂放在一起写篇文章简介一下（如果只有一个的话我就不写了）。这两个优化器的名字都挺有意思的，一个是look ahead（往前看？），一个是lazy（偷懒？），难道是两个完全不同的优化思路么？非也非也～...
Python-lookahead优化器的Keras实现
08-11
lookahead优化器的Keras实现
Lookahead优化器
weixin_38241876的博客
05-28 536
from collections import defaultdict from itertools import chain from torch.optim import Optimizer import torch import warnings class Lookahead(Optimizer): def __init__(self, optimizer, k=5, alpha=0.5): self.optimizer = optimizer self..
LookaHead优化器
Major_S的博客
01-04 436
LookaHead优化器LookaHead优化器LookaHead优化器 https://arxiv.org/pdf/1907.08610.pdf
Lookahead 优化器
最新发布
weixin_73639838的博客
09-23 283
optimizer.sync_lookahead()` 的作用是同步主要优化器和 Lookahead 优化器之间的状态，以确保它们的状态保持一致。这样可以避免主要优化器和 Lookahead 优化器之间的不同步，以获得更好的训练效果。2. Lookahead 优化器：它在主要优化器的基础上进行操作，具有额外的状态和操作，旨在改善优化的稳定性和收敛性。例如，可以是常见的优化器如 Adam、SGD 等。Lookahead 是一种优化器的扩展技术，不是所有的深度学习框架和优化器都支持。
Pytorch 版本的lookahead 优化函数使用(附代码)
xiaoxifei的专栏
11-30 2833
Lookahead 优化算法是Adam的作者继Adam之后的又一力作，论文可以参见https://arxiv.org/abs/1907.08610 这篇博客先不讲述Lookahead具体原理，先介绍如何将Lookahead集成到现有的代码中。 本人在三个项目中（涉及风格转换、物体识别）使用该优化器，最大的感受就是使用该优化器十分有利于模型收敛，原本不收敛或者收敛过慢的模型在使用lookahea...
lookahead:先行优化器的实现
05-27
前瞻优化器该存储库包含实现在TensorFlow和PyTorch中。 前瞻性提高了学习稳定性，并降低了内部优化器的方差，而计算和存储成本却可以忽略不计。 很容易将其合并到现有的机器学习管道中。用法在PyTorch中： optimizer...
Ranger-Deep-Learning-Optimizer:Ranger-在一个代码库中使用RAdam（Rectified Adam），Gradient Centralization和LookAhead的协同优化器
05-12
Ranger-一种协同优化器，将RAdam（Rectified Adam）和LookAhead结合在一起，现在将GC（梯度集中化）集成到一个优化器中。 快速说明-Ranger21现在处于beta中，并且Ranger具有许多新改进。 建议您将结果与Ranger21...
over9000:Over9000优化器
05-02
优化器和测试每个结果平均20次。 数据集LR时间表Imagenette大小128，5个时代Imagewoof尺寸128，5个时代亚当-基线独轮车0.8493 0.6125 游侠Lars（RAdam + LARS + Lookahead） 平坦和退火0.8732 0.6523 拉兰布（RAdam ...
乘法器的Verilog实现
12-07
4. **乘法算法**：乘法可以使用不同的算法实现，如Booth算法、Kogge-Stone算法或Carry-Lookahead算法。这些算法通过减少乘法过程中的延迟和逻辑门数量来优化性能。 5. **仿真测试**：描述了乘法器后，我们需要编写...
32位加法器 lookahead算法 verilog
08-14
32位加法器 lookahead算法 verilog 先实现4位，再实现4*8=32位
优化算法：《Lookahead Optimizer: k steps forward, 1 step back》
Mingx9527
08-13 5245
《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...
组合器 post_RAdam优化器又进化：与LookAhead强强结合，性能更优速度更快
weixin_30873127的博客
01-13 131
鱼羊 编译整理 量子位 报道 | 公众号 QbitAI上周，来自UIUC的中国博士生Liyuan Liu提出了一种兼具Adam和SGD两者之美的新优化器RAdam，收敛速度快，还很鲁棒，一度登上了GitHub趋势榜。而今年七月，图灵奖得主Hinton的团队同样在优化器上下了功夫，对SGD进行改进，提出了一种新的优化器LookAhead，在各种深度学习任务上实现了更快的收敛。那么，把两者结合起来又会...
lookahead
jacke121的专栏
07-25 4504
2019最牛的梯度优化算法出炉，AdaBound实验对比代码 RAdam: https://github.com/LiyuanLucasLiu/RAdam lookahead 73上用的这个： https://github.com/alphadl/lookahead.pytorch https://github.com/dseuss/pytorch-lookahead-op...
Lookahead
qq_43152949的博客
11-07 2067
Lookahead 1 Introduction 想要在神经网络中获得更好的性能，往往需要代价高昂的超参数调节。 使用lookahead 可以改进内部优化器的收敛性，并经常提高泛化性能，同时对超参数变化鲁棒性很好，实验证明，lookahead对内循环优化器的变化，快速权值更新的次数和慢的权重学习速率具有很强的鲁棒性。 2 Method lookahead维护了一组slow weights φ和fa...
keras优化算法_Keras实现两个优化器：Lookahead和LazyOptimizer
weixin_39541600的博客
12-19 399
最近用Keras实现了两个优化器，也算是有点实现技巧，遂放在一起写篇文章简介一下(如果只有一个的话我就不写了)。这两个优化器的名字都挺有意思的，一个是look ahead(往前看？)，一个是lazy(偷懒？)，难道是两个完全不同的优化思路么？非也非也～只能说发明者们起名字太有创意了。Lookahead#首先登场的是Lookahead优化器，它源于论文《Lookahead Optimizer: k ...
javacc之路2--- LOOCAHEAD
u013257767的博客
11-26 843
解析器的工作是读取输入流并确定输入流是否符合语法。这种最一般形式的确定可能非常耗时。示例 1{}{}{}{}在这个简单的例子中，很明显恰好有两个字符串符合上面的语法，即：abcabcc这里只有一个选择——第一个输入字符必须是a，既然确实如此，我们就可以了。我们现在继续处理非终结符 BC。同样，下一个输入字符只有一个选择——它必须是b。输入也匹配这个，所以我们仍然可以。我们现在来到语法中的一个选择点。我们可以进入[…]并匹配它，也可以完全忽略它。我们决定进去。
radam+lookahead optimizer
paradoxgao的博客
04-21 364
radam+lookahead optimizertorch 中 optimizer的类lookahead 源码解析radams 源码解析 torch 中 optimizer的类 optimizer的类中的link optimizer详解 主要说明optimizer里面的param_groups这个属性，param_group是一个list，在里面存放着字典 dict，dict中的key包括下面的几个部分: lookahead 源码解析 lookahead 使用的是向前k步，然后倒退一步，这可以理解为
李宏毅机器学习第6周New Optimization 新优化器
weixin_44162879的博客
09-03 187
本文首先对之前学习的优化器进行了简略的复习，并对比了adam与SGDM两种算法各自的优势。之后将目光聚焦于如何优化这两种算法以克服各自缺点。之后介绍了RAdam算法，该算法吸取了One-cycle LR中的warm-up暖机机制，目的是在训练的开始阶段需要保持步长较小以减小梯度的方差。而Lookahead算法在优化器外进行了“包裹”，以实现在行进k步之后进行检查并做出修正。为了达到Lookahead算法先确定梯度的后续效果再行进，Nadam算法引用了NAG算法对Adam算法进行了改进。
深度学习优化器Ranger代码
06-08
以下是使用 PyTorch 实现的深度学习优化器 Ranger 的代码： ```python import math from torch.optim.optimizer import Optimizer import torch.optim as optim class Ranger(Optimizer): def __init__(self, params, lr=1e-3, alpha=0.5, k=6, N_sma_threshhold=5, betas=(0.95, 0.999), eps=1e-5, weight_decay=0): defaults = dict(lr=lr, alpha=alpha, k=k, N_sma_threshhold=N_sma_threshhold, betas=betas, eps=eps, weight_decay=weight_decay) super().__init__(params, defaults) def __setstate__(self, state): super().__setstate__(state) def step(self, closure=None): loss = None if closure is not None: loss = closure() # Gradient centralization for group in self.param_groups: for p in group['params']: if p.grad is None: continue grad = p.grad.data if grad.is_sparse: raise RuntimeError('Ranger optimizer does not support sparse gradients') grad_data = grad.data if len(grad_data.shape) > 1: mean = torch.mean(grad_data, dim=tuple(range(1, len(grad_data.shape))), keepdim=True) var = torch.var(grad_data, dim=tuple(range(1, len(grad_data.shape))), keepdim=True) grad_data = (grad_data - mean) / (torch.sqrt(var) + group['eps']) p.grad.data = grad_data # Perform optimization step beta1, beta2 = group['betas'] N_sma_threshhold = group['N_sma_threshhold'] grad_ema_beta = 1 - beta1 sqr_ema_beta = 1 - beta2 step_size = group['lr'] eps = group['eps'] k = group['k'] alpha = group['alpha'] weight_decay = group['weight_decay'] for group in self.param_groups: for p in group['params']: if p.grad is None: continue grad = p.grad.data if grad.is_sparse: raise RuntimeError('Ranger optimizer does not support sparse gradients') state = self.state[p] # State initialization if len(state) == 0: state['step'] = 0 state['exp_avg'] = torch.zeros_like(p.data) state['exp_avg_sq'] = torch.zeros_like(p.data) state['SMA'] = 0 exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq'] SMA = state['SMA'] state['step'] += 1 # Gradient centralization grad_data = grad.data if len(grad_data.shape) > 1: mean = torch.mean(grad_data, dim=tuple(range(1, len(grad_data.shape))), keepdim=True) var = torch.var(grad_data, dim=tuple(range(1, len(grad_data.shape))), keepdim=True) grad_data = (grad_data - mean) / (torch.sqrt(var) + eps) grad = grad_data bias_correction1 = 1 - beta1 ** state['step'] bias_correction2 = 1 - beta2 ** state['step'] step_size = step_size * math.sqrt(bias_correction2) / bias_correction1 # Compute exponential moving average of gradient and squared gradient exp_avg = beta1 * exp_avg + grad_ema_beta * grad exp_avg_sq = beta2 * exp_avg_sq + sqr_ema_beta * grad * grad # Compute SMA SMA_prev = SMA SMA = alpha * SMA + (1 - alpha) * exp_avg_sq.mean() # Update parameters if state['step'] <= k: # Warmup p.data.add_(-step_size * exp_avg / (torch.sqrt(exp_avg_sq) + eps)) else: if SMA > SMA_prev or state['step'] <= N_sma_threshhold: # If SMA is increasing, skip lookahead and perform RAdam step denom = torch.sqrt(exp_avg_sq) + eps p.data.add_(-step_size * exp_avg / denom) else: # Lookahead slow_state = state['slow_buffer'] if len(slow_state) == 0: slow_state['step'] = 0 slow_state['exp_avg'] = torch.zeros_like(p.data) slow_state['exp_avg_sq'] = torch.zeros_like(p.data) slow_state['SMA'] = 0 for key in state.keys(): if key != 'slow_buffer': slow_state[key] = state[key].clone() slow_exp_avg, slow_exp_avg_sq = slow_state['exp_avg'], slow_state['exp_avg_sq'] slow_SMA = slow_state['SMA'] slow_state['step'] += 1 # Gradient centralization grad_data = grad.data if len(grad_data.shape) > 1: mean = torch.mean(grad_data, dim=tuple(range(1, len(grad_data.shape))), keepdim=True) var = torch.var(grad_data, dim=tuple(range(1, len(grad_data.shape))), keepdim=True) grad_data = (grad_data - mean) / (torch.sqrt(var) + eps) grad = grad_data # Compute exponential moving average of gradient and squared gradient slow_exp_avg = beta1 * slow_exp_avg + grad_ema_beta * grad slow_exp_avg_sq = beta2 * slow_exp_avg_sq + sqr_ema_beta * grad * grad # Compute SMA slow_SMA_prev = slow_SMA slow_SMA = alpha * slow_SMA + (1 - alpha) * slow_exp_avg_sq.mean() # Update parameters if slow_state['step'] <= k: # Warmup pass else: if slow_SMA > slow_SMA_prev or slow_state['step'] <= N_sma_threshhold: # If SMA is increasing, skip lookahead and perform RAdam step denom = torch.sqrt(slow_exp_avg_sq) + eps p.data.add_(-step_size * slow_exp_avg / denom) else: # Lookahead p.data.add_(-step_size * (exp_avg + slow_exp_avg) / (2 * torch.sqrt((beta2 * exp_avg_sq + sqr_ema_beta * slow_exp_avg_sq) / (1 - bias_correction2 ** state['step'])) + eps)) # Weight decay if weight_decay != 0: p.data.add_(-step_size * weight_decay * p.data) return loss ``` 以上的代码实现了 Ranger 优化器，其中包括了 RAdam 和 LookAhead 的结合，以及动态学习率和权重衰减等技巧。可以将其应用于 PyTorch 中的深度学习模型训练中。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值