别再只用CrossEntropyLoss了！PyTorch实战Label Smoothing，让你的分类模型涨点更稳（附完整代码）

PyTorch分类任务进阶：Label Smoothing原理剖析与实战调优指南

在深度学习分类任务中，我们常常会遇到模型在训练集上表现优异，但在验证集或测试集上表现波动较大的情况。这种现象往往源于模型对训练数据的"过度自信"——即对预测结果过于确定，导致泛化能力下降。本文将深入探讨一种简单却有效的正则化技术Label Smoothing，并展示如何在PyTorch中实现和优化这一技术。

1. 理解Label Smoothing的核心思想

传统的分类任务中，我们通常使用"硬标签"（Hard Label）来表示类别，即正确的类别标签为1，其他类别为0。这种表示方式虽然直观，但也存在几个潜在问题：

• 模型过度自信：模型会被迫将正确类别的预测概率推向1，其他类别推向0，这可能导致过拟合
• 标签噪声敏感：当训练数据中存在错误标签时，模型会强行拟合这些噪声
• 类别间关系忽略：硬标签无法表达类别之间的相似性关系

Label Smoothing通过将硬标签"软化"来解决这些问题。具体来说，它将正确类别的标签从1调整为1-α，将其他类别的标签从0调整为α/(K-1)，其中K是类别总数，α是一个小的平滑系数（通常取0.1）。

数学表达： 对于有K个类别的分类问题，给定一个样本的真实类别为i，经过Label Smoothing后的标签向量y为：

y_j = { 1 - α 如果 j = i α / (K - 1) 如果 j ≠ i }

这种平滑处理带来了几个好处：

1. 防止模型对预测结果过于自信
2. 提高模型对标签噪声的鲁棒性
3. 鼓励模型学习更通用的特征表示
4. 通常能带来1-2%的准确率提升

2. PyTorch中的三种实现方式

2.1 基础实现：手动平滑标签

最直接的方式是在训练循环中手动对标签进行平滑处理，然后使用KL散度损失：

import torch import torch.nn.functional as F def smooth_labels(labels, n_classes, alpha=0.1): """ 标签平滑处理 :param labels: 原始标签，形状[batch_size] :param n_classes: 类别数量 :param alpha: 平滑系数 :return: 平滑后的标签，形状[batch_size, n_classes] """ device = labels.device labels = labels.to(device) smoothed = torch.full((labels.size(0), n_classes), alpha/(n_classes-1), device=device) smoothed.scatter_(1, labels.unsqueeze(1), 1-alpha) return smoothed # 使用示例 criterion = torch.nn.KLDivLoss(reduction='batchmean') logits = model(inputs) # 模型输出 smoothed_labels = smooth_labels(labels, num_classes=10) loss = criterion(F.log_softmax(logits, dim=1), smoothed_labels)

2.2 封装为自定义损失函数

为了更方便地使用，我们可以将标签平滑逻辑封装成一个自定义的PyTorch损失函数：

import torch.nn as nn import torch.nn.functional as F class LabelSmoothingLoss(nn.Module): def __init__(self, classes, smoothing=0.1, dim=-1): super(LabelSmoothingLoss, self).__init__() self.confidence = 1.0 - smoothing self.smoothing = smoothing self.cls = classes self.dim = dim def forward(self, pred, target): pred = pred.log_softmax(dim=self.dim) with torch.no_grad(): true_dist = torch.zeros_like(pred) true_dist.fill_(self.smoothing / (self.cls - 1)) true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence) return torch.mean(torch.sum(-true_dist * pred, dim=self.dim))

2.3 与交叉熵损失结合的高效实现

我们还可以直接修改交叉熵损失的实现，避免显式创建平滑后的标签矩阵：

class LabelSmoothingCrossEntropy(nn.Module): def __init__(self, smoothing=0.1): super().__init__() self.smoothing = smoothing def forward(self, x, target): logprobs = F.log_softmax(x, dim=-1) nll_loss = -logprobs.gather(dim=-1, index=target.unsqueeze(1)) nll_loss = nll_loss.squeeze(1) smooth_loss = -logprobs.mean(dim=-1) loss = (1.0 - self.smoothing) * nll_loss + self.smoothing * smooth_loss return loss.mean()

这种实现方式更加内存高效，特别适合类别数量大的场景。

3. 实战调优技巧

3.1 平滑系数α的选择

平滑系数α控制着标签平滑的强度，通常取值范围在0.05到0.3之间。不同任务和数据集的最佳α值可能不同：

调优建议：

• 从0.1开始尝试
• 对于噪声较多的数据，可以尝试更大的α值
• 对于类别间差异明显的任务，可以使用较小的α值

3.2 与其他正则化技术的配合

Label Smoothing可以与其他正则化技术协同使用：

1. 与Dropout配合：

   • Dropout率通常可以设置得比不使用Label Smoothing时略低
   • 例如，原本用0.5的dropout率，配合Label Smoothing可以用0.3-0.4

2. 与权重衰减配合：

   • Label Smoothing可以减少对权重衰减系数的敏感度
   • 可以尝试更大的权重衰减值

3. 与数据增强配合：

   • 当使用强数据增强时，Label Smoothing的效果通常更加明显

3.3 训练动态调整策略

我们可以实现动态调整的Label Smoothing策略，在训练过程中逐渐改变平滑强度：

class DynamicLabelSmoothing(nn.Module): def __init__(self, classes, initial_smoothing=0.2, final_smoothing=0.0): super().__init__() self.classes = classes self.initial = initial_smoothing self.final = final_smoothing self.current_epoch = 0 self.total_epochs = 100 # 默认值，可通过set_epochs调整 def set_epochs(self, total_epochs): self.total_epochs = total_epochs def forward(self, pred, target): # 计算当前平滑系数 progress = min(self.current_epoch / self.total_epochs, 1.0) smoothing = self.initial + (self.final - self.initial) * progress pred = pred.log_softmax(dim=-1) with torch.no_grad(): true_dist = torch.zeros_like(pred) true_dist.fill_(smoothing / (self.classes - 1)) true_dist.scatter_(1, target.unsqueeze(1), 1 - smoothing) self.current_epoch += 1 return torch.mean(torch.sum(-true_dist * pred, dim=-1))

这种策略在训练初期使用较强的平滑，随着训练进行逐渐减弱，可以帮助模型在早期更稳定地学习特征。

4. 效果验证与对比实验

为了验证Label Smoothing的效果，我们在CIFAR-10数据集上进行了对比实验，使用ResNet-18架构，训练300个epoch。

实验设置：

• 基线：标准交叉熵损失
• 实验组：Label Smoothing (α=0.1)
• 优化器：SGD，动量0.9，初始学习率0.1，每100epoch乘以0.1
• 批量大小：128

结果对比：

从结果可以看出，虽然Label Smoothing略微降低了训练准确率，但显著提高了测试准确率，降低了测试损失，并且使训练过程更加稳定。

实际应用建议：

• 当模型在训练集上表现很好但验证集上波动较大时，尝试Label Smoothing
• 当数据可能存在标签噪声时，Label Smoothing通常能带来明显改善
• 在模型蒸馏任务中，Label Smoothing可以作为教师模型正则化的有效手段

5. 高级技巧与前沿进展

5.1 类别感知的Label Smoothing

传统的Label Smoothing对所有类别使用相同的平滑强度，但在实际应用中，不同类别可能需要不同的平滑策略。我们可以根据类别的样本数量或类间相似度来调整平滑强度：

class ClassAwareLabelSmoothing(nn.Module): def __init__(self, classes, class_weights, base_smoothing=0.1): super().__init__() self.classes = classes self.base = base_smoothing # class_weights是每个类别的权重，可以基于样本数量或领域知识 self.weights = torch.tensor(class_weights).view(1, -1) def forward(self, pred, target): pred = pred.log_softmax(dim=-1) with torch.no_grad(): # 为每个类别计算不同的平滑强度 smoothing = self.base * (1 - self.weights / self.weights.max()) true_dist = smoothing / (self.classes - 1) true_dist.scatter_(1, target.unsqueeze(1), 1 - smoothing.gather(1, target.unsqueeze(1))) return torch.mean(torch.sum(-true_dist * pred, dim=-1))

5.2 在线Label Smoothing

论文《Delving Deep into Label Smoothing》提出了一种在线学习Label Smoothing的策略，根据模型的预测动态调整平滑标签：

class OnlineLabelSmoothing(nn.Module): def __init__(self, alpha, n_classes, smoothing=0.1): super().__init__() self.alpha = alpha # 硬损失和软损失的平衡系数 self.n_classes = n_classes # 初始化监督矩阵 self.register_buffer('supervise', torch.eye(n_classes) * (1 - smoothing) + (1 - torch.eye(n_classes)) * smoothing / (n_classes - 1)) # 更新矩阵 self.register_buffer('update', torch.zeros_like(self.supervise)) self.register_buffer('count', torch.zeros(n_classes)) self.hard_loss = nn.CrossEntropyLoss() def forward(self, pred, target): soft_loss = self.soft_loss(pred, target) hard_loss = self.hard_loss(pred, target) return self.alpha * hard_loss + (1 - self.alpha) * soft_loss def soft_loss(self, pred, target): pred = pred.log_softmax(dim=-1) if self.training: with torch.no_grad(): self.update_supervise(pred.exp(), target) true_dist = torch.index_select(self.supervise, 1, target).transpose(1, 0) return torch.mean(torch.sum(-true_dist * pred, dim=-1)) def update_supervise(self, probs, target): pred_classes = probs.argmax(dim=-1) correct_mask = pred_classes == target correct_probs = probs[correct_mask] correct_pred_classes = pred_classes[correct_mask] # 更新监督矩阵 self.update.index_add_(1, correct_pred_classes, correct_probs.T) self.count.index_add_(0, correct_pred_classes, torch.ones_like(correct_pred_classes)) def next_epoch(self): # 归一化更新矩阵 self.count[self.count == 0] = 1 # 避免除以0 self.update /= self.count self.supervise = self.update # 重置 self.update.zero_() self.count.zero_()

在线Label Smoothing能够根据模型的实际表现动态调整平滑策略，通常能获得比固定Label Smoothing更好的性能。

5.3 与知识蒸馏的结合

Label Smoothing与知识蒸馏有天然的契合点。在蒸馏过程中，教师模型的软标签已经包含了类别间的关系信息，可以看作是更高级的Label Smoothing：

class DistillationWithLabelSmoothing(nn.Module): def __init__(self, teacher_model, base_loss, temp=1.0, alpha=0.5, smoothing=0.1): super().__init__() self.teacher = teacher_model self.base_loss = base_loss self.temp = temp self.alpha = alpha self.smoothing = smoothing def forward(self, inputs, student_logits, labels): # 教师模型预测 with torch.no_grad(): teacher_logits = self.teacher(inputs) teacher_probs = F.softmax(teacher_logits / self.temp, dim=-1) # 学生模型概率 student_probs = F.log_softmax(student_logits / self.temp, dim=-1) # 蒸馏损失 distillation_loss = F.kl_div( student_probs, teacher_probs, reduction='batchmean') * (self.temp ** 2) # 标签平滑的交叉熵损失 smoothed_labels = smooth_labels(labels, student_logits.size(1), self.smoothing) ce_loss = F.kl_div(F.log_softmax(student_logits, dim=-1), smoothed_labels, reduction='batchmean') return self.alpha * distillation_loss + (1 - self.alpha) * ce_loss

这种组合方式能够同时利用教师模型的知识和Label Smoothing的正则化效果，通常能获得更好的学生模型性能。