当前位置：首页 > news >正文

深度学习优化：学习率调度与早停

news 2026/4/28 4:47:14

深度学习优化：学习率调度与早停

1. 学习率的重要性

学习率是深度学习中最重要的超参数之一，它控制着模型参数更新的步长。合适的学习率能够：

加速模型收敛
避免模型陷入局部最优
提高模型的泛化能力
减少训练时间

1.1 学习率对训练的影响

学习率过大：可能导致模型发散，损失函数值震荡甚至增大
学习率过小：收敛速度慢，可能陷入局部最优
学习率适中：能够快速收敛到全局最优或接近最优的解

2. 学习率调度策略

2.1 固定学习率

最简单的学习率策略是使用固定值：

optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

适用场景：简单模型和数据集，或者已经通过交叉验证确定了最佳学习率

2.2 步进衰减（Step Decay）

在训练过程中按照固定的 epoch 间隔降低学习率：

# 每 10 个 epoch 将学习率减半 scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5) for epoch in range(epochs): train(...) scheduler.step()

适用场景：大多数深度学习任务，特别是当训练时间较长时

2.3 指数衰减（Exponential Decay）

学习率按指数规律衰减：

# 每个 epoch 后学习率乘以 gamma scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.95) for epoch in range(epochs): train(...) scheduler.step()

适用场景：需要学习率平滑下降的场景

2.4 余弦退火（Cosine Annealing）

学习率按照余弦函数的规律衰减：

# T_max 是余弦周期的一半 scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50, eta_min=0) for epoch in range(epochs): train(...) scheduler.step()

适用场景：需要精细调整学习率的场景，特别是在模型接近收敛时

2.5 ReduceLROnPlateau

当验证损失不再下降时降低学习率：

# 当验证损失连续 patience 个 epoch 没有改善时，将学习率乘以 factor scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=5, verbose=True) for epoch in range(epochs): train(...) val_loss = validate(...) scheduler.step(val_loss)

适用场景：需要自适应调整学习率的场景，特别是当训练过程中损失曲线不稳定时

2.6 循环学习率（Cyclical Learning Rate）

学习率在一个范围内周期性变化：

from torch.optim.lr_scheduler import CyclicLR # base_lr 是最小学习率，max_lr 是最大学习率 scheduler = CyclicLR(optimizer, base_lr=0.001, max_lr=0.01, step_size_up=2000, mode='triangular') for batch in dataloader: train_batch(...) scheduler.step()

适用场景：需要在训练过程中探索不同学习率的场景，特别是在模型陷入局部最优时

3. 学习率预热（Warmup）

3.1 线性预热

在训练初期使用较小的学习率，然后逐渐增加到目标学习率：

# 自定义预热 scheduler class WarmupLR: def __init__(self, optimizer, warmup_steps, base_lr): self.optimizer = optimizer self.warmup_steps = warmup_steps self.base_lr = base_lr self.step_count = 0 def step(self): self.step_count += 1 if self.step_count <= self.warmup_steps: lr = self.base_lr * (self.step_count / self.warmup_steps) for param_group in self.optimizer.param_groups: param_group['lr'] = lr # 使用 optimizer = torch.optim.SGD(model.parameters(), lr=0.1) warmup_scheduler = WarmupLR(optimizer, warmup_steps=1000, base_lr=0.1) for batch in dataloader: train_batch(...) warmup_scheduler.step()

适用场景：使用大学习率或大批量训练时，防止模型在训练初期发散

3.2 余弦预热

结合余弦退火和预热策略：

from torch.optim.lr_scheduler import CosineAnnealingLR # 先预热，再余弦退火 class WarmupCosineLR: def __init__(self, optimizer, warmup_steps, total_steps, eta_min=0): self.optimizer = optimizer self.warmup_steps = warmup_steps self.total_steps = total_steps self.eta_min = eta_min self.step_count = 0 def step(self): self.step_count += 1 if self.step_count <= self.warmup_steps: # 预热阶段 lr = 0.001 + (0.1 - 0.001) * (self.step_count / self.warmup_steps) else: # 余弦退火阶段 progress = (self.step_count - self.warmup_steps) / (self.total_steps - self.warmup_steps) lr = self.eta_min + (0.1 - self.eta_min) * (1 + math.cos(math.pi * progress)) / 2 for param_group in self.optimizer.param_groups: param_group['lr'] = lr

适用场景：需要精细控制学习率变化的场景，特别是在使用Transformer等复杂模型时

4. 早停（Early Stopping）

4.1 基本原理

早停是一种正则化技术，当模型在验证集上的性能不再改善时停止训练，防止模型过拟合：

训练模型并在每个 epoch 结束后在验证集上评估
记录最佳验证性能和对应的模型参数
如果验证性能在连续多个 epoch 内没有改善，则停止训练
恢复到最佳验证性能对应的模型参数

4.2 实现早停

class EarlyStopping: def __init__(self, patience=10, delta=0, path='checkpoint.pt'): self.patience = patience self.delta = delta self.path = path self.counter = 0 self.best_score = None self.early_stop = False self.val_loss_min = float('inf') def __call__(self, val_loss, model): score = -val_loss if self.best_score is None: self.best_score = score self.save_checkpoint(val_loss, model) elif score < self.best_score + self.delta: self.counter += 1 print(f'EarlyStopping counter: {self.counter} out of {self.patience}') if self.counter >= self.patience: self.early_stop = True else: self.best_score = score self.save_checkpoint(val_loss, model) self.counter = 0 def save_checkpoint(self, val_loss, model): torch.save(model.state_dict(), self.path) self.val_loss_min = val_loss # 使用 early_stopping = EarlyStopping(patience=10, path='best_model.pt') for epoch in range(epochs): train(...) val_loss = validate(...) early_stopping(val_loss, model) if early_stopping.early_stop: print("Early stopping") break # 加载最佳模型 model.load_state_dict(torch.load('best_model.pt'))

4.3 早停的超参数

patience：连续多少个 epoch 验证性能没有改善后停止训练
delta：验证性能改善的最小阈值
metric：用于评估的指标（如验证损失、准确率等）

5. 学习率调度与早停的结合

5.1 典型训练流程

# 初始化模型、优化器 model = MyModel() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # 学习率调度器 scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=5) # 早停 early_stopping = EarlyStopping(patience=10, path='best_model.pt') # 训练循环 for epoch in range(epochs): # 训练 train_loss = train(model, optimizer, train_loader) # 验证 val_loss, val_acc = validate(model, val_loader) # 学习率调度 scheduler.step(val_loss) # 早停检查 early_stopping(val_loss, model) if early_stopping.early_stop: print("Early stopping") break # 加载最佳模型 model.load_state_dict(torch.load('best_model.pt'))

5.2 超参数调优策略

网格搜索：尝试不同的学习率初始值和调度策略
随机搜索：在一定范围内随机采样超参数
贝叶斯优化：基于历史性能自动调整超参数

6. 性能评估与分析

6.1 学习率曲线分析

import matplotlib.pyplot as plt # 记录学习率变化 lr_history = [] for epoch in range(epochs): # 记录当前学习率 lr = optimizer.param_groups[0]['lr'] lr_history.append(lr) train(...) val_loss = validate(...) scheduler.step(val_loss) # 绘制学习率曲线 plt.figure(figsize=(10, 6)) plt.plot(lr_history) plt.xlabel('Epoch') plt.ylabel('Learning Rate') plt.title('Learning Rate Schedule') plt.savefig('lr_schedule.png')

6.2 损失曲线分析

# 记录损失变化 train_loss_history = [] val_loss_history = [] for epoch in range(epochs): train_loss = train(...) val_loss = validate(...) train_loss_history.append(train_loss) val_loss_history.append(val_loss) # 绘制损失曲线 plt.figure(figsize=(10, 6)) plt.plot(train_loss_history, label='Train Loss') plt.plot(val_loss_history, label='Validation Loss') plt.xlabel('Epoch') plt.ylabel('Loss') plt.title('Training and Validation Loss') plt.legend() plt.savefig('loss_curve.png')

6.3 不同学习率策略的对比

学习率策略	优点	缺点	适用场景
固定学习率	简单，易于实现	难以适应不同阶段的训练需求	简单模型，短训练时间
步进衰减	实现简单，效果稳定	衰减时机固定，不够灵活	大多数深度学习任务
指数衰减	学习率平滑下降	可能衰减过快	需要精细调整的场景
余弦退火	学习率变化平滑，效果好	实现稍复杂	需要高精度模型的场景
ReduceLROnPlateau	自适应调整，效果好	依赖验证性能，可能反应滞后	复杂模型，长时间训练
循环学习率	探索不同学习率，避免局部最优	超参数较多，调优复杂	模型陷入局部最优时

7. 最佳实践

7.1 学习率选择

初始学习率：
- 小批量（< 256）：0.001-0.01
- 大批量（> 256）：0.01-0.1
- 预训练模型：0.0001-0.001
学习率调度：
- 通用场景：ReduceLROnPlateau
- 精细调整：余弦退火
- 快速收敛：步进衰减
早停设置：
- patience：5-20（根据训练速度调整）
- delta：1e-4-1e-3（根据损失量级调整）

7.2 常见问题与解决方案

问题	原因	解决方案
训练发散	学习率过大	减小初始学习率，使用预热
收敛速度慢	学习率过小	增大初始学习率，使用学习率调度
过拟合	训练时间过长	使用早停，增加正则化
验证性能波动	学习率调度不合适	调整调度策略，使用 ReduceLROnPlateau

7.3 代码规范

# 好的实践 def train_model(model, train_loader, val_loader, epochs=100): # 优化器 optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # 学习率调度器 scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( optimizer, mode='min', factor=0.1, patience=5, verbose=True ) # 早停 early_stopping = EarlyStopping(patience=10, path='best_model.pt') # 训练循环 for epoch in range(epochs): # 训练 model.train() train_loss = 0.0 for batch in train_loader: optimizer.zero_grad() outputs = model(batch[0]) loss = criterion(outputs, batch[1]) loss.backward() optimizer.step() train_loss += loss.item() train_loss /= len(train_loader) # 验证 model.eval() val_loss = 0.0 with torch.no_grad(): for batch in val_loader: outputs = model(batch[0]) loss = criterion(outputs, batch[1]) val_loss += loss.item() val_loss /= len(val_loader) # 学习率调度 scheduler.step(val_loss) # 早停检查 early_stopping(val_loss, model) # 打印信息 print(f'Epoch {epoch+1}/{epochs}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}') if early_stopping.early_stop: print("Early stopping") break # 加载最佳模型 model.load_state_dict(torch.load('best_model.pt')) return model

8. 高级技巧

8.1 分层学习率

为不同层设置不同的学习率：

# 为不同层设置不同的学习率 optimizer = torch.optim.Adam([ {'params': model.features.parameters(), 'lr': 0.0001}, {'params': model.classifier.parameters(), 'lr': 0.001} ])

适用场景：微调预训练模型时，冻结底层参数或为不同层设置不同的学习率

8.2 梯度裁剪

结合学习率调度使用梯度裁剪，防止梯度爆炸：

# 梯度裁剪 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

适用场景：使用RNN、LSTM等容易出现梯度爆炸的模型时

8.3 批量大小与学习率的关系

批量大小与学习率通常成正比：

# 线性缩放学习率 batch_size = 256 base_lr = 0.001 scaled_lr = base_lr * (batch_size / 64) optimizer = torch.optim.Adam(model.parameters(), lr=scaled_lr)

适用场景：使用不同批量大小进行训练时，保持学习率与批量大小的比例

9. 实际应用案例

9.1 图像分类

# 图像分类模型训练 def train_classification_model(): # 模型 model = torchvision.models.resnet50(pretrained=True) model.fc = nn.Linear(model.fc.in_features, 10) # 优化器 optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=1e-4) # 学习率调度器 scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100, eta_min=0) # 早停 early_stopping = EarlyStopping(patience=15, path='best_resnet.pt') # 训练循环 for epoch in range(100): # 训练代码... # 验证代码... scheduler.step() early_stopping(val_loss, model) if early_stopping.early_stop: break return model

9.2 目标检测

# 目标检测模型训练 def train_detection_model(): # 模型 model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True) # 优化器 optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=1e-4) # 学习率调度器 scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[16, 22], gamma=0.1) # 早停 early_stopping = EarlyStopping(patience=10, path='best_detector.pt') # 训练循环 for epoch in range(24): # 训练代码... # 验证代码... scheduler.step() early_stopping(val_loss, model) if early_stopping.early_stop: break return model

9.3 自然语言处理

# NLP模型训练 def train_nlp_model(): # 模型 model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2) # 优化器 optimizer = AdamW(model.parameters(), lr=2e-5, eps=1e-8) # 学习率调度器 scheduler = get_linear_schedule_with_warmup( optimizer, num_warmup_steps=0, num_training_steps=total_steps ) # 早停 early_stopping = EarlyStopping(patience=5, path='best_bert.pt') # 训练循环 for epoch in range(3): # 训练代码... # 验证代码... scheduler.step() early_stopping(val_loss, model) if early_stopping.early_stop: break return model

10. 未来发展

10.1 自适应学习率算法

Adam：结合了动量和自适应学习率
RMSprop：基于梯度的平方移动平均
Adagrad：对每个参数使用不同的学习率
Adadelta：改进的Adagrad，解决学习率衰减过快的问题

10.2 自动学习率搜索

LR Finder：自动寻找最佳学习率
Hyperband：结合随机搜索和早停
贝叶斯优化：基于概率模型选择超参数

10.3 学习率调度的新趋势

OneCycleLR：在一个周期内先增加后减少学习率
SGDR：带重启的随机梯度下降
Warmup + Cosine Annealing：结合预热和余弦退火

11. 代码示例：完整的训练框架

"""深度学习训练框架""" import torch import torch.nn as nn import torch.optim as optim from torch.optim.lr_scheduler import ReduceLROnPlateau, CosineAnnealingLR from torch.utils.data import DataLoader import matplotlib.pyplot as plt import time class EarlyStopping: """早停类""" def __init__(self, patience=10, delta=0, path='checkpoint.pt'): self.patience = patience self.delta = delta self.path = path self.counter = 0 self.best_score = None self.early_stop = False self.val_loss_min = float('inf') def __call__(self, val_loss, model): score = -val_loss if self.best_score is None: self.best_score = score self.save_checkpoint(val_loss, model) elif score < self.best_score + self.delta: self.counter += 1 print(f'EarlyStopping counter: {self.counter} out of {self.patience}') if self.counter >= self.patience: self.early_stop = True else: self.best_score = score self.save_checkpoint(val_loss, model) self.counter = 0 def save_checkpoint(self, val_loss, model): torch.save(model.state_dict(), self.path) self.val_loss_min = val_loss def train_model(model, train_loader, val_loader, config): """训练模型""" # 损失函数 criterion = nn.CrossEntropyLoss() # 优化器 if config['optimizer'] == 'adam': optimizer = optim.Adam(model.parameters(), lr=config['learning_rate']) elif config['optimizer'] == 'sgd': optimizer = optim.SGD(model.parameters(), lr=config['learning_rate'], momentum=0.9, weight_decay=1e-4) # 学习率调度器 if config['lr_scheduler'] == 'plateau': scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=5, verbose=True) elif config['lr_scheduler'] == 'cosine': scheduler = CosineAnnealingLR(optimizer, T_max=config['epochs'], eta_min=0) # 早停 early_stopping = EarlyStopping(patience=config['patience'], path=config['checkpoint_path']) # 记录 train_loss_history = [] val_loss_history = [] lr_history = [] # 训练循环 start_time = time.time() for epoch in range(config['epochs']): # 训练 model.train() train_loss = 0.0 for batch in train_loader: inputs, targets = batch inputs, targets = inputs.to(config['device']), targets.to(config['device']) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, targets) loss.backward() # 梯度裁剪 if config['gradient_clip']: torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) optimizer.step() train_loss += loss.item() train_loss /= len(train_loader) train_loss_history.append(train_loss) # 验证 model.eval() val_loss = 0.0 correct = 0 total = 0 with torch.no_grad(): for batch in val_loader: inputs, targets = batch inputs, targets = inputs.to(config['device']), targets.to(config['device']) outputs = model(inputs) loss = criterion(outputs, targets) val_loss += loss.item() _, predicted = outputs.max(1) total += targets.size(0) correct += predicted.eq(targets).sum().item() val_loss /= len(val_loader) val_loss_history.append(val_loss) val_acc = 100. * correct / total # 记录学习率 lr = optimizer.param_groups[0]['lr'] lr_history.append(lr) # 学习率调度 if config['lr_scheduler'] == 'plateau': scheduler.step(val_loss) elif config['lr_scheduler'] == 'cosine': scheduler.step() # 早停检查 early_stopping(val_loss, model) # 打印信息 print(f'Epoch {epoch+1}/{config["epochs"]}, ' f'Train Loss: {train_loss:.4f}, ' f'Val Loss: {val_loss:.4f}, ' f'Val Acc: {val_acc:.2f}%, ' f'LR: {lr:.6f}') if early_stopping.early_stop: print("Early stopping") break # 训练时间 end_time = time.time() print(f'Training time: {end_time - start_time:.2f} seconds') # 加载最佳模型 model.load_state_dict(torch.load(config['checkpoint_path'])) # 绘制曲线 plt.figure(figsize=(15, 5)) # 损失曲线 plt.subplot(1, 2, 1) plt.plot(train_loss_history, label='Train Loss') plt.plot(val_loss_history, label='Validation Loss') plt.xlabel('Epoch') plt.ylabel('Loss') plt.title('Training and Validation Loss') plt.legend() # 学习率曲线 plt.subplot(1, 2, 2) plt.plot(lr_history) plt.xlabel('Epoch') plt.ylabel('Learning Rate') plt.title('Learning Rate Schedule') plt.tight_layout() plt.savefig('training_curves.png') return model # 示例配置 config = { 'device': torch.device('cuda' if torch.cuda.is_available() else 'cpu'), 'epochs': 100, 'learning_rate': 0.01, 'optimizer': 'sgd', 'lr_scheduler': 'cosine', 'patience': 10, 'gradient_clip': True, 'checkpoint_path': 'best_model.pt' } # 使用示例 if __name__ == '__main__': # 假设我们有数据加载器 # train_loader = DataLoader(...) # val_loader = DataLoader(...) # model = MyModel().to(config['device']) # trained_model = train_model(model, train_loader, val_loader, config) pass