Momentum、Adagrad、RMSprop、Adadelta、Adam【详细公式总结对比、pytorch实现】

最新推荐文章于 2024-09-12 06:30:00 发布
最新推荐文章于 2024-09-12 06:30:00 发布
阅读量1.2k 收藏 8
点赞数
分类专栏： pyTorch深度学习框架 文章标签： python 深度学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43360533/article/details/107517653
版权

先放一张公式汇总图：
在这里插入图片描述

Contents

1 Momentum动量优化算法

1.1 梯度下降的问题

    SGD方法的一个缺点是其更新方向完全依赖于当前batch计算出的梯度，因而十分不稳定。下图显示了在优化过程中x2方向的变化量远大于x1方向上的。

%matplotlib inline
import sys
sys.path.append("..") 
import d2lzh_pytorch as d2l
import torch

eta = 0.4 # 学习率

def f_2d(x1, x2):
    return 0.1 * x1 ** 2 + 2 * x2 ** 2

def gd_2d(x1, x2, s1, s2):
    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)

d2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))

epoch 20, x1 -0.943467, x2 -0.000073

在这里插入图片描述

# 略微增大学习率，x2方向已发散
eta=0.6
d2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))

epoch 20, x1 -0.387814, x2 -1673.365109

在这里插入图片描述

1.2 动量法

    Momentum算法借用了物理中的动量概念，使得参数更新的时候在一定程度上保留之前更新的方向，同时利用当前batch的梯度微调最终的更新方向。

在这里插入图片描述
其中，动量超参数γ满足0≤γ<1。当γ=0时，动量法等价于小批量随机梯度下降。

def momentum_2d(x1, x2, v1, v2):
    v1 = gamma * v1 +eta * 0.2*x1
    v2 = gamma * v2 +eta * 4*x2
    return x1-v1, x2-v2, v1, v2

eta, gamma = 0.4, 0.5
d2l.show_trace_2d(f_2d, d2l.train_2d(momentum_2d))

epoch 20, x1 -0.062843, x2 0.001202

在这里插入图片描述

# 可以看到，在lr = 0.6时，使用动量法后x2方向不再发散
eta=0.6
d2l.show_trace_2d(f_2d, d2l.train_2d(momentum_2d))

epoch 20, x1 0.007188, x2 0.002553

在这里插入图片描述

features, labels = d2l.get_data_ch7()
def init_momentum_states():
    v_w = torch.zeros((features.shape[-1],1 ),dtype = torch.float32)
    v_b = torch.zeros(1,dtype = torch.float32)
    return (v_w, v_b)

def sgd_momentum(params, states, hyperparams):
    for p, v in zip(params, states):
        v.data = hyperparams['momentum'] * v.data+hyperparams['lr']*p.grad.data
        p.data -= v.data

d2l.train_ch7(sgd_momentum,init_momentum_states(), {'lr':0.02, 'momentum': 0.5 }, features, labels )

loss: 0.243766, 0.113696 sec per epoch

在这里插入图片描述

d2l.train_ch7(sgd_momentum,init_momentum_states(), {'lr':0.02, 'momentum': 0.9 }, features, labels )

loss: 0.257525, 0.084765 sec per epoch

在这里插入图片描述

d2l.train_ch7(sgd_momentum,init_momentum_states(), {'lr':0.004, 'momentum': 0.9 }, features, labels )

loss: 0.246566, 0.081785 sec per epoch

在这里插入图片描述

1.3 动量法的简洁实现

# 在PyTorch中，只需要通过参数momentum来指定动量超参数即可使用动量法。
d2l.train_pytorch_ch7(torch.optim.SGD, {'lr':0.004, 'momentum': 0.9 }, features, labels )

loss: 0.242601, 0.087179 sec per epoch

在这里插入图片描述

2 ADAGRA算法

2.1 算法简介

    AdaGrad算法根据自变量在每个维度的梯度值的大小来调整各个维度上的学习率，从而避免统一的学习率难以适应所有维度的问题。
    Adagrad算法能够在训练中自动的对learning rate进行调整，对于出现频率较低参数采用较大的α更新；相反，对于出现频率较高的参数采用较小的α更新。因此，Adagrad非常适合处理稀疏数据。

在这里插入图片描述在这里插入图片描述     AdaGrad算法在迭代过程中不断调整学习率，并让目标函数自变量中每个元素都分别拥有自己的学习率。使用AdaGrad算法时，自变量中每个元素的学习率在迭代过程中一直在降低。

%matplotlib inline
import math
import torch
import sys
sys.path.append("..")
import d2lzh_pytorch as d2l

def adagrad_2d(x1, x2, s1, s2):
    g1, g2, eps = 0.2 * x1, 4*x2, 1e-6
    s1 += g1**2
    s2 += g2**2
    x1 -= eta / math.sqrt(s1 + eps) * g1
    x2 -= eta / math.sqrt(s2 + eps) * g2
    return x1, x2, s1, s2

def f_2d(x1, x2):
    return 0.1*x1**2+2*x2**2

eta = 0.4
d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))

epoch 20, x1 -2.382563, x2 -0.158591

在这里插入图片描述

# 将学习率增大到2, 自变量更为迅速地逼近了最优解
eta = 2
d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))

epoch 20, x1 -0.002295, x2 -0.000000

在这里插入图片描述

2.2 从零开始实现

# 根据AdaGrad算法中的公式实现该算法
features, labels = d2l.get_data_ch7()
def init_adagrad_states():
    s_w = torch.zeros((features.shape[1], 1), dtype = torch.float32)
    s_b = torch.zeros(1, dtype = torch.float32)
    return (s_w, s_b)

def adagrad(params, states, hyperparams):
    eps = 1e-6
    for p, s in zip(params, states):
        s.data +=(p.grad.data**2)
        p.data -= hyperparams['lr'] * p.grad.data / torch.sqrt(s + eps)
    
d2l.train_ch7(adagrad, init_adagrad_states(), {'lr':0.1}, features, labels)  

loss: 0.243151, 0.089867 sec per epoch

在这里插入图片描述

2.3ADAGRAD简洁实现

# pytorch中提供名为Adagrad的优化器
d2l.train_pytorch_ch7(torch.optim.Adagrad, {'lr': 0.1}, features, labels)

loss: 0.243228, 0.133283 sec per epoch

在这里插入图片描述

3 RMSprop算法

3.1 算法简介

    不同于AdaGrad算法里状态变量st是截至时间步t所有小批量随机梯度gt按元素平方和，RMSProp算法将梯度 按元素平方做指数加权移动平均，因此可缓解Adagrad算法学习率下降较快的问题。

在这里插入图片描述在这里插入图片描述

def rmsprop_2d(x1, x2, s1, s2):
    g1, g2, eps = 0.2 * x1, 4*x2, 1e-6
    s1 = gamma*s1 + (1-gamma)* g1**2
    s2 = gamma*s2 + (1-gamma)* g2**2
    x1 -= eta / math.sqrt(s1 + eps) * g1
    x2 -= eta / math.sqrt(s2 + eps) * g2
    return x1, x2, s1, s2

def f_2d(x1, x2):
    return 0.1*x1**2+2*x2**2
eta,gamma = 0.4, 0.9
d2l.show_trace_2d(f_2d, d2l.train_2d(rmsprop_2d))

epoch 20, x1 -0.010599, x2 0.000000

在这里插入图片描述

3.2 从零开始实现

按照RMSProp算法中的公式实现该算法

features, labels = d2l.get_data_ch7()
def init_rmsprop_states():
    s_w = torch.zeros((features.shape[1], 1), dtype = torch.float32)
    s_b = torch.zeros(1, dtype = torch.float32)
    return (s_w, s_b)

def rmeprop(params, states, hyperparams):
    gamma, eps = hyperparams['gamma'], 1e-6
    for p, s in zip(params, states):
        s.data = gamma * s.data + (1-gamma) * (p.grad.data**2)
        p.data -= hyperparams['lr'] * p.grad.data / torch.sqrt(s + eps)

d2l.train_ch7(rmeprop, init_rmsprop_states(), {'lr':0.01, 'gamma':0.9}, features, labels)

loss: 0.242842, 0.127647 sec per epoch

在这里插入图片描述

3.3 RMSprop简洁实现

# pytorch中提供名为RMSprop的优化器
d2l.train_pytorch_ch7(torch.optim.RMSprop, {'lr': 0.01, 'alpha':0.9}, features, labels)

loss: 0.243309, 0.129653 sec per epoch

在这里插入图片描述

4 AdaDelta优化算法

4.1 算法简介

    AdaDelta算法没有学习率这一超参数；
    AdaDelta算法也像RMSProp算法一样，使用了 小批量随机梯度gt按元素平方的指数加权移动平均变量st。在时间步t=0，它的所有元素被初始化为0。给定超参数0≤ρ<1（对应RMSProp算法中的γ），在时间步t>0，同RMSProp算法一样计算
在这里插入图片描述
    与RMSProp算法不同的是，AdaDelta算法还维护一个额外的状态变量Δxt，其元素同样在时间步0时被初始化为0。我们使用Δxt−1来计算自变量的变化量：
在这里插入图片描述
    其中ϵ是为了维持数值稳定性而添加的常数，如10−5。接着更新自变量：
在这里插入图片描述
    最后，我们使用Δxt来记录自变量变化量g′t按元素平方的指数加权移动平均：
在这里插入图片描述
    可以看到，如不考虑ϵ的影响，AdaDelta算法跟RMSProp算法的不同之处在于 使用√ Δx t−1来替代学习率η。

4.2 从零开始实现

# 按AdaDelta算法中的公式实现该算法。
features, labels = d2l.get_data_ch7()
def init_adadelta_states():
    s_w = torch.zeros((features.shape[1], 1), dtype = torch.float32)
    s_b = torch.zeros(1, dtype = torch.float32)    
    delta_w = torch.zeros((features.shape[1], 1), dtype = torch.float32)
    delta_b = torch.zeros(1, dtype = torch.float32)
    return ((s_w, delta_w),(s_b, delta_b))

def adadelta(params, states, hyperparams):
    rho, eps = hyperparams['rho'], 1e-5
    for p, (s, delta) in zip(params, states):
        s[:] = rho * s.data + (1-rho) * (p.grad.data**2)
        g = p.grad.data * torch.sqrt((delta+eps)/(s+eps))
        p.data -= g
        delta[:] = rho*delta + (1-rho) * g**2  
        
d2l.train_ch7(adadelta, init_adadelta_states(), {'rho':0.9}, features, labels)

loss: 0.242433, 0.185503 sec per epoch

在这里插入图片描述

4.3 AdaDelta的简洁实现

d2l.train_pytorch_ch7(torch.optim.Adadelta, { 'rho':0.9}, features, labels)

loss: 0.270904, 0.110704 sec per epoch

在这里插入图片描述

5 ADAM优化算法

5.1 算法简介

   Adam(Adaptive Moment Estimation)是另一种自适应学习率的方法，它在RMSProp算法基础上对小批量随机梯度也做了指数加权移动平均，所以Adam算法可以看做是RMSProp算法与动量法的结合。

   Adam算法还使用了偏差修正。
在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

5.2 从零开始实现

# 按照Adam算法中的公式实现该算法。其中时间步t通过hyperparams参数传入adam函数

features, labels = d2l.get_data_ch7()

def init_adam_states():
    v_w = torch.zeros((features.shape[1], 1), dtype = torch.float32)
    v_b = torch.zeros(1, dtype = torch.float32)
    s_w = torch.zeros((features.shape[1], 1), dtype = torch.float32)
    s_b = torch.zeros(1, dtype = torch.float32)
    return ((v_w, s_w),(v_b, s_b))

def adam(params, states, hyperparams):
    beta1, beta2, eps = 0.9, 0.999, 1e-6
    for p, (v, s) in zip(params, states):
        v[:] = beta1 * v + (1-beta1) * p.grad.data
        s[:] = beta2 * s + (1-beta2) * (p.grad.data**2)
        v_bias_corr = v / (1-beta1**hyperparams['t'])
        s_bias_corr = s / (1-beta2**hyperparams['t'])
        g = hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)
        p.data -= g
        
    hyperparams['t'] += 1
        
d2l.train_ch7(adam, init_adam_states(), {'lr':0.01, 't':1}, features, labels)

loss: 0.244003, 0.170542 sec per epoch

在这里插入图片描述

5.3 Adam简洁实现

d2l.train_pytorch_ch7(torch.optim.Adam, {'lr':0.01}, features, labels)

loss: 0.244895, 0.135288 sec per epoch

在这里插入图片描述

最后通过两张动图从直观上展现算法的优化过程：

1、下图为不同算法在损失平面等高线上随时间的变化情况：

不同算法在损失平面等高线上随时间的变化情况
2、下图为不同算法在鞍点处的行为比较：
不同算法在鞍点处的行为比较
动图参考来源点击这里
参考原文：《动手学深度学习（pyTorch）》

欢迎关注【OAOA】

Pytorch Note19 优化算法5 Adadelta算法
风信子的猫Redamancy的快乐星球
07-20 2323
Pytorh Note19 优化算法5 Adadelta算法 文章目录Pytorh Note19 优化算法5 Adadelta算法AdadeltaAdadelta 算法代码从0实现pytorch内置优化器 全部笔记的汇总贴：Pytorch Note 快乐星球 Adadelta Adadelta 算是 Adagrad 法的延伸，它跟 RMSProp 一样，都是为了解决 Adagrad 中学习率不断减小的问题，RMSProp 是通过移动加权平均的方式，而 Adadelta 也是一种方法，有趣的是，它并不需要学习
深度学习知识点全面总结
热门推荐
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
01-05 27万+
本文详细介绍深度学习概念及原理，参考网上相关资料汇总，内容包含众多章节，包括神经网络基础及常见深度学习网络结构介绍，用于个人学习总结，适合深度学习初学者学习。同时介绍机器学习常见的分类算法：SVM、神经网络、随机森林、逻辑回归、KNN、贝叶斯。常见的监督学习算法：感知机、SVM、人工神经网络、决策树、逻辑回归.........
机器学习 SGD Momentum RMSprop Adam 优化器对比(pytorch)
Johnny Liao的博客
05-27 550
下面直接给出代码, 中间带有我个人的注释: # -*- coding: utf-8 -*- # 4种优化器的对比 import torch import torch.utils.data as Data import torch.nn.functional as F from torch.autograd import Variable import matplotlib.pyplot as plt ##优化器的对比 LR = 0.01 BATCH_SIZE = 32 EPOCH = 12 x
AI学习指南深度学习篇-Adam的数学原理
最新发布
俞兆鹏的博客
09-12 1362
在深度学习中，优化算法起着至关重要的作用。Adam优化算法是一种结合了动量项和自适应学习率的优化算法，被广泛应用于深度学习的训练中。在本文中，我们将深入探讨Adam的数学原理，包括动量项和自适应学习率的计算公式，以及如何根据梯度的矩估计自适应地调整学习率。
0_4-优化方法-SGD、AdaGrad、RMSProp、Adadelta、Adam
default
09-11 1196
SGD AdaGrad 特点 RMSProp 参考 SGD ​ 随机梯度下降，注意这里的随机梯度下降是mini-batch gradient descent。一般深度学习中就用sgd代表。 a) 权重参数www , 权重梯度∇w∇w\nabla_w b) 学习率 ηη\eta , 学习率衰减decaydecaydecay (一般设置很小) c...
优化算法--Adagrad，RMSProp，AdaDelta，Adam
zenglaoshi的博客
11-26 1261
优化算法–Adagrad 自适应学习率 ​ 随机梯度下降算法，目标函数自变量的每一个元素在相同时间步都使用同一个学习率来自我迭代。举个例子，假设目标函数为fff，自变量为一个二维向量[x1,x2]⊤[x_1, x_2]^\top[x1​,x2​]⊤，该向量中每一个元素在迭代时都使用相同的学习率。例如，在学习率为η\etaη的梯度下降中，元素x1x_1x1​和x2x_2x2​都使用相同的学习率η\...
基于Pytorch源码对Adagrad、Adadelta、RMSProp、Adam等自适应学习率进行学习
MacKendy的博客
06-16 1011
公式是实现的原理，而源码才是让想法落地的媒介。希望能透过源代码，对原理有更具体的理解，回顾公式，也会有更深入的感受。 前期基于Pytorch的源码，对SGD进行了学习：基于torch.optim.sgd.py源码对SGD、momentum、Nesterov学习 本文会基于Pytorch源码，对Adagrad进行学习。 Adagrad 在SGD的年代，我们只能通过学习率（learning rate）来宏观控制网络的参数的学习速度，这从直观上是不太细致的。 随着人脑突触的实验进展，发现人脑神经元是有一定稀疏性的
【超详细】对比10种优化函数BGD、SGD、mini-batch GD、Momentum、NAG、Adagrad、RMSProp、Adadelta、Adam、AMSgrad
雷恩Layne
08-13 2232
在实践中常用到一阶优化函数，典型的一阶优化函数包括 BGD、SGD、mini-batch GD、Momentum、Adagrad、RMSProp、Adadelta、Adam 等等，一阶优化函数在优化过程中求解的是参数的一阶导数，这些一阶导数的值就是模型中参数的微调值。另外，近年来二阶优化函数也开始慢慢被研究起来，二阶方法因为计算量的问题，现在还没有被广泛地使用。 深度学习模型的优化是一个非凸函数优化问题，这是与凸函数优化问题对应的。对于凸函数优化，任何局部最优解即为全局最优解。几乎所有用梯度下降的优化方法都
10种优化迭代算法基础详解及其pytorch实现
nstarLDS的博客
03-14 5829
基本概念 优化器的功能：管理并更新模型中可学习参数的值，使得模型输出更接近真实标签。 这里的可学习参数一般就是指权值和偏置了，管理指优化器可以修改哪一部分参数。更新就是优化器的更新策略，每个不同的优化器会采取不同的策略去更新参数的值，这里策略通常是梯度下降。 在展开讨论之前，先明确下面几个基本概念： 导数：函数在指定坐标轴上的变化率 方向导数：指定方向上的变化率 梯度：一个向量。方向为使得方向导...
RMSProp优化器原理与代码实例讲解
AI天才研究院
08-05 640
RMSProp优化器原理与代码实例讲解 1. 背景介绍 1.1 优化算法在机器学习中的重要性 在机器学习和深度学习领域中,优化算法扮演着至关重要的角色。训练模型的目标是找到一组参数值,使得模型在训练数据上的损失函数(lo
AdaGrad优化器原理与代码实例讲解
AI天才研究院
08-09 715
AdaGrad优化器原理与代码实例讲解 1. 背景介绍 1.1 深度学习优化器简介 在深度学习模型的训练过程中,优化器(Optimizer)扮演着至关重要的角色。优化器通过不断调整模型参数,使得模型在训练数据上的损失函数最小化,从
卷积神经网络（五）：SGD、adagrad与RMSprop，梯度下降法总结
qwioer的博客
03-05 884
SGD SGD即随机梯度下降法，在每次更新中，计算一个Minibatch的数据，然后以Minibatch中数据的总损失对神经网络各权值...
深度学习系列（七） 优化算法（梯度下降、动量法、AdaGrad算法、RMSProp算法、AdaDelta算法、Adam算法） 2020.6.24
闵行小鱼塘
06-24 3016
在训练模型时，会使⽤优化算法不断迭代模型参数以降低模型损失函数的值，本节详细学习常用的优化算法：梯度下降、动量法、AdaGrad算法、RMSProp算法、AdaDelta算法、Adam算法
十一、改变神经网络的学习方法（5）：随机梯度下降的变化形式(Adagrad、RMSProp、Adadelta、Momentum、NAG)
dugudaibo的博客
08-19 5097
本文主要介绍随机梯度下降以及他的他的各种变化形式。首先回顾随机梯度下降方法，并指出它具有学习率固定，只能利用一阶导数信息的缺点，针对学习率固定的缺点，首先采用Adagrad首先学习率的自我调节，但是这种方法后期学习速度过慢，进而进入RMSProp和Adadelta两种方法。从利用导数的方面，介绍了牛顿法，Momentum和NAG，最后介绍结合RMSProp和Momentum的Adam。并对上述的所有方法进行一个总结。
（十）pytorch学习笔记---内容为学习资源摘录整合の梯度下降方法--Adadelta（5）
weixin_40245436的博客
03-02 1996
AdadeltaAdadelta 算是 Adagrad 法的延伸，它跟 RMSProp 一样，都是为了解决 Adagrad 中学习率不断减小的问题，RMSProp 是通过移动加权平均的方式，而 Adadelta 也是一种方法，有趣的是，它并不需要学习率这个参数。 Adadelta 法 def adadelta(parameters, sqrs, deltas, rho): e...
Mxnet (30): RMSProp、AdaDelta、Adam算法
泛泛之素
10-02 459
1. RMSProp算法 RMSProp跟Adagrad一样作为将速率计划与坐标自适应学习速率分离的简单解决方案。 Adagrad累积梯度的平方 gt\mathbf{g}_tgt​ 到state向量 st=st−1+gt2\mathbf{s}_t = \mathbf{s}_{t-1} + \mathbf{g}_t^2st​=st−1​+gt2​。 由于 st\mathbf{s}_tst​缺少正则化会跟随算法的收敛呈线性增长。RMSProp算法将这些梯度按元素平方做指数加权移动平均：st←γst−1+(1−
优化方法总结：SGD，Momentum，AdaGrad，RMSProp，AdaDelta，Adam
qq_27292549的博客
04-03 269
神经网络，优化方法（SGD，Momentum，AdaGrad，RMSProp，Adam），反向传播，各个网络层的导数，神经网络的正则化总结 https://blog.csdn.net/BVL10101111/article/details/72614711 https://blog.csdn.net/u010089444/article/details/76725843 ...
Optimizer （一）Adagrad 矩阵形式公式理解
wuhao1205的博客
05-13 579
学习记录，如有错误请指出，感谢大家指导谢大家指导建议。 本篇记录来自medium原网址 Adagrad的特点在于对于每一个参数的学习率是不同的，除了公共学习率 之外，每一个参数的学习率还有一个额外的系数。 其中代表极小数防止分母为0， I为单位矩阵。是当前轮次和下一轮的参数向量，维度等于参数个数。是当前轮次每一个参数的导数。是一个矩阵，定义如下 可以看到Gt就是每一轮导数向量和自身的外积，取对角线元素后加上一个极小值防止分母为0。 这里只取对角线说明假设了每一个参数之间的更新是...
AdaGrad算法
qq_24503095的博客
12-27 858
在动量法和梯度下降优化算法中，损失函数自变量的每一个元素在相同时间步都使用同一个学习率来自我迭代。 例如：假设损失函数为fff，自变量为一个二维变量[x1,x2]T[x_1,x_2]^T[x1​,x2​]T，该向量中每一个元素在迭代时都使用相同的学习率。例如，在学习率为η\etaη的梯度下降中，元素x1x_1x1​和x2x_2x2​都使用相同的学习率。但是两个自变量的梯度值有较大的差别时，使用相同...
深度学习中优化方法——momentum、Nesterov Momentum、AdaGrad、Adadelta、RMSprop、Adam
05-17
深度学习中的优化方法是指在训练神经网络时，通过更新模型参数来最小化损失函数的过程中所采用的算法。常用的优化方法包括：momentum、Nesterov Momentum、AdaGrad、Adadelta、RMSprop、Adam等。 1. Momentum Momentum是一种基于梯度下降的优化方法，它通过引入动量来加速收敛。在更新模型参数时，不仅考虑当前的梯度，还考虑之前的梯度对更新方向的影响，通过累积之前的梯度，使得更新方向更加稳定，加速收敛。 2. Nesterov Momentum Nesterov Momentum是Momentum的一种变体，它在更新模型参数之前，先向前“看一步”，计算模型参数在当前动量下的移动方向，然后再计算当前位置的梯度，最后根据这两个信息来更新模型参数。相比于Momentum，Nesterov Momentum能够更快地收敛。 3. AdaGrad AdaGrad是一种自适应学习率的优化方法，它通过动态地调整学习率来适应不同参数的更新需求。具体地说，它将学习率分别应用于每个参数的更新量上，使得每个参数的学习率随着训练的进行不断减小，从而减少参数更新的震荡。 4. Adadelta Adadelta也是一种自适应学习率的优化方法，它和AdaGrad不同之处在于，它不仅考虑了过去的梯度信息，还考虑了过去的参数更新信息。具体地说，它通过维护一个累积梯度平方的指数衰减平均值和一个累积参数更新平方的指数衰减平均值，来动态调整学习率和更新量，使得参数更新更加平稳。 5. RMSprop RMSprop也是一种自适应学习率的优化方法，它和Adadelta类似，但只考虑了过去的梯度信息，没有考虑过去的参数更新信息。具体地说，它通过维护一个梯度平方的指数衰减平均值来动态调整学习率，使得参数更新更加平稳。 6. Adam Adam是一种结合了Momentum和RMSprop的优化方法，它不仅考虑了梯度的一阶矩和二阶矩信息，还引入了偏置修正，使得参数更新更加准确。相比于其他优化方法，Adam不仅收敛速度快，还具有较好的性能表现。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值