BCELoss损失函数计算公式详解：从数学原理到PyTorch实战

1次阅读

没有评论

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

在二分类任务中，BCELoss（Binary Cross Entropy Loss）是最常用的损失函数之一。它通过衡量预测概率分布与真实标签之间的差异来指导模型优化。但在实际应用中，很多开发者会遇到以下问题：

直接对原始概率使用 BCELoss 可能导致数值不稳定，特别是在概率接近 0 或 1 时。
不清楚 BCELoss 与 Logits 版本的区别，导致模型训练效果不佳。
在多任务学习中，如何合理调整 BCELoss 的权重也是一个常见挑战。

BCELoss 的原始公式如下：

$$
L = -[y \cdot \log(p) + (1 – y) \cdot \log(1 – p)]
$$

其中，(y) 是真实标签（0 或 1），(p) 是预测概率（0 到 1 之间）。这个公式的核心思想是通过对数函数放大预测概率与真实标签之间的差异，从而更敏感地反映模型的错误。

然而，直接使用这个公式可能会导致数值不稳定问题。例如，当 (p) 接近 0 或 1 时，(\log(p) ) 或 (\log(1 – p) ) 会趋向于负无穷，导致梯度爆炸或消失。

为了解决这个问题，PyTorch 提供了BCEWithLogitsLoss，它结合了 Sigmoid 激活函数和 BCELoss 的计算过程，直接在 logits 空间进行计算，从而避免了数值不稳定的问题。

nn.BCELoss要求输入的是经过 Sigmoid 处理后的概率值，范围在 [0, 1] 之间。以下是一个简单的示例：

import torch
import torch.nn as nn

# 定义 BCELoss
criterion = nn.BCELoss()

# 模拟预测概率和真实标签
predictions = torch.tensor([0.9, 0.1, 0.8], dtype=torch.float32)
labels = torch.tensor([1.0, 0.0, 1.0], dtype=torch.float32)

# 计算损失
loss = criterion(predictions, labels)
print(f"BCELoss: {loss.item()}")

nn.BCEWithLogitsLoss则直接接受 logits 作为输入，内部会自动应用 Sigmoid 函数。这种方式在数值稳定性上更有优势：

# 定义 BCEWithLogitsLoss
criterion = nn.BCEWithLogitsLoss()

# 模拟 logits 和真实标签
logits = torch.tensor([2.0, -2.0, 1.5], dtype=torch.float32)
labels = torch.tensor([1.0, 0.0, 1.0], dtype=torch.float32)

# 计算损失
loss = criterion(logits, labels)
print(f"BCEWithLogitsLoss: {loss.item()}")

以下是一个常见的错误用法，直接对未归一化的 logits 使用 BCELoss：

# 错误用法：直接对 logits 使用 BCELoss
predictions = torch.tensor([2.0, -2.0, 1.5], dtype=torch.float32)
labels = torch.tensor([1.0, 0.0, 1.0], dtype=torch.float32)

# 未应用 Sigmoid，导致数值不稳定
loss = criterion(predictions, labels)
print(f"错误用法的 BCELoss: {loss.item()}")  # 可能输出 nan 或 inf

为了避免数值不稳定，可以在计算 BCELoss 时添加一个小的 epsilon 值，防止 (\log(0) ) 的情况：

epsilon = 1e-7
predictions = torch.clamp(predictions, epsilon, 1.0 - epsilon)
loss = - (labels * torch.log(predictions) + (1 - labels) * torch.log(1 - predictions))
loss = loss.mean()

在多任务学习中，不同任务的样本分布可能不均衡。可以通过调整 BCELoss 的权重来平衡各任务的重要性：

# 定义权重
pos_weight = torch.tensor([2.0])  # 正样本权重
criterion = nn.BCEWithLogitsLoss(pos_weight=pos_weight)

计算效率 ：在 GPU 上，BCEWithLogitsLoss 通常比手动组合 Sigmoid 和 BCELoss 更快，因为它融合了多个操作。
内存占用：使用半精度浮点数（torch.float16）可以显著减少内存占用，但需要注意数值精度问题。

以下是一个手动实现 BCELoss 的示例，用于理解其内部机制：

def manual_bce(predictions, labels, epsilon=1e-7):
    predictions = torch.clamp(predictions, epsilon, 1.0 - epsilon)
    loss = - (labels * torch.log(predictions) + (1 - labels) * torch.log(1 - predictions))
    return loss.mean()

# 测试手动实现
predictions = torch.tensor([0.9, 0.1, 0.8], dtype=torch.float32)
labels = torch.tensor([1.0, 0.0, 1.0], dtype=torch.float32)

manual_loss = manual_bce(predictions, labels)
print(f"手动实现 BCELoss: {manual_loss.item()}")