BP算法梯度下降实战：从数学原理到工程调优

1次阅读

没有评论

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

在深层神经网络训练中，标准的梯度下降算法（Batch Gradient Descent）存在两个主要问题：

梯度消失 / 爆炸问题 ：
在反向传播过程中，梯度会随着层数的增加而指数级缩小或放大。数学上可以表示为：
$$\frac{\partial L}{\partial W^{(l)}} = \frac{\partial L}{\partial a^{(L)}} \prod_{k=l}^{L-1} (W^{(k+1)})^T \odot \sigma'(z^{(k)})$$
其中连乘操作导致梯度不稳定
固定学习率的局限性 ：
统一的学习率 η 难以适应所有参数更新需求，特别是在损失曲面崎岖时容易陷入局部最优或震荡

引入物理动量概念，累积历史梯度方向
更新公式：
$$v_t = \gamma v_{t-1} + \eta \nabla_\theta J(\theta)$$
$$\theta = \theta – v_t$$

自适应调整各参数的学习率
通过梯度平方的指数移动平均调整步长：
$$E[g^2]t = \beta E[g^2] + (1-\beta)g_t^2$$
$$\theta_{t+1} = \theta_t – \frac{\eta}{\sqrt{E[g^2]_t + \epsilon}}g_t$$

结合了 Momentum 和 RMSprop 的优点，包含：

一阶矩估计 （梯度均值）：
$$m_t = \beta_1 m_{t-1} + (1-\beta_1)g_t$$
二阶矩估计 （梯度方差）：
$$v_t = \beta_2 v_{t-1} + (1-\beta_2)g_t^2$$
偏差校正：
$$\hat{m}_t = \frac{m_t}{1-\beta_1^t}$$
$$\hat{v}_t = \frac{v_t}{1-\beta_2^t}$$
参数更新：
$$\theta_{t+1} = \theta_t – \frac{\eta}{\sqrt{\hat{v}_t} + \epsilon}\hat{m}_t$$

import torch
from torch.optim import Optimizer

class WarmupAdam(Optimizer):
    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8,
                 weight_decay=0, warmup_steps=4000, max_grad_norm=1.0):
        defaults = dict(lr=lr, betas=betas, eps=eps,
                        weight_decay=weight_decay,
                        warmup_steps=warmup_steps,
                        max_grad_norm=max_grad_norm)
        super().__init__(params, defaults)

    def step(self, closure=None):
        """Performs a single optimization step"""
        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 = p.grad.data
                if group['max_grad_norm'] > 0:
                    grad = torch.nn.utils.clip_grad_norm_(p, group['max_grad_norm'])

                # 学习率预热
                step_num = self.state[p].get('step', 0)
                warmup_factor = min(step_num / group['warmup_steps'], 1.0)
                current_lr = group['lr'] * warmup_factor

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

                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']

                # 权重衰减
                if group['weight_decay'] > 0:
                    grad = grad.add(p.data, alpha=group['weight_decay'])

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

                # 计算更新量
                denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])
                step_size = current_lr / bias_correction1

                # 参数更新
                p.data.addcdiv_(exp_avg, denom, value=-step_size)

        return loss

学习率与 batch size
当增大 batch size 时，应同步增大学习率（线性缩放规则）
实践公式：$\eta_{new} = \eta_{base} \times \frac{batch_size_{new}}{batch_size_{base}}$
验证集震荡处理
检查数据分布是否一致
尝试增加 L2 正则化强度
降低学习率并增加训练轮次
混合精度训练
使用 torch.cuda.amp 自动管理梯度缩放
注意检查梯度 underflow 情况