交叉熵损失函数（Cross-Entropy Loss）

原理

交叉熵损失函数是深度学习中分类问题常用的损失函数，特别适用于多分类问题。它通过度量预测分布与真实分布之间的差异，来衡量模型输出的准确性。

交叉熵的数学公式

交叉熵的定义如下：
$$\begin{array}{c}CrossEntroyLoss=-\sum _{i=1}^N{y}_i\cdot log({\hat{y}}_i)\end{array}$$

• $N$：类别数
• $y_i$：真实的标签（用 one-hot 编码表示，只有目标类别对应的位置为 1，其他位置为 0）。
• ${\hat{y}}_i$​：模型的预测概率，即 softmax 的输出值。

对于单个样本：
$$\begin{array}{c}Loss=-log({\hat{y}}_c)\end{array}$$
其中$c$是真实类别的索引。

解释：

• 如果模型的预测概率${\hat{y}}_c$越接近1，则$-log({\hat{y}}_c)$越小，损失越大。
• 如果${\hat{y}}_c$越接近0，则$-log({\hat{y}}_c)$​越大，损失越大。

交叉熵损失和softmax函数的关系

• 模型通常输出logits（未归一化的分数），例如$[z_1,z_2,\cdots ,z_N]$。

• softmax函数将logits转化为概率分布：
  $$\begin{array}{c}{\hat{y}}_i=\frac{z^{z_i}}{{\sum }_{j=1}^N{e}^{z_j}}\end{array}$$

• 交叉熵损失结合 softmax，用来计算预测分布与真实分布之间的差异。

在 PyTorch 的 CrossEntropyLoss 中，softmax 和交叉熵是结合在一起实现的，因此你不需要手动调用 softmax。

特性

应用场景：

• 多分类任务，例如图像分类、文本分类等。
• 真实标签通常以整数形式存储（如 0, 1, 2）。

数值稳定性：

• 由于 softmax 和交叉熵结合在一起，可以避免单独计算 softmax 导致的数值不稳定问题。

Pytorch中的实现

构造函数

PyTorch 提供了 torch.nn.CrossEntropyLoss：

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

参数说明：

• weight：用于对不同类别赋予不同的权重。
• ignore_index：指定忽略某些类别的损失（通常用于处理 padding）。
• reduction：决定损失的输出形式：
  • 'mean'（默认）：返回损失的均值。
  • 'sum'：返回损失的总和。
  • 'none'：返回每个样本的损失值。

使用示例

1、单样本交叉熵损失

import torch
import torch.nn as nn

# 模型的输出 logits 和真实标签
logits = torch.tensor([[2.0, 1.0, 0.1]])  # 未经过 softmax 的输出
labels = torch.tensor([0])               # 真实标签（类别索引）

# 定义交叉熵损失函数
criterion = nn.CrossEntropyLoss()

# 计算损失
loss = criterion(logits, labels)
print("CrossEntropyLoss:", loss.item())

解释：

• logits 是未归一化的分数。
• labels 是类别索引（如类别 0）。
• 内部会先对 logits 应用 softmax，再计算交叉熵损失。

计算细节：

a)、给定的数据

• logits: $\left[\begin{array}{ccc}2.0& 1.0& 0.1\end{array}\right]$
  • 这是模型输出的未归一化分数（logits）。
• labels: $\left[\begin{array}{c}0\end{array}\right]$
  • 真实标签，表示类别索引（0 表示第一类）。

b)、CrossEntropyLoss 的计算公式，交叉熵损失公式如下：
$$\begin{array}{c}Loss=-\frac{1}{N}\sum _{i=1}^{N}log\left(\frac{exp(logi{t}_{y_i})}{{\sum }_{j}exp(logi{t}_j)}\right)\end{array}$$
其中：

• $N$: 样本数量（在这里为 1）。
• $logi{t}_j$: 第$j$类的 logit 值。
• $y_i$: 样本 $i$​ 的真实类别索引。

c)、具体的步骤

step 1：softmax计算概率分布

softmax函数将logits转换为概率分布：
$$\begin{array}{c}softmax(z_i)=\frac{exp(z_i)}{{\sum }_{j}exp(z_j)}\end{array}$$
对于logits: $\left[\begin{array}{ccc}2.0& 1.0& 0.1\end{array}\right]$，计算如下：

• 计算每个元素的指数：

$$\begin{array}{c}exp(2.0)=e^2\approx 7.389,exp(1.0)=e^1\approx 2.718,exp(0.1)=e^{0.1}\approx 1.105\end{array}$$

• 求和：

$$\begin{array}{c}sum=7.389+2.718+1.105\approx 11.212\end{array}$$

• 计算每个类别的概率：

$$\begin{array}{c}softmax(2.0)=\frac{7.389}{11.212}\approx 0.659,softmax(1.0)=\frac{2.718}{11.212}\approx 0.242,softmax(0.1)=\frac{1.105}{11.212}\approx 0.099\end{array}$$

概率分布为：
$$\left[\begin{array}{ccc}0.659& 0.242& 0.099\end{array}\right]$$
step 2：取真实标签对应的概率

真实标签$y=0$，对应的概率为第一个类别的softmax输出：
$$\begin{array}{c}P(y=0)=0.659\end{array}$$
step 3：计算交叉熵损失

根据交叉熵公式，损失为：
$$\begin{array}{c}Loss=-log(P(y=0))=-log(0.659)\end{array}$$
计算对数值：
$$\begin{array}{c}log(0.659)\approx -0.416\end{array}$$
因此，损失为：
$$\begin{array}{c}Loss=0.416\end{array}$$

2、多样本交叉熵损失

logits = torch.tensor(
        [[1.5, 0.3, 2.1], [2.0, 1.0, 0.1], [0.1, 2.2, 1.0]]
    )  # Batch size = 3

labels = torch.tensor([2, 0, 1])  # Batch size = 3

# 定义交叉熵损失函数
criterion = nn.CrossEntropyLoss()

# 计算损失
loss = criterion(logits, labels)
print("CrossEntropyLoss:", loss.item())

a)、给定的数据

logits（未归一化的分数）：
$$logits=\left[\begin{array}{ccc}1.5& 0.3& 2.1\\ 2.0& 1.0& 0.1\\ 0.1& 2.2& 1.0\end{array}\right]$$
labels（真实标签的索引）：
$$labels=\left[\begin{array}{ccc}2& 0& 1\end{array}\right]$$

• 第一行对应的类别2
• 第二行对应的类别0
• 第三行对应的类别1

b)、交叉熵损失函数
$$\begin{array}{c}Loss=-\frac{1}{N}\sum _{i=1}^{N}log\left(\frac{exp(logi{t}_{i,y_i})}{{\sum }_{j}exp(logi{t}_{i,j})}\right)\end{array}$$
其中：

• $N=3$: 是批量大小。
• $logi{t}_{i,j}$: 是样本$i$对类别$j$的预测分数。
• $y_i$: 样本 $i$​​ 的真实类别索引。

c)、逐行计算softmax概率和交叉熵损失

step 1：第一行 $logits=\left[\begin{array}{ccc}1.5& 0.3& 2.1\end{array}\right]$​，真实标签 = 2

• 计算softmax：

  • 计算每个分数的指数值：

  $$\begin{array}{c}exp(1.5)\approx 4.481,exp(0.3)\approx 1.350,exp(2.1)\approx 8.165\end{array}$$

  • 求和

  $$\begin{array}{c}sum=4.481+1.350+8.165\approx 13.996\end{array}$$

  • 计算每个类别的概率

  $$\begin{array}{c}P(0)=\frac{4.481}{13.996}\approx 0.32,P(1)=\frac{1.350}{13.996}\approx 0.096,P(2)=\frac{8.165}{13.996}\approx 0.583\end{array}$$

• 取真实类别2的概率：

$$\begin{array}{c}P(y=2)=0.583\end{array}$$

• 计算损失：

$$\begin{array}{c}Los{s}_1=-log(0.583)\approx 0.540\end{array}$$

step 2：第二行 $logits=\left[\begin{array}{ccc}2.0& 1.0& 0.1\end{array}\right]$​，真实标签 = 0

• 计算softmax：

  • 计算每个分数的指数值：

  $$\begin{array}{c}exp(2.0)\approx 7.389,exp(1.0)\approx 2.718,exp(0.1)\approx 1.105\end{array}$$

  • 求和

  $$\begin{array}{c}sum=7.389+2.718+1.105\approx 11.212\end{array}$$

  • 计算每个类别的概率

  $$\begin{array}{c}P(0)=\frac{7.389}{11.212}\approx 0.659,P(1)=\frac{2.718}{11.212}\approx 0.242,P(2)=\frac{1.105}{11.212}\approx 0.099\end{array}$$

• 取真实类别0的概率：

$$\begin{array}{c}P(y=0)=0.659\end{array}$$

• 计算损失：

$$\begin{array}{c}Los{s}_2=-log(0.659)\approx 0.417\end{array}$$

step 3：第二行 $logits=\left[\begin{array}{ccc}0.1& 2.2& 1.0\end{array}\right]$​，真实标签 = 1

• 计算softmax：

  • 计算每个分数的指数值：

  $$\begin{array}{c}exp(0.1)\approx 1.105,exp(2.2)\approx 9.025,exp(1.0)\approx 2.718\end{array}$$

  • 求和

  $$\begin{array}{c}sum=1.105+9.025+2.718\approx 12.848\end{array}$$

  • 计算每个类别的概率

  $$\begin{array}{c}P(0)=\frac{1.105}{12.848}\approx 0.086,P(1)=\frac{9.025}{12.848}\approx 0.703,P(2)=\frac{2.718}{12.848}\approx 0.211\end{array}$$

• 取真实类别1的概率：

$$\begin{array}{c}P(y=1)=0.703\end{array}$$

• 计算损失：

$$\begin{array}{c}Los{s}_3=-log(0.703)\approx 0.353\end{array}$$

d)、批量损失

将每个样本的损失平均：
$$\begin{array}{c}Loss=\frac{Los{s}_1+Los{s}_2+Los{s}_3}{3}=\frac{0.540+0.417+0.353}{3}\approx 0.437\end{array}$$
3、带权重的交叉熵

在某些情况下，类别分布不平衡，可以为不同类别设置权重：

weights = torch.tensor([1.0, 2.0, 3.0])  # 类别权重
criterion = nn.CrossEntropyLoss(weight=weights)

loss = criterion(logits, labels)
print("Weighted CrossEntropyLoss:", loss.item())

4、示例：在神经网络中的应用

import torch
import torch.nn as nn
import torch.optim as optim

# 定义一个简单的神经网络
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc = nn.Linear(4, 3)  # 输入 4 维特征，输出 3 类

    def forward(self, x):
        return self.fc(x)

# 模型、损失函数和优化器
model = SimpleNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

# 输入数据和标签
inputs = torch.tensor([[0.5, 1.2, -1.3, 0.8], [0.3, -0.7, 1.0, 1.5]])  # Batch size = 2
labels = torch.tensor([0, 2])  # 两个样本对应的真实类别

# 前向传播
outputs = model(inputs)

# 计算损失
loss = criterion(outputs, labels)
print("Loss:", loss.item())

# 反向传播和优化
loss.backward()
optimizer.step()

5、总结

• 交叉熵损失函数用于度量预测分布与真实分布之间的差异，是分类问题中的核心工具。

• 在 PyTorch 中，torch.nn.CrossEntropyLoss 结合了 softmax 和交叉熵计算，使用简单且高效。

• 可以通过参数调整（如权重）来适应不平衡数据集。

整合的代码

import torch
import torch.nn as nn
import torch.optim as optim


def single_instance_CrossEntropyLoss():
    # 模型的输出 logits 和真实标签
    logits = torch.tensor([[2.0, 1.0, 0.1]])  # 未经过 softmax 的输出
    labels = torch.tensor([0])  # 真实标签（类别索引）

    # 定义交叉熵损失函数
    criterion = nn.CrossEntropyLoss()

    # 计算损失
    loss = criterion(logits, labels)
    print("CrossEntropyLoss:", loss.item())


def multi_instance_CrossEntropyLoss():
    logits = torch.tensor(
        [[1.5, 0.3, 2.1], [2.0, 1.0, 0.1], [0.1, 2.2, 1.0]]
    )  # Batch size = 3

    labels = torch.tensor([2, 0, 1])  # Batch size = 3

    # 定义交叉熵损失函数
    criterion = nn.CrossEntropyLoss()

    # 计算损失
    loss = criterion(logits, labels)
    print("CrossEntropyLoss:", loss.item())


# 定义一个简单的神经网络
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc = nn.Linear(4, 3)  # 输入 4 维特征，输出 3 类

    def forward(self, x):
        return self.fc(x)


def apply_deepLearning_CrossEntropyLoss():

    # 模型、损失函数和优化器
    model = SimpleNet()
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.01)

    # 输入数据和标签
    inputs = torch.tensor(
        [[0.5, 1.2, -1.3, 0.8], [0.3, -0.7, 1.0, 1.5]]
    )  # Batch size = 2
    labels = torch.tensor([0, 2])  # 两个样本对应的真实类别

    # 前向传播
    outputs = model(inputs)

    # 计算损失
    loss = criterion(outputs, labels)
    print("Loss:", loss.item())

    # 反向传播和优化
    loss.backward()
    optimizer.step()


if __name__ == "__main__":
    print("*" * 30)
    single_instance_CrossEntropyLoss()
    multi_instance_CrossEntropyLoss()
    apply_deepLearning_CrossEntropyLoss()