提升精度小技巧，梯度裁剪，学习率预热，标签平滑

一、梯度裁剪 (Gradient Clipping)

1. 核心原理

梯度裁剪是解决梯度爆炸问题的经典手段：反向传播计算完所有参数的梯度后，若梯度的总范数超过设定阈值，就按比例缩放所有梯度，使梯度范数等于阈值，从而避免梯度过大导致模型参数更新剧烈、训练震荡不收敛。

最常用的是L2 范数裁剪，此外还有按值裁剪（限制每个梯度元素的取值范围）。

2. PyTorch 实现代码

PyTorch 提供了官方 API，只需在loss.backward()之后、optimizer.step()之前插入一行即可。

python

运行

import torch import torch.nn as nn # —— 模拟模型和数据 —— model = nn.Linear(10, 2) optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) criterion = nn.CrossEntropyLoss() x = torch.randn(8, 10) # batch=8, 特征维度10 y = torch.randint(0, 2, (8,)) # 二分类标签 # —— 训练一步 + 梯度裁剪 —— optimizer.zero_grad() # 1. 清空梯度 loss = criterion(model(x), y) # 2. 前向传播计算损失 loss.backward() # 3. 反向传播计算梯度 # ========== 梯度裁剪核心代码 ========== # 方式1：L2范数裁剪（最常用） max_norm = 1.0 # 梯度L2范数的最大阈值 grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=max_norm, norm_type=2) # 方式2：按值裁剪（每个梯度元素限制在 [-clip_value, clip_value]） # torch.nn.utils.clip_grad_value_(model.parameters(), clip_value=0.5) optimizer.step() # 5. 更新参数

3. 逐行解释

• torch.nn.utils.clip_grad_norm_(parameters, max_norm, norm_type=2)

  • parameters：需要裁剪的参数列表，通常传入model.parameters()对所有参数统一裁剪
  • max_norm：梯度范数的上限，常用取值 0.5 / 1.0 / 5.0，需根据任务调参
  • norm_type：范数类型，2 代表 L2 范数，1 代表 L1 范数，inf代表无穷范数
  • 返回值：裁剪之前所有梯度的总范数，可用于日志记录、监控梯度大小
  • 注意：函数名末尾的_代表原地操作，直接修改参数的.grad属性

• 裁剪逻辑：设总梯度范数为total_norm，若total_norm > max_norm，则所有梯度乘以max_norm / total_norm，保证裁剪后总范数等于max_norm；若未超过阈值则不做修改。

4. 适用场景

• RNN、LSTM、Transformer 等序列模型（易出现梯度爆炸）
• 深层网络、大学习率训练场景
• 训练中 loss 突然飙升、出现 NaN 的排查与修复

二、学习率预热 (Learning Rate Warmup)

1. 核心原理

训练初期，模型参数是随机初始化的，梯度方向波动大，若直接使用大学习率容易导致模型不稳定、收敛慢甚至发散。

学习率预热：在训练的前warmup_steps步，让学习率从 0 线性（或其他方式）逐步上升到预设的初始学习率，预热结束后再使用正常的学习率衰减策略（余弦退火、步长衰减等）。该技巧在 Transformer、大模型训练中几乎是标配。

2. PyTorch 实现代码

使用 PyTorch 官方SequentialLR组合预热调度器 + 主调度器，规范且易维护。

python

运行

import torch from torch.optim.lr_scheduler import LinearLR, CosineAnnealingLR, SequentialLR # —— 模型与优化器 —— model = nn.Linear(10, 2) optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) # 目标初始学习率 # ========== 学习率预热核心配置 ========== total_steps = 10000 # 总训练步数 warmup_steps = 1000 # 预热步数，通常取总步数的 5%~10% # 1. 预热调度器：前warmup_steps步，学习率从 0.01*lr 线性增长到 1.0*lr warmup_scheduler = LinearLR( optimizer, start_factor=0.01, # 初始学习率 = base_lr * start_factor end_factor=1.0, # 结束学习率 = base_lr * end_factor total_iters=warmup_steps ) # 2. 主调度器：预热结束后，使用余弦退火衰减学习率 main_scheduler = CosineAnnealingLR( optimizer, T_max=total_steps - warmup_steps, # 余弦退火的周期 eta_min=1e-6 # 学习率最小值 ) # 3. 组合调度器：先执行预热，再执行主调度 scheduler = SequentialLR( optimizer, schedulers=[warmup_scheduler, main_scheduler], milestones=[warmup_steps] # 第warmup_steps步切换调度器 ) # —— 训练循环中使用 —— for step in range(total_steps): # 前向、反向、更新参数 optimizer.zero_grad() loss = ... loss.backward() optimizer.step() # 每步更新一次学习率（step级更新，预热必须按step来） scheduler.step() # 打印当前学习率 current_lr = optimizer.param_groups[0]['lr']

3. 逐行解释

• LinearLR：线性学习率调度器，通过start_factor和end_factor控制学习率的起始和结束比例，total_iters控制线性变化的步数。
• SequentialLR：按顺序执行多个调度器，milestones列表指定切换步数，第milestones[i]步结束后切换到第i+1个调度器。
• 关键注意点：
  • 预热必须是step 级更新（每训练一个 batch 更新一次），不能等 epoch 结束再更新，否则预热阶段步数太少，失去意义。
  • warmup_steps常用取值：总步数的 5%~10%，或固定 500/1000/2000 步，数据集越小、模型越小，预热步数可越少。

4. 手动实现版（LambdaLR）

若需要更灵活的预热策略（如常数预热、指数预热），可用LambdaLR自定义：

python

运行

warmup_steps = 1000 lr_lambda = lambda step: min(step / warmup_steps, 1.0) # 线性预热到1.0倍 scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lr_lambda)

三、标签平滑 (Label Smoothing)

1. 核心原理

标准分类任务使用独热硬标签（真实类别为 1，其余为 0）训练，容易导致模型对预测结果过度自信（输出概率接近 1），泛化能力差，易过拟合。

标签平滑将硬标签替换为软标签：

• 真实类别概率：1 - ε（ε 为平滑系数，通常 0.1）
• 其余类别概率：ε / (K - 1)（K 为总类别数）

公式化的交叉熵损失变为：

\(Loss = -(1-\epsilon)\log(p_k) - \frac{\epsilon}{K-1}\sum_{i\neq k}\log(p_i)\)

其中 k 为真实类别，\(p_i\) 为模型对第 i 类的预测概率。

2. 实现方式 1：PyTorch 内置 API（推荐）

PyTorch 1.10+ 版本的CrossEntropyLoss已内置标签平滑参数，一行即可启用。

python

运行

import torch import torch.nn as nn num_classes = 10 smoothing = 0.1 # 平滑系数，常用0.1 # 内置标签平滑的交叉熵损失 criterion = nn.CrossEntropyLoss(label_smoothing=smoothing) # 使用方式和普通CE完全一致 logits = torch.randn(8, num_classes) # 模型输出的logits（未经过softmax） targets = torch.randint(0, num_classes, (8,)) # 类别索引标签 loss = criterion(logits, targets)

3. 实现方式 2：自定义实现（原理级）

为了更清晰地理解原理，下面手动实现标签平滑交叉熵损失：

python

运行

class LabelSmoothingCrossEntropy(nn.Module): def __init__(self, smoothing=0.1, num_classes=10): super().__init__() self.smoothing = smoothing self.num_classes = num_classes self.confidence = 1.0 - smoothing # 真实类别的权重 self.log_softmax = nn.LogSoftmax(dim=1) # 数值更稳定 def forward(self, logits, target): # 1. 计算log(softmax(logits))，避免数值溢出 log_probs = self.log_softmax(logits) # shape: [batch, num_classes] # 2. 构造平滑后的标签分布 true_dist = torch.zeros_like(log_probs) # 非真实类别统一填充 smoothing / (num_classes - 1) true_dist.fill_(self.smoothing / (self.num_classes - 1)) # 真实类别位置替换为 confidence true_dist.scatter_(dim=1, index=target.unsqueeze(1), value=self.confidence) # 3. 计算交叉熵：-sum(真实分布 * log(预测分布))，再对batch求平均 loss = (-true_dist * log_probs).sum(dim=1).mean() return loss

4. 逐行解释

• LogSoftmax：先做 softmax 再取 log 会有数值不稳定问题，直接用LogSoftmax是工业界标准写法。
• scatter_：按索引给指定位置赋值，高效实现 one-hot 到软标签的转换。
• smoothing取值：通常 0.1~0.2，类别数越多可适当调大；值越大正则化越强，过大可能导致欠拟合。

5. 适用场景

• 图像分类、文本分类等多分类任务
• 模型参数量大、训练数据有限，易过拟合的场景
• 知识蒸馏、半监督等对概率分布校准有要求的任务

四、三者整合：完整训练循环示例

下面给出一个包含梯度裁剪 + 学习率预热 + 标签平滑的完整训练代码模板，可直接修改后用于分类任务。

python

运行

import torch import torch.nn as nn from torch.optim import Adam from torch.optim.lr_scheduler import LinearLR, CosineAnnealingLR, SequentialLR from torch.utils.data import DataLoader, TensorDataset # ===================== 1. 配置超参数 ===================== num_classes = 10 input_dim = 28*28 batch_size = 32 total_epochs = 20 base_lr = 1e-3 warmup_ratio = 0.1 # 预热步数占总步数的比例 max_grad_norm = 1.0 # 梯度裁剪阈值 label_smoothing = 0.1 # 标签平滑系数 # ===================== 2. 模拟数据与模型 ===================== # 模拟数据集（替换为真实数据集即可） x_train = torch.randn(1000, input_dim) y_train = torch.randint(0, num_classes, (1000,)) train_dataset = TensorDataset(x_train, y_train) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) # 简单分类模型 model = nn.Sequential( nn.Linear(input_dim, 256), nn.ReLU(), nn.Linear(256, 128), nn.ReLU(), nn.Linear(128, num_classes) ) # ===================== 3. 核心组件初始化 ===================== # 优化器 optimizer = Adam(model.parameters(), lr=base_lr) # 标签平滑损失 criterion = nn.CrossEntropyLoss(label_smoothing=label_smoothing) # 学习率预热 + 余弦退火 total_steps = len(train_loader) * total_epochs warmup_steps = int(total_steps * warmup_ratio) warmup_scheduler = LinearLR(optimizer, start_factor=0.01, end_factor=1.0, total_iters=warmup_steps) main_scheduler = CosineAnnealingLR(optimizer, T_max=total_steps - warmup_steps, eta_min=1e-6) scheduler = SequentialLR(optimizer, schedulers=[warmup_scheduler, main_scheduler], milestones=[warmup_steps]) # ===================== 4. 训练循环 ===================== model.train() global_step = 0 for epoch in range(total_epochs): epoch_loss = 0.0 for batch_x, batch_y in train_loader: optimizer.zero_grad() # 前向传播 logits = model(batch_x) loss = criterion(logits, batch_y) # 反向传播 loss.backward() # ===== 梯度裁剪 ===== torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=max_grad_norm) # 参数更新 optimizer.step() # ===== 学习率更新（step级）===== scheduler.step() epoch_loss += loss.item() global_step += 1 # 打印日志 avg_loss = epoch_loss / len(train_loader) current_lr = optimizer.param_groups[0]['lr'] print(f"Epoch {epoch+1}/{total_epochs} | Loss: {avg_loss:.4f} | LR: {current_lr:.6f}")

五、总结与调参建议

表格

三者经常搭配使用，是深度学习训练的标准优化三件套，在 CV、NLP、多模态任务中都有广泛应用。