AI梯度下降优化实战：解决训练过程中的收敛难题

1次阅读

没有评论

共计 3199 个字符，预计需要花费 8 分钟才能阅读完成。

背景痛点：传统梯度下降的局限性
优化器技术对比
PyTorch 实战：带学习率热重启的 AdamW
性能验证：CIFAR-10 测试
避坑指南
延伸思考

在训练复杂神经网络时，传统梯度下降（SGD）常遇到三个典型问题：

鞍点停滞：在高维非凸函数中，鞍点（梯度为零但非极值点）的数量远多于局部最小值。SGD 因梯度为零会停止更新，例如在 ResNet-50 的训练中，约 15% 的停滞来自鞍点而非局部最优。
学习率敏感：固定学习率下，平坦区域需要大学习率快速通过，而陡峭区域需要小学习率避免震荡。手工调整学习率往往需要数十次试验。
梯度消失 / 爆炸：当网络层数较深（如 Transformer 的 12 层以上），梯度模长可能指数级衰减或增长，导致参数更新失效。

Vanilla SGD:
$$\theta_{t+1} = \theta_t – \eta \nabla_\theta J(\theta_t)$$
直接使用当前梯度更新，简单但容易震荡。
Momentum（动量法）:
$$v_t = \gamma v_{t-1} + \eta \nabla_\theta J(\theta_t)$$
$$\theta_{t+1} = \theta_t – v_t$$
引入动量项 $\gamma$（通常 0.9）缓解震荡，适合损失曲面存在长峡谷的情况。
Adam:
$$m_t = \beta_1 m_{t-1} + (1-\beta_1)\nabla_\theta J(\theta_t)$$
$$v_t = \beta_2 v_{t-1} + (1-\beta_2)(\nabla_\theta J(\theta_t))^2$$
$$\hat{m}t = m_t / (1-\beta_1^t)$$
$$\hat{v}_t = v_t / (1-\beta_2^t)$$
$$\theta + \epsilon)$$
自适应调整各参数学习率，默认超参 $\beta_1=0.9$, $\beta_2=0.999$。} = \theta_t – \eta \hat{m}_t / (\sqrt{\hat{v}_t

SGD：小型数据集、凸优化问题
Momentum：RNN 类时序模型
Adam：默认首选，尤其适合超参搜索成本高的场景

import torch
from torch.optim import Optimizer

class AdamW(Optimizer):
    """ 实现 AdamW 优化器（带权重解耦）Args:
        params: 待优化参数组
        lr: 初始学习率 (default: 1e-3)
        betas: 动量系数 (default: (0.9, 0.999))
        weight_decay: 权重衰减系数 (default: 0.01)
        restart_period: 学习率热重启周期 (default: 10)
    """
    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), weight_decay=0.01, restart_period=10):
        defaults = dict(lr=lr, betas=betas, weight_decay=weight_decay)
        super().__init__(params, defaults)
        self.restart_period = restart_period
        self.step_count = 0

    def step(self, closure=None):
        """执行单次优化步骤"""
        loss = None
        if closure is not None:
            loss = closure()

        for group in self.param_groups:
            for p in group['params']:
                if p.grad is None:
                    continue

                # 梯度裁剪（处理异常值）grad = torch.clamp(p.grad, -10, 10)

                # Adam 更新逻辑
                state = self.state[p]
                if len(state) == 0:
                    state['step'] = 0
                    state['exp_avg'] = torch.zeros_like(p)
                    state['exp_avg_sq'] = torch.zeros_like(p)

                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
                beta1, beta2 = group['betas']

                state['step'] += 1
                bias_correction1 = 1 - beta1 ** state['step']
                bias_correction2 = 1 - beta2 ** state['step']

                # 更新一阶和二阶动量
                exp_avg.mul_(beta1).add_(grad, alpha=1-beta1)
                exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1-beta2)

                # 应用学习率热重启
                t = state['step'] % self.restart_period
                current_lr = group['lr'] * (0.5 + 0.5 * math.cos(math.pi * t / self.restart_period))

                # 参数更新（权重解耦）p.data.mul_(1 - group['weight_decay'] * current_lr)
                denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(1e-8)
                p.data.addcdiv_(exp_avg, denom, value=-current_lr / bias_correction1)

        self.step_count += 1
        return loss

权重衰减 vs L2 正则化：
数学等价但实现不同：L2 正则化修改损失函数 $L'(\theta)=L(\theta)+\lambda|\theta|^2$，而权重衰减直接修改更新规则 $\theta_{t+1}=(1-\eta\lambda)\theta_t-\eta\nabla L(\theta_t)$
当使用动量或自适应学习率时，两者不等价。AdamW 通过解耦权重衰减实现正确效果

model = ResNet18()
optimizers = {'SGD': torch.optim.SGD(model.parameters(), lr=0.1),
    'Adam': torch.optim.Adam(model.parameters(), lr=0.001),
    'AdamW': AdamW(model.parameters(), lr=0.001, weight_decay=0.01)
}