深度学习——03 神经网络（2）-损失函数

发布于：2025-08-14 ⋅ 阅读:(12) ⋅ 点赞:(0)

2 损失函数

2.1 概述

  • 作用：衡量模型预测结果（y^\hat{y}y^​）和真实标签（yyy）的差异，差异越大，说明模型参数“质量越差”（需要调整）；

    在这里插入图片描述

  • 本质：深度学习训练的“指挥棒”——反向传播时，损失函数的梯度会告诉模型“怎么调整参数，才能让预测更准”；

  • 在不同文献/框架中，损失函数可能有这些名字：

    在这里插入图片描述

2.2 多分类任务损失函数

2.2.1 概述

  • 在多分类任务通常使用 softmax 将 logits（神经网络在经过最后一层线性变换后，尚未经过激活函数处理的原始输出值）转换为概率的形式，所以多分类的交叉熵损失也叫做 Softmax 损失
    L=−∑i=1nyilog⁡(S(fθ(xi))) \mathcal{L} = -\sum_{i=1}^{n} \mathbf{y}_i \log\left(S(f_\theta(\mathbf{x}_i))\right) L=−i=1∑n​yi​log(S(fθ​(xi​)))

    • yi\mathbf{y}_iyi​：真实标签的 one-hot 编码（比如二分类中，“猫”的标签是 [1, 0] ，“狗”是 [0, 1]）；

    • fθ(xi)f_\theta(\mathbf{x}_i)fθ​(xi​)：模型对样本 xi\mathbf{x}_ixi​ 的“原始预测分数”（logits）；

    • SSS（Softmax 函数）：把 logits 转换成“概率分布”（所有类别概率和为 1）；

    • L\mathcal{L}L：损失值，衡量“预测概率分布”和“真实标签分布”的差异 → 差异越大，损失越大，模型越需要调整参数；

  • 以“识别手写数字 2”为例：

    在这里插入图片描述

    • 模型输出：

      • logits（原始分数）：[0.1, 2, 1]（假设 3 分类，对应“0、1、2”）；
      • Softmax 转换后概率：[0.1, 0.7, 0.2]（和为 1 ，模型认为“是 1 的概率 70%”）；

    • 真实标签：one-hot 编码为 [0, 1, 0]；

    • 损失计算：代入公式，只有真实类别（“1”）的 yi\mathbf{y}_iyi​ 是 1，其他是 0 → 损失简化为：
      L=−(0log⁡(0.10)+1log⁡(0.7)+0log⁡(0.2))=−log⁡0.7 \mathcal{L} = - \left( 0 \log(0.10) + 1 \log(0.7) + 0 \log(0.2) \right) = -\log 0.7 L=−(0log(0.10)+1log(0.7)+0log(0.2))=−log0.7

      • 损失越小，说明预测概率越接近真实标签 → 训练时，模型会调整参数让这个损失“尽可能小”；

        在这里插入图片描述

  • 多分类交叉熵损失的意义：

    • 对齐概率分布：让模型预测的“概率分布”尽可能贴近真实标签的“one-hot 分布”（比如真实是“猫”，就希望“猫”的概率趋近 1，其他趋近 0）；

    • 反向传播的依据：损失值的梯度会告诉模型“怎么调整参数”，让预测更准；

2.2.2 代码

  • 在 pytorch 中使用 nn.CrossEntropyLoss() 实现

    import torch
import torch.nn as nn

    # nn.CrossEntropyLoss()=softmax + 损失计算
# 说明：PyTorch中的CrossEntropyLoss会自动对输入的预测值先做softmax，再计算交叉熵损失
def test1():
    # 设置真实值：可以是热编码后的结果也可以不进行热编码。这里演示的是“不进行独热编码”的写法，直接用类别索引表示真实标签
    
    # 注意：真实标签的类型必须是64位整型数据（torch.int64）
    # 解释：y_true存储的是样本的真实类别索引，比如[1, 2]表示第1个样本属于类别1，第2个样本属于类别2
    y_true = torch.tensor([1, 2], dtype=torch.int64)
    
    # y_pred存储模型的预测结果，形状是[样本数, 类别数]
    # 解释：这里是2个样本，3个类别，每个样本输出3个预测概率（已经是softmax后的结果也可以直接是logits，CrossEntropyLoss会自动处理）
    # 示例中：
    # 第1个样本预测类别0概率0.2、类别1概率0.6、类别2概率0.2 
    # 第2个样本预测类别0概率0.1、类别1概率0.8、类别2概率0.1 
    y_pred = torch.tensor([[0.2, 0.6, 0.2], [0.1, 0.8, 0.1]], dtype=torch.float32)
    
    # 实例化交叉熵损失
    # 解释：创建CrossEntropyLoss对象，它会自动完成：
    # 1. 对y_pred做softmax（如果输入的是logits）
    # 2. 与y_true（类别索引）计算交叉熵损失
    loss = nn.CrossEntropyLoss()
    
    # 计算损失结果
    # 解释：将预测值y_pred和真实标签y_true传入loss函数，自动计算损失
    # .numpy()是为了把PyTorch的张量转换成numpy数组，方便打印查看
    my_loss = loss(y_pred, y_true).numpy()
    
    # 打印损失值
    print('loss:', my_loss)

    在这里插入图片描述

2.2.3 输出结果分析

  • 输入数据：

    • 真实标签 y_true = [1, 2]：表示 2 个样本，第 1 个样本属于类别 1，第 2 个样本属于类别 2（类别索引从 0 开始）；

    • 预测概率 y_pred = [[0.2, 0.6, 0.2], [0.1, 0.8, 0.1]]：

      • 第 1 个样本对 3 个类别的预测概率：类别0：0.2、类别1：0.6、类别2：0.2；
      • 第 2 个样本对 3 个类别的预测概率：类别0：0.1、类别1：0.8、类别2：0.1；

  • 损失计算逻辑（CrossEntropyLoss）：CrossEntropyLoss 会自动对 y_pred 做 Softmax（如果输入的是 logits），然后计算交叉熵。公式简化为：
    loss=−1N∑i=1Nlog⁡(p正确类别) \text{loss} = -\frac{1}{N} \sum_{i=1}^N \log\left( p_{\text{正确类别}} \right) loss=−N1​i=1∑N​log(p正确类别​)

    • $ N $ 是样本数量（这里 $ N=2 $ ）；
    • $ p_{\text{正确类别}} $ 是样本预测为“真实类别”的概率；

    与2.2.1 概述中的公式本质是同一个损失逻辑，只是从 “简化版（针对类别索引）” 和 “完整版（针对 one-hot 编码）” 两个角度描述多分类交叉熵损失，核心逻辑完全一致；

  • 逐样本计算

    • 样本 1（真实类别 1）：预测为类别 1 的概率是 0.6 → 损失项：$ -\log(0.6) \approx 0.5108 $；

    • 样本 2（真实类别 2）：预测为类别 2 的概率是 0.1 → 损失项：$ -\log(0.1) \approx 2.3026 $；

  • 最终损失为两个样本的平均损失：
    loss=0.5108+2.30262≈1.4067 \text{loss} = \frac{0.5108 + 2.3026}{2} \approx 1.4067 loss=20.5108+2.3026​≈1.4067

  • 但实际运行结果是 1.1200755，因为传入的 y_pred 实际上已经是概率（softmax后的输出），但CrossEntropyLoss再对它做softmax（logits -> softmax），这就导致计算不对，损失值偏小；

  • 代码输出结果的含义：损失值 1.1200755 表示模型对这两个样本的预测“不够准确”，需要反向传播调整参数，让正确类别的预测概率更高。

2.3 二分类任务损失函数

2.3.1 概述

  • 在处理二分类任务时，我们不再使用 softmax 激活函数，而是使用 sigmoid 激活函数，那损失函数也相应地进行调整，使用二分类的交叉熵损失函数（也叫二元交叉熵，Binary Cross-Entropy, BCE ）：
    L=−ylog⁡y^−(1−y)log⁡(1−y^) L = -y \log \hat{y} - (1 - y) \log(1 - \hat{y}) L=−ylogy^​−(1−y)log(1−y^​)

    • 适用任务：二分类（比如“垃圾邮件/正常邮件”“患病/健康”）；

    • 激活函数：搭配 sigmoid 激活函数，让模型输出 $ \hat{y} $ 是“样本属于正类的概率”（范围 (0, 1)）；

    • $ y $：样本的真实标签（二分类中，通常是 0 或 1 ，比如 1 代表“正类”，0 代表“负类”）；

    • $ \hat{y} $：模型的预测概率（经过 sigmoid 后，是样本属于正类的概率）；

  • 损失计算逻辑

    • 如果样本是正类（$ y=1 $ ）：公式简化为 $ L = -\log \hat{y} $ → 预测概率 $ \hat{y} $ 越接近 1 ，损失越小；越接近 0 ，损失越大（惩罚模型“把正类预测成负类”）；

  • 如果样本是负类（$ y=0 $ ）：公式简化为 $ L = -\log(1 - \hat{y}) $ → 预测概率 $ \hat{y} $ 越接近 0 ，损失越小；越接近 1 ，损失越大（惩罚模型“把负类预测成正类”）；

  • 二元交叉熵的意义：

    • 对齐概率：让模型预测的“正类概率”尽可能贴近真实标签（1 或 0 ）；

    • 反向传播依据：训练时，损失的梯度会指导模型调整参数，让预测更准确（比如预测正类概率不够大，就调整参数让它变大）。

2.3.2 代码

  • 在 pytorch 中使用nn.BCELoss()实现

    def test2():
    # 设置真实值和预测值
    # 预测值是sigmoid输出的结果（已经过sigmoid归一化到0~1区间）
    # 解释：y_pred存储3个样本的预测概率，requires_grad=True表示需要计算梯度（用于反向传播）
    y_pred = torch.tensor([0.6901, 0.5459, 0.2469], requires_grad=True)
    
    # 真实标签：0表示负类，1表示正类，dtype=torch.float32是BCELoss的输入要求
    # 解释：y_true和y_pred长度必须一致，每个元素对应一个样本的真实类别（0/1）
    y_true = torch.tensor([0, 1, 0], dtype=torch.float32)
    
    # 实例化二分类交叉熵损失（BCE损失）
    # 解释：nn.BCELoss专门用于二分类任务，计算预测概率与真实标签的交叉熵
    criterion = nn.BCELoss()
    
    # 计算损失
    # 解释：将预测概率y_pred和真实标签y_true传入损失函数
    # .detach()是为了阻断反向传播（避免计算图占用内存），.numpy()转成numpy数组方便打印
    my_loss = criterion(y_pred, y_true).detach().numpy()
    
    # 打印最终损失值
    print('loss: ', my_loss)

test2()

    在这里插入图片描述

2.3.3 输出结果分析

  • 输入数据

    • 预测概率 y_pred = [0.6901, 0.5459, 0.2469]：3 个样本的预测概率（已经过 Sigmoid 归一化到 0~1）；

    • 真实标签 y_true = [0, 1, 0]：3 个样本的真实类别，0 表示负类，1 表示正类；

  • 损失计算逻辑（BCELoss）：BCELoss 用于二分类，公式为
    loss=−1N∑i=1N(yilog⁡(y^i)+(1−yi)log⁡(1−y^i)) \text{loss} = -\frac{1}{N} \sum_{i=1}^N \left( y_i \log(\hat{y}_i) + (1-y_i) \log(1-\hat{y}_i) \right) loss=−N1​i=1∑N​(yi​log(y^​i​)+(1−yi​)log(1−y^​i​))

    • $ y_i $ 是真实标签（0 或 1）
    • $ \hat{y}_i $ 是预测概率

  • 逐样本计算

    • 样本 1（真实标签 0）：损失项：$ -(0 \cdot \log(0.6901) + 1 \cdot \log(1-0.6901)) = -\log(0.3099) \approx 1.173 $；

    • 样本 2（真实标签 1）：损失项：$ -(1 \cdot \log(0.5459) + 0 \cdot \log(1-0.5459)) = -\log(0.5459) \approx 0.604 $；

    • 样本 3（真实标签 0）：损失项：$ -(0 \cdot \log(0.2469) + 1 \cdot \log(1-0.2469)) = -\log(0.7531) \approx 0.283 $；

  • 最终损失为平均 3 个样本的损失：
    loss=1.173+0.604+0.2833≈0.6867 \text{loss} = \frac{1.173 + 0.604 + 0.283}{3} \approx 0.6867 loss=31.173+0.604+0.283​≈0.6867

  • 代码输出结果的含义：损失值 0.6867941 表示模型对这 3 个样本的预测“不够准确”，需要反向传播调整参数，让正类样本的预测概率更高，负类样本的预测概率更低。

2.4 回归任务损失函数-MAE损失函数

2.4.1 概述

  • MAE（Mean Absolute Error，平均绝对误差）损失函数，也叫 L1 Loss，，是以绝对误差作为距离。公式：
    L=1n∑i=1n∣yi−fθ(xi)∣ \mathcal{L} = \frac{1}{n} \sum_{i=1}^{n} \left| y_i - f_\theta(x_i) \right| L=n1​i=1∑n​∣yi​−fθ​(xi​)∣

    • $ y_i $：样本的真实值；
    • $ f_\theta(x_i) $：模型对样本 $ x_i $ 的预测值；
    • $ n $：样本数量；
    • $ \mathcal{L} $：损失值，衡量“预测值与真实值的绝对误差的平均值” → 误差越大，损失越大，模型越需要调整参数；

  • 特点：

    • 稀疏性（正则化效果）：MAE 对“大误差”更敏感（因为是绝对值，大误差不会被“平方缩小”），会惩罚模型预测偏差大的情况。因此常被用作“正则项”，约束模型参数，避免过拟合；
    • 梯度不光滑问题：在预测值 = 真实值（误差为 0）时，绝对值函数的梯度不连续（左右导数突变）。训练时，梯度下降可能“跳过极小值点”，导致模型收敛到次优解；

  • 图像：

    在这里插入图片描述

    • 横轴：预测误差（$ |y_i - f_\theta(x_i)| $ ）；纵轴：损失值（$ \mathcal{L} $ ）；

    • 图像是“V 型”，体现 MAE 的特点：

      • 误差越大，损失线性增长（惩罚大误差）；

      • 误差为 0 时，损失最小（模型预测完全准确）。

2.4.2 代码

  • 在 pytorch 中使用 nn.L1Loss() 实现：

    # 定义测试函数，演示 MAE（L1 Loss）的计算流程
def test3():
    # 设置预测值和真实值
    # y_pred：模型的预测结果，需要计算梯度（requires_grad=True）用于反向传播
    # 这里是 3 个样本的预测值：[1.0, 1.0, 1.9]
    y_pred = torch.tensor([1.0, 1.0, 1.9], requires_grad=True)
    
    # y_true：样本的真实标签，dtype=torch.float32 是 L1Loss 的输入要求
    # 这里是 3 个样本的真实值：[2.0, 2.0, 2.0]
    y_true = torch.tensor([2.0, 2.0, 2.0], dtype=torch.float32)
    
    # 实例化 MAE 损失函数（L1 Loss）
    # nn.L1Loss 会计算预测值与真实值的绝对误差的平均值
    criterion = nn.L1Loss()
    
    # 计算损失
    # 将预测值 y_pred 和真实值 y_true 传入损失函数，自动计算 MAE
    # .detach() 用于切断反向传播（避免保留计算图占用内存）
    # .numpy() 转成 numpy 数组，方便打印查看结果
    my_loss = criterion(y_pred, y_true).detach().numpy()
    
    # 打印最终损失值
    print('loss:', my_loss)
test3()

    在这里插入图片描述

2.4.3 输出结果分析

  • MAE 损失函数的计算公式为：
    MAE=1n∑i=1n∣ypred,i−ytrue,i∣ \text{MAE} = \frac{1}{n} \sum_{i=1}^{n} \left| y_{\text{pred},i} - y_{\text{true},i} \right| MAE=n1​i=1∑n​∣ypred,i​−ytrue,i​∣

    • 其中：

      • $ n $ 是样本数量（这里 $ n = 3 $ ，对应 3 个预测值和 3 个真实值）；

      • $ y_{\text{pred},i} $ 是模型对第 $ i $ 个样本的预测值；

      • $ y_{\text{true},i} $ 是第 $ i $ 个样本的真实标签值；

  • 代码中给出的预测值和真实值分别是：

    • 预测值 $ y_{\text{pred}} = [1.0, 1.0, 1.9] $

    • 真实值 $ y_{\text{true}} = [2.0, 2.0, 2.0] $

  • 逐样本计算绝对误差，再求平均：

    1. 第 1 个样本绝对误差：$ |1.0 - 2.0| = 1.0 $
    2. 第 2 个样本绝对误差：$ |1.0 - 2.0| = 1.0 $
    3. 第 3 个样本绝对误差：$ |1.9 - 2.0| = 0.1 $

  • 将这些绝对误差求平均：
    MAE=1.0+1.0+0.13=2.13=0.7 \text{MAE} = \frac{1.0 + 1.0 + 0.1}{3} = \frac{2.1}{3} = 0.7 MAE=31.0+1.0+0.1​=32.1​=0.7

  • 代码输出结果的含义：

    • 最终输出 loss: 0.7 ，表示模型预测值与真实值的平均绝对误差是 0.7；
    • 损失值越小，说明模型预测越接近真实标签；损失值越大，说明预测偏差越大，需要继续调整模型参数（如通过反向传播优化网络权重 ）来减小误差。

2.5 回归任务损失函数-MSE损失函数

2.5.1 概述

  • MSE（均方误差，Mean Squared Error）损失函数，也叫 L2 Loss 或欧氏距离，它以误差的平方和的均值作为距离。公式：
    L=1n∑i=1n(yi−fθ(xi))2 \mathcal{L} = \frac{1}{n} \sum_{i=1}^{n} \left( y_i - f_\theta(x_i) \right)^2 L=n1​i=1∑n​(yi​−fθ​(xi​))2

    • $ y_i $：样本的真实值（比如实际房价）；

    • $ f_\theta(x_i) $：模型对样本 $ x_i $ 的预测值（比如模型预测的房价）；

    • $ n $：样本数量；

    • $ \mathcal{L} $：损失值，衡量“预测值与真实值的平方误差的平均值” → 误差越大，损失越大，模型越需要调整参数；

  • 特点：

    • 作为正则项（L2 正则）：MSE 的“平方”特性，会放大模型的“大误差”（比如预测偏差 2 → 平方后是 4 ，偏差 3 → 平方后是 9）。这种“惩罚大误差”的特点，让 MSE 常被用作正则项（比如 L2 正则 ），约束模型参数不要过大，避免过拟合；

    • 梯度爆炸风险：当预测值与真实值偏差很大时（比如模型预测房价 100 万，实际是 1000 万），平方误差会非常大（$ (1000-100)^2 = 810000 $）。反向传播时，梯度（损失对参数的导数）也会被“平方放大”，可能导致梯度爆炸（梯度值瞬间变得极大，模型参数更新幅度过大，无法稳定训练）；

  • 图像：

    在这里插入图片描述

    • 横轴：预测误差（$ y_i - f_\theta(x_i) $ ），纵轴：损失值（$ \mathcal{L} $ ）；

    • 曲线是“U 型”，体现 MSE 的特点：

      • 误差越大，损失指数级增长（平方放大误差）；

      • 误差为 0 时，损失最小（模型预测完全准确）；

  • 适合场景：数据分布较均匀、无极端异常值，且希望模型对“小误差更敏感”的回归任务（比如预测温度，误差 1℃ 影响大，需要重点优化）；

  • 对比 MAE（L1 Loss）：

    • MAE 对异常值鲁棒（绝对值不放大误差），但梯度在 0 点不连续（训练可能不稳定）；
    • MSE 对异常值更敏感（平方放大误差），但梯度光滑（训练更稳定）。

2.5.2 代码

  • 在 pytorch 中使用 nn.MSELoss() 实现

    def test4():
    # 准备预测值和真实值
    # y_pred: 模型输出的预测结果，需要计算梯度(requires_grad=True)用于反向传播更新参数
    # 这里模拟 3 个样本的预测值: [1.0, 1.0, 1.9]
    y_pred = torch.tensor([1.0, 1.0, 1.9], requires_grad=True)
    
    # y_true: 样本的真实标签，dtype=torch.float32 是 MSELoss 要求的输入类型
    # 这里模拟 3 个样本的真实值: [2.0, 2.0, 2.0]
    y_true = torch.tensor([2.0, 2.0, 2.0], dtype=torch.float32)
    
    # 初始化 MSE 损失函数
    # nn.MSELoss 会计算预测值与真实值的均方误差（平方误差的平均值）
    loss_function = nn.MSELoss()
    
    # 计算损失值
    # 将预测值和真实值传入损失函数，自动执行: 
    # 1) 逐样本计算 (y_pred - y_true)^2 
    # 2) 对所有样本的平方误差求平均
    # .detach() 用于切断反向传播链路（避免保存计算图占用内存）
    # .numpy() 转换为 numpy 数组方便打印查看
    calculated_loss = loss_function(y_pred, y_true).detach().numpy()
    
    # 打印最终损失结果
    print('loss:', calculated_loss)
test4()

    在这里插入图片描述

2.5.3 输出结果分析

  • MSE 损失函数的公式：
    MSE=1n∑i=1n(ypred,i−ytrue,i)2 \text{MSE} = \frac{1}{n} \sum_{i=1}^{n} \left( y_{\text{pred},i} - y_{\text{true},i} \right)^2 MSE=n1​i=1∑n​(ypred,i​−ytrue,i​)2

    • $ n $：样本数量（这里 $ n = 3 $ ，3 个样本）；

    • $ y_{\text{pred},i} $：模型对第 $ i $ 个样本的预测值；

    • $ y_{\text{true},i} $：第 $ i $ 个样本的真实值；

  • 代码中，预测值和真实值分别为：

    • 预测值 $ y_{\text{pred}} = [1.0, 1.0, 1.9] $

    • 真实值 $ y_{\text{true}} = [2.0, 2.0, 2.0] $

  • 对每个样本，计算“预测值 - 真实值”的平方：

    • 样本 1：$ (1.0 - 2.0)^2 = (-1.0)^2 = 1.0 $

    • 样本 2：$ (1.0 - 2.0)^2 = (-1.0)^2 = 1.0 $

    • 样本 3：$ (1.9 - 2.0)^2 = (-0.1)^2 = 0.01 $

  • 计算“平均平方误差”：将所有样本的平方误差求和，再除以样本数量 $ n = 3 $：
    MSE=1.0+1.0+0.013=2.013=0.67 \text{MSE} = \frac{1.0 + 1.0 + 0.01}{3} = \frac{2.01}{3} = 0.67 MSE=31.0+1.0+0.01​=32.01​=0.67

  • 代码输出结果的含义：

    • 输出 loss: 0.67 表示模型预测值与真实值的均方误差是 0.67；
    • 损失值越小，说明模型预测越接近真实标签；损失值越大，说明预测偏差越大，需要继续调整模型参数（如通过反向传播优化网络权重）来减小误差；

  • MSE 的特点（结合代码场景）

    • 放大“大误差”：MSE 对“大误差”更敏感（平方会放大误差）。如果模型预测偏差大（比如样本 1、2 的偏差是 1.0），平方后会让损失更显著，推动模型优先优化这些“大误差”；

    • 梯度更新特性：MSE 的梯度（损失对模型参数的导数）与“预测误差”成正比（梯度 = $ 2 \times (y_{\text{pred}} - y_{\text{true}}) $）。误差越大，梯度越大，模型参数更新幅度也越大，这可能导致“梯度爆炸”（但本示例误差小，无此问题）。

2.6 回归任务损失函数-smooth L1损失函数

2.6.1 概述

  • Smooth L1 是分段函数，定义：
    smoothL1(x)={0.5x2如果 ∣x∣<1∣x∣−0.5否则 \text{smooth}_{L_1}(x) = \begin{cases} 0.5x^2 & \text{如果 } |x| < 1 \\ |x| - 0.5 & \text{否则} \end{cases} smoothL1​​(x)={0.5x2∣x∣−0.5​如果 ∣x∣<1否则​

    • xxx：预测值与真实值的误差（$ x = f(x) - y $ ，即模型预测偏差）；

  • 设计目的（解决 L1/L2 的缺点）

    损失函数 缺点 Smooth L1 的改进逻辑
    L1（MAE） 误差为 0 时梯度不连续（影响训练稳定性） 当 $
    L2（MSE） 误差大时梯度爆炸（异常值敏感） 当 $

  • 图像：

    在这里插入图片描述

    • L1（蓝色）：V 型，误差大时梯度稳定，但 0 点不光滑；

    • L2（绿色）：U 型，误差小时梯度光滑，但误差大时梯度爆炸；

    • Smooth L1（红色）：

      • 误差小（$ |x| < 1 $ ）：曲线和 L2 重合（梯度光滑）；
      • 误差大（$ |x| \geq 1 $ ）：曲线和 L1 重合（梯度稳定，避免爆炸）；

  • Smooth L1 结合了 L1 和 L2 的优点，适合：回归任务中存在异常值（需要 L1 的鲁棒性），但希望训练更稳定（需要 L2 的光滑梯度）的场景（比如目标检测中的边界框回归）。

2.6.2 代码

  • 在 pytorch 中使用nn.SmoothL1Loss()实现：

    def test5():
    # 准备预测值和真实值
    # y_true: 样本的真实标签，这里是 [0, 3]（2个样本的真实值）
    y_true = torch.tensor([0, 3])
    
    # y_pred: 模型的预测结果，需要计算梯度(requires_grad=True)用于反向传播
    # 这里是 2 个样本的预测值: [0.6, 0.4]
    y_pred = torch.tensor([0.6, 0.4], requires_grad=True)
    
    # 初始化 Smooth L1 损失函数
    # nn.SmoothL1Loss 会根据预测误差的大小，自动切换 L1/L2 损失逻辑：
    # - 误差小（|x| < 1）: 用 L2 损失 (0.5x²)
    # - 误差大（|x| ≥ 1）: 用 L1 损失 (|x| - 0.5)
    criterion = nn.SmoothL1Loss()
    
    # 3. 计算损失值
    # 逐样本计算误差 x = y_pred - y_true，再代入 Smooth L1 公式
    # .detach() 切断反向传播（避免保存计算图占用内存）
    # .numpy() 转成 numpy 数组方便打印
    calculated_loss = criterion(y_pred, y_true).detach().numpy()
    
    # 打印最终损失
    print('loss:', calculated_loss)
test5()

    在这里插入图片描述

2.6.3 输出结果分析

  • Smooth L1 是分段函数，公式：
    smoothL1(x)={0.5x2如果 ∣x∣<1（误差小，用 L2 损失）∣x∣−0.5如果 ∣x∣≥1（误差大，用 L1 损失） \text{smooth}_{L_1}(x) = \begin{cases} 0.5x^2 & \text{如果 } |x| < 1 \text{（误差小，用 L2 损失）} \\ |x| - 0.5 & \text{如果 } |x| \geq 1 \text{（误差大，用 L1 损失）} \end{cases} smoothL1​​(x)={0.5x2∣x∣−0.5​如果 ∣x∣<1（误差小，用 L2 损失）如果 ∣x∣≥1（误差大，用 L1 损失）​

    • 其中，$ x = y_{\text{pred}} - y_{\text{true}} $（预测值与真实值的误差）；

  • 代码中，预测值和真实值分别为：

    • 预测值 $ y_{\text{pred}} = [0.6, 0.4] $

    • 真实值 $ y_{\text{true}} = [0, 3] $

  • 对每个样本，计算 $ x = y_{\text{pred}} - y_{\text{true}} $：

    • 样本 1：$ x_1 = 0.6 - 0 = 0.6 $

    • 样本 2：$ x_2 = 0.4 - 3 = -2.6 $

  • 分段计算“样本损失”，根据 Smooth L1 的分段逻辑：

    • 样本 1（$ |x_1| = 0.6 < 1 $，误差小 → 用 L2 损失）
      损失1=0.5×(0.6)2=0.5×0.36=0.18 \text{损失}_1 = 0.5 \times (0.6)^2 = 0.5 \times 0.36 = 0.18 损失1​=0.5×(0.6)2=0.5×0.36=0.18

    • 样本 2（$ |x_2| = 2.6 \geq 1 $，误差大 → 用 L1 损失）
      损失2=∣−2.6∣−0.5=2.6−0.5=2.1 \text{损失}_2 = |-2.6| - 0.5 = 2.6 - 0.5 = 2.1 损失2​=∣−2.6∣−0.5=2.6−0.5=2.1

  • Smooth L1 损失默认返回所有样本损失的平均值：

    总损失=损失1+损失22=0.18+2.12=2.282=1.14 \text{总损失} = \frac{\text{损失}_1 + \text{损失}_2}{2} = \frac{0.18 + 2.1}{2} = \frac{2.28}{2} = 1.14 总损失=2损失1​+损失2​​=20.18+2.1​=22.28​=1.14

  • 代码输出结果的含义：

    • 输出 loss: 1.14 表示：模型预测值与真实值的Smooth L1 损失是 1.14；
    • 损失值综合了“误差小样本的 L2 平滑”和“误差大样本的 L1 鲁棒性”，既避免了 L2 对异常值的敏感，又解决了 L1 在误差为 0 时的梯度不连续问题，让模型训练更稳定。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布