python

关注公众号 jb51net

关闭
首页 > 脚本专栏 > python > pytorch损失函数与反向传播

pytorch基础之损失函数与反向传播详解

作者：Overboom

损失函数(Loss Function)用于衡量神经网络输出与目标值之间的误差,指导网络通过反向传播优化参数,常见的损失函数包括均方误差和交叉熵误差,在训练过程中,通过不断最小化损失函数值来调整网络权重,以期达到输出接近目标值的效果

1 损失函数

1.1 Loss Function的作用

Loss Function的作用：

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

（2）为我们更新输出提供一定的依据，这个提供依据的过程也叫反向传播。

我们可以看下pytorch为我们提供的损失函数：https://pytorch.org/docs/stable/nn.html#loss-functions

1.2 损失函数简单示例

以L1Loss损失函数为例子，他其实很简单，就是把实际值与目标值，挨个相减，再求个均值。就是结果。（这个结果就反映了实际值的好坏程度，这个结果越小，说明越靠近目标值）

示例代码

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) # 目标值
loss = L1Loss()
result = loss(inputs,targets)
print(result)

输出结果：tensor(0.6667)

接下来我们看下两个常用的损失函数：均方差和交叉熵误差

1.3 均方差

均方差：实际值与目标值对应做差，再平方，再求和，再求均值。

那么套用刚才的例子就是：(0+0+2^2)/3=4/3=1.33333…

代码实现

import torch
from torch.nn import L1Loss, MSELoss

inputs = torch.tensor([1,2,3],dtype=torch.float32) # 实际值
targets = torch.tensor([1,2,5],dtype=torch.float32) # 目标值
loss_mse = MSELoss()

result = loss_mse(inputs,targets)
print(result)

输出结果：tensor(1.3333)

1.4 交叉熵误差：

这个比较复杂一点，首先我们看官方文档给出的公式

这里先用代码实现一下他的简单用法：

import torch
from torch.nn import L1Loss, MSELoss, CrossEntropyLoss

x = torch.tensor([0.1,0.2,0.3]) # 预测出三个类别的概率值
y = torch.tensor([1]) # 目标值  应该是这三类中的第二类 也就是下标为1（从0开始的）
x = torch.reshape(x,(1,3)) # 修改格式  交叉熵函数的要求格式是 （N，C） N是bitch_size C是类别
# print(x.shape)
loss_cross = CrossEntropyLoss()
result = loss_cross(x,y)
print(result)

输出结果：tensor(1.1019)

1.5 如何在神经网络中用到Loss Function

# -*- coding: utf-8 -*-
# 作者：小土堆
# 公众号：土堆碎念
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 Tudui(nn.Module):
    def __init__(self):
        super(Tudui, 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()
tudui = Tudui()
for data in dataloader:
    imgs, targets = data
    outputs = tudui(imgs)
    result_loss = loss(outputs, targets)
    print(result_loss)

2 反向传播

所谓的反向传播，就是利用我们得到的loss值，来对我们神经网络中的一些参数做调整，以达到loss值降低的目的。（图片经过一层一层网络的处理，最终得到结果，这是正向传播。最终结果与期望值运算得到loss，用loss反过来调整参数，叫做反向传播。个人理解，不一定严谨！）

2.1 backward

这里利用loss来调整参数，主要使用的方法是梯度下降法。

这个方法原理其实还是有点复杂的，但是pytorch为我们实现好了，所以用起来很简单。

调用损失函数得到的值的backward函数即可。

loss = CrossEntropyLoss() # 定义loss函数
# 实例化这个网络
test = Network()
for data in dataloader:
    imgs,targets = data
    outputs = test(imgs) # 输入图片
    result_loss = loss(outputs,targets)
    result_loss.backward() # 反向传播
    print('ok')

打断点调试，可以看到，grad属性被赋予了一些值。如果不用反向传播，是没有值的

当然，计算出这个grad值只是梯度下降法的第一步，算出了梯度，如何下降呢，要靠优化器

2.2 optimizer

优化器也有好几种，官网对优化器的介绍：https://pytorch.org/docs/stable/optim.html

不同的优化器需要设置的参数不同，但是有两个是大部分都有的：模型参数与学习速率

我们以SDG优化器为例，看下用法：

# 实例化这个网络
test = Network()
loss = CrossEntropyLoss() # 定义loss函数
# 构造优化器
# 这里我们选择的优化器是SGD 传入两个参数 第一个是个模型test的参数 第二个是学习率
optim = torch.optim.SGD(test.parameters(),lr=0.01)

for data in dataloader:
    imgs,targets = data
    outputs = test(imgs) # 输入图片
    result_loss = loss(outputs,targets) # 计算loss
    optim.zero_grad() #因为这是在循环里面 所以每次开始优化之前要把梯度置为0 防止上一次的结果影响这一次
    result_loss.backward() # 反向传播 求得梯度
    optim.step() # 对参数进行调优

这里面我们刚学得主要是这三行：

清零，反向传播求梯度，调优

optim.zero_grad() #因为这是在循环里面 所以每次开始优化之前要把梯度置为0 防止上一次的结果影响这一次
result_loss.backward() # 反向传播 求得梯度
optim.step() # 对参数进行调优

我们可以打印一下loss，看下调优后得loss有什么变化。

注意：我们dataloader是把数据拿出来一遍，那么看了一遍之后，经过这一遍的调整，下一遍再看的时候，loss才有变化。

所以，我们先让让他学习20轮，然后看一下每一轮的loss是多少

# 实例化这个网络
test = Network()
loss = CrossEntropyLoss() # 定义loss函数
# 构造优化器
# 这里我们选择的优化器是SGD 传入两个参数 第一个是个模型test的参数 第二个是学习率
optim = torch.optim.SGD(test.parameters(),lr=0.01)
for epoch in range(20):
    running_loss = 0.0
    for data in dataloader:
        imgs,targets = data
        outputs = test(imgs) # 输入图片
        result_loss = loss(outputs,targets) # 计算loss
        optim.zero_grad() #因为这是在循环里面 所以每次开始优化之前要把梯度置为0 防止上一次的结果影响这一次
        result_loss.backward() # 反向传播 求得梯度
        optim.step() # 对参数进行调优
        running_loss = running_loss + result_loss # 记录下这一轮中每个loss的值之和
    print(running_loss) # 打印每一轮的loss值之和

可以看到，loss之和一次比一次降低了。

总结

具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教

您可能感兴趣的文章:
阅读全文