Adam梯度下降优化算法：原理剖析与工程实践中的关键调参技巧

1次阅读

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

在深度学习模型训练过程中，我们常常会遇到以下问题：

梯度消失或爆炸导致训练困难
学习率难以选择，过大导致震荡，过小导致收敛缓慢
不同参数可能需要不同的学习速率
噪声梯度导致优化过程不稳定

传统的优化算法如 SGD(随机梯度下降)虽然简单直接，但对学习率的选择非常敏感，且对所有参数使用相同的学习率。Adagrad 虽然能自适应调整学习率，但会累积所有历史梯度导致学习率过早衰减。这些局限性促使了更先进的优化算法如 Adam 的出现。

Adam(Adaptive Moment Estimation)结合了动量 (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$$

偏差校正：由于初始时刻的 m 和 v 会被初始化为 0，导致在训练初期会有偏差，因此需要进行校正：

$$\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$$

其中，$\beta_1$ 和 $\beta_2$ 是衰减率，通常设为 0.9 和 0.999；$\epsilon$ 是一个很小的数 (如 1e-8) 用于数值稳定。

我们在 MNIST 数据集上对比了 SGD、Adagrad 和 Adam 三种优化算法的表现：

训练损失曲线：
Adam 表现出最快的初始收敛速度
Adagrad 初期收敛快但后期学习率衰减过快
SGD 收敛最慢但最终能达到与 Adam 相当的性能
验证准确率：
Adam 在 100 个 epoch 内达到 98% 以上的准确率
Adagrad 在 150 个 epoch 达到类似性能
SGD 需要约 200 个 epoch 才能达到 98% 准确率

以下是 PyTorch 中实现 Adam 优化器的示例代码：

import torch
import math

class CustomAdam:
    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0):
        self.params = list(params)
        self.lr = lr
        self.beta1, self.beta2 = betas
        self.eps = eps
        self.weight_decay = weight_decay
        self.m = [torch.zeros_like(p) for p in self.params]
        self.v = [torch.zeros_like(p) for p in self.params]
        self.t = 0

    def step(self):
        self.t += 1
        for i, (p, m, v) in enumerate(zip(self.params, self.m, self.v)):
            if p.grad is None:
                continue

            grad = p.grad.data
            if self.weight_decay != 0:  # 权重衰减
                grad.add_(p.data, alpha=self.weight_decay)

            # 更新一阶和二阶矩估计
            m.mul_(self.beta1).add_(grad, alpha=1-self.beta1)
            v.mul_(self.beta2).addcmul_(grad, grad, value=1-self.beta2)

            # 偏差校正
            m_hat = m / (1 - self.beta1**self.t)
            v_hat = v / (1 - self.beta2**self.t)

            # 更新参数
            p.data.addcdiv_(m_hat, v_hat.sqrt().add_(self.eps), value=-self.lr)

    def zero_grad(self):
        for p in self.params:
            if p.grad is not None:
                p.grad.detach_()
                p.grad.zero_()