损失函数与反向传播

# 1.损失函数
# Loss损失函数一方面计算实际输出和目标之间的差距。
# Loss损失函数另一方面为我们更新输出提供一定的依据。
import torch
import torchvision
from torch import nn
from torch.nn import L1Loss, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader

# 2.L1loss损失函数
# 数学公式：l(x,y)=L={l1,...,Ln}T      ln=|xn-yn|
# l(x,y)=mean(L) if reduction='mean'
# l(x,y)=sum(L) if reduction='sum'
# 例如：X=1，2，3  Y=1，2，5   L1loss=(0+0+2)/3=0.6

inputs = torch.tensor([1, 2, 3], dtype=torch.float32)
targets = torch.tensor([1, 2, 5], dtype=torch.float32)
inputs = torch.reshape(inputs, (1, 1, 1, 3))
targets = torch.reshape(targets, (1, 1, 1, 3))
loss = L1Loss()  # 默认为mean
result = loss(inputs, targets)
print(result)

loss_1 = L1Loss(reduction="sum")  # 修改为sum，三个值的差值，然后取和
result_1 = loss_1(inputs, targets)
print(result_1)

# 3.MSE损失函数
# 数学公式：l(x,y)=L={l1,...,Ln}T      ln=(xn-yn)2
# l(x,y)=mean(L) if reduction='mean'
# l(x,y)=sum(L) if reduction='sum'
# 例如：X=1，2，3  Y=1，2，5   L1loss=(0+0+4)/3=1.3333

inputs_1 = torch.tensor([1, 2, 3], dtype=torch.float32)
targets_1 = torch.tensor([1, 2, 5], dtype=torch.float32)
inputs_1 = torch.reshape(inputs_1, (1, 1, 1, 3))
targets_1 = torch.reshape(targets_1, (1, 1, 1, 3))
loss_mse = nn.MSELoss()  # 默认为mean
result_mse = loss_mse(inputs_1, targets_1)
print(result_mse)

# 4.交叉熵损失函数
x = torch.tensor([0.1, 0.2, 0.3])
y = torch.tensor([1])
x = torch.reshape(x, (1, 3))  # 1个batch_size有三类
loss_cross = nn.CrossEntropyLoss()
result_cross = loss_cross(x, y)
print(result_cross)

# 5.搭建神经网络
dataset = torchvision.datasets.CIFAR10(root='D:\PyCharm\CIFAR10', train=False,
                                       transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=64, drop_last=True)


class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.model1 = nn.Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2, 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):
        return self.model1(x)
        return x


model = MyModel()
for data in dataloader:
    imgs, targets = data
    outputs = model(imgs)
    print(outputs.shape)
    print(targets)

# 6.数据集计算损失函数
loss = nn.CrossEntropyLoss()  # 交叉熵损失
model_1 = MyModel()
for data in dataloader:
    imgs, targets = data
    outputs = model_1(imgs)
    result_cross = loss(outputs, targets)  # 计算实际输出与目标输出之间的差距
    print(result_cross)

# 7.损失函数反向传播
# 反向传播通过梯度来更新参数，使得loss损失最小
loss_2 = nn.CrossEntropyLoss()  # 交叉熵损失
model_2 = MyModel()
for data in dataloader:
    imgs, targets = data
    outputs_2 = model_2(imgs)
    result_loss = loss_2(outputs_2, targets)
    result_loss.backward()  # 计算出来的 loss 值有 backward 方法属性，反向传播来计算每个节点的更新的参数。
    # 这里查看网络的属性 grad 梯度属性刚开始没有，反向传播计算出来后才有，后面优化器会利用梯度优化网络参数。
    print(result_loss)