Pytorch学习笔记--损失函数Lossfunction

Lossfunction的大致作用：

1.计算实际输出和目标之间的差距

2.为我们更新输出提供一定的依据（反向传播）

import torch
from torch.nn import L1Loss

# 原始输入和目标张量
inputs = torch.tensor([1, 2, 3], dtype=torch.float32)  # 输入张量
targets = torch.tensor([1, 2, 5], dtype=torch.float32)  # 目标张量

# 重塑输入和目标张量为相同的形状
inputs = inputs.view(1, 1, 3)  # 形状： (1, 1, 3)
targets = targets.view(1, 1, 3)  # 形状： (1, 1, 3)

# 实例化 L1 损失函数
loss_fn = L1Loss()

# 计算 L1 损失
result = loss_fn(inputs, targets)

# 打印结果
print(result)  # 将输出 L1 损失值

输出结果为：tensor(0.6667)  #（（1-1）+（2-2）+（5-3））/2

均方误差MSE：

#方差损失
loss_mse=nn.MSELoss()
result_mse=loss_mse(inputs,targets)
print(result_mse)   #tensor(1.3333)

交叉熵损失函数：

交叉熵损失函数（Cross-Entropy Loss）是一种常用于分类问题的损失函数，特别是在深度学习中，用于评估模型输出的概率分布与真实标签的概率分布之间的差异。它主要用于多类分类和二分类问题。

定义

对于一组真实标签和预测概率，交叉熵损失函数的定义如下：

二分类交叉熵损失

对于二分类问题，设真实标签为 𝑦y（取值为0或1），预测概率为 𝑦^y^​，交叉熵损失函数可以表示为：

𝐿(𝑦,𝑦^)=−[𝑦log⁡(𝑦^)+(1−𝑦)log⁡(1−𝑦^)]L(y,y^​)=−[ylog(y^​)+(1−y)log(1−y^​)]

• 当 𝑦=1y=1 时，损失为 −log⁡(𝑦^)−log(y^​)。
• 当 𝑦=0y=0 时，损失为 −log⁡(1−𝑦^)−log(1−y^​)。

多分类交叉熵损失

对于多分类问题，设真实标签为 𝑦y（是一个one-hot向量），预测概率为 𝑦^y^​，交叉熵损失函数可以表示为：

𝐿(𝑦,𝑦^)=−∑𝑖𝑦𝑖log⁡(𝑦^𝑖)L(y,y^​)=−i∑​yi​log(y^​i​)

在这里，𝑖i 是类别索引，𝑦𝑖yi​ 是实际标签（one-hot编码），而 𝑦^𝑖y^​i​ 是模型对类别 𝑖i 的预测概率。

特点

1. 可微性：交叉熵函数是连续且可微的，适合用于梯度优化算法（如SGD）。
2. 惩罚重：交叉熵在预测概率接近真实标签时，损失较小，反之则损失增加得更快，使得它在训练过程中能快速收敛。
3. 概率输出：交叉熵损失函数直接对概率分布进行优化，因此通常与Softmax输出层结合使用。

应用

• 深度学习：常用于神经网络模型的训练，特别是在图像分类、自然语言处理等任务中。
• 模型评价：通过最小化交叉熵损失，可以提高分类模型的性能。

#交叉熵损失
x=torch.tensor([0.1,0.2,0.3])   #命中率
y=torch.tensor([1])
x=torch.reshape(x,(1,3))  #1 batch_size  3代表三类

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

放在神经网络里面：

import torch
import torchvision.datasets
from torch import nn
from torch.utils.data import DataLoader
from torchvision import transforms

from Projects.py.nn_loss import result

# 加载 CIFAR-10 数据集
dataset = torchvision.datasets.CIFAR10("../data", train=False, transform=transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset, batch_size=1)

class Aaxxx(nn.Module):
    def __init__(self):
        super(Aaxxx, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(32, 32, 5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(32, 64, 5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),
            nn.Linear(64 * 4 * 4, 64),  # 线性层输入调整
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.model(x)
        return x
loss_cross=nn.CrossEntropyLoss()
# 实例化模型
aa = Aaxxx()

# 进行推理
for data in dataloader:
    imgs, targets = data
    outputs = aa(imgs)  # 前向传播
    # print(outputs)  # 打印输出
    # print(targets)  # 打印目标
    result_loss=loss_cross(outputs,targets)
    result_loss.backward()#反向传播