[人工智能]01.12 pytorch学习（损失函数与反向传播）

损失函数

我们称作神经网络的预测值的错误率（非百分比）为损失函数
计算损失值的方法不一样，torch.nn里面提供了多种损失函数
这里不得不提一下，据我所知，在线性激活函数过后，得到一组一维数组，值对应的是网络预测的每个类别的概率。

举个例子
[0.1,0.2,0.3]
那么这个数据最有可能是target=2（下标从0开始）

用代码来演示一下损失函数

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

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))

#平均损失函数
#reduction:计算的方式
loss = L1Loss(reduction='sum')
#均方损失函数
loss2 = MSELoss()

result1=loss(inputs,targets)
result2=loss2(inputs,targets)
print(result1)
print(result2)

#演示
x = torch.tensor([0.1,0.2,0.3])
y = torch.tensor([1])
crossentropyloss = CrossEntropyLoss()
print(x.shape)#如果不reshape，就是是[3]，不会是[1，3]
x = torch.reshape(x,(1,3))#reshape一下
print(x.shape)
c = crossentropyloss(x,y)
print(c)

#结果
#tensor(2.)
#tensor(1.3333)
#torch.Size([3])
#torch.Size([1, 3])
#tensor(1.1019)

1.1019是我们的损失函数的输出，有什么用呢，我们可以使用梯度下降法，使损失函数变成最小（就是求导）

对于分类的问题，有交叉熵损失函数
下面介绍：

我们使用CIFAR10数据集来举例

CIFAR10共10个类别
一张图像（batch_size,chanel,W,H）通过神经网络的处理变更成大小为10的一维数组（见文章第一张图下面），然后由损失函数求出误差进行优化，优化这节还没讲

代码：

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

dataset = torchvision.datasets.CIFAR10("./dataset2", train=True, transform=torchvision.transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset,batch_size=64)

#生成一个(64,3,32,32)格式的全1矩阵
input = torch.ones((64,3,32,32))

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

index = 0
loss = nn.CrossEntropyLoss()
tudui = Tudui()
for data in dataloader:
    #这里的img和target和上一节代码的输入有点不同，
    #Input: (N, C) where C = number of classes, or (N,C,d1 ,d2 ,...,dK ) with K \geq 1K≥1 in the case of K-dimensional loss.
    #翻译下英文就知道了，都是第一种方式，一个输入(batch_size=1)，和一组输入(batch_size=64)。
    img,target = data
    print(img.shape)#torch.Size([64, 3, 32, 32])
    print(target)
    output = tudui(img)
    print(output.shape)#torch.Size([64, 10])
    outputloss = loss(output,target)
    print(outputloss)
    index += 1
    if index>= 10:
        break

反向传播：backward使用方法下节讲