动手学深度学习11.7. AdaGrad算法-笔记练习（PyTorch）

以下内容为结合李沐老师的课程和教材补充的学习笔记，以及对课后练习的一些思考，自留回顾，也供同学之人交流参考。

本节课程地址：72 优化算法【动手学深度学习v2】_哔哩哔哩_bilibili

本节教材地址：11.7. AdaGrad算法 — 动手学深度学习 2.0.0 documentation

本节开源代码：...>d2l-zh>pytorch>chapter_optimization>adagrad.ipynb

AdaGrad算法

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

稀疏特征和学习率

假设我们正在训练一个语言模型。为了获得良好的准确性，我们大多希望在训练的过程中降低学习率，速度通常为 $\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算法 (ef="https://zh-v2.d2l.ai/chapter_references/zreferences.html#id36">Duchiet al., 2011) 通过将粗略的计数器 $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$ 这一问题。

正如在 11.6节中那样，我们可以根据其特征分解 $\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.$

在这里我们使用了 $\bar{\mathbf{x}} = \mathbf{U} \mathbf{x}$ ，且因此 $\bar{\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}.$

如果条件数 $\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$ 。可惜，这是一个相当不切实际的想法。一般而言，计算特征值和特征向量要比解决实际问题“贵”得多。

虽然准确计算特征值可能会很昂贵，但即便只是大致猜测并计算它们，也可能已经比不做任何事情好得多。特别是，我们可以使用 Q 的对角线条目并相应地重新缩放它。这比计算特征值开销小的多。

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

在这种情况下，我们得到了 $\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),$

其中 $\bar{\mathbf{x}}_0$ 是 $\bar{f}$ 的最小化器。因此，梯度的大小取决于 $\boldsymbol{\Lambda}$ 和 $\bar{\mathbf{x}}$ 与最佳值的差值。如果 $\bar{\mathbf{x}} - \bar{\mathbf{x}}_0$ 没有改变，那这就是我们所求的。毕竟在这种情况下，梯度 $\partial{\bar{\mathbf{x}}} \bar{f}(\bar{\mathbf{x}})$ 的大小就足够了。由于AdaGrad算法是一种随机梯度下降算法，所以即使是在最佳值中，我们也会看到具有非零方差的梯度。因此，我们可以放心地使用梯度的方差作为黑塞矩阵比例的廉价替代。详尽的分析（要花几页解释）超出了本节的范围，请读者参考(ef="https://zh-v2.d2l.ai/chapter_references/zreferences.html#id36">Duchiet al., 2011)。

算法

让我们接着上面正式开始讨论。我们使用变量 $\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}$

在这里，操作是按照坐标顺序应用。也就是说， $\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.$

我们将使用与之前相同的学习率来实现AdaGrad算法，即 $\eta = 0.4$ 。可以看到，自变量的迭代轨迹较平滑。但由于 st 的累加效果使学习率不断衰减，自变量在迭代后期的移动幅度较小。

%matplotlib inline
import math
import torch
from d2l import torch as d2l
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))

输出结果：
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

从零开始实现

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

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_()

与 11.5节一节中的实验相比，这里使用更大的学习率来训练模型。

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)

输出结果：
loss: 0.242, 0.029 sec/epoch

简洁实现

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

trainer = torch.optim.Adagrad
d2l.train_concise_ch11(trainer, {'lr': 0.1}, data_iter)

输出结果：
loss: 0.242, 0.011 sec/epoch

小结

AdaGrad算法会在单个坐标层面动态降低学习率。
AdaGrad算法利用梯度的大小作为调整进度速率的手段：用较小的学习率来补偿带有较大梯度的坐标。
在深度学习问题中，由于内存和计算限制，计算准确的二阶导数通常是不可行的。梯度可以作为一个有效的代理。
如果优化问题的结构相当不均匀，AdaGrad算法可以帮助缓解扭曲。
AdaGrad算法对于稀疏特征特别有效，在此情况下由于不常出现的问题，学习率需要更慢地降低。
在深度学习问题上，AdaGrad算法有时在降低学习率方面可能过于剧烈。我们将在 11.10节一节讨论缓解这种情况的策略。

练习

证明对于正交矩阵 $\mathbf{U}$ 和向量 $\mathbf{c}$ ，以下等式成立： $\|\mathbf{c} - \mathbf{\delta}\|_2 = \|\mathbf{U} \mathbf{c} - \mathbf{U} \mathbf{\delta}\|_2$ 。为什么这意味着在变量的正交变化之后，扰动的程度不会改变？
解：
对于正交矩阵 $\mathbf{U}$ ，满足 $\mathbf{U}^\top \mathbf{U} = \mathbf{I}$ ，其中 $\mathbf{I}$ 是单位矩阵。
根据欧几里得范数的定义 $|\mathbf{v}|_2 = \sqrt{\mathbf{v}^\top \mathbf{v}}$ ，展开 $|\mathbf{U} \mathbf{c} - \mathbf{U} \mathbf{\delta}|_2^2$ ，可得：
$\|\mathbf{U} \mathbf{c} - \mathbf{U} \mathbf{\delta}\|_2^2 = \sqrt{(\mathbf{U} \mathbf{c} - \mathbf{U} \mathbf{\delta})^\top (\mathbf{U} \mathbf{c} - \mathbf{U} \mathbf{\delta})} \\ = (\mathbf{U} \mathbf{c} - \mathbf{U} \mathbf{\delta})^\top (\mathbf{U} \mathbf{c} - \mathbf{U} \mathbf{\delta}) \\ = (\mathbf{c}^\top \mathbf{U}^\top - \mathbf{\delta}^\top \mathbf{U}^\top) (\mathbf{U} \mathbf{c} - \mathbf{U} \mathbf{\delta}) \\ = \mathbf{c}^\top \mathbf{c} - \mathbf{c}^\top \mathbf{\delta} - \mathbf{\delta}^\top \mathbf{c} + \mathbf{\delta}^\top \mathbf{\delta}$
由于 $\mathbf{c}^\top \mathbf{\delta} = \mathbf{\delta}^\top \mathbf{c}$ ，故上式可以简化为： $\mathbf{c}^\top \mathbf{c} - 2 \mathbf{c}^\top \mathbf{\delta} + \mathbf{\delta}^\top \mathbf{\delta}$
而 $|\mathbf{c} - \mathbf{\delta}|_2^2$ 展开为：
$\|\mathbf{c} - \mathbf{\delta}\|_2^2 = (\mathbf{c} - \mathbf{\delta})^\top (\mathbf{c} - \mathbf{\delta}) \\ = \mathbf{c}^\top \mathbf{c} - 2 \mathbf{c}^\top \mathbf{\delta} + \mathbf{\delta}^\top \mathbf{\delta}$
因此： $\|\mathbf{c} - \mathbf{\delta}\|_2^2 = \|\mathbf{U} \mathbf{c} - \mathbf{U} \mathbf{\delta}\|_2^2$
等式两边同时开平方根，即证： $\|\mathbf{c} - \mathbf{\delta}\|_2 = \|\mathbf{U} \mathbf{c} - \mathbf{U} \mathbf{\delta}\|_2$
以上证明表明，由于正交变换保持了向量之间的欧几里得距离不变，所以在变量的正交变化之后，扰动的程度不会改变。
尝试对函数 $f(\mathbf{x}) = 0.1 x_1^2 + 2 x_2^2$ 、以及它旋转45度后的函数即 $f(\mathbf{x}) = 0.1 (x_1 + x_2)^2 + 2 (x_1 - x_2)^2$ 使用AdaGrad算法。它的表现会不同吗？
解：
$f(\mathbf{x}) = 0.1 (x_1 + x_2)^2 + 2 (x_1 - x_2)^2 \\ = 2.1 x_1^2 - 3.8 x_1 x_2 + 2.1 x_2^2$
对于旋转后的 $f(\mathbf{x})$ ，AdaGrad算法也是使学习率不断衰减，自变量在迭代后期的移动幅度较小。
同时，旋转后的函数在梯度方向上更加对称，这有助于AdaGrad算法更均匀地调整学习率，进一步提高了收敛性。
代码如下：

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

def adagrad_2d_rotation(x1, x2, s1, s2):
    eps = 1e-6
    g1, g2 = 4.2 * x1 - 3.8 * x2, 4.2 * x2 - 3.8 * x1
    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

d2l.show_trace_2d(f_2d_rotation, d2l.train_2d(adagrad_2d_rotation))

输出结果：
epoch 20, x1: -1.054791, x2: -1.046482

3. 证明格什戈林圆盘定理，其中提到，矩阵 $\mathbf{M}$ 的特征值 $\lambda_i$ 在至少一个 $j$ 的选项中满足 $|\lambda_i - \mathbf{M}_{jj}| \leq \sum_{k \neq j} |\mathbf{M}_{jk}|$ 的要求。
解：
格什戈林圆盘定理可用于估计矩阵特征值的范围，具体定义是指：
对于任意一个 $n \times n$ 复数矩阵 $\mathbf{M}$ ，其特征值 $\lambda_i$ 满足：
对于每一个 $i=1,2,\dots,n$ ，存在至少一个 $j$ 使得 $\lambda_i$ 位于以 $\mathbf{M}_{jj}$ 为中心，半径为 $\sum_{k \neq j} |\mathbf{M}_{jk}|$ 的圆盘内，即： $|\lambda_i - \mathbf{M}_{jj}| \leq \sum_{k \neq j} |\mathbf{M}_{jk}|$
证明如下：
$\mathbf{x}=(x_1,x_2,\cdots,x_n)^T$ 是对应于 $\lambda$ 的特征向量，即 $\mathbf{M}\mathbf{x}=\lambda\mathbf{x}$ ，且 $\mathbf{x}\neq\mathbf{0}$ 。
设 $x_j$ 满足 $|x_j|=\max\left\{ {|x_1|,|x_2|,\cdots,|x_n|} \right\}$ ，且因为 $\mathbf{x}\neq\mathbf{0}$ ，所以 $|x_j|>0$ 。
将 $\mathbf{M}\mathbf{x}=\lambda\mathbf{x}$ 按分量展开，得到 $\sum_{k = 1}^{n}\mathbf{M}_{jk}x_k=\lambda x_j$ 。
把等式左边的 $\mathbf{M}_{jj}x_j$ 单独分离出来，移项可得:
$(\lambda - \mathbf{M}_{jj}) x_j = \sum_{k \neq j}\mathbf{M}_{jk} x_k$
对上式两边取绝对值，根据绝对值不等式 $|\sum_{i = 1}^{s}a_i|\leq\sum_{i = 1}^{s}|a_i|$ ，有
$|\lambda - \mathbf{M}_{jj}||x_j|=|\sum_{k\neq j}\mathbf{M}_{jk}x_k|\leq\sum_{k\neq j}|\mathbf{M}_{jk}||x_k|$ 。
又由于 $|x_j|=\max\left\{ {|x_1|,|x_2|,\cdots,|x_n|} \right\}$ ，所以对于所有的 $k$ ，都有 $|x_k|\leq|x_j|$ 。
由此可得： $|\lambda - \mathbf{M}_{jj}||x_j|\leq\sum_{k\neq j}|\mathbf{M}_{jk}||x_k|\leq\sum_{k\neq j}|\mathbf{M}_{jk}||x_j|$
上式两边同时除以 $|x_j|$ ，即证 $|\lambda - \mathbf{M}_{jj}|\leq\sum_{k\neq j}|\mathbf{M}_{jk}|$ 。

4. 关于对角线预处理矩阵 $\mathrm{diag}^{-\frac{1}{2}}(\mathbf{M}) \mathbf{M} \mathrm{diag}^{-\frac{1}{2}}(\mathbf{M})$ 的特征值，格什戈林的定理告诉了我们什么？
解：
对于 $n$ 阶矩阵 $\mathbf{M}$ ， $\mathrm{diag}(\mathbf{M})=\text{diag}(\mathbf{M}_{11},\mathbf{M}_{22},\cdots,\mathbf{M}_{nn})$ ，令 $\mathbf{D}=\mathrm{diag}^{-\frac{1}{2}}(\mathbf{M})$ ，是一个对角矩阵，其对角元素 $\mathbf{D}_{ii}=\frac{1}{\sqrt{\mathbf{D}_{ii}}}$ （假设 $\mathbf{M}_{ii}\neq0$ ）。
则对角线预处理矩阵 $\mathbf{B}=\mathrm{diag}^{-\frac{1}{2}}(\mathbf{M}) \mathbf{M} \mathrm{diag}^{-\frac{1}{2}}(\mathbf{M})=\mathbf{DMD}$ ，其中 $\mathbf{B}_{ij}$ 为： $\mathbf{B}_{ij}=\mathbf{D}_{ii}\mathbf{M}_{ij}\mathbf{D}_{jj}=\frac{\mathbf{M}_{ij}}{\sqrt{\mathbf{M}_{ii}\mathbf{M}_{jj}}}$
对于矩阵 $\mathbf{B}$ 的特征值 $\lambda$ ，根据格什戈林定理，至少存在一个 $j$ 使得： $|\lambda - \mathbf{B}_{jj}| \leq \sum_{k\neq j}|\mathbf{B}_{jk}|$
将 $\mathbf{B}_{ij}=\frac{\mathbf{M}_{ij}}{\sqrt{\mathbf{M}_{ii}\mathbf{M}_{jj}}}$ 代入上述不等式，可得：
$|\lambda-\frac{\mathbf{M}_{jj}}{\mathbf{M}_{jj}}|=|\lambda - 1| \leq \sum_{k\neq j}|\frac{\mathbf{M}_{jk}}{\sqrt{\mathbf{M}_{jj}\mathbf{M}_{kk}}}|$
所以，格什戈林的定理告诉我们，对角线预处理矩阵 $\mathrm{diag}^{-\frac{1}{2}}(\mathbf{M}) \mathbf{M} \mathrm{diag}^{-\frac{1}{2}}(\mathbf{M})$ 的特征值至少位于以 1 为圆心，以 $\sum_{k\neq j}|\frac{m_{jk}}{\sqrt{m_{jj}m_{kk}}}|$ 为半径的圆盘内。这为我们估计预处理后矩阵的特征值提供了一个直观的几何区域，有助于判断特征值大致分布在哪些范围内。通过这些圆盘的位置和大小，我们可以对预处理后矩阵的一些性质进行分析。例如，如果所有圆盘都集中在复平面上靠近 1 的位置，说明预处理后的矩阵的特征值相对比较集中，可能具有较好的条件数，这在数值计算中对于迭代算法的收敛性等方面是有利的；反之，如果圆盘分布比较分散，则特征值的分布范围较广，可能会对数值计算带来一些挑战。

5. 尝试对适当的深度网络使用AdaGrad算法，例如，6.6节中应用于Fashion-MNIST的深度网络。
解：
代码如下：

import torch
from torch import nn
from d2l import torch as d2l

net = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)
def train_ch6_optimizer(net, optimizer, train_iter, test_iter, num_epochs, lr, device):
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            nn.init.xavier_uniform_(m.weight)
    net.apply(init_weights)
    print('training on', device)
    net.to(device)
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
                            legend=['train loss', 'train acc', 'test acc'])
    timer, num_batches = d2l.Timer(), len(train_iter)
    for epoch in range(num_epochs):
        metric = d2l.Accumulator(3)
        net.train()
        for i, (X, y) in enumerate(train_iter):
            timer.start()
            optimizer.zero_grad()
            X, y = X.to(device), y.to(device)
            y_hat = net(X)
            l = loss(y_hat, y)
            l.backward()
            optimizer.step()
            with torch.no_grad():
                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])
            timer.stop()
            train_l = metric[0] / metric[2]
            train_acc = metric[1] / metric[2]
            if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
                animator.add(epoch + (i + 1) / num_batches,
                             (train_l, train_acc, None))
        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)
        animator.add(epoch + 1, (None, None, test_acc))
    print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, '
          f'test acc {test_acc:.3f}')
    print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec '
          f'on {str(device)}')
lr, num_epochs = 0.01, 10
optimizer = torch.optim.Adagrad(net.parameters(), lr=lr)
train_ch6_optimizer(net, optimizer, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

输出结果：
loss 0.620, train acc 0.759, test acc 0.758
25309.8 examples/sec on cpu

6. 要如何修改AdaGrad算法，才能使其在学习率方面的衰减不那么激进？
解：
AdaGrad 算法通过累积梯度的平方和来调整每个参数的学习率，在训练后期，由于梯度平方和的不断累积，学习率会衰减得非常快，导致参数更新变得缓慢，甚至可能使模型提前停止学习。可以做如下改进：

11.8节的RMSProp算法是基于指数移动平均来改进AdaGrad的学习率衰减问题。它通过对梯度平方的累积和进行指数加权平均，使得学习率的衰减更加平滑。具体算法更改为：
$s_t=\gamma s_{t - 1}+(1 - \gamma)g_t^2$
其中γ是衰减率， $\gamma > 0$ 。
$x_{t}=x_{t-}-\frac{\eta}{\sqrt{s_t+\epsilon}}g_t$
这里 $\eta$ 是初始学习率， $\epsilon$ 是一个很小的常数（通常 $=10^{-6}$ ），用于避免分母为零。
11.9节的AdaDelta算法也是对AdaGrad的改进，它不再使用梯度平方的累积和，而是引入了一个指数移动平均的思想，对梯度平方的累积和进行平滑处理，避免了学习率的过度衰减。具体算法更改为：
$s_t=\rho s_{t - 1}+(1 - \rho)g_t^2$
其中 $\rho$ 是衰减率， $\rho > 0$ 。
$x_{t}=x_{t-1}-g'_t$
其中 $g'_t$ 是重新缩放的梯度,
$g'_t = \frac{\sqrt{\Delta x_{t-1} + \epsilon}}{\sqrt{s_t + \epsilon}}\bigodot g_t$
其中 $\epsilon$ 是一个很小的常数（通常 $=10^{-5}$ ），用于避免分母为零。 $\Delta x_{t-1}$ 是重新缩放梯度的平方 $g'_t$ 的泄漏平均值。 $\Delta x_0$ 初始化为0，每步用 $g'_t$ 更新， $\Delta x_t = \rho \Delta x_{t-1} + (1 - \rho){g'_t}^2$

下面将RMSProp和AdaDelta应用于Fashion-MNIST的深度网络，与Adagrad算法进行比较，代码如下：

lr, num_epochs = 0.001, 10
optimizer = torch.optim.RMSprop(net.parameters(), lr=lr)
train_ch6_optimizer(net, optimizer, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

输出结果：
loss 0.480, train acc 0.822, test acc 0.816
24535.0 examples/sec on cpu

lr, num_epochs = 0.01, 10
optimizer = torch.optim.Adadelta(net.parameters())
train_ch6_optimizer(net, optimizer, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

输出结果：
loss 0.483, train acc 0.818, test acc 0.801
23222.0 examples/sec on cpu