BCE损失函数在类别不平衡场景下的优化策略与实践

1次阅读

共计 2188 个字符，预计需要花费 6 分钟才能阅读完成。

在机器学习分类任务中，类别不平衡问题非常普遍。例如在医疗诊断中，健康样本远多于患病样本；在欺诈检测中，正常交易远多于欺诈交易。这种不平衡会导致模型倾向于预测多数类，忽略少数类。

二元交叉熵损失函数 (BCE) 是二分类任务中最常用的损失函数之一。其数学表达式为：

BCE = -[y*log(p) + (1-y)*log(1-p)]

其中 y 是真实标签(0 或 1)，p 是预测概率。这个损失函数在类别平衡时表现良好，但在不平衡场景下会出现问题。

标准 BCE 损失函数在不平衡数据中存在以下缺陷：

样本贡献不均衡：多数类样本会主导损失函数计算，导致模型优化方向偏向多数类
梯度贡献不均：多数类样本产生的梯度会淹没少数类样本的梯度信号
分类边界偏移：决策边界会向少数类方向偏移，降低少数类的召回率

针对以上问题，业界提出了多种改进方法：

在损失函数中为不同类别赋予不同权重，表达式变为：

Weighted BCE = -[w_pos*y*log(p) + w_neg*(1-y)*log(1-p)]

其中 w_pos 和 w_neg 分别是正负样本的权重，通常设置为类别数量的倒数。

优点：实现简单，计算量小
缺点：需要手动调整权重，对极端不平衡数据效果有限

Focal Loss 通过降低易分类样本的权重，让模型更关注难样本。表达式为：

FL = -[y*(1-p)^γ*log(p) + (1-y)*p^γ*log(1-p)]

其中 γ 是调节因子，通常取 2。

优点：自动调整样本权重，对极端不平衡数据效果好
缺点：需要调整 γ 参数，训练初期可能不稳定

以下是 PyTorch 的实现示例：

import torch
import torch.nn as nn
import torch.nn.functional as F

# 数据加载
class ImbalancedDataset(torch.utils.data.Dataset):
    def __init__(self, data, targets):
        self.data = data
        self.targets = targets

    def __len__(self):
        return len(self.targets)

    def __getitem__(self, idx):
        return self.data[idx], self.targets[idx]

# 加权 BCE
class WeightedBCELoss(nn.Module):
    def __init__(self, pos_weight=1.0, neg_weight=1.0):
        super().__init__()
        self.pos_weight = pos_weight
        self.neg_weight = neg_weight

    def forward(self, input, target):
        loss = - (self.pos_weight * target * torch.log(input) + 
                 self.neg_weight * (1 - target) * torch.log(1 - input))
        return loss.mean()

# Focal Loss
class FocalLoss(nn.Module):
    def __init__(self, gamma=2):
        super().__init__()
        self.gamma = gamma

    def forward(self, input, target):
        bce = F.binary_cross_entropy(input, target, reduction='none')
        pt = torch.exp(-bce)
        loss = (1 - pt)**self.gamma * bce
        return loss.mean()

# 训练循环
def train(model, train_loader, criterion, optimizer, device):
    model.train()
    total_loss = 0

    for data, target in train_loader:
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target.float())
        loss.backward()
        optimizer.step()
        total_loss += loss.item()

    return total_loss / len(train_loader)

我们在信用卡欺诈检测数据集上对比了不同方法的表现：