损失函数及反向传播

什么是损失函数:

损失函数（Loss Function）是用来度量模型预测值与真实标签之间差异的函数。它接受模型的输出和真实标签作为输入，并输出一个数值，该数值表示模型预测的错误程度或差异程度。损失函数通常被设计成非负的，当模型预测值与真实标签完全一致时，损失函数达到最小值。

常见的损失函数:

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

• 用于多分类任务，特别是在类别互斥的情况下；

2. 均方误差损失函数（Mean Squared Error Loss）：

• 用于回归任务；
• 计算模型输入与真实标签之间的平方差；

3. 平均绝对误差损失函数（Mean Absolute Error Loss）：

• 用于回归任务；
• 计算模型输出与真实标签之间的绝对差；

三个函数的代码展示：

L1Loss函数：

import torch
from torch import nn
from torch.nn import L1Loss

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

inputs = torch.reshape(inputs, (1, 1, 1, 3))
targets = torch.reshape(targets, (1, 1, 1, 3))

loss = L1Loss(reduction='sum')
result = loss(inputs, targets)

print(reult)

MSE函数：

import torch
from torch import nn
from torch.nn import MSELoss

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

inputs = torch.reshape(inputs, (1, 1, 1, 3))
targets = torch.reshape(targets, (1, 1, 1, 3))

loss_mse = nn.MSELoss()
result_mse = loss_mse(inputs, targets)

print(reult_mse)

交叉熵损失函数：

import torch
from torch import nn

x = torch.tensor([0.1, 0.2, 0.3])
y = torch.tensor([1])

x = torch.reshape(x, (1, 3))
loss_cross = nn.CrossEntropyLoss()
result_cross = loss_cross(x, y)
print(result_cross)

反向传播（Backward Propagation）：

计算预测输出与实际标签之间的误差，然后将误差从输出层传播回网络的每一层。在每一层中，根据误差和网络参数的梯度，使用链式法则来计算每个参数对误差的贡献，然后使用优化算法（如梯度下降）来更新参数，以减小误差。

作用：

反向传播的作用在于使神经网络能够学习到输入与输出之间的映射关系，从而使网络能够进行准确的预测或分类任务。通过多次迭代前向传播和反向传播过程，网络参数不断调整，使得网络的预测结果逐渐逼近实际标签，达到训练的目的。

import torch
import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10("./data", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)

dataloader = DataLoader(dataset, batch_size=1)


class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

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


loss = nn.CrossEntropyLoss()
my_module = MyModule()

for data in dataloader:
    imgs, targets = data
    outputs = my_module(imgs)
    result_loss = loss(outputs, targets)
    result_loss.backward()
    print(outputs)
    print(targets)