2025-05-27 Python&深度学习7——损失函数和反向传播-EW帮帮网

文章目录

1 损失函数
2 反向传播

本文环境：

Pycharm 2025.1

Python 3.12.9

Pytorch 2.6.0+cu124

1 损失函数

损失函数 (loss function) 是将随机事件或其有关随机变量的取值映射为非负实数以表示该随机事件的"风险"或"损失"的函数。在机器学习中，损失函数通常作为学习准则与优化问题相联系，通过最小化损失函数来求解和评估模型。

损失函数主要分为两类：

回归问题：常用 L1 损失函数 (MAE) 和 L2 损失函数 (MSE)。
分类问题：常用 0-1 损失函数及其代理损失 (如交叉熵损失、铰链损失等)。

1.1 L1Loss

L1Loss 计算输入 ( $x$ ) 和目标 ( $y$ ) 之间的平均绝对误差 (MAE)。数学公式如下：
$l_n=|x_n-y_n|$

参数	类型	说明
`size_average`	(bool, 可选)	已弃用(请使用reduction)。默认情况下，损失会对批中每个损失元素求平均。注意对于某些损失，每个样本可能有多个元素。如果设为False，则对每个minibatch的损失求和。当reduce为False时被忽略。默认: True
`reduce`	(bool, 可选)	已弃用(请使用reduction)。默认情况下，根据size_average对每个minibatch的观测值求平均或求和。当reduce为False时，返回每个批元素的损失并忽略size_average。默认: True
`reduction`	(str, 可选)	指定应用于输出的缩减方式: ‘none’\|‘mean’\|‘sum’。 - ‘none’: 不应用缩减， - ‘mean’: 输出总和除以元素数量， - ‘sum’: 输出求和。注意: size_average和reduce正在被弃用，目前指定这两个参数中的任何一个都会覆盖reduction。默认: ‘mean’

依据reduction的不同，输出结果也不同：
$\ell(x,y)= \begin{cases} \displaystyle\frac{1}{N}\sum_{n=1}^N l_n,&\text{if reduction}=\text{'mean'}.\\\\ \displaystyle\sum_{n=1}^N l_n,&\text{ if reduction}=\text{'sum'}. \end{cases}$
其中， $N$ 为每个批次的数量。

输入: (∗), 其中 ∗ 表示任意维数。
目标: (∗), 与输入形状相同。
输出: 标量。如果reduction为’none’，则形状与输入相同(∗)。

import torch
from torch import nn

inputs = torch.tensor([1., 2, 3])
targets = torch.tensor([1, 2, 5])

loss = nn.L1Loss()
result = loss(inputs, targets)  # 计算平均绝对误差
print(result)  # tensor(0.6667) 计算：(0 + 0 + 2)/3 = 0.6667

特点：

对异常值不敏感，具有较好的鲁棒性。
梯度恒定（±1），在接近最优解时可能导致震荡。
适用于对异常值敏感的场景。

1.2 MSELoss

MSELoss 计算输入 ( $x$ ) 和目标 ( $y$ ) 之间的均方误差 (MSE)。
$l_n=(x_n-y_n)^2$

参数	类型	说明
`size_average`	(bool, 可选)	已弃用(请使用reduction)。默认对批中每个损失元素求平均。设为False则对每个minibatch的损失求和。当reduce为False时被忽略。默认: True
`reduce`	(bool, 可选)	已弃用(请使用reduction)。默认根据size_average对观测值求平均或求和。当reduce为False时，返回每个批元素的损失。默认: True
`reduction`	(str, 可选)	指定输出缩减方式: ‘none’\|‘mean’\|‘sum’。 - ‘none’: 不缩减， - ‘mean’: 输出总和除以元素数量， - ‘sum’: 输出求和。注意: size_average和reduce将被弃用。默认: ‘mean’

输入: (∗), 其中 ∗ 表示任意维数
目标: (∗), 与输入形状相同
输出: 标量。如果reduction为’none’，则形状与输入相同(∗)

解释import torch
from torch import nn

inputs = torch.tensor([1., 2, 3])
targets = torch.tensor([1, 2, 5])

loss_mse = nn.MSELoss()
result_mse = loss_mse(inputs, targets)
print(result_mse)  # tensor(1.3333) 计算：(0 + 0 + 4)/3 = 1.3333

特点：

对较大误差惩罚更重（平方放大效应）。
对异常值敏感。
梯度随误差减小而减小，收敛速度较快。
适用于数据质量较好的场景。

1.3 CrossEntropyLoss

CrossEntropyLoss 计算输入 ($x$) 和目标 ($y$) 之间的交叉熵。该损失函数结合 LogSoftmax 和 NLLLoss (负对数似然损失) 的操作，适用于多类分类任务。

$l_n=-\sum_{c=1}^Cw_c\log\frac{\exp(x_{n,c})}{\sum_{i=1}^C\exp(x_{n,i})}y_{n,c}$
其中 $w$ 为权重， $C$ 为类别数。

参数	类型	说明
`weight`	(Tensor, 可选)	为每个类别分配权重的一维张量，用于处理类别不平衡问题
`ignore_index`	(int, 可选)	指定要忽略的目标值，不参与梯度计算
`reduction`	(str, 可选)	指定输出缩减方式: ‘none’\|‘mean’\|‘sum’。默认: ‘mean’
`label_smoothing`	(float, 可选)	标签平滑系数，范围[0.0,1.0]。0.0表示无平滑

输入形状：

无批处理: $(C)$ 。
批处理: $(N, C)$ 或 $d₂,...,d_K), K≥1$ 。

目标形状：

类别索引: $(), (N)$ 或 $d₂,...,d_K)$ 。
类别概率: 必须与输入形状相同。

from torch import nn

x = torch.tensor([0.1, 0.2, 0.3])  # 预测值(未归一化)
y = torch.tensor([1])  # 真实类别索引
x = x.reshape(1, -1)  # 调整为(batch_size, num_classes)

loss_cross = nn.CrossEntropyLoss()
result_cross = loss_cross(x, y)
print(result_cross)  # tensor(1.1019)

计算过程：

对 x 应用 softmax 得到概率分布：[0.3006,0.3322,0.3672]。
取真实类别 (1) 的概率：0.3322。
计算负对数： $-log(0.3322)\approx1.1019$ 。

特点：

结合了 Softmax 和负对数似然。
梯度计算高效，适合多分类问题。
对预测概率与真实标签的差异敏感。

2 反向传播

反向传播（Backpropagation）是神经网络训练的核心算法，通过链式法则计算损失函数对网络参数的梯度。关键步骤：

前向传播：计算网络输出和损失值。
反向传播：
- 计算损失函数对输出的梯度。
- 逐层传播梯度到各参数。
- 应用链式法则计算参数梯度。
参数更新：使用优化器根据梯度更新参数。

以 CIFAR10 网络为例：

from collections import OrderedDict

import torch
import torchvision
from torch import nn

from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms

# 加载CIFAR10数据集
dataset = torchvision.datasets.CIFAR10(
    root='./dataset',  # 数据集存放路径
    train=False,  # 是否为训练集
    download=True,  # 是否下载数据集
    transform=transforms.ToTensor()  # 数据预处理
)

# 加载数据集
dataloader = DataLoader(dataset, batch_size=1)

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.model1 = nn.Sequential(OrderedDict([
            ('conv1', nn.Conv2d(3, 32, 5, padding=2)),
            ('maxpool1', nn.MaxPool2d(2)),
            ('conv2', nn.Conv2d(32, 32, 5, padding=2)),
            ('maxpool2', nn.MaxPool2d(2)),
            ('conv3', nn.Conv2d(32, 64, 5, padding=2)),
            ('maxpool3', nn.MaxPool2d(2)),
            ('flatten', nn.Flatten()),
            ('linear1', nn.Linear(64 * 4 * 4, 64)),
            ('linear2', nn.Linear(64, 10))
        ]))

    def forward(self, x):
        x = self.model1(x)
        return x

loss = nn.CrossEntropyLoss()

model = MyModel()
for data in dataloader:
    imgs, targets = data
    outputs = model(imgs)
    result_loss = loss(outputs, targets)
    result_loss.backward()  # 使用反向传播
    print(result_loss)