实施学习率调度

调整训练期间的学习率能够增强深度学习模型优化效果。实际实施学习率调度方法通常会用到PyTorch等常用深度学习框架。

大多数深度学习库都提供了便捷的方式，可以直接将学习率调度器关联到优化器。通常的工作流程包括：

1. 使用初始学习率初始化优化器（例如SGD、Adam）。
2. 初始化调度器，并将其与优化器关联，然后指定调度策略的参数。
3. 在训练循环中的适当位置（通常在每个epoch之后，但有时在每个批次之后）调用调度器的step()方法。

接下来我们考察如何实施前面讨论的一些常见调度方法。

使用PyTorch学习率调度器

PyTorch的torch.optim.lr_scheduler模块中提供了多种内置学习率调度器。我们将演示几个常用的。

首先，假设您已定义好模型和优化器，例如：

import torch
import torch.optim as optim
from torch.optim.lr_scheduler import StepLR, ExponentialLR, CosineAnnealingLR

# 假设'model'是您定义的神经网络
# 初始学习率
initial_lr = 0.01

# 初始化优化器（例如Adam）
optimizer = optim.Adam(model.parameters(), lr=initial_lr)

# 接下来我们将定义调度器...

现在，我们关联不同的调度器。

步进衰减（StepLR）

步进衰减会在每经过step_size个epoch后，将学习率乘以一个因子（gamma）进行降低。

# 定义StepLR调度器
# 每step_size=10个epoch将学习率衰减gamma=0.1
scheduler_step = StepLR(optimizer, step_size=10, gamma=0.1)

# 在训练循环中的用法示例（简化）：
# num_epochs = 50
# for epoch in range(num_epochs):
#     # --- 训练阶段 ---
#     # model.train()
#     # 遍历数据加载器中的每个批次：
#     #     optimizer.zero_grad()
#     #     outputs = model(batch.features)
#     #     loss = compute_loss(outputs, batch.labels)
#     #     loss.backward()
#     #     optimizer.step()
#     # --- 训练阶段结束 ---
#
#     # 在每个epoch后更新学习率
#     scheduler_step.step()
#
#     current_lr = optimizer.param_groups[0]['lr']
#     print(f"Epoch {epoch+1}: Current LR = {current_lr:.6f}")

该调度器将在epoch 1-10期间保持学习率为$0.01$，然后在epoch 11-20期间将其降至$0.001$，接着在epoch 21-30期间降至$0.0001$，依此类推。

StepLR学习率在50个epoch内的衰减情况，初始学习率为0.01，步长为10，衰减因子为0.1。Y轴为对数刻度。

指数衰减（ExponentialLR）

指数衰减在每个epoch之后，将学习率乘以一个因子（gamma）。

# 定义ExponentialLR调度器
# 每个epoch将学习率衰减gamma=0.95
scheduler_exp = ExponentialLR(optimizer, gamma=0.95)

# 在训练循环中的用法示例（简化）：
# num_epochs = 50
# for epoch in range(num_epochs):
#     # --- 训练阶段（同上）---
#
#     # 在每个epoch后更新学习率
#     scheduler_exp.step()
#
#     current_lr = optimizer.param_groups[0]['lr']
#     print(f"Epoch {epoch+1}: Current LR = {current_lr:.6f}")

在这里，学习率与步进衰减相比下降得更平滑：$0.01$， $0.01 \times 0.95$， $0.01 \times 0.95^2$，依此类推。

ExponentialLR学习率在50个epoch内的衰减情况，初始学习率为0.01，衰减因子为0.95。

余弦退火（CosineAnnealingLR）

余弦退火会按照余弦曲线逐渐降低学习率，通常在指定的epoch数量（T_max）内达到最小值（eta_min）。它还可以选择性地重新开始退火周期。

# 定义CosineAnnealingLR调度器
# 在T_max=50个epoch内进行退火，最小学习率eta_min=0
scheduler_cos = CosineAnnealingLR(optimizer, T_max=50, eta_min=0)

# 在训练循环中的用法示例（简化）：
# num_epochs = 50
# for epoch in range(num_epochs):
#     # --- 训练阶段（同上）---
#
#     # 在每个epoch后更新学习率
#     scheduler_cos.step()
#
#     current_lr = optimizer.param_groups[0]['lr']
#     print(f"Epoch {epoch+1}: Current LR = {current_lr:.6f}")

该调度器会在T_max个epoch内，将学习率从初始值平滑地降低到eta_min。

CosineAnnealingLR学习率在50个epoch内的衰减情况，初始学习率为0.01，最大周期为50，最小学习率为0。

实施热身阶段

学习率热身，即学习率在最初的几个epoch或步进中从很低的值开始线性或非线性增加，本身通常不是一个独立的内置调度器类。它常与另一种衰减调度方案结合使用。

您可以手动实现热身阶段，或使用Hugging Face的transformers等库提供的工具函数/类。一个在warmup_epochs内进行线性热身的简单方法是：

# 手动热身（在训练循环内）
initial_lr = 0.01
warmup_epochs = 5
num_epochs = 50
# 假设scheduler_main是另一个调度器，如CosineAnnealingLR，在热身阶段结束后启动

for epoch in range(num_epochs):
    if epoch < warmup_epochs:
        # 将学习率从0线性增加到initial_lr
        lr = initial_lr * (epoch + 1) / warmup_epochs
        for param_group in optimizer.param_groups:
            param_group['lr'] = lr
    elif epoch == warmup_epochs:
         # 确保热身结束后学习率正好是initial_lr
         for param_group in optimizer.param_groups:
            param_group['lr'] = initial_lr
         # 如果需要，可以在此处初始化主调度器，或让它直接接管
         # scheduler_main = CosineAnnealingLR(optimizer, T_max=num_epochs - warmup_epochs, eta_min=0)
    else:
        # 热身完成后应用主调度器
        # scheduler_main.step() # 调用主调度器的step方法
        pass # 如果主调度器已提前初始化，此为占位符

    # --- 训练阶段 ---

    current_lr = optimizer.param_groups[0]['lr']
    print(f"Epoch {epoch+1}: Current LR = {current_lr:.6f}")

注意：PyTorch 1.10+引入了SequentialLR和ChainedScheduler，它们提供了更便捷的方式来组合调度器，例如热身阶段后接衰减。

集成到训练循环中

重要的一点是在正确的时间调用scheduler.step()。大多数调度器，如StepLR、ExponentialLR和CosineAnnealingLR，都设计为每个epoch调用一次，通常是在该epoch的验证循环之后。

# 基于epoch的调度器标准训练循环结构

# 初始化优化器和调度器
optimizer = optim.Adam(model.parameters(), lr=0.01)
scheduler = StepLR(optimizer, step_size=10, gamma=0.1) # 示例

num_epochs = 50
for epoch in range(num_epochs):
    # --- 训练阶段 ---
    model.train()
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step() # 根据当前梯度更新权重

    # --- 验证阶段（可选）---
    # model.eval()
    # ... 验证逻辑 ...

    # --- 学习率更新 ---
    # 在该epoch的训练和验证步骤*之后*更新学习率
    scheduler.step()

    # 记录学习率（可选）
    current_lr = optimizer.param_groups[0]['lr']
    print(f"Epoch {epoch+1} finished. New LR for next epoch: {current_lr:.6f}")

重要事项： 始终在optimizer.step()之后调用scheduler.step()。这个顺序很重要，尤其是在某些框架或自定义设置中，它们之间有更复杂的关联。对于设计为每批次步进的调度器（较不常见，但有可能），scheduler.step()的调用应在批次循环内部。请查阅您所用特定调度器的文档。

通过实施学习率调度，您可以更好地控制优化过程，这通常会带来更快的收敛速度和更好的最终模型表现，相较于使用固定学习率而言。尝试不同的调度方案及其参数是深度学习模型调整中的一个常规部分。