当前位置: 首页 > article >正文

动手学深度学习11.8. RMSProp算法-笔记练习(PyTorch)

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

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

本节教材地址:11.8. RMSProp算法 — 动手学深度学习 2.0.0 documentation

本节开源代码:...>d2l-zh>pytorch>chapter_optimization>rmsprop.ipynb


RMSProp算法

11.7节 中的关键问题之一,是学习率按预定时间表 \mathcal{O}(t^{-\frac{1}{2}}) 显著降低。 虽然这通常适用于凸问题,但对于深度学习中遇到的非凸问题,可能并不理想。 但是,作为一个预处理器,Adagrad算法按坐标顺序的适应性是非常可取的。

(Tieleman and Hinton, 2012) 建议以RMSProp算法作为将速率调度与坐标自适应学习率分离的简单修复方法。 问题在于,Adagrad算法将梯度 \mathbf{g}_t 的平方累加成状态矢量 \mathbf{s}_t = \mathbf{s}_{t-1} + \mathbf{g}_t^2 。 因此,由于缺乏规范化,没有约束力, \mathbf{s}_t 持续增长,几乎上是在算法收敛时呈线性递增。

解决此问题的一种方法是使用 \mathbf{s}_t / t 。 对 \mathbf{g}_t 的合理分布来说,它将收敛。 遗憾的是,限制行为生效可能需要很长时间,因为该流程记住了值的完整轨迹。 另一种方法是按动量法中的方式使用泄漏平均值,即 \mathbf{s}_t \leftarrow \gamma \mathbf{s}_{t-1} + (1-\gamma) \mathbf{g}_t^2 ,其中参数 \gamma > 0 。 保持所有其它部分不变就产生了RMSProp算法。

算法

让我们详细写出这些方程式。

\begin{aligned} \mathbf{s}_t & \leftarrow \gamma \mathbf{s}_{t-1} + (1 - \gamma) \mathbf{g}_t^2, \\ \mathbf{x}_t & \leftarrow \mathbf{x}_{t-1} - \frac{\eta}{\sqrt{\mathbf{s}_t + \epsilon}} \odot \mathbf{g}_t. \end{aligned}

常数 \epsilon > 0 通常设置为 10^{-6} ,以确保我们不会因除以零或步长过大而受到影响。 鉴于这种扩展,我们现在可以自由控制学习率 \eta ,而不考虑基于每个坐标应用的缩放。 就泄漏平均值而言,我们可以采用与之前在动量法中适用的相同推理。 扩展 \mathbf{s}_t 定义可获得

\begin{aligned} \mathbf{s}_t & = (1 - \gamma) \mathbf{g}_t^2 + \gamma \mathbf{s}_{t-1} \\ & = (1 - \gamma) \left(\mathbf{g}_t^2 + \gamma \mathbf{g}_{t-1}^2 + \gamma^2 \mathbf{g}_{t-2} + \ldots, \right). \end{aligned}

同之前在 11.6节 小节一样,我们使用 1 + \gamma + \gamma^2 + \ldots, = \frac{1}{1-\gamma} 。 因此,权重总和标准化为 1 且观测值的半衰期为 \gamma^{-1} 。 让我们图像化各种数值的 \gamma 在过去40个时间步长的权重。


补充:

每个过去的梯度平方 \mathbf{g}_{t-k}^2 的权重是 \gamma^k 。随着时间步 k 的增加,权重 \gamma^k 会逐渐衰减。因此, \gamma 的值决定了历史梯度平方对当前更新的贡献程度。

  • 如果 \gamma 接近 1,权重衰减得慢,历史信息的影响持续时间长。
  • 如果 \gamma 接近 0,权重衰减得快,历史信息的影响持续时间短。

import math
import torch
from d2l import torch as d2l
d2l.set_figsize()
gammas = [0.95, 0.9, 0.8, 0.7]
for gamma in gammas:
    x = torch.arange(40).detach().numpy()
    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')
d2l.plt.xlabel('time')

 

从零开始实现

和之前一样,我们使用二次函数 f(\mathbf{x})=0.1x_1^2+2x_2^2 来观察RMSProp算法的轨迹。 回想在 11.7节 一节中,当我们使用学习率为0.4的Adagrad算法时,变量在算法的后期阶段移动非常缓慢,因为学习率衰减太快。 RMSProp算法中不会发生这种情况,因为 \eta 是单独控制的。

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

接下来,我们在深度网络中实现RMSProp算法。

def init_rmsprop_states(feature_dim):
    s_w = torch.zeros((feature_dim, 1))
    s_b = torch.zeros(1)
    return (s_w, s_b)
def rmsprop(params, states, hyperparams):
    gamma, eps = hyperparams['gamma'], 1e-6
    for p, s in zip(params, states):
        with torch.no_grad():
            s[:] = gamma * s + (1 - gamma) * torch.square(p.grad)
            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)
        p.grad.data.zero_()

我们将初始学习率设置为0.01,加权项 \gamma 设置为0.9。 也就是说, \mathbf{s} 累加了过去的 1/(1-\gamma) = 10 次平方梯度观测值的平均值。

data_iter, feature_dim = d2l.get_data_ch11(batch_size=10)
d2l.train_ch11(rmsprop, init_rmsprop_states(feature_dim),
               {'lr': 0.01, 'gamma': 0.9}, data_iter, feature_dim)

输出结果:
loss: 0.245, 0.025 sec/epoch

简洁实现

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

trainer = torch.optim.RMSprop
d2l.train_concise_ch11(trainer, {'lr': 0.01, 'alpha': 0.9},
                       data_iter)

输出结果:
loss: 0.244, 0.012 sec/epoch

小结

  • RMSProp算法与Adagrad算法非常相似,因为两者都使用梯度的平方来缩放系数。
  • RMSProp算法与动量法都使用泄漏平均值。但是,RMSProp算法使用该技术来调整按系数顺序的预处理器。
  • 在实验中,学习率需要由实验者调度。
  • 系数 \gamma 决定了在调整每坐标比例时历史记录的时长。

补充

在RMSProp算法中,系数 \gamma 决定了历史梯度平方对当前更新的贡献程度。具体来说,\gamma 决定了历史信息的保留时长:

  • 较大的 \gamma(越接近于1):保留更多历史信息,对近期梯度变化反应较慢。
  • 较小的 \gamma(越接近于0):保留较少历史信息,对近期梯度变化反应更快。

这种机制使得RMSProp能够在动态调整学习率的同时,平衡对历史梯度信息的依赖程度。

练习

  1. 如果我们设置 \gamma = 1 ,实验会发生什么?为什么?
    解:
    如果设置 
    \gamma = 1,则更新公式变为: s_t = s_{t-1}
    这意味着 
    \mathbf{s}_t 的值将不再更新,始终保持为初始值s_0,RMSProp算法失去了动态动态调整学习率的能力,也无法根据梯度的历史信息进行优化,算法无法正常工作。
    代码如下:
d2l.train_concise_ch11(trainer, {'lr': 0.01, 'alpha': 1},
                       data_iter)

输出结果:
loss: nan, 0.012 sec/epoch

2. 旋转优化问题以最小化 f(\mathbf{x}) = 0.1 (x_1 + x_2)^2 + 2 (x_1 - x_2)^2 。收敛会发生什么?
解:
RMSProp算法通过维护梯度平方的加权平均值来调整学习率,这使得它能够适应不同方向上的梯度变化,并相应地调整学习率,收敛到接近(1,1)。
代码如下:

def rmsprop_2d_rotation(x1, x2, s1, s2):
    g1, g2, eps = 4.2 * x1 - 3.8, 4.2 * x2 - 3.8, 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_rotation(x1, x2):
    return 0.1 * (x1 + x2) ** 2 + 2 * (x1 - x2) ** 2

eta, gamma = 0.4, 0.9
d2l.show_trace_2d(f_2d, d2l.train_2d(rmsprop_2d_rotation))

输出结果:
epoch 20, x1: 0.840102, x2: 0.904762

3. 试试在真正的机器学习问题上应用RMSProp算法会发生什么,例如在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, alpha, num_epochs = 0.01, 0.9, 10
optimizer = torch.optim.RMSprop(net.parameters(), lr=lr, alpha=alpha)
train_ch6_optimizer(net, optimizer, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

输出结果:
loss 0.262, train acc 0.900, test acc 0.883
22394.2 examples/sec on cpu

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

输出结果:
loss 0.308, train acc 0.886, test acc 0.875
25487.7 examples/sec on cpu

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

输出结果:
loss 0.388, train acc 0.863, test acc 0.848
24416.1 examples/sec on cpu

4. 随着优化的进展,需要调整 \gamma 吗?RMSProp算法对此有多敏感?
解:
在大多数情况下,RMSProp算法的 
\gamma 是一个相对稳定的超参数。默认值通常为0.9。这些值在许多任务中表现良好,因此在训练过程中通常不需要动态调整 \gamma 
但如果训练过程中发现算法对历史梯度信息的依赖过强(例如收敛速度过慢),可以尝试略微降低 
\gamma 的值,以增加对近期梯度的敏感性。 反之,如果发现算法对近期梯度变化过于敏感(例如出现震荡),可以尝试增加 \gamma 的值。
RMSProp算法对 
\gamma 的选择较为敏感。不同的 \gamma 值会显著影响优化过程。例如,较高的 \gamma 值会使算法更多地依赖历史梯度信息,适合需要长期记忆的场景;而较低的 \gamma 值则更适合对近期梯度变化更敏感的任务。


http://www.kler.cn/a/586452.html

相关文章:

  • 【YOLOv8】YOLOv8改进系列(5)----替换主干网络之EfficientFormerV2
  • 麒麟系统利用pycharm生成deb文件
  • 机器视觉条形光源应用解析
  • UDP__网络编程——Linux
  • SQLark 实战 | 如何从Excel、csv、txt等外部文件进行数据导入
  • 《Python实战进阶》No23: 使用 Selenium 自动化浏览器操作
  • Go string 字符串底层逻辑
  • 用Python玩转Hyperledger:构建企业级区块链解决方案
  • HTML5-基础知识
  • Android 底部 Tab 导航终极指南:封装 BottomTabHelper 实现高效、灵活的 Tab 布局
  • kafka rocketmq rabbitmq 都是怎么实现顺序消费的
  • C#控制台应用程序学习——3.11
  • 如何选择适合您智能家居解决方案的通信协议?
  • 《GitHub网路访问不稳定:解决办法》:此文为AI自动生成
  • SQL语言的编译原理
  • leetcode top100矩阵题73.54.48.240
  • 【react】react中的<></>和React Fragment的用法及区别详解
  • 数据结构与算法——数据结构4
  • apollo3录音到wav播放解决方法
  • 投资早报 3.14