（十）损失函数与反向传播

【声明】来源b站视频小土堆PyTorch深度学习快速入门教程（绝对通俗易懂！）【小土堆】_哔哩哔哩_bilibili

简单的理解就是每一个样本经过模型后会得到一个预测值，然后得到的预测值和真实值的差值就成为损失（当然损失值越小证明模型越是成功），我们知道有许多不同种类的损失函数，这些函数本质上就是计算预测值和真实值的差距的一类型函数，然后经过库（如pytorch，tensorflow等）的封装形成了有具体名字的函数
 

---

L1Loss，MSELoss

import torch
from torch.nn import L1Loss,MSELoss

input = torch.tensor([1,2,3],dtype=torch.float32)
label = torch.tensor([1,2,5],dtype=torch.float32)

input = torch.reshape(input,(1,1,1,3))
label = torch.reshape(label,(1,1,1,3))
#L1Loss
loss = L1Loss()
result = loss(input,label)
#MSELoss
loss_mse = MSELoss()
result_mse = loss_mse(input,label)
#输出
print(result)
print(result_mse)

 交叉熵损失CrossEntropyloss

 处理分类问题

 

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

input = torch.tensor([1,2,3],dtype=torch.float32)
label = torch.tensor([1,2,5],dtype=torch.float32)

input = torch.reshape(input,(1,1,1,3))
label = torch.reshape(label,(1,1,1,3))

loss = L1Loss()
result = loss(input,label)

loss_mse = MSELoss()
result_mse = loss_mse(input,label)

print(result)
print(result_mse)
'''交叉熵损失CrossEntropyLoss'''
x = torch.tensor([0.1,0.2,0.3])
y = torch.tensor([1])
x = torch.reshape(x,(1,3))#batch为1 ，类别为3
loss_cross= nn.CrossEntropyLoss()
result_cross = loss_cross(x,y )
print(result_cross)

 

import torch.nn as nn
import torchvision

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

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

dataloader = DataLoader(dataset,batch_size=1,num_workers=0)

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()

        self.sequntial = 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.sequntial(x)
        return x

mymodel = MyModel()
for data in dataloader:
    imgs, labels = data
    output = mymodel(imgs)#imgs通过神经网络得到的输出
    #我们看下output和labels长什么样，看选择什么样的损失函数
    print(output)
    print(labels)

结果

经过神经网络有10个输出，每个数代表预测这个类别的概率

是分类问题，可以用交叉熵损失函数

loss_cro = nn.CrossEntropyLoss()


mymodel = MyModel()
for data in dataloader:
    imgs, labels = data
    output = mymodel(imgs)#imgs通过神经网络得到的输出
    #我们看下output和labels长什么样，看选择什么样的损失函数
    # print(output)
    # print(labels)
    result = loss_cro(output,labels)
    print(result)

结果

神经网络输出和真实的误差

 

---

 

 反向传播是如何提供的呢?

对于神经网络的卷积核就是我们需要调节的，给每一个卷积核设置了一个参数为grad(梯度), 当采用反向传播的时候，每一个需要更新的参数都会求出来一个对应的梯度，然后再优化过程中就可以根据这个梯度对其中的参数进行优化，降低loss

梯度下降法

梯度下降法（Gradient descent ）是一个一阶最优化算法，通常也称为最陡下降法 ，要使用梯度下降法找到一个函数的局部极小值 ，必须向函数上当前点对应梯度（或者是近似梯度）的反方向的规定步长距离点进行迭代搜索。 如果相反地向梯度正方向迭代进行搜索，则会接近函数的局部极大值点；这个过程则被称为梯度上升法 ，相反则称之为梯度下降法。
 

 完整代码

import torch.nn as nn
import torchvision

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

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

dataloader = DataLoader(dataset,batch_size=1,num_workers=0)

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()

        self.sequntial = 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.sequntial(x)
        return x

loss_cro = nn.CrossEntropyLoss()


mymodel = MyModel()
for data in dataloader:
    imgs, labels = data
    output = mymodel(imgs)#imgs通过神经网络得到的输出
    #我们看下output和labels长什么样，看选择什么样的损失函数
    # print(output)
    # print(labels)
    result = loss_cro(output,labels)
    result.backward()
    print("ok")