首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >【深度学习优化算法】07:AdaGrad算法

【深度学习优化算法】07:AdaGrad算法

作者头像
Francek Chen
发布2025-07-19 10:51:07
发布2025-07-19 10:51:07
13600
代码可运行
举报
运行总次数:0
代码可运行

【作者主页】Francek Chen 【专栏介绍】

PyTorch深度学习

深度学习 (DL, Deep Learning) 特指基于深层神经网络模型和方法的机器学习。它是在统计机器学习、人工神经网络等算法模型基础上,结合当代大数据和大算力的发展而发展出来的。深度学习最重要的技术特征是具有自动提取特征的能力。神经网络算法、算力和数据是开展深度学习的三要素。深度学习在计算机视觉、自然语言处理、多模态数据分析、科学探索等领域都取得了很多成果。本专栏介绍基于PyTorch的深度学习算法实现。 【GitCode】专栏资源保存在我的GitCode仓库:https://gitcode.com/Morse_Chen/PyTorch_deep_learning

  我们从有关特征学习中并不常见的问题入手。

一、稀疏特征和学习率

  假设我们正在训练一个语言模型。为了获得良好的准确性,我们大多希望在训练的过程中降低学习率,速度通常为

\mathcal{O}(t^{-\frac{1}{2}})

或更低。现在讨论关于稀疏特征(即只在偶尔出现的特征)的模型训练,这对自然语言来说很常见。例如,我们看到“预先条件”这个词比“学习”这个词的可能性要小得多。但是,它在计算广告学和个性化协同过滤等其他领域也很常见。

  只有在这些不常见的特征出现时,与其相关的参数才会得到有意义的更新。鉴于学习率下降,我们可能最终会面临这样的情况:常见特征的参数相当迅速地收敛到最佳值,而对于不常见的特征,我们仍缺乏足够的观测以确定其最佳值。换句话说,学习率要么对于常见特征而言降低太慢,要么对于不常见特征而言降低太快。

  解决此问题的一个方法是记录我们看到特定特征的次数,然后将其用作调整学习率。即我们可以使用大小为

\eta_i = \frac{\eta_0}{\sqrt{s(i, t) + c}}

的学习率,而不是

\eta = \frac{\eta_0}{\sqrt{t + c}}

。在这里

s(i, t)

计下了我们截至

t

时观察到功能

i

的次数。这其实很容易实施且不产生额外损耗。

  AdaGrad算法通过将粗略的计数器

s(i, t)

替换为先前观察所得梯度的平方之和来解决这个问题。它使用

s(i, t+1) = s(i, t) + \left(\partial_i f(\mathbf{x})\right)^2

来调整学习率。这有两个好处:首先,我们不再需要决定梯度何时算足够大。其次,它会随梯度的大小自动变化。通常对应于较大梯度的坐标会显著缩小,而其他梯度较小的坐标则会得到更平滑的处理。在实际应用中,它促成了计算广告学及其相关问题中非常有效的优化程序。但是,它遮盖了AdaGrad固有的一些额外优势,这些优势在预处理环境中很容易被理解。

二、预处理

  凸优化问题有助于分析算法的特点。毕竟对大多数非凸问题来说,获得有意义的理论保证很难,但是直觉和洞察往往会延续。让我们来看看最小化

f(\mathbf{x}) = \frac{1}{2} \mathbf{x}^\top \mathbf{Q} \mathbf{x} + \mathbf{c}^\top \mathbf{x} + b

这一问题。

  正如在动量法中那样,我们可以根据其特征分解

\mathbf{Q} = \mathbf{U}^\top \boldsymbol{\Lambda} \mathbf{U}

重写这个问题,来得到一个简化得多的问题,使每个坐标都可以单独解出:

f(\mathbf{x}) = \bar{f}(\bar{\mathbf{x}}) = \frac{1}{2} \bar{\mathbf{x}}^\top \boldsymbol{\Lambda} \bar{\mathbf{x}} + \bar{\mathbf{c}}^\top \bar{\mathbf{x}} + b \tag{1}

在这里我们使用了

\mathbf{x} = \mathbf{U} \mathbf{x}

,且因此

\mathbf{c} = \mathbf{U} \mathbf{c}

。修改后优化器为

\bar{\mathbf{x}} = -\boldsymbol{\Lambda}^{-1} \bar{\mathbf{c}}

且最小值为

-\frac{1}{2} \bar{\mathbf{c}}^\top \boldsymbol{\Lambda}^{-1} \bar{\mathbf{c}} + b

。这样更容易计算,因为

\boldsymbol{\Lambda}

是一个包含

\mathbf{Q}

特征值的对角矩阵。

  如果稍微扰动

\mathbf{c}

,我们会期望在

f

的最小化器中只产生微小的变化。遗憾的是,情况并非如此。虽然

\mathbf{c}

的微小变化导致了

\bar{\mathbf{c}}

同样的微小变化,但

f

的(以及

\bar{f}

的)最小化器并非如此。每当特征值

\boldsymbol{\Lambda}_i

很大时,我们只会看到

\bar{x}_i

\bar{f}

的最小值发声微小变化。相反,对小的

\boldsymbol{\Lambda}_i

来说,

\bar{x}_i

的变化可能是剧烈的。最大和最小的特征值之比称为优化问题的条件数(condition number):

\kappa = \frac{\boldsymbol{\Lambda}_1}{\boldsymbol{\Lambda}_d} \tag{2}

如果条件编号

\kappa

很大,准确解决优化问题就会很难。我们需要确保在获取大量动态的特征值范围时足够谨慎:难道我们不能简单地通过扭曲空间来“修复”这个问题,从而使所有特征值都是

1

?理论上这很容易:我们只需要

\mathbf{Q}

的特征值和特征向量即可将问题从

\mathbf{x}

整理到

\mathbf{z} := \boldsymbol{\Lambda}^{\frac{1}{2}} \mathbf{U} \mathbf{x}

中的一个。在新的坐标系中,

\mathbf{x}^\top \mathbf{Q} \mathbf{x}

可以被简化为

\|\mathbf{z}\|^2

。可惜,这是一个相当不切实际的想法。一般而言,计算特征值和特征向量要比解决实际问题“贵”得多。

  虽然准确计算特征值可能会很昂贵,但即便只是大致猜测并计算它们,也可能已经比不做任何事情好得多。特别是,我们可以使用

\mathbf{Q}

的对角线条目并相应地重新缩放它。这比计算特征值开销小的多。

\tilde{\mathbf{Q}} = \mathrm{diag}^{-\frac{1}{2}}(\mathbf{Q}) \mathbf{Q} \mathrm{diag}^{-\frac{1}{2}}(\mathbf{Q}) \tag{3}

  在这种情况下,我们得到了

\tilde{\mathbf{Q}}_{ij} = \mathbf{Q}_{ij} / \sqrt{\mathbf{Q}_{ii} \mathbf{Q}_{jj}}

,特别注意对于所有

i

\tilde{\mathbf{Q}}_{ii} = 1

。在大多数情况下,这大大简化了条件数。例如我们之前讨论的案例,它将完全消除眼下的问题,因为问题是轴对齐的。

  遗憾的是,我们还面临另一个问题:在深度学习中,我们通常情况甚至无法计算目标函数的二阶导数:对于

\mathbf{x} \in \mathbb{R}^d

,即使只在小批量上,二阶导数可能也需要

\mathcal{O}(d^2)

空间来计算,导致几乎不可行。AdaGrad算法巧妙的思路是,使用一个代理来表示黑塞矩阵(Hessian)的对角线,既相对易于计算又高效。

  为了了解它是如何生效的,让我们来看看

\bar{f}(\bar{\mathbf{x}})

。我们有

\partial_{\bar{\mathbf{x}}} \bar{f}(\bar{\mathbf{x}}) = \boldsymbol{\Lambda} \bar{\mathbf{x}} + \bar{\mathbf{c}} = \boldsymbol{\Lambda} \left(\bar{\mathbf{x}} - \bar{\mathbf{x}}_0\right) \tag{4}

其中

\bar{\mathbf{x}}_0

\bar{f}

的优化器。因此,梯度的大小取决于

\boldsymbol{\Lambda}

和与最佳值的差值。如果

\bar{\mathbf{x}} - \bar{\mathbf{x}}_0

没有改变,那这就是我们所求的。毕竟在这种情况下,梯度

\partial_{\bar{\mathbf{x}}} \bar{f}(\bar{\mathbf{x}})

的大小就足够了。由于AdaGrad算法是一种随机梯度下降算法,所以即使是在最佳值中,我们也会看到具有非零方差的梯度。因此,我们可以放心地使用梯度的方差作为黑塞矩阵比例的廉价替代。

三、算法

  让我们接着上面正式开始讨论。我们使用变量

\mathbf{s}_t

来累加过去的梯度方差,如下所示:

\begin{aligned} \mathbf{g}_t & = \partial_{\mathbf{w}} l(y_t, f(\mathbf{x}_t, \mathbf{w})) \\ \mathbf{s}_t & = \mathbf{s}_{t-1} + \mathbf{g}_t^2 \\ \mathbf{w}_t & = \mathbf{w}_{t-1} - \frac{\eta}{\sqrt{\mathbf{s}_t + \epsilon}} \cdot \mathbf{g}_t \end{aligned} \tag{5}

在这里,操作是按照坐标顺序应用。也就是说,

\mathbf{v}^2

有条目

v_i^2

。同样,

\frac{1}{\sqrt{v}}

有条目

\frac{1}{\sqrt{v_i}}

,并且

\mathbf{u} \cdot \mathbf{v}

有条目

u_i v_i

。与之前一样,

\eta

是学习率,

\epsilon

是一个为维持数值稳定性而添加的常数,用来确保我们不会除以

0

。最后,我们初始化

\mathbf{s}_0 = \mathbf{0}

  就像在动量法中我们需要跟踪一个辅助变量一样,在AdaGrad算法中,我们允许每个坐标有单独的学习率。与SGD算法相比,这并没有明显增加AdaGrad的计算代价,因为主要计算用在

l(y_t, f(\mathbf{x}_t, \mathbf{w}))

及其导数。

  请注意,在

\mathbf{s}_t

中累加平方梯度意味着

\mathbf{s}_t

基本上以线性速率增长(由于梯度从最初开始衰减,实际上比线性慢一些)。这产生了一个学习率

\mathcal{O}(t^{-\frac{1}{2}})

,但是在单个坐标的层面上进行了调整。对于凸问题,这完全足够了。然而,在深度学习中,我们可能希望更慢地降低学习率。这引出了许多AdaGrad算法的变体,我们将在后续章节中讨论它们。眼下让我们先看看它在二次凸问题中的表现如何。我们仍然以同一函数为例:

f(\mathbf{x}) = 0.1 x_1^2 + 2 x_2^2 \tag{6}

  我们将使用与之前相同的学习率来实现AdaGrad算法,即

\eta = 0.4

。可以看到,自变量的迭代轨迹较平滑。但由于

\boldsymbol{s}_t

的累加效果使学习率不断衰减,自变量在迭代后期的移动幅度较小。

代码语言:javascript
代码运行次数:0
运行
复制
%matplotlib inline
import math
import torch
from d2l import torch as d2l
代码语言:javascript
代码运行次数:0
运行
复制
def adagrad_2d(x1, x2, s1, s2):
    eps = 1e-6
    g1, g2 = 0.2 * x1, 4 * x2
    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

,可以看到更好的表现。这已经表明,即使在无噪声的情况下,学习率的降低可能相当剧烈,我们需要确保参数能够适当地收敛。

代码语言:javascript
代码运行次数:0
运行
复制
eta = 2
d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

四、从零开始实现

  同动量法一样,AdaGrad算法需要对每个自变量维护同它一样形状的状态变量。

代码语言:javascript
代码运行次数:0
运行
复制
def init_adagrad_states(feature_dim):
    s_w = torch.zeros((feature_dim, 1))
    s_b = torch.zeros(1)
    return (s_w, s_b)

def adagrad(params, states, hyperparams):
    eps = 1e-6
    for p, s in zip(params, states):
        with torch.no_grad():
            s[:] += torch.square(p.grad)
            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)
        p.grad.data.zero_()

  与小批量随机梯度下降一节中的实验相比,这里使用更大的学习率来训练模型。

代码语言:javascript
代码运行次数:0
运行
复制
data_iter, feature_dim = d2l.get_data_ch11(batch_size=10)
d2l.train_ch11(adagrad, init_adagrad_states(feature_dim), {'lr': 0.1}, data_iter, feature_dim);
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

五、简洁实现

  我们可直接使用深度学习框架中提供的AdaGrad算法来训练模型。

代码语言:javascript
代码运行次数:0
运行
复制
trainer = torch.optim.Adagrad
d2l.train_concise_ch11(trainer, {'lr': 0.1}, data_iter)

小结

  • AdaGrad算法会在单个坐标层面动态降低学习率。
  • AdaGrad算法利用梯度的大小作为调整进度速率的手段:用较小的学习率来补偿带有较大梯度的坐标。
  • 在深度学习问题中,由于内存和计算限制,计算准确的二阶导数通常是不可行的。梯度可以作为一个有效的代理。
  • 如果优化问题的结构相当不均匀,AdaGrad算法可以帮助缓解扭曲。
  • AdaGrad算法对于稀疏特征特别有效,在此情况下由于不常出现的问题,学习率需要更慢地降低。
  • 在深度学习问题上,AdaGrad算法有时在降低学习率方面可能过于剧烈。我们将在Adam算法一节讨论缓解这种情况的策略。
本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2025-07-18,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 一、稀疏特征和学习率
  • 二、预处理
  • 三、算法
  • 四、从零开始实现
  • 五、简洁实现
  • 小结
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档