学习率调度策略

一句话概述

学习率（Learning Rate）是深度学习中最关键的超参数——太大则无法收敛（震荡甚至发散），太小则收敛极慢。学习率调度（Learning Rate Scheduling）的核心思想是在训练过程中动态调整学习率：前期使用较大学习率快速逼近最优点，后期逐步减小学习率精细搜索。常见策略包括：阶梯衰减（Step Decay）、指数衰减（Exponential Decay）、余弦退火（Cosine Annealing）、预热（Warmup）和循环学习率（Cyclical LR）。现代训练中，Warmup + Cosine Annealing是Transformer类模型的标准配置——先用少量步数将学习率从极小值线性提升到峰值（预热），再用余弦曲线将学习率衰减到接近0（退火）。

💡 核心要点：①学习率调度是平衡收敛速度和最终效果的艺术——前期大步快走，后期小步精调 ②Warmup预热防止训练初期的不稳定，是Transformer训练的必备技巧 ③余弦退火是最常用的衰减策略，相比阶梯衰减更平滑 ④循环学习率通过周期性振荡帮助跳出局部最优 ⑤好的调度策略能让模型在相同训练步数下获得更低的最终损失

教学与演示

一、学习率的核心作用与基本调度

是什么（定义）：学习率η控制着每次参数更新时的步长：θ_t+1 = θ_t - η · ∇L(θ_t)。在随机梯度下降中，梯度∇L(θ_t)是"前进方向"，学习率η是"前进速度"。学习率调度器在训练过程中按预定规则改变η的值，通常从大到小——初始值η_0约为1e-3到1e-1（取决于优化器），最终衰减三个数量级以上。

大白话 学习率就是"迈步子的大小"。如果步子太大，可能直接跨过最低点甚至从山谷另一边滚出去（震荡发散）；如果步子太小，走到天黑还没到终点（收敛慢）。调度策略是说：一开始山谷还很远时大步流星地走；快接近谷底时换成小碎步；刚开始走时先"热身"慢慢加速（warmup）；如果觉得陷入了一个假谷底，就左右晃一晃看看能不能跳出去（循环学习率）。

为什么（原理）：基于SGD的收敛理论，当步长逐步减小时，SGD以概率1收敛到局部最优。实际情况中：①训练初期参数离最优很远，大的学习率能快速减少损失；②训练后期参数接近最优，需要小步长精细调整，否则会在最优附近震荡；③过大的学习率导致梯度的方差主导更新方向，模型无法收敛；④过小的学习率导致参数更新近乎停滞，表现为loss plateaus（损失平台）。

import numpy as np

# 实现常见的学习率调度器
# 展示不同调度策略的学习率变化曲线

class LRScheduler:
    """学习率调度器基类"""
    def __init__(self, initial_lr):
        self.initial_lr = initial_lr
        self.history = []

    def get_lr(self, step):
        raise NotImplementedError

    def simulate(self, total_steps):
        self.history = [self.get_lr(s) for s in range(total_steps)]
        return self.history


class StepDecay(LRScheduler):
    """阶梯衰减：每隔step_size步，学习率乘以gamma"""
    def __init__(self, initial_lr, step_size, gamma=0.1):
        super().__init__(initial_lr)
        self.step_size = step_size
        self.gamma = gamma

    def get_lr(self, step):
        return self.initial_lr * (self.gamma ** (step // self.step_size))


class ExponentialDecay(LRScheduler):
    """指数衰减：lr = lr_0 * gamma^step"""
    def __init__(self, initial_lr, gamma=0.999):
        super().__init__(initial_lr)
        self.gamma = gamma

    def get_lr(self, step):
        return self.initial_lr * (self.gamma ** step)


class CosineAnnealing(LRScheduler):
    """余弦退火：按余弦曲线从初始值衰减到0"""
    def __init__(self, initial_lr, T_max, eta_min=0):
        super().__init__(initial_lr)
        self.T_max = T_max
        self.eta_min = eta_min

    def get_lr(self, step):
        if step >= self.T_max:
            return self.eta_min
        return self.eta_min + 0.5 * (self.initial_lr - self.eta_min) * (1 + np.cos(np.pi * step / self.T_max))


class WarmupCosine(LRScheduler):
    """预热+余弦退火：前warmup_steps步线性增长，后续余弦衰减"""
    def __init__(self, initial_lr, warmup_steps, T_max, eta_min=0):
        super().__init__(initial_lr)
        self.warmup_steps = warmup_steps
        self.T_max = T_max
        self.eta_min = eta_min

    def get_lr(self, step):
        if step < self.warmup_steps:
            # 线性预热：从接近0线性增长到initial_lr
            return self.initial_lr * (step + 1) / self.warmup_steps
        elif step >= self.T_max:
            return self.eta_min
        else:
            # 余弦退火
            cos_inner = np.pi * (step - self.warmup_steps) / (self.T_max - self.warmup_steps)
            return self.eta_min + 0.5 * (self.initial_lr - self.eta_min) * (1 + np.cos(cos_inner))


class CyclicalLR(LRScheduler):
    """循环学习率：在[min_lr, max_lr]之间周期性三角波振荡"""
    def __init__(self, initial_lr, min_lr, step_size_up, step_size_down=None):
        super().__init__(initial_lr)
        self.min_lr = min_lr
        self.step_size_up = step_size_up
        self.step_size_down = step_size_down if step_size_down else step_size_up

    def get_lr(self, step):
        cycle = step // (self.step_size_up + self.step_size_down)
        pos = step % (self.step_size_up + self.step_size_down)
        if pos < self.step_size_up:
            # 上升阶段
            return self.min_lr + (self.initial_lr - self.min_lr) * pos / self.step_size_up
        else:
            # 下降阶段
            pos_down = pos - self.step_size_up
            return self.initial_lr - (self.initial_lr - self.min_lr) * pos_down / self.step_size_down


print("=== 学习率调度策略：曲线对比 ===\n")

total_steps = 1000
warmup_steps = 100

schedulers = {
    'Step (step=200, gamma=0.5)': StepDecay(0.1, 200, 0.5),
    'Exponential (gamma=0.997)': ExponentialDecay(0.1, 0.997),
    'Cosine Annealing': CosineAnnealing(0.1, T_max=total_steps),
    'Warmup + Cosine': WarmupCosine(0.1, warmup_steps, total_steps),
    'Cyclical (up=200)': CyclicalLR(0.1, 1e-4, 200),
}

for name, scheduler in schedulers.items():
    lr_history = scheduler.simulate(total_steps)
    final_lr = lr_history[-1]
    max_lr = max(lr_history)
    print(f"  {name:25s}: 初始={lr_history[0]:.4f}, 最大={max_lr:.4f}, 最终={final_lr:.6f}")

print("\n→ 不同调度策略的学习率变化曲线各具特点")
print("→ Warmup+Cosine是现代Transformer训练的标准配置")

二、Warmup预热——Transformer训练的必备技巧

是什么（定义）：Warmup（预热）指训练开始时先用若干步将学习率从极小值（或0）线性增长到目标学习率。典型的Transformer配置：前4000步（或10k步）学习率从0线性增长到峰值（如1e-3），之后再按余弦曲线衰减。预热步数通常占总步数的5%-15%。

大白话 Warmup就是"先慢跑再冲刺"。刚开跑时如果直接全速冲刺（大学习率），容易扭伤（梯度不稳定）。先慢慢加速让身体适应（参数分布调整），等状态稳定了再提上目标速度。对于Transformer尤其重要——因为它有一堆残差连接和LayerNorm，初始参数和梯度都比较"野"，需要预热来稳定。

为什么（原理）：Transformer需要Warmup的原因：①训练初期参数分布混乱，残差连接前的方差很大，大学习率会导致梯度爆炸；②Layer Normalization在训练初期统计量不稳定，需要时间来建立合理的running statistics；③多头注意力在初始化时各头的梯度差异大，大学习率会放大这种差异导致训练不稳定。预热给网络"缓冲时间"——参数先在小步更新下逐渐调整到合理范围，之后再用大学习率加速。

import numpy as np

# 模拟warmup对训练稳定性的影响
# 对比有无warmup时梯度和损失的演化

def simulate_training_with_warmup(total_steps=500, warmup_steps=50, peak_lr=0.01, noise_level=0.3):
    """模拟一个简单二次优化问题，观察warmup的效果"""
    np.random.seed(42)
    
    # 真实最优参数
    theta_true = np.array([1.0, -0.5, 2.0, 0.8, -1.2])
    dim = len(theta_true)
    
    # 初始化参数（随机初始化，离最优较远）
    theta = np.random.randn(dim) * 2.0
    
    # 损失函数：二次型 f(theta) = 0.5 * ||theta - theta_true||^2
    def loss(theta):
        return 0.5 * np.sum((theta - theta_true) ** 2)
    
    def gradient(theta):
        return theta - theta_true
    
    # 无warmup训练
    theta_no_warmup = theta.copy()
    losses_no_warmup = []
    grad_norms_no_warmup = []
    
    for t in range(total_steps):
        lr = peak_lr  # 固定学习率，无预热
        grad = gradient(theta_no_warmup) + np.random.randn(dim) * noise_level
        grad_norm = np.linalg.norm(grad)
        theta_no_warmup -= lr * grad
        losses_no_warmup.append(loss(theta_no_warmup))
        grad_norms_no_warmup.append(grad_norm)
    
    # 有warmup训练
    theta_warmup = theta.copy()
    losses_warmup = []
    grad_norms_warmup = []
    
    for t in range(total_steps):
        if t < warmup_steps:
            lr = peak_lr * (t + 1) / warmup_steps  # 线性预热
        else:
            lr = peak_lr  # 预热后使用目标学习率
        
        grad = gradient(theta_warmup) + np.random.randn(dim) * noise_level
        grad_norm = np.linalg.norm(grad)
        theta_warmup -= lr * grad
        losses_warmup.append(loss(theta_warmup))
        grad_norms_warmup.append(grad_norm)
    
    return losses_no_warmup, losses_warmup, grad_norms_no_warmup, grad_norms_warmup


# 执行模拟
losses_nw, losses_w, grads_nw, grads_w = simulate_training_with_warmup(
    total_steps=500, warmup_steps=50, peak_lr=0.01, noise_level=0.3
)

print("=== Warmup预热效果：训练稳定性对比 ===\n")

print("【损失函数值对比】")
print(f"  无预热 - 初始损失: {losses_nw[0]:.4f}")
print(f"  无预热 - 第10步: {losses_nw[9]:.4f}")
print(f"  无预热 - 最终损失: {losses_nw[-1]:.6f}")
print(f"  有预热 - 初始损失: {losses_w[0]:.4f}")
print(f"  有预热 - 第10步: {losses_w[9]:.4f}")
print(f"  有预热 - 最终损失: {losses_w[-1]:.6f}")

print(f"\n【梯度范数对比（前10步）】")
print(f"  无预热梯度范数: {[round(g, 3) for g in grads_nw[:10]]}")
print(f"  有预热梯度范数: {[round(g, 3) for g in grads_w[:10]]}")

# 统计稳定性指标
early_loss_std_nw = np.std(losses_nw[:50])
early_loss_std_w = np.std(losses_w[:50])
print(f"\n【前50步损失标准差（稳定性指标）】")
print(f"  无预热: {early_loss_std_nw:.4f}")
print(f"  有预热: {early_loss_std_w:.4f}")
print(f"  稳定性提升: {(1 - early_loss_std_w / early_loss_std_nw) * 100:.1f}%")

print("\n→ Warmup能在训练初期减少震荡，提高稳定性")
print("→ 虽然最终损失差异不大，但预热训练更平滑可靠")

三、高级调度策略与实战选择

是什么（定义）：除了基础的衰减曲线，还有多种进阶策略：①OneCycleLR——学习率先上升后下降，在单个周期内覆盖整个训练过程，配合动量反向变化；②ReduceLROnPlateau——当验证损失停滞（plateau）时降低学习率，是一种自适应策略；③多项式衰减——按幂函数曲线衰减lr_t = lr_0 * (1 - t/T)^power；④分段常数——手动指定每段的学习率。

大白话 OneCycleLR的哲学是"先冲后收"——像赛车手过弯，直线加速（学习率上升），弯道减速（学习率下降）。这样可以更快地遍历参数空间，尤其在训练初期快速逃离"高原区"。ReduceLROnPlateau则是"看菜下饭"——当validation loss不降了，说明当前学习率太大在最优附近震荡，就减小学习率。

怎么做（选择指南）：

import numpy as np

# 实现更多调度策略并对比
# 包含OneCycleLR和多项式衰减

class OneCycleLR(LRScheduler):
    """OneCycle学习率：前一半上升，后一半下降"""
    def __init__(self, initial_lr, max_lr, total_steps, pct_start=0.3):
        super().__init__(initial_lr)
        self.max_lr = max_lr
        self.total_steps = total_steps
        self.step_size_up = int(total_steps * pct_start)
        self.step_size_down = total_steps - self.step_size_up

    def get_lr(self, step):
        if step < self.step_size_up:
            # 上升阶段：余弦式上升
            cos_val = np.cos(np.pi * step / self.step_size_up)
            return self.initial_lr + 0.5 * (self.max_lr - self.initial_lr) * (1 - cos_val)
        else:
            # 下降阶段：余弦式下降到initial_lr的0.01倍
            pos = step - self.step_size_up
            cos_val = np.cos(np.pi * pos / self.step_size_down)
            return self.initial_lr * 0.01 + 0.5 * (self.max_lr - self.initial_lr * 0.01) * (1 + cos_val)


class PolynomialDecay(LRScheduler):
    """多项式衰减：lr = lr_0 * (1 - step/T_max)^power"""
    def __init__(self, initial_lr, T_max, power=1.0, eta_min=0):
        super().__init__(initial_lr)
        self.T_max = T_max
        self.power = power
        self.eta_min = eta_min

    def get_lr(self, step):
        if step >= self.T_max:
            return self.eta_min
        return (self.initial_lr - self.eta_min) * (1 - step / self.T_max) ** self.power + self.eta_min


# 对比所有调度策略在关键时间点的学习率
print("=== 高级学习率调度策略 ===\n")

total = 1000
warmup = 100

all_schedulers = {
    'Warmup+Cosine': WarmupCosine(0.1, warmup, total),
    'OneCycle': OneCycleLR(1e-4, 0.1, total, pct_start=0.3),
    'Step(gamma=0.1)': StepDecay(0.1, 250, 0.1),
    'Cosine': CosineAnnealing(0.1, total),
    'Poly(power=2)': PolynomialDecay(0.1, total, power=2.0),
    'Exponential(0.997)': ExponentialDecay(0.1, 0.997),
}

print(f"调度策略在关键步数的学习率：\n")
print(f"{'调度器':<20s} {'step=0':>8s} {'step=100':>8s} {'step=500':>8s} {'step=999':>8s}")
print("-" * 56)

for name, sched in all_schedulers.items():
    lrs = [sched.get_lr(s) for s in [0, 99, 499, 999]]
    print(f"  {name:<18s} {lrs[0]:8.6f} {lrs[1]:8.6f} {lrs[2]:8.6f} {lrs[3]:8.6f}")

print("\n→ Warmup+Cosine：蓝色——先上升后平滑下降，初始值为0然后线性增加")
print("→ OneCycle：红色——先上升到峰值再下降，适合快速实验")
print("→ Step：离散跳跃下降，每250步衰减10倍")
print("→ Cosine：从最大值平滑降到0，没有预热阶段")

概念关系图谱

重点答疑

Q1: 为什么学习率不能一直保持很大？

大学习率在训练初期有益——快速降低损失、越过"高原区"。但接近最优时，大学习率会导致参数在最优附近来回震荡而无法精确收敛。从SGD收敛理论看，需要满足∑η_t → ∞（保证能走足够远）和∑η_t² < ∞（保证能停下来）这两个条件，只有递减学习率能同时满足。

Q2: Warmup预热多少步合适？

经验法则：占总训练步数的5%-15%。具体参考：①BERT原论文4000步预热（总约1M步，0.4%）；②GPT-3使用前375M tokens作为warmup（总300B tokens）；③Vision Transformer使用10k步预热（总约300k步，3%）。核心是让网络在前几千步稳定下来。预热太短则不足以稳定，太长则浪费训练时间。

Q3: 余弦退火比阶梯衰减好在哪里？

余弦退火在衰减初期较慢（微积分意义上dη/dt在t=0附近为0），给予了充分的大学习率探索时间；在中后期加速衰减，使模型快速聚焦精细搜索。而阶梯衰减在衰减点突然跳跃，可能导致损失突然上升（loss spike）。此外余弦退火是平滑的，更容易配合Warmup形成连续的"上升-下降"曲线。

章节单词汇总