pytorch中BCELoss、CrossEntropyLoss和NLLLoss

这篇博客详细介绍了PyTorch中二分类任务中常用的三种损失函数:BCELoss、BCEWithLogitsLoss和CrossEntropyLoss的区别。BCEWithLogitsLoss已经包含了Sigmoid,而CrossEntropyLoss包含了Softmax。CrossEntropyLoss的输入可以直接是类别标签,而BCE系列需要一维目标。博客通过代码展示了它们的计算过程,并给出了手动计算交叉熵损失的方法。此外,还实现了一个自定义的SCELoss,它结合了交叉熵和相对熵损失。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

在PyTorch中进行二分类,有三种主要的全连接层,激活函数和loss function组合的方法,分别是:torch.nn.Linear+torch.sigmoid+torch.nn.BCELoss,torch.nn.Linear+BCEWithLogitsLoss,和torch.nn.Linear(输出维度为2)+torch.nn.CrossEntropyLoss,BCEWithLogitsLoss集成了Sigmoid,但是CrossEntropyLoss集成了Softmax。

下面重点写写几点区别:

  • CrossEntropyLoss的输入logits=(3,2),target=(3)就够了,但是BCELoss、BCEWithLogitsLoss的输入得是logits=(3,2),target=(3,2)。也就是说BCE系列在设计的时候是期待把输出压缩成一维再过;但是CrossEntropyLoss是可以多维且每一维对应某一个类别的logit。
  • CrossEntropyLoss的target是LongTensor,表示是哪一类;但是BCE系列是0到1之间的FloatTensor
  • CrossEntropyLoss和BCE系列从数值上看除了0.5的情况下其他情况完全不一样。BCE系列的数值计算思路是target*log(logits)+(1-target)*log(1-logits);但是CrossEntropyLoss实际上是Softmax+NLLLoss, 最后数值计算思路变成-logits[sample_index][选中类别]+sum(exp(logits[sample_index][i]) for i in all),CE的推导可以参考信息熵 条件熵 交叉熵 联合熵 相对熵 KL散度 SCE MAE 互信息(信息增益)

来点代码:

import torch
from torch import nn
import math

loss_f = nn.CrossEntropyLoss(reduction='none')
output = torch.randn(2, 3)  # 表示2个样本,3个类别
# target = torch.from_numpy(np.array([1, 0])).type(torch.LongTensor)
target = torch.LongTensor([0, 2])  # 表示label0和label2
loss = loss_f(output, target)

print('CrossEntropy loss: ', loss)
print(f'reduction=none,所以可以看到每一个样本loss,输出为[{loss}]')

nll = nn.NLLLoss(reduction='none')
logsoftmax = nn.LogSoftmax(dim=-1)
print('logsoftmax(output) result: {}'.format(logsoftmax(output)))
#可以清晰地看到nll这个loss在pytorch多分类里作用就是取个负号,同时去target对应下标拿一下已经算好的logsoftmax的值
print('nll(logsoftmax(output), target) :{}'.format(nll(logsoftmax(output), target)))


def manual_cal(sample_index, target, output):
    # 输入是样本下标
    sample_output = output[sample_index]
    sample_target = target[sample_index]
    x_class = sample_output[sample_target]
    sample_output_len = len(sample_output)
    log_sigma_exp_x = math.log(sum(math.exp(sample_output[i]) for i in range(sample_output_len)))
    sample_loss = -x_class + log_sigma_exp_x
    print(f'交叉熵手动计算loss{sample_index}:{sample_loss}')
    return sample_loss

for i in range(2):
    manual_cal(i, target, output)

# 如果nn.CrossEntropyLoss(reduction='mean')模式,刚好是手动计算的每个样本的loss取平均,最后输出的是一个值
# 如果nn.CrossEntropyLoss(reduction='none')模式,手动计算的loss0和loss1都会被列出来

'''
贴一个输出
CrossEntropy loss:  tensor([2.7362, 0.9749])
reduction=none,所以可以看到每一个样本loss,输出为[tensor([2.7362, 0.9749])]
logsoftmax(output) result: tensor([[-2.7362, -1.4015, -0.3726],
        [-0.8505, -1.6319, -0.9749]])
nll(logsoftmax(output), target) :tensor([2.7362, 0.9749])
交叉熵手动计算loss0:2.736179828643799
交叉熵手动计算loss1:0.9749272465705872
'''

如果用Pytorch来实现,可以看以下脚本,顺带连rce(logit和pred对换)和sce(ce和rce加强)也实现了:

import torch.nn.functional as F
import torch
import torch.nn as nn
# nn.CrossEntropyLoss() 和  KLDivLoss 关系

class SCELoss(nn.Module):
    def __init__(self, num_classes=10, a=1, b=1, eps=1e-18):
        super(SCELoss, self).__init__()
        self.num_classes = num_classes
        self.a = a #两个超参数
        self.b = b
        self.cross_entropy = nn.CrossEntropyLoss()
        self.cross_entropy_none = nn.CrossEntropyLoss(reduction="none")
        self.eps = eps

    def forward(self, raw_pred, labels):
        # CE 部分,正常的交叉熵损失
        ce = self.cross_entropy(raw_pred, labels)
        # RCE
        pred = F.softmax(raw_pred, dim=1)
        pred = torch.clamp(pred, min=self.eps, max=1.0)
        label_one_hot = F.one_hot(labels, self.num_classes).float().to(pred.device)
        label_one_hot = torch.clamp(label_one_hot, min=self.eps, max=1.0) #最小设为 1e-4,即 A 取 -4

        my_ce = (-1 * torch.sum(label_one_hot * torch.log(pred), dim=1))
        print('pred={} label_one_hot={} my_ce={}'.format(pred, label_one_hot, my_ce))
        print('raw_pred={} labels={} official_ce={}'.format(raw_pred, labels, self.cross_entropy_none(raw_pred, labels)))

        rce = (-1 * torch.sum(pred * torch.log(label_one_hot), dim=1))
        print('pred={} label_one_hot={} rce={}'.format(pred, label_one_hot, rce))

        loss = self.a * ce + self.b * rce.mean()
        return loss

y_pred = torch.tensor([[10.0, 5.0, -6.0], [8.0, 8.0, 8.0]])
y_true = torch.tensor([0, 2])
ce1 = SCELoss(num_classes=3)(y_pred, y_true)

来个各种CE的完整实现:

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

class MyCE1(nn.Module):
    def __init__(self):
        super(MyCE1, self).__init__()
        self.nll = nn.NLLLoss(reduction='none')
        self.logsoftmax = nn.LogSoftmax(dim=-1)
    def forward(self, logits, targets):
        return self.nll(self.logsoftmax(logits), targets)

class MyCE2(nn.Module):
    def __init__(self):
        super(MyCE2, self).__init__()

    def forward(self, logits, targets):
        label_one_hot = F.one_hot(targets, num_classes=max(targets)+1)
        logits_softmax_log = torch.log(logits.softmax(dim=-1))
        res = -1*torch.sum(label_one_hot*logits_softmax_log, dim=-1)
        return res

if __name__ == '__main__':
    logits = torch.rand(4,3)
    targets = torch.LongTensor([1,2,1,0])
    myce1 = MyCE1()
    myce2 = MyCE2()
    ce = nn.CrossEntropyLoss(reduction='none')
    print(myce1(logits, targets))
    print(myce2(logits, targets))
    print(ce(logits, targets))
'''
tensor([0.8806, 0.9890, 1.1915, 1.2485])
tensor([0.8806, 0.9890, 1.1915, 1.2485])
tensor([0.8806, 0.9890, 1.1915, 1.2485])
'''

----------------------------------------

转载自: 二分类问题,应该选择sigmoid还是softmax? - 知乎 

pytorch验证CrossEntropyLoss ,BCELoss 和 BCEWithLogitsLoss - CodeAntenna

PyTorch二分类时BCELoss,CrossEntropyLoss,Sigmoid等的选择和使用 - 知乎

### PyTorchCrossEntropyLossBCELoss的区别 #### CrossEntropyLoss适用场景 对于多分类问题,`torch.nn.CrossEntropyLoss` 是更为常见的选择。该损失函数适用于具有多个类别的单标签分类任务,在这种情况下,每个样本只属于一个类别。此函数内部实现了softmax层加上负对数似然损失(NLL),这意味着输入不需要预先通过softmax处理[^1]。 ```python import torch import torch.nn as nn criterion = nn.CrossEntropyLoss() output = torch.randn(4, 5, requires_grad=True) # batch_size=4, num_classes=5 target = torch.empty(4, dtype=torch.long).random_(5) loss = criterion(output, target) print(loss.item()) ``` #### BCELoss适用场景 另一方面,二元交叉熵损失(`torch.nn.BCELoss`)用于解决二分类或多标签分类问题。当面对的是多标签情况时——即允许一个实例可以归属于超过一个类别的情况,则应该采用这个损失函数。值得注意的是,使用`BCELoss`前需确保网络输出已经过sigmoid激活函数转换成概率形式[^2]。 ```python criterion = nn.BCELoss() input = torch.sigmoid(torch.randn((3, 2), requires_grad=True)) # 假设有三个样例两个标签 target = torch.tensor([[0., 1.], [1., 0.], [1., 1.]]) loss = criterion(input, target) print(loss.item()) ``` #### 主要差异总结 - **应用场景**: `CrossEntropyLoss`针对单一真实标签的多分类;而`BCELoss`适合于二分类以及允许多个正类别的多标签设置。 - **预处理需求**: 使用`CrossEntropyLoss`时不必显式应用softmax变换;相反地,利用`BCELoss`之前则通常需要先经过sigmoid运算来获得每种类别上的独立概率估计值。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值