PyTorch nn.CrossEntropyLoss() 交叉熵损失函数详解和要点提醒

2024-06-23 06:52
文章标签 pytorch nn crossentropyloss 详解 要点 交叉 函数 提醒 损失

本文主要是介绍PyTorch nn.CrossEntropyLoss() 交叉熵损失函数详解和要点提醒，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

  • 前置知识
  • nn.CrossEntropyLoss() 交叉熵损失
    • 参数
    • 数学公式
      • 带权重的公式（weight）
      • 标签平滑（label_smoothing）
    • 要点
  • 附录
  • 参考链接

前置知识

深度学习：关于损失函数的一些前置知识（PyTorch Loss）

nn.CrossEntropyLoss() 交叉熵损失

torch.nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean', label_smoothing=0.0)

This criterion computes the cross entropy loss between input logits and target.

该函数计算输入 logits 和目标之间的交叉熵损失。

参数

  • weight (Tensor, 可选): 一个形状为 ( C ) (C) (C) 的张量，表示每个类别的权重。如果提供了这个参数，损失函数会根据类别的权重来调整各类别的损失，适用于类别不平衡的问题。默认值是 None。
  • size_average (bool, 可选): 已弃用。如果 reduction 不是 'none'，则默认情况下损失是取平均（True）；否则，是求和（False）。默认值是 None。
  • ignore_index (int, 可选): 如果指定了这个参数，则该类别的索引会被忽略，不会对损失和梯度产生影响。默认值是 -100。
  • reduce (bool, 可选): 已弃用。请使用 reduction 参数。默认值是 None。
  • reduction (str, 可选): 指定应用于输出的归约方式。可选值为 'none'、'mean'、'sum'。'none' 表示不进行归约，'mean' 表示对所有样本的损失求平均，'sum' 表示对所有样本的损失求和。默认值是 'mean'。
  • label_smoothing (float, 可选): 标签平滑值，范围在 [0.0, 1.0] 之间。默认值是 0.0。标签平滑是一种正则化技术，通过在真实标签上添加一定程度的平滑来避免过拟合。

数学公式

附录部分会验证下述公式和代码的一致性。

假设有 N N N 个样本，每个样本属于 C C C 个类别之一。对于第 i i i 个样本，它的真实类别标签为 y i y_i yi​，模型的输出 logits 为 x i = ( x i 1 , x i 2 , … , x i C ) \mathbf{x}_i = (x_{i1}, x_{i2}, \ldots, x_{iC}) xi​=(xi1​,xi2​,…,xiC​)，其中 x i c x_{ic} xic​ 表示第 i i i 个样本在第 c c c 类别上的原始输出分数（logits）。

交叉熵损失的计算步骤如下：

  1. Softmax 函数：
    对 logits 进行 softmax 操作，将其转换为概率分布：
    p i c = exp ⁡ ( x i c ) ∑ j = 1 C exp ⁡ ( x i j ) p_{ic} = \frac{\exp(x_{ic})}{\sum_{j=1}^{C} \exp(x_{ij})} pic​=∑j=1C​exp(xij​)exp(xic​)​
    其中 $ p_{ic} $ 表示第 $ i $ 个样本属于第 $ c $ 类别的预测概率。
  2. 负对数似然（Negative Log-Likelihood）：
    计算负对数似然：
    ℓ i = − log ⁡ ( p i y i ) \ell_i = -\log(p_{iy_i}) ℓi​=−log(piyi​​)
    其中 ℓ i \ell_i ℓi​ 是第 i i i 个样本的损失， p i y i p_{iy_i} piyi​​ 表示第 i i i 个样本在真实类别 y i y_i yi​ 上的预测概率。
  3. 总损失：
    计算所有样本的平均损失（ reduction 参数默认为 'mean'）：
    L = 1 N ∑ i = 1 N ℓ i = 1 N ∑ i = 1 N − log ⁡ ( p i y i ) \mathcal{L} = \frac{1}{N} \sum_{i=1}^{N} \ell_i = \frac{1}{N} \sum_{i=1}^{N} -\log(p_{iy_i}) L=N1​i=1∑N​ℓi​=N1​i=1∑N​−log(piyi​​)
    如果 reduction 参数为 'sum'，总损失为所有样本损失的和：
    L = ∑ i = 1 N ℓ i = ∑ i = 1 N − log ⁡ ( p i y i ) \mathcal{L} = \sum_{i=1}^{N} \ell_i = \sum_{i=1}^{N} -\log(p_{iy_i}) L=i=1∑N​ℓi​=i=1∑N​−log(piyi​​)
    如果 reduction 参数为 'none'，则返回每个样本的损失 ℓ i \ell_i ℓi​​ 组成的张量。
    L = [ ℓ 1 , ℓ 2 , … , ℓ N ] = [ − log ⁡ ( p i y 1 ) , − log ⁡ ( p i y 2 ) , … , − log ⁡ ( p i y N ) ] \mathcal{L} = [\ell_1, \ell_2, \ldots, \ell_N] = [-\log(p_{iy_1}), -\log(p_{iy_2}), \ldots, -\log(p_{iy_N})] L=[ℓ1​,ℓ2​,…,ℓN​]=[−log(piy1​​),−log(piy2​​),…,−log(piyN​​)]

带权重的公式（weight）

如果指定了类别权重 w = ( w 1 , w 2 , … , w C ) \mathbf{w} = (w_1, w_2, \ldots, w_C) w=(w1​,w2​,…,wC​)，则总损失公式为：

L = 1 N ∑ i = 1 N w y i ⋅ ℓ i = ∑ i = 1 N w y i ⋅ ( − log ⁡ ( p i y i ) ) ∑ i = 1 N w y i \mathcal{L} = \frac{1}{N} \sum_{i=1}^{N} w_{y_i} \cdot \ell_i = \frac{\sum_{i=1}^{N} w_{y_i} \cdot (-\log(p_{iy_i}))}{\sum_{i=1}^{N} w_{y_i}} L=N1​i=1∑N​wyi​​⋅ℓi​=∑i=1N​wyi​​∑i=1N​wyi​​⋅(−log(piyi​​))​

其中 w y i w_{y_i} wyi​​ 是第 i i i 个样本真实类别的权重。

标签平滑（label_smoothing）

如果标签平滑（label smoothing）参数 α \alpha α 被启用，目标标签 y i \mathbf{y}_i yi​ 会被平滑处理：

y i ′ = ( 1 − α ) ⋅ y i + α C \mathbf{y}_i' = (1 - \alpha) \cdot \mathbf{y}_i + \frac{\alpha}{C} yi′​=(1−α)⋅yi​+Cα​

其中， y i \mathbf{y}_i yi​ 是原始的 one-hot 编码目标标签， y i ′ \mathbf{y}_i' yi′​ 是平滑后的标签。

总的损失公式会相应调整：

ℓ i = − ∑ c = 1 C y i c ′ ⋅ log ⁡ ( p i c ) \ell_i = - \sum_{c=1}^{C} y_{ic}' \cdot \log(p_{ic}) ℓi​=−c=1∑C​yic′​⋅log(pic​)

其中， y i c y_{ic} yic​ 是第 i i i 个样本在第 c c c 类别上的标签，为原标签 y i y_i yi​ 经过 one-hot 编码后 y i \mathbf{y}_i yi​ 中的值。对于一个 one-hot 编码标签向量， y i c y_{ic} yic​ 在样本属于类别 c c c 时为 1，否则为 0。

要点

  1. nn.CrossEntropyLoss() 接受的输入是 logits，这说明分类的输出不需要提前经过 softmax。如果提前经过 softmax，则需要使用 nn.NLLLoss()（负对数似然损失）。
    import torch
import torch.nn as nn
import torch.nn.functional as F# 定义输入和目标标签
logits = torch.tensor([[2.0, 0.5], [0.5, 2.0]])  # 未经过 softmax 的 logits
target = torch.tensor([0, 1])  # 目标标签# 使用 nn.CrossEntropyLoss 计算损失（接受 logits）
criterion_ce = nn.CrossEntropyLoss()
loss_ce = criterion_ce(logits, target)# 使用 softmax 后再使用 nn.NLLLoss 计算损失
log_probs = F.log_softmax(logits, dim=1)
criterion_nll = nn.NLLLoss()
loss_nll = criterion_nll(log_probs, target)print(f"Loss using nn.CrossEntropyLoss: {loss_ce.item()}")
print(f"Loss using softmax + nn.NLLLoss: {loss_nll.item()}")# 验证两者是否相等
assert torch.allclose(loss_ce, loss_nll), "The losses are not equal, which indicates a mistake in the assumption."
print("The losses are equal, indicating that nn.CrossEntropyLoss internally applies softmax.")

    >>> Loss using nn.CrossEntropyLoss: 0.2014133334159851
>>> Loss using softmax + nn.NLLLoss: 0.2014133334159851
>>> The losses are equal, indicating that nn.CrossEntropyLoss internally applies softmax.
    拓展： F.log_softmax()
    F.log_softmax 等价于先应用 softmax 激活函数，然后对结果取对数 log()。它是将 softmax 和 log 这两个操作结合在一起，以提高数值稳定性和计算效率。具体的数学定义如下：
    log_softmax ( x i ) = log ⁡ ( softmax ( x i ) ) = log ⁡ ( exp ⁡ ( x i ) ∑ j exp ⁡ ( x j ) ) = x i − log ⁡ ( ∑ j exp ⁡ ( x j ) ) \text{log\_softmax}(x_i) = \log\left(\text{softmax}(x_i)\right) = \log\left(\frac{\exp(x_i)}{\sum_j \exp(x_j)}\right) = x_i - \log\left(\sum_j \exp(x_j)\right) log_softmax(xi​)=log(softmax(xi​))=log(∑j​exp(xj​)exp(xi​)​)=xi​−log(j∑​exp(xj​))
    在代码中，F.log_softmax 的等价操作可以用以下步骤实现：
    1. 计算 softmax。
    2. 计算 softmax 的结果的对数。
    import torch
import torch.nn.functional as F# 定义输入 logits
logits = torch.tensor([[2.0, 1.0, 0.1], [1.0, 3.0, 0.2]])# 计算 log_softmax
log_softmax_result = F.log_softmax(logits, dim=1)# 分开计算 softmax 和 log
softmax_result = F.softmax(logits, dim=1)
log_result = torch.log(softmax_result)print("Logits:")
print(logits)print("\nLog softmax (using F.log_softmax):")
print(log_softmax_result)print("\nSoftmax result:")
print(softmax_result)print("\nLog of softmax result:")
print(log_result)# 验证两者是否相等
assert torch.allclose(log_softmax_result, log_result), "The results are not equal."
print("\nThe results are equal, indicating that F.log_softmax is equivalent to softmax followed by log.")

    >>> Logits:
>>> tensor([[2.0000, 1.0000, 0.1000],
>>>         [1.0000, 3.0000, 0.2000]])>>> Log softmax (using F.log_softmax):
>>> tensor([[-0.4170, -1.4170, -2.3170],
>>>         [-2.1791, -0.1791, -2.9791]])>>> Softmax result:
>>> tensor([[0.6590, 0.2424, 0.0986],
>>>         [0.1131, 0.8360, 0.0508]])>>> Log of softmax result:
>>> tensor([[-0.4170, -1.4170, -2.3170],
>>>         [-2.1791, -0.1791, -2.9791]])>>> The results are equal, indicating that F.log_softmax is equivalent to softmax followed by log.
    从结果中可以看到 F.log_softmax 的结果等价于先计算 softmax 再取对数。
  2. nn.CrossEntropyLoss() 实际上默认（reduction=‘mean’）计算的是每个样本的平均损失，已经做了归一化处理，所以不需要对得到的结果进一步除以 batch_size 或其他某个数，除非是用作 loss_weight。下面是一个简单的例子：
    import torch
import torch.nn as nn# 定义损失函数
criterion = nn.CrossEntropyLoss()# 定义输入和目标标签
input1 = torch.tensor([[2.0, 0.5], [0.5, 2.0]], requires_grad=True)  # 批量大小为 2
target1 = torch.tensor([0, 1])  # 对应的目标标签input2 = torch.tensor([[2.0, 0.5], [0.5, 2.0], [2.0, 0.5], [0.5, 2.0]], requires_grad=True)  # 批量大小为 4
target2 = torch.tensor([0, 1, 0, 1])  # 对应的目标标签# 计算损失
loss1 = criterion(input1, target1)
loss2 = criterion(input2, target2)print(f"Loss with batch size 2: {loss1.item()}")
print(f"Loss with batch size 4: {loss2.item()}")

    >>> Loss with batch size 2: 0.2014133334159851
>>> Loss with batch size 4: 0.2014133334159851
    可以看到这里的 input2 实际上等价于 torch.cat([input1, input1], dim=0)，target2 等价于 torch.cat([target1, target1], dim=0)，简单拓展了 batch_size 大小但最终的 Loss 没变，这也就验证了之前的说法。
  3. 目标标签 target 期望两种格式：

    • 类别索引: 类别的整数索引，而不是 one-hot 编码。范围在 [ 0 , C ) [0, C) [0,C) 之间，其中 C C C​ 是类别数。如果指定了 ignore_index，则该类别索引也会被接受（即便可能不在类别范围内）
      使用示例：

      # Example of target with class indices
import torch
import torch.nn as nnloss = nn.CrossEntropyLoss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.empty(3, dtype=torch.long).random_(5)
output = loss(input, target)
output.backward()

    • 类别概率: 类别的概率分布，适用于需要每个批次项有多个类别标签的情况，如标签平滑等。
      使用示例：

      # Example of target with class probabilities
import torch
import torch.nn as nnloss = nn.CrossEntropyLoss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5).softmax(dim=1)
output = loss(input, target)
output.backward()

      The performance of this criterion is generally better when target contains class indices, as this allows for optimized computation. Consider providing target as class probabilities only when a single class label per minibatch item is too restrictive.

      通常情况下，当目标为类别索引时，该函数的性能更好，因为这样可以进行优化计算。只有在每个批次项的单一类别标签过于限制时，才考虑使用类别概率。

附录

用于验证数学公式和函数实际运行的一致性

import torch
import torch.nn.functional as F# 假设有两个样本，每个样本有三个类别
logits = torch.tensor([[1.5, 2.0, 0.5], [1.0, 0.5, 2.5]], requires_grad=True)
targets = torch.tensor([1, 2])# 根据公式实现 softmax
def softmax(x):return torch.exp(x) / torch.exp(x).sum(dim=1, keepdim=True)# 根据公式实现 log-softmax
def log_softmax(x):return x - torch.log(torch.exp(x).sum(dim=1, keepdim=True))# 根据公式实现负对数似然损失（NLLLoss）
def nll_loss(log_probs, targets):N = log_probs.size(0)return -log_probs[range(N), targets].mean()# 根据公式实现交叉熵损失
def custom_cross_entropy(logits, targets):log_probs = log_softmax(logits)return nll_loss(log_probs, targets)# 使用 PyTorch 计算交叉熵损失
criterion = torch.nn.CrossEntropyLoss(reduction='mean')
loss_torch = criterion(logits, targets)# 使用根据公式实现的交叉熵损失
loss_custom = custom_cross_entropy(logits, targets)# 打印结果
print("PyTorch 计算的交叉熵损失:", loss_torch.item())
print("根据公式实现的交叉熵损失:", loss_custom.item())# 验证结果是否相等
assert torch.isclose(loss_torch, loss_custom), "数学公式验证失败"# 带权重的交叉熵损失
weights = torch.tensor([0.7, 0.2, 0.1])
criterion_weighted = torch.nn.CrossEntropyLoss(weight=weights, reduction='mean')
loss_weighted_torch = criterion_weighted(logits, targets)# 根据公式实现带权重的交叉熵损失
def custom_weighted_cross_entropy(logits, targets, weights):log_probs = log_softmax(logits)N = logits.size(0)weighted_loss = -log_probs[range(N), targets] * weights[targets]return weighted_loss.sum() / weights[targets].sum()loss_weighted_custom = custom_weighted_cross_entropy(logits, targets, weights)# 打印结果
print("PyTorch 计算的带权重的交叉熵损失:", loss_weighted_torch.item())
print("根据公式实现的带权重的交叉熵损失:", loss_weighted_custom.item())# 验证结果是否相等
assert torch.isclose(loss_weighted_torch, loss_weighted_custom, atol=1e-6), "带权重的数学公式验证失败"# 标签平滑的交叉熵损失
alpha = 0.1
criterion_label_smoothing = torch.nn.CrossEntropyLoss(label_smoothing=alpha, reduction='mean')
loss_label_smoothing_torch = criterion_label_smoothing(logits, targets)# 根据公式实现标签平滑的交叉熵损失
def custom_label_smoothing_cross_entropy(logits, targets, alpha):N, C = logits.size()log_probs = log_softmax(logits)one_hot = torch.zeros_like(log_probs).scatter(1, targets.view(-1, 1), 1)smooth_targets = (1 - alpha) * one_hot + alpha / Closs = - (smooth_targets * log_probs).sum(dim=1).mean()return lossloss_label_smoothing_custom = custom_label_smoothing_cross_entropy(logits, targets, alpha)# 打印结果
print("PyTorch 计算的标签平滑的交叉熵损失:", loss_label_smoothing_torch.item())
print("根据公式实现的标签平滑的交叉熵损失:", loss_label_smoothing_custom.item())# 验证结果是否相等
assert torch.isclose(loss_label_smoothing_torch, loss_label_smoothing_custom, atol=1e-6), "标签平滑的数学公式验证失败"

>>> PyTorch 计算的交叉熵损失: 0.45524317026138306
>>> 根据公式实现的交叉熵损失: 0.4552431106567383
>>> PyTorch 计算的带权重的交叉熵损失: 0.5048722624778748
>>> 根据公式实现的带权重的交叉熵损失: 0.50487220287323
>>> PyTorch 计算的标签平滑的交叉熵损失: 0.5469098091125488
>>> 根据公式实现的标签平滑的交叉熵损失: 0.5469098091125488

输出没有抛出 AssertionError，验证通过。

参考链接

CrossEntropyLoss - Docs

这篇关于PyTorch nn.CrossEntropyLoss() 交叉熵损失函数详解和要点提醒的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1086440。

相关文章

十四、观察者模式与访问者模式详解

十四、观察者模式与访问者模式详解

21.观察者模式 21.1.课程目标 1、 掌握观察者模式和访问者模式的应用场景。 2、 掌握观察者模式在具体业务场景中的应用。 3、 了解访问者模式的双分派。 4、 观察者模式和访问者模式的优、缺点。 21.2.内容定位 1、 有 Swing开发经验的人群更容易理解观察者模式。 2、 访问者模式被称为最复杂的设计模式。 21.3.观察者模式 观 察 者 模 式 ( Obser
阅读更多...
【操作系统】信号Signal超详解|捕捉函数

【操作系统】信号Signal超详解|捕捉函数

🔥博客主页： 我要成为C++领域大神🎥系列专栏：【C++核心编程】 【计算机网络】 【Linux编程】 【操作系统】 ❤️感谢大家点赞👍收藏⭐评论✍️ 本博客致力于知识分享，与更多的人进行学习交流 ​ 如何触发信号 信号是Linux下的经典技术，一般操作系统利用信号杀死违规进程，典型进程干预手段，信号除了杀死进程外也可以挂起进程 kill -l 查看系统支持的信号
阅读更多...
java中查看函数运行时间和cpu运行时间

java中查看函数运行时间和cpu运行时间

android开发调查性能问题中有一个现象，函数的运行时间远低于cpu执行时间，因为函数运行期间线程可能包含等待操作。native层可以查看实际的cpu执行时间和函数执行时间。在java中如何实现？ 借助AI得到了答案 import java.lang.management.ManagementFactory;import java.lang.management.Threa
阅读更多...
Jitter Injection详解

Jitter Injection详解

一、定义与作用 Jitter Injection，即抖动注入，是一种在通信系统中人为地添加抖动的技术。该技术通过在发送端对数据包进行延迟和抖动调整，以实现对整个通信系统的时延和抖动的控制。其主要作用包括： 改善传输质量：通过调整数据包的时延和抖动，可以有效地降低误码率，提高数据传输的可靠性。均衡网络负载：通过对不同的数据流进行不同程度的抖动注入，可以实现网络资源的合理分配，提高整体传输效率。增
阅读更多...
SQL Server中，isnull（）函数以及null的用法

SQL Server中，isnull（）函数以及null的用法

SQL Serve中的isnull()函数：          isnull(value1,value2)         1、value1与value2的数据类型必须一致。         2、如果value1的值不为null，结果返回value1。         3、如果value1为null，结果返回vaule2的值。vaule2是你设定的值。        如
阅读更多...
Steam邮件推送内容有哪些？配置教程详解！

Steam邮件推送内容有哪些？配置教程详解！

Steam邮件推送功能是否安全？如何个性化邮件推送内容？ Steam作为全球最大的数字游戏分发平台之一，不仅提供了海量的游戏资源，还通过邮件推送为用户提供最新的游戏信息、促销活动和个性化推荐。AokSend将详细介绍Steam邮件推送的主要内容。 Steam邮件推送：促销优惠 每当平台举办大型促销活动，如夏季促销、冬季促销、黑色星期五等，用户都会收到邮件通知。这些邮件详细列出了打折游戏、
阅读更多...
探索Elastic Search：强大的开源搜索引擎，详解及使用

探索Elastic Search：强大的开源搜索引擎，详解及使用

🎬 鸽芷咕：个人主页  🔥 个人专栏: 《C++干货基地》《粉丝福利》 ⛺️生活的理想，就是为了理想的生活! 引入 全文搜索属于最常见的需求，开源的 Elasticsearch （以下简称 Elastic）是目前全文搜索引擎的首选，相信大家多多少少的都听说过它。它可以快速地储存、搜索和分析海量数据。就连维基百科、Stack Overflow、
阅读更多...
tf.split()函数解析

tf.split()函数解析

API原型（TensorFlow 1.8.0）： tf.split(     value,     num_or_size_splits,     axis=0,     num=None,     name='split' ) 这个函数是用来切割张量的。输入切割的张量和参数，返回切割的结果。  value传入的就是需要切割的张量。  这个函数有两种切割的方式： 以三个维度的张量为例，比如说一
阅读更多...
基于CTPN（tensorflow）+CRNN（pytorch）+CTC的不定长文本检测和识别

基于CTPN（tensorflow）+CRNN（pytorch）+CTC的不定长文本检测和识别

转发来源：https://swift.ctolib.com/ooooverflow-chinese-ocr.html chinese-ocr 基于CTPN（tensorflow）+CRNN（pytorch）+CTC的不定长文本检测和识别 环境部署 sh setup.sh 使用环境： python 3.6 + tensorflow 1.10 +pytorch 0.4.1 注：CPU环境
阅读更多...
常用MQ消息中间件Kafka、ZeroMQ和RabbitMQ对比及RabbitMQ详解

常用MQ消息中间件Kafka、ZeroMQ和RabbitMQ对比及RabbitMQ详解

1、概述   在现代的分布式系统和实时数据处理领域，消息中间件扮演着关键的角色，用于解决应用程序之间的通信和数据传递的挑战。在众多的消息中间件解决方案中，Kafka、ZeroMQ和RabbitMQ 是备受关注和广泛应用的代表性系统。它们各自具有独特的特点和优势，适用于不同的应用场景和需求。   Kafka 是一个高性能、可扩展的分布式消息队列系统，被设计用于处理大规模的数据流和实时数据传输。它
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2