损失函数与反向传播 (1)

损失函数与反向传播(1)

一、损失函数

pytorch官方文档中的torch.nn板块中的Loss Functions

计算实际输出与目标之间的差距

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

1.nn.L1Loss()

CLASS  torch.nn.L1Loss(size_average=None, reduce=None, reduction='mean')

创建一个度量输入 x和目标y中每个元素之间的平均绝对误差(MAE)的标准,需要注意参数的shape

使用案例：

import torch
from torch import nn

inputs = torch.Tensor([1,2,3])
targets = torch.Tensor([1,2,5])

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

# 创建损失函数实例
loss = nn.L1Loss()   # reduction='sum' 可以选择计算的方式
result = loss(inputs,targets)  # [(1-1) + (2-2) + (5-3)]/3 = 0.667

print(result)  #  tensor(0.6667)

2.nn.MSELOSS()

CLASS  torch.nn.MSELoss(size_average=None, reduce=None, reduction='mean')

创建一个标准，测量输入x和目标y中每个元素之间的均方误差(L2范数的平方)

使用案例：

import torch
from torch import nn

inputs = torch.Tensor([1,2,3])
targets = torch.Tensor([1,2,5])

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

# 创建损失函数实例
loss = nn.MSELoss()
result = loss(inputs,targets)  # [(1-1)^2 + (2-2)^2 + (5-3)^2]/3 = 1.3333

print(result)  #  tensor(1.3333)

3.nn.CrossEntropyLoss()

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

该准则计算输入对数和目标之间的交叉熵损失

使用案例：

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

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

# 利用DataLoader加载数据集
train_dataloader = DataLoader(train_data,batch_size=1)

# 搭建神经网络
class Module(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3,32,5,1,2),  # 卷积
            nn.MaxPool2d(2) ,       # 最大池化
            nn.Conv2d(32,32,5,1,2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,64,5,1,2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64*4*4,64),
            nn.Linear(64,10)
        )

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

# 损失函数（交叉熵）
loss = nn.CrossEntropyLoss()

if __name__ == '__main__':
    # 新建网络实例
    mymodule = Module()
    for data in train_dataloader:
        imgs,targets = data
        # 将图片传入网络中进行训练，得到网络输出的结果
        outputs = mymodule(imgs)
        # outputs  因为dataloader 中 batch_size=1 因此该结果为 神经网络对该图片的每一种分类可能的概率
        # tensor([[ 0.0668,  0.0049, -0.0903, -0.0869, -0.0769,  0.1024,  0.1060, -0.0309,
        #           0.0157,  0.0693]], grad_fn=<AddmmBackward>)
        print(outputs)
        # tensor([0])   targets 为 网络对该图片得到的分类结果（可能不准与模型训练程度有关）
        print(targets)

        result_loss = loss(outputs,targets)  # 得到损失函数的值
        print("result_loss: {}".format(result_loss))

一部分运行结果：

Files already downloaded and verified
tensor([[-0.0980, -0.0868,  0.1535, -0.0101, -0.0753, -0.0731, -0.0828, -0.0236,
         -0.0943, -0.1019]], grad_fn=<AddmmBackward>)
tensor([6])
result_loss: 2.3390400409698486
tensor([[-0.1120, -0.1046,  0.1884, -0.0205, -0.0701, -0.0963, -0.0721, -0.0202,
         -0.0620, -0.0840]], grad_fn=<AddmmBackward>)
tensor([9])
result_loss: 2.3449268341064453