嵌入式学习-PyTorch(7)-day23

损失函数的调用

python 复制代码
import torch
from torch import nn
from torch.nn import L1Loss

inputs = torch.tensor([1.0,2.0,3.0])
target = torch.tensor([1.0,2.0,5.0])

inputs = torch.reshape(inputs, (1, 1, 1, 3))
target = torch.reshape(target, (1, 1, 1, 3))
#损失函数
loss = L1Loss(reduction='sum')
#MSELoss均值方差
loss_mse = nn.MSELoss()
result1 = loss(inputs, target)
result2 = loss_mse(inputs, target)
print(result1, result2)

实际应用

python 复制代码
import torch
import torchvision.datasets
from torch import nn
from torch.nn import Conv2d

dataset = torchvision.datasets.CIFAR10(root='./data_CIF', train=False, download=True, transform=torchvision.transforms.ToTensor())
dataloader = torch.utils.data.DataLoader(dataset, batch_size=1)

class Tudui(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2)
        self.maxpool1 = nn.MaxPool2d(kernel_size=2)
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2)
        self.maxpool2 = nn.MaxPool2d(kernel_size=2)
        self.conv3 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2)
        self.maxpool3 = nn.MaxPool2d(kernel_size=2)
        self.flatten = nn.Flatten()
        self.linear1 = nn.Linear(in_features=1024, out_features=64)
        self.linear2 = nn.Linear(in_features=64, out_features=10)
        self.model1 = nn.Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),
            nn.Linear(in_features=1024, out_features=64),
            nn.Linear(in_features=64, out_features=10)
        )
    def forward(self, x):
        
        x = self.model1(x)
        return x
loss = nn.CrossEntropyLoss()
tudui = Tudui()
for data in dataloader:
    imgs,targets = data
    outputs = tudui(imgs)
    result1 = loss(outputs, targets)
    print(result1)
    #反向传播
    result1.backward()#梯度grad会改变,从而通过grad来降低loss

torch.nn.CrossEntropyLoss

🧩 CrossEntropyLoss 是什么?

本质上是:

Softmax + NLLLoss(负对数似然) 的组合。

公式:

  • ​:模型预测的概率(通过 softmax 得到)

  • ​:真实类别的 one-hot 标签

PyTorch 不需要你手动做 softmax,它会直接从 logits(未经过 softmax 的原始输出)算起,防止数值不稳定。


🏷️ 常用参数

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

参数 含义
weight 给不同类别加权(处理类别不均衡)
ignore_index 忽略某个类别(常见于 NLP 的 padding)
reduction mean(默认平均)、sum(求和)、none(逐个样本返回 loss)

🎨 最小使用例子

python 复制代码
import torch
import torch.nn as nn

criterion = nn.CrossEntropyLoss()

# 假设 batch_size=3, num_classes=5
outputs = torch.tensor([[1.0, 2.0, 0.5, -1.0, 0.0],
                        [0.1, -0.2, 2.3, 0.7, 1.8],
                        [2.0, 0.1, 0.0, 1.0, 0.5]])  # logits
labels = torch.tensor([1, 2, 0])  # 真实类别索引

loss = criterion(outputs, labels)
print(loss.item())
  • outputs:模型输出 logits,不需要 softmax;

  • labels :真实类别(索引型),如 0, 1, 2,...

  • loss.item():输出标量值。


💡 你需要注意:

⚠️ 重点 📌 说明
logits 直接输入 不要提前做 softmax
label 是类别索引 不是 one-hot,而是整数(如 [1, 3, 0]
自动求 batch 平均 默认 reduction='mean'
多分类用它最合适 二分类也能用,但 BCEWithLogitsLoss 更常见

🎁 总结

优点 缺点
✅ 简单强大,适合分类 ❌ 不适合回归任务
✅ 内置 softmax + log ❌ label 不能是 one-hot
✅ 数值稳定性强 ❌ 类别极度不均衡需额外加 weight

🎯 一句话总结

CrossEntropyLoss 是深度学习中分类问题的"首选痛点衡量尺",帮你用"正确标签"去教训"错误预测",模型越聪明 loss 越小。

公式:

1️⃣ 第一部分:

这是经典 负对数似然(Negative Log-Likelihood):

  • 分子:你模型对正确类别 class 输出的得分(logits),取 exp;

  • 分母:所有类别的 logits 做 softmax 归一化;

  • 再取负 log ------ 意思是"你对正确答案预测得越自信,loss 越小"。


2️⃣ 推导为:

log(a/b) = log(a) - log(b) 的变形:

  • :你对正确类输出的分值直接扣掉;

  • :对所有类别的总分值做归一化。

这是交叉熵公式最常用的"log-sum-exp"形式。


📌 为什么这么写?

  • 避免直接用 softmax(softmax+log 合并后可以避免数值不稳定 🚀)

  • 计算量更高效(框架底层可以优化)


🌟 直观理解:

场景 解释
正确类分数高 越大,loss 越小
错误类分数高 越大,loss 越大
目标 压低 log-sum-exp,拉高正确类别 logits

🎯 一句话总结:

交叉熵 = "扣掉正确答案得分" + "对所有类别归一化",越接近正确答案,loss 越小。

这就是你训练神经网络时 模型越来越聪明的数学依据 😎

举例:

python 复制代码
logits = torch.tensor([1.0, 2.0, 0.1])  # 模型输出 (C=3)
label = torch.tensor([1])  # 真实类别索引 = 1

其中:

  • N=1(batch size)

  • C=3(类别数)

  • 正确类别是索引1,对应第二个值:2.0

🎁 完整公式回顾


🟣 第一步:Softmax + log 逻辑

softmax 本质上是:

但是 PyTorch 的 CrossEntropyLoss 内部直接用:


🧮 你这个例子手动算:

logits = [1.0, 2.0, 0.1],class = 1,对应 logit = 2.0

第一部分:

第二部分:

先算:

  • exp(1.0)≈2.718

  • exp(2.0)≈7.389

  • exp(0.1)≈1.105

加起来:

∑=2.718+7.389+1.105=11.212

取对数:

log⁡(11.212)≈2.418

最终 loss:

loss=−2.0+2.418=0.418

🌟 你可以这样理解

部分 含义
−x[class]- x[\text{class}]−x[class] 惩罚正确答案打分太低
log⁡∑exp⁡(x)\log \sum \exp(x)log∑exp(x) 考虑所有类别的对比,如果错误类别打分高也被惩罚
最终目标 "提升正确答案打分、降低错误答案打分"
相关推荐
视觉语言导航11 分钟前
CVPR-2025 | 具身导航指令高效生成!MAPInstructor:基于场景图的导航指令生成Prompt调整策略
人工智能·机器人·具身智能
wanhengidc17 分钟前
云手机与人工智能之间的关系
人工智能·智能手机
Sic_MOS_7801682423 分钟前
超高密度2kW GaN基低压电机驱动器的设计
人工智能·经验分享·汽车·集成测试·硬件工程·能源
老坛程序员42 分钟前
抓包解析MCP协议:基于JSON-RPC的MCP host与MCP server的交互
人工智能·网络协议·rpc·json·交互
月盈缺1 小时前
学习嵌入式的第四十一天——ARM——时钟与定时器
arm开发·学习
努力毕业的小土博^_^1 小时前
【深度学习|学习笔记】详细讲解一下 深度学习训练过程中 为什么 Momentum 可以加速训练?
人工智能·笔记·深度学习·学习·momentum
飞哥数智坊1 小时前
DeepSeek 节前突袭发布 V3.2-Exp:长文本推理成本直降75%!
人工智能·deepseek
清风吹过1 小时前
少样本学习论文分享:多模态和类增量学习
论文阅读·人工智能·深度学习·学习·机器学习
Larry_Yanan1 小时前
QML学习笔记(十四)QML的自定义模块
开发语言·笔记·qt·学习·ui
居然JuRan1 小时前
抽丝剥茧的Transformer详解
人工智能