pytorch学习-9.多分类问题

9.1 代码复现：

复制代码

import torch
from torchvision import datasets,transforms
from torch.utils.data import DataLoader
import torch.nn.functional as F
import numpy as np

#一.准备数据集
#定义数据预处理变换
batch_size=64
transform=transforms.Compose([
    transforms.ToTensor(),
    #将PIL图像转为tensor,并且将像素值缩放到[0,1]之间

    transforms.Normalize((0.1307,),(0.3081,))
    #对图像数据进行归一化处理, 均值height=0.1307, 标准差=0.3081
])

#加载训练数据集,测试数据集,以及相应的加载器

train_dataset = datasets.MNIST(root='../dataset/mnist/',
                               train=True,
                               download=True,
                               transform=transform)
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist/',
                              train=False,
                              download=True,
                              transform=transform)
test_loader = DataLoader(test_dataset,
                         shuffle=False,
                         batch_size=batch_size)


#二.定义模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.l1=torch.nn.Linear(28*28,512)
        self.l2=torch.nn.Linear(512,256)
        self.l3=torch.nn.Linear(256,128)
        self.l4=torch.nn.Linear(128,64)
        self.l5=torch.nn.Linear(64,10)

    def forward(self,x):
        x=x.view(-1,28*28)  #view函数将tensor展平为2维矩阵,[N,28*28]
        x=F.relu(self.l1(x))
        x=F.relu(self.l2(x))
        x=F.relu(self.l3(x))
        x=F.relu(self.l4(x))
        x=self.l5(x)         #输出层没有激活函数
        return x
#实例化模型
model=Net()

#三.定义损失函数和优化器
criterion=torch.nn.CrossEntropyLoss()
optimizer=torch.optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

#四.训练模型
#定义训练函数
def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs,labels=data   #获取输入数据和标签
        y_pred=model(inputs)    #预测输出
        loss=criterion(y_pred,labels)    #计算损失
        optimizer.zero_grad()    #梯度清零
        loss.backward()          #反向传播
        optimizer.step()         #更新参数

        running_loss+=loss.item() #累计损失
        if batch_idx%300==299:    #每300个batch打印一次损失
            print('[%d, %5d] loss: %.3f' % (epoch+1,batch_idx+1,running_loss/300))
            running_loss=0.0

#定义测试函数
def test():
    correct=0   #记录预测正确的样本数
    total=0     #记录测试集样本总数
    with torch.no_grad():    #测试时不需要更新参数,所以关闭梯度计算可以加快速度
        for data in test_loader:
            images,labels=data
            outputs=model(images)
            _,predicted=torch.max(outputs.data,1)    #返回每行最大值的索引和值
            total+=labels.size(0)                      #统计测试集样本总数
            correct+=(predicted==labels).sum().item()  #统计预测正确的样本数
    print('Accuracy of the network  test : %d %%' % (100*correct/total))


#开始训练
if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()

9.1.1多分类问题

以MNIST数据集为例，数字一共有0~9一共10种类别，利用深度学习来识别十种数字的类别，这就是多分类问题。需要计算出每个方框属于不同数字的10个概率，这10个概率需要满足：

即一个图像的每种类别的概率大于等于0，各种类别概率之和为1。

9.1.2Softmax层

Softmax函数公式如下：其中表示的是线性层 输出的数值（分为K个类别）；对每个类别值 的求指数 ，之后再计算每个类别指数值 占总所有类别指数值之和 的比例，就是计算出的该类别的概率。公式如下

保证该类别概率大于0
可确保

举个例子：

如下图所示，经过处理后，有三个类别的值输出到SoftMax层中，首先将（0.2，0.1，-0.1）分别求指数，得到（1.22，1.11，0.90），将其求和得到公式的分母（sum=3.23），最后（1.22/sum，1.11/sum，0.90/sum）即可得到最终结果。

9.1.3NLLLoss (负对数似然损失)函数

NLLLoss损失函数 如下图所示：（最大的对应的值为1，其余都为0.）,在使用NLLLoss 之前，模型的输出需要先经过Softmax函数处理。

9.1.4CrossEntropyLoss (交叉熵损失)函数

CrossEntropyLoss损失函数 是将Softmax层 和NLLLoss损失函数 整合在一起，在使用CrossEntropyLoss损失函数 时，不用经过Softmax层的计算，直接输入到CrossEntropyLoss损失函数中就可以。CrossEntropyLoss损失函数如下图所示：

9.1.5图像映射成一个矩向量

MNIST图像是由28x28=784个像素组成，其中越深的地方数值越接近0，越亮的地方数值越接近1。

9.1.6数据集

图像张量：

灰度图（黑白图像）就是一个单通道 的图像，彩色图像是多通道的图像（分别是R,G,B三个通道），一个通道具有高度---H，宽度---W，通道由------C表示。

transformer作用：

再pytorch中读取图像时使用的是python的PIL ，而由PIL读取的图像一般是由组成,transform的作用就是将PIL读取的图像顺序转换成，像素值值从0~255转换成0~1(更高效)。

对图像数据进行归一化处理，均值为0.1307，标准差为0.3081

9.1.7建立模型

全连接网络中，要求输入的是一个矩阵，因此需要将1x28x28的这个三阶的张量变成一个一阶的向量，因此将图像的每一行的向量横着拼起来变成一串，这样就变成了一个维度为1x784的向量，一共输入N个手写数图，因此，输入矩阵维度为（N，784）。最后一个线性层，不需要激活函数，是因为 CrossEntropyLoss 函数会在内部自动处理 SoftMax操作。如下图所示：