深度学习优化算法实战：从梯度下降到Adam/RMSprop的演进与避坑指南

1次阅读

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

深度学习的核心是通过反向传播不断调整模型参数，使得损失函数最小化。传统的梯度下降（Gradient Descent, GD）虽然直观，但在实际应用中会遇到不少问题：

非凸函数的震荡问题：现实中的损失函数往往是高维非凸的，存在大量局部极小值。GD 容易陷入这些局部最优或者在鞍点附近震荡。
内存与收敛速度的矛盾：
批量梯度下降（BGD）需要计算整个数据集的梯度，内存消耗大但收敛稳定
随机梯度下降（SGD）每次只用一个样本，内存友好但波动剧烈
小批量梯度下降（Mini-batch GD）是折中方案，但 batch size 的选择又成了新问题

算法	参数更新公式	核心特点
SGD	$\theta_{t+1} = \theta_t – \eta \nabla J(\theta_t)$	基础版本，学习率固定
Momentum	$v_t = \gamma v_{t-1} + \eta \nabla J(\theta_t)$
$\theta_{t+1} = \theta_t – v_t$	引入动量项加速收敛
RMSprop	$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$	自适应调整学习率
Adam	$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 numpy as np
import matplotlib.pyplot as plt

def rosenbrock(x, y):
    return (1 - x)**2 + 100*(y - x**2)**2

# 不同优化器的轨迹可视化代码示例（伪代码）# 这里展示 Adam 和 SGD 的优化路径对比
plt.contour(X, Y, Z, levels=np.logspace(-1, 3, 20))
plt.plot(adam_path[:,0], adam_path[:,1], 'r-', label='Adam')
plt.plot(sgd_path[:,0], sgd_path[:,1], 'b--', label='SGD')
plt.legend()

import torch
from torchvision import datasets, transforms

# 数据归一化
transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

train_loader = torch.utils.data.DataLoader(datasets.MNIST('../data', train=True, download=True, transform=transform),
    batch_size=64, shuffle=True)

class SimpleCNN(torch.nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 32, 3, 1)  # 输入通道 1，输出 32，3x3 卷积核
        self.conv2 = torch.nn.Conv2d(32, 64, 3, 1)
        self.fc1 = torch.nn.Linear(9216, 128)  # 64*12*12=9216
        self.fc2 = torch.nn.Linear(128, 10)

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.max_pool2d(x, 2)
        x = torch.relu(self.conv2(x))
        x = torch.max_pool2d(x, 2)
        x = torch.flatten(x, 1)
        x = torch.relu(self.fc1(x))
        return self.fc2(x)

def train(model, optimizer, epochs=5):
    losses = []
    for epoch in range(epochs):
        for batch_idx, (data, target) in enumerate(train_loader):
            optimizer.zero_grad()
            output = model(data)
            loss = torch.nn.functional.cross_entropy(output, target)
            loss.backward()

            # 梯度裁剪（避坑点 1）torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

            optimizer.step()

            if batch_idx % 100 == 0:
                losses.append(loss.item())
                print(f'Epoch: {epoch} | Loss: {loss.item():.4f}')
    return losses

# 测试不同优化器
sgd_loss = train(SimpleCNN(), torch.optim.SGD(model.parameters(), lr=0.01))
adam_loss = train(SimpleCNN(), torch.optim.Adam(model.parameters(), lr=0.001))

beta1（默认 0.9）：控制一阶矩估计的衰减率，影响动量大小
beta2（默认 0.999）：控制二阶矩估计的衰减率，影响自适应学习率
epsilon（默认 1e-8）：数值稳定项，防止除零

# 更保守的参数设置（适合不稳定任务）optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999), eps=1e-8)

# Transformer 中常用的线性 warm-up
optimizer = torch.optim.Adam(model.parameters(), lr=0)
scheduler = torch.optim.lr_scheduler.LambdaLR(
    optimizer,
    lambda step: min(step / warmup_steps, 1.0)
)

梯度爆炸 ：使用clip_grad_norm_ 或clip_grad_value_
batch size 与学习率：当 batch 扩大 k 倍时，学习率也应线性缩放（但不超过上限）
```
lr = base_lr * batch_size / 256  # 以 256 为基准
```
损失震荡：尝试减小学习率或增加 batch size

在小样本场景下，Adam 可能因为二阶矩估计不准而表现不佳。如何改进？可能的思路：