精华内容
下载资源
问答
  • AdaGrad算法

    千次阅读 2019-08-02 17:04:52
    AdaGrad算法介绍 表示第i个参数的梯度,对于经典的SGD优化方法,参数θ的更新为: 再来看AdaGrad算法表示为: 其中,r为梯度累积变量,r的初始值为0。ε为全局学习率,需要自己设置。δ为小常数,为了...

    参考:

    深度学习优化方法-AdaGrad https://blog.csdn.net/program_developer/article/details/80756008


    AdaGrad算法介绍

    表示第i个参数的梯度,对于经典的SGD优化方法,参数θ的更新为:

    再来看AdaGrad算法表示为:

    其中,r为梯度累积变量,r的初始值为0。ε为全局学习率,需要自己设置。δ为小常数,为了数值稳定大约设置为。

    AdaGrad算法分析

     (1)从AdaGrad算法中可以看出,随着算法不断迭代,r会越来越大,整体的学习率会越来越小。所以,一般来说AdaGrad算法一开始是激励收敛,到了后面就慢慢变成惩罚收敛,速度越来越慢

    (2)在SGD中,随着梯度的增大,我们的学习步长应该是增大的。但是在AdaGrad中,随着梯度g的增大,我们的r也在逐渐的增大,且在梯度更新时r在分母上,也就是整个学习率是减少的,这是为什么呢?
    这是因为随着更新次数的增大,我们希望学习率越来越慢。因为我们认为在学习率的最初阶段,我们距离损失函数最优解还很远,随着更新次数的增加,越来越接近最优解,所以学习率也随之变慢。
    (3)经验上已经发现,对于训练深度神经网络模型而言,从训练开始时积累梯度平方会导致有效学习率过早和过量的减小。AdaGrade在某些深度学习模型上效果不错,但不是全部。

    优势:

    在数据分布稀疏的场景,能更好利用稀疏梯度的信息,比标准的SGD算法更有效地收敛。

    缺点:

    主要缺陷来自分母项的对梯度平方不断累积,随之时间步地增加,分母项越来越大,最终导致学习率收缩到太小无法进行有效更新。

    展开全文
  • 深度学习AdaGrad算法

    千次阅读 2021-01-02 10:45:24
    AdaGrad算法 在一般的优化算法中,目标函数自变量的每一个元素在相同时间步都使用同一个学习率来自我迭代。 例如,假设目标函数为fff,自变量为一个二维向量[x1,x2]⊤[x_1, x_2]^\top[x1​,x2​]⊤,该向量中每一个...

    AdaGrad算法

    在一般的优化算法中,目标函数自变量的每一个元素在相同时间步都使用同一个学习率来自我迭代。

    例如,假设目标函数为 f f f,自变量为一个二维向量 [ x 1 , x 2 ] ⊤ [x_1, x_2]^\top [x1,x2],该向量中每一个元素在迭代时都使用相同的学习率。

    例如,在学习率为 η \eta η的梯度下降中,元素 x 1 x_1 x1 x 2 x_2 x2都使用相同的学习率 η \eta η来自我迭代:

    x 1 ← x 1 − η ∂ f ∂ x 1 , x 2 ← x 2 − η ∂ f ∂ x 2 . x_1 \leftarrow x_1 - \eta \frac{\partial{f}}{\partial{x_1}}, \quad x_2 \leftarrow x_2 - \eta \frac{\partial{f}}{\partial{x_2}}. x1x1ηx1f,x2x2ηx2f.

    在(动量法)里我们看到当 x 1 x_1 x1 x 2 x_2 x2的梯度值有较大差别时,需要选择足够小的学习率使得自变量在梯度值较大的维度上不发散。但这样会导致自变量在梯度值较小的维度上迭代过慢。动量法依赖指数加权移动平均使得自变量的更新方向更加一致,从而降低发散的可能。

    而AdaGrad算法根据自变量在每个维度的梯度值的大小来调整各个维度上的学习率,从而避免统一的学习率难以适应所有维度的问题。

    算法内容

    AdaGrad算法会使用一个小批量随机梯度 g t \boldsymbol{g}_t gt按元素平方的累加变量 s t \boldsymbol{s}_t st

    • 在时间步0,AdaGrad将 s 0 \boldsymbol{s}_0 s0中每个元素初始化为0
    • 在时间步 t t t,首先将小批量随机梯度 g t \boldsymbol{g}_t gt按元素平方后累加到变量 s t \boldsymbol{s}_t st

    s t ← s t − 1 + g t ⊙ g t , \boldsymbol{s}_t \leftarrow \boldsymbol{s}_{t-1} + \boldsymbol{g}_t \odot \boldsymbol{g}_t, stst1+gtgt,

    其中 ⊙ \odot 是按元素相乘。接着,我们将目标函数自变量中每个元素的学习率通过按元素运算重新调整一下:

    x t ← x t − 1 − η s t + ϵ ⊙ g t , \boldsymbol{x}_t \leftarrow \boldsymbol{x}_{t-1} - \frac{\eta}{\sqrt{\boldsymbol{s}_t + \epsilon}} \odot \boldsymbol{g}_t, xtxt1st+ϵ ηgt,

    其中 η \eta η是学习率, ϵ \epsilon ϵ是为了维持数值稳定性而添加的常数,如 1 0 − 6 10^{-6} 106。这里开方、除法和乘法的运算都是按元素运算的。这些按元素运算使得目标函数自变量中每个元素都分别拥有自己的学习率。

    小批量随机梯度按元素平方的累加变量 s t \boldsymbol{s}_t st出现在学习率的分母项中。因此

    • 如果目标函数有关自变量中某个元素的偏导数一直都较大,那么该元素的学习率将下降较快
    • 反之,如果目标函数有关自变量中某个元素的偏导数一直都较小,那么该元素的学习率将下降较慢。

    然而,由于 s t \boldsymbol{s}_t st一直在累加按元素平方的梯度,自变量中每个元素的学习率在迭代过程中一直在降低(或不变)。所以,当学习率在迭代早期降得较快且当前解依然不佳时,AdaGrad算法在迭代后期由于学习率过小,可能较难找到一个有用的解

    • 目标函数 f ( x ) = 0.1 x 1 2 + 2 x 2 2 f(\boldsymbol{x})=0.1x_1^2+2x_2^2 f(x)=0.1x12+2x22
    • 学习率0.4
    from matplotlib import pyplot as plt
    
    def show_trace_2d(f, results):  
        plt.plot(*zip(*results), '-o', color='#ff7f0e')
        x1, x2 = np.meshgrid(np.arange(-5.5, 1.0, 0.1), np.arange(-3.0, 1.0, 0.1))
        plt.contour(x1, x2, f(x1, x2), colors='#1f77b4')
        plt.xlabel('x1')
        plt.ylabel('x2')
    
    def train_2d(trainer):  
        x1, x2, s1, s2 = -5, -2, 0, 0  # s1和s2是自变量状态,本章后续几节会使用
        results = [(x1, x2)]
        for i in range(20):
            x1, x2, s1, s2 = trainer(x1, x2, s1, s2)
            results.append((x1, x2))
        print('epoch %d, x1 %f, x2 %f' % (i + 1, x1, x2))
        return results
    
    %matplotlib inline
    import math
    import torch
    
    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
    show_trace_2d(f_2d, train_2d(adagrad_2d))
    

    可以看到,自变量的迭代轨迹较平滑。但由于 s t \boldsymbol{s}_t st的累加效果使学习率不断衰减,自变量在迭代后期的移动幅度较小。

    将学习率增大到2。可以看到自变量更为迅速地逼近了最优解。

    eta = 2
    show_trace_2d(f_2d, train_2d(adagrad_2d))
    

    实现AdaGrad算法

    def get_data_ch7():  
        data = np.genfromtxt('data/airfoil_self_noise.dat', delimiter='\t')
        data = (data - data.mean(axis=0)) / data.std(axis=0)
        return torch.tensor(data[:1500, :-1], dtype=torch.float32), \
            torch.tensor(data[:1500, -1], dtype=torch.float32) # 前1500个样本(每个样本5个特征)
    
    features, labels = 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)
    
    def train_ch7(optimizer_fn, states, hyperparams, features, labels,
                  batch_size=10, num_epochs=2):
        # 初始化模型
        net, loss = linreg, squared_loss
        
        w = torch.nn.Parameter(torch.tensor(np.random.normal(0, 0.01, size=(features.shape[1], 1)), dtype=torch.float32),
                               requires_grad=True)
        b = torch.nn.Parameter(torch.zeros(1, dtype=torch.float32), requires_grad=True)
    
        def eval_loss():
            return loss(net(features, w, b), labels).mean().item()
    
        ls = [eval_loss()]
        data_iter = torch.utils.data.DataLoader(
            torch.utils.data.TensorDataset(features, labels), batch_size, shuffle=True)
        
        for _ in range(num_epochs):
            start = time.time()
            for batch_i, (X, y) in enumerate(data_iter):
                l = loss(net(X, w, b), y).mean()  # 使用平均损失
                
                # 梯度清零
                if w.grad is not None:
                    w.grad.data.zero_()
                    b.grad.data.zero_()
                    
                l.backward()
                optimizer_fn([w, b], states, hyperparams)  # 迭代模型参数
                if (batch_i + 1) * batch_size % 100 == 0:
                    ls.append(eval_loss())  # 每100个样本记录下当前训练误差
        # 打印结果和作图
        print('loss: %f, %f sec per epoch' % (ls[-1], time.time() - start))
        set_figsize()
        plt.plot(np.linspace(0, num_epochs, len(ls)), ls)
        plt.xlabel('epoch')
        plt.ylabel('loss')
    
    train_ch7(adagrad, init_adagrad_states(), {'lr': 0.1}, features, labels)
    

    也可以使用pytorch内置的optim.Adagrad实现AdaGrad优化器:

    train_pytorch_ch7(torch.optim.Adagrad, {'lr': 0.1}, features, labels)
    
    展开全文
  • ADaGrad算法的理解

    2021-04-06 20:59:22
    AdaGrad算法 作用:独立地适应模型的每个参数:具有较大偏导的参数相应有一个较大的学习率,而具有小偏导的参数则对应一个较小的学习率 通过下面公式调整学习率 这里的学习率其实没有被更新而是每次应用时被缩放 ...

    AdaGrad算法
    作用:独立地适应模型的每个参数:具有较大偏导的参数相应有一个较大的学习率,而具有小偏导的参数则对应一个较小的学习率
    通过下面公式调整学习率

    在这里插入图片描述

    这里的学习率其实没有被更新而是每次应用时被缩放
    存在问题
    学习率是单调递减的,训练后期学习率过小会导致训练困难,甚至提前结束
    代码展示
    在这里插入图片描述
    当学习率为0.4时到最后很难达到最优解
    在这里插入图片描述
    当学习率为2时达到最优解的速度很快

    展开全文
  • 动手学PyTorch | (41) Adagrad算法

    千次阅读 2019-11-26 17:49:51
    在之前介绍过的优化算法中,⽬标函数⾃变量的每一个元素在相同时间步都使用同一个学习率来⾃我迭代。举个例子,假设⽬标函数为f,⾃变量为一个二维向量,该向量中每一个元素在迭代时都使⽤相同的学习率。例如,在学习...

    在之前介绍过的优化算法中,⽬标函数⾃变量的每一个元素在相同时间步都使用同一个学习率来⾃我迭代。举个例子,假设⽬标函数为f,⾃变量为一个二维向量[x_1,x_2]^T,该向量中每一个元素在迭代时都使⽤相同的学习率。例如,在学习率为\eta的梯度下降中,元素x_1,x_2都使用相同的学习率\eta来自我迭代:

    在(动量法)里我们看到当x_1,x_2的梯度值有较大差别时,需要选择⾜够小的学习率使得⾃变量(参数)在梯度值较大的维度上不发散。但这样会导致⾃变量在梯度值较小的维度上迭代过慢。动量法依赖指数加权移动平均使得⾃变量的更新⽅向更加一致,从⽽降低发散的可能。本节我们介绍AdaGrad算法, 它根据⾃变量在每个维度的梯度值的⼤小来调整各个维度上的学习率,从⽽而避免统一的学习率难以适应所有(参数)维度的问题。 

    目录

    1. 算法

    2. 特点

    3. 从0开始实现

    4. 简洁实现

    5. 小结


    1. 算法

    AdaGrad算法会使用⼀个⼩批量随机梯度g_t按元素平方的累加变量s_t 。在时间步0,AdaGrad将s_0中每个元素初始化为0。在时间步t,⾸先将小批量随机梯度g_t按元素平方后累加到变量s_t:

    其中\odot是按元素相乘。接着,我们将目标函数⾃变量中每个元素的学习率通过按元素运算􏰀重新调整一下:

    其中\eta是学习率, \epsilon是为了维持数值稳定性⽽添加的常数,如10^{-6}.这⾥开⽅、除法和乘法的运算都是按元素运算的。这些按元素运算使得目标函数⾃变量中每个元素都分别拥有⾃己的学习率。

    之前的方法,参数中的所有元素都拥有一个统一的学习率,adagram中参数中的每个元素的学习率都是不同的。

     

    2. 特点

    需要强调的是,⼩批量随机梯度按元素平方的累加变量 s_t出现在学习率的分母项中。因此,如果⽬标函数有关⾃变量中某个元素的偏导数⼀直都较大,那么该元素的学习率将下降较快;反之,如果目标函数有关⾃变量中某个元素的偏导数⼀直都较小,那么该元素的学习率将下降较慢。然⽽,由于一直在累加按元素平方的梯度,⾃变量中每个元素的学习率在迭代过程中⼀直在降低(或不变)。所以,当学习率在迭代早期降得较快且当前解依然不佳时,AdaGrad算法在迭代后期由于学习率过小,可能较难找到⼀个有用的解。

    下⾯我们仍然以目标函数f(x) = 0.1x_1^2+2x_2^2为例观察AdaGrad算法对自变量的迭代轨迹。我们实现AdaGrad算法并使用和上⼀节实验中相同的学习率0.4。可以看到,自变量的迭代轨迹较平滑。但由于s_t的累加效果使学习率不断衰减,⾃变量在迭代后期的移动幅度较小。

    %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))

    下⾯将学习率增大到2。可以看到⾃变量更为迅速地逼近了最优解。

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

     

    3. 从0开始实现

    同动量法⼀样,AdaGrad算法需要对每个自变量(参数)维护同它一样形状的状态变量。我们根据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)

     

    4. 简洁实现

    通过名称为Adagrad的优化器方法,我们便可使用PyTorch提供的AdaGrad算法来训练模型。

     

    d2l.train_pytorch_ch7(torch.optim.Adagrad, {'lr': 0.1}, features, labels)

     

    5. 小结

    1)AdaGrad算法在迭代过程中不断调整学习率,并让目标函数自变量(参数)中每个元素都分别拥有⾃己的学习率。

    2)使用AdaGrad算法时,⾃变量中每个元素的学习率在迭代过程中⼀直在降低(或不变)。

     

    展开全文
  • 原文链接:动手学深度学习pytorch版:7.5 AdaGrad算法 github:https://github.com/ShusenTang/Dive-into-DL-PyTorch 原论文: [1] Duchi, J., Hazan, E., & Singer, Y. (2011). Adaptive subgradient methods ...
  • 深度学习之AdaGrad算法

    2020-04-02 21:00:00
    AdaGrad 算法根据自变量在每个维度的梯度值调整各个维度的学习率,从而避免统一的维度难以适应所有维度的问题。 特点: 小批量随机梯度按元素累加变量,出现在学习率的...实现AdaGrad算法,使⽤的学习率为0.4。...
  • Pytorch Note17 优化算法3 Adagrad算法

    千次阅读 2021-06-13 15:07:30
    Pytoch Note17 优化算法3 Adagrad 文章目录Pytoch Note17 优化算法3 AdagradAdagrad 算法自适应学习率代码从0实现pytorch内置优化器比较Compare Adagrad 算法 在前面,我们能够根据误差函数的斜率调整我们的更新并反...
  • Mxnet (29): AdaGrad算法

    2020-10-02 13:52:04
    2.AdaGrad算法 AdaGrad算法会使用一个小批量随机梯度 gtg_tgt​ 通过 sts_tst​累计过去梯度的方差: gt=∂wl(yt,f(xt,w)),st=st−1+gt2,wt=wt−1−ηst+ϵ⋅gt.\begin{aligned} \mathbf{g}_t & = \partial_{\...
  • 在训练模型时,会使⽤优化算法不断迭代模型参数以降低模型损失函数的值,本节详细学习常用的优化算法:梯度下降、动量法、AdaGrad算法、RMSProp算法、AdaDelta算法、Adam算法
  • Adagrad 思想:如果一个参数的梯度一直都非常大,就让它的学习率变小一点,防止震动,反之,则让其学习率变大,使其能更快更新 做法:学习率由下列式子所得 +后的参数是为了防止分母等于0,一般取10的-10次方 ...
  • AdaGrad算法 提出动机 在SGD的每次迭代中,目标函数自变量的每一个元素在相同时间步都使用同一个学习率来进行迭代。我们考虑一个二维输入向量x=[x1,x2]Tx = [x_1,x_2]^Tx=[x1​,x2​]T和目标函数$f(x) $。 x1=x1−η...
  • 7.5 AdaGrad算法在之前介绍过的优化算法中,目标函数自变量的每一个元素在相同时间步都使用同一个学习率来自我迭代。举个例子,假设目标函数为ff fst​的累加效果使学习率不断衰减,自变量在迭代后期的移动幅度较小...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,570
精华内容 3,028
关键字:

adagrad算法