损失函数与优化器

损失函数与反向传播

计算模型目标输出和实际输出之间的误差。并通过反向传播算法更新模型的权重和参数，以减小预测输出和实际输出之间的误差。

• 计算实际输出和目标输出之间的差距
• 为更新输出提供一定依据(反向传播)

不同的模型用的损失函数一般也不一样。

平均绝对误差MAE Mean Absolute Error

torch.nn.L1Loss(size_average=None, reduce=None, reduction=‘mean’)

import torch
import torch.nn as nn
# 实例化
criterion1 = nn.L1Loss(reduction='mean')#mean
criterion2 = nn.L1Loss(reduction="sum")#sum
output = torch.tensor([1.0, 2.0, 3.0])#或dtype=torch.float32
target = torch.tensor([2.0, 2.0, 2.0])#或dtype=torch.float32
# 平均值损失值
loss = criterion1(output, target)
print(loss)  # 输出：tensor(0.6667)
# 误差和
loss1 = criterion2(output,target)
print(loss1) # tensor(2.)

tensor(0.6667)
tensor(2.)

loss = nn.L1Loss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)
output.backward()
output

tensor(1.0721, grad_fn=<MeanBackward0>)

均方误差MSE Mean-Square Error

torch.nn.MSELoss(size_average=None, reduce=None, reduction=‘mean’)

import torch.nn as nn
# 实例化
criterion1 = nn.MSELoss(reduction='mean')
criterion2 = nn.MSELoss(reduction="sum")
output = torch.tensor([1, 2, 3],dtype=torch.float32)
target = torch.tensor([1, 2, 5],dtype=torch.float32)
# 平均值损失值
loss = criterion1(output, target)
print(loss)  # 输出：tensor(1.3333)
# 误差和
loss1 = criterion2(output,target)
print(loss1) # tensor(4.)

tensor(1.3333)
tensor(4.)

交叉熵损失 CrossEntropyLoss

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

当你有一个不平衡的训练集时，这是特别有用的

import torch
import torch.nn as nn

# 设置三分类问题，假设是人的概率是0.1，狗的概率是0.2，猫的概率是0.3
x = torch.tensor([0.1, 0.2, 0.3])
print(x)
y = torch.tensor([1]) # 设目标标签为1，即0.2狗对应的标签,目标标签张量y
x = torch.reshape(x, (1, 3))  # tensor([[0.1000, 0.2000, 0.3000]]),批次大小为1，分类数3，即为3分类
print(x)
print(y)
# 实例化对象
loss_cross = nn.CrossEntropyLoss()
# 计算结果
result_cross = loss_cross(x, y)
print(result_cross)

tensor([0.1000, 0.2000, 0.3000])
tensor([[0.1000, 0.2000, 0.3000]])
tensor([1])
tensor(1.1019)

import torch
import torchvision
from torch.utils.data import DataLoader

# 准备数据集
dataset = torchvision.datasets.CIFAR10(root="dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
# 数据集加载器
dataloader = DataLoader(dataset, batch_size=1)
"""
输入图像是3通道的32×32的，
先后经过卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
拉直、
全连接层的处理，
最后输出的大小为10
"""

# 搭建神经网络
class BS(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Conv2d(in_channels=3,
                      out_channels=32,
                      kernel_size=5,
                      stride=1,
                      padding=2),  #stride和padding计算得到
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32,
                      out_channels=32,
                      kernel_size=5,
                      stride=1,
                      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(),  #变为64*4*4=1024
            nn.Linear(in_features=1024, out_features=64),
            nn.Linear(in_features=64, out_features=10),
        )

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


# 实例化
bs = BS()
loss = torch.nn.CrossEntropyLoss()
# 对每一张图片进行CrossEntropyLoss损失函数计算
# 使用损失函数loss计算预测结果和目标标签之间的交叉熵损失

for inputs,labels in dataloader:
    outputs = bs(inputs)
    result = loss(outputs,labels)
    print(result)

tensor(2.3497, grad_fn=<NllLossBackward0>)
tensor(2.2470, grad_fn=<NllLossBackward0>)
tensor(2.2408, grad_fn=<NllLossBackward0>)
tensor(2.2437, grad_fn=<NllLossBackward0>)
tensor(2.3121, grad_fn=<NllLossBackward0>)
........

优化器

优化器(Optimizer)是用于更新神经网络参数的工具

它根据计算得到的损失函数的梯度来调整模型的参数，以最小化损失函数并改善模型的性能

常见的优化器包括:SGD、Adam

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

model.parameters()用于获取模型的可学习参数

learning rate,lr表示学习率，即每次参数更新的步长

在每个训练批次中，需要执行以下操作:

1. 输入训练数据到模型中，进行前向传播

2. 根据损失函数计算损失

3. 调用优化器的zero_grad()方法清零之前的梯度

4. 调用backward()方法进行反向传播，计算梯度

5. 调用优化器的step()方法更新模型参数

伪代码如下(运行不了的)

import torch
import torch.optim as optim

# Step 1: 定义模型
model = ...
# Step 2: 定义优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)
# Step 3: 定义损失函数
criterion = ...
# Step 4: 训练循环
for inputs, labels in dataloader:
    # 前向传播
    outputs = model(inputs)

    # 计算损失
    loss = criterion(outputs, labels)

    # 清零梯度
    optimizer.zero_grad()

    # 反向传播,得到梯度
    loss.backward()

    # 更新参数，根据梯度就行优化
    optimizer.step()

在上述模型代码中，SGD作为优化器，lr为0.01。同时根据具体任务选择适合的损失函数，例如torch.nn.CrossEntropyLoss、torch.nn.MSELoss等，以CIFRA10为例

import torch
import torch.optim as optim
import torchvision
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10(root="dataset", train=False, transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(dataset,batch_size=1)

class BS(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Conv2d(in_channels=3,
                      out_channels=32,
                      kernel_size=5,
                      stride=1,
                      padding=2),  #stride和padding计算得到
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32,
                      out_channels=32,
                      kernel_size=5,
                      stride=1,
                      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(),  #变为64*4*4=1024
            nn.Linear(in_features=1024, out_features=64),
            nn.Linear(in_features=64, out_features=10),
        )

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


model = BS()  #定义model
optimizer = optim.SGD(model.parameters(), lr=0.01)  #定义优化器SGD
criterion = nn.CrossEntropyLoss()  #定义损失函数，交叉熵损失函数

'''循环一次，只对数据就行了一轮的学习'''
for inputs, labels in dataloader:
    # 前向传播
    outputs = model(inputs)
    # 计算损失
    loss = criterion(outputs, labels)
    # 清零梯度
    optimizer.zero_grad()
    # 反向传播
    loss.backward()
    # 更新参数
    optimizer.step()
    # 打印经过优化器后的结果
    print(loss)
    
"""训练循环20次"""
# for epoch in range(20):
#     running_loss = 0.0
#     for inputs, labels in dataloader:
#         # 前向传播
#         outputs = model(inputs)
#         # 计算损失
#         loss = criterion(outputs,labels)
#         # 清零梯度
#         optimizer.zero_grad()
#         # 反向传播
#         loss.backward()
#         # 更新参数
#         optimizer.step()
#         # 打印经过优化器后的结果
#         running_loss = running_loss + loss
#     print(running_loss)

Files already downloaded and verified
tensor(2.3942, grad_fn=<NllLossBackward0>)
tensor(2.2891, grad_fn=<NllLossBackward0>)
tensor(2.2345, grad_fn=<NllLossBackward0>)
tensor(2.2888, grad_fn=<NllLossBackward0>)
tensor(2.2786, grad_fn=<NllLossBackward0>)
........