[人工智能]【PyTorch】2.2 使用Pytorch构建一个分类器(使用真实数据集CIFAR10)

2.2 使用Pytorch构建一个分类器

学习目标

• 了解分类器的任务和数据样式
• 掌握如何使用Pytorch实现一个分类器

分类器任务和数据介绍

• 构建一个将不同图像进行分类的神经网络分类器，对输入的图片进行判断并完成分类
• 本案例采用CIFAR0数据集作为原始图片数据

CIFAR10数据集介绍

• 数据集中每张图片的尺寸是33232，代表彩色3通道
• CIFAR10数据集共有10种不同的分类，分别是：airplane automobile bird cat deer dog frog horse ship truck

训练分类器步骤

• 1：使用torchvision下载CIFAR10数据集
• 2：定义卷积神经网络
• 3：定义损失函数
• 4：在训练集上训练模型
• 5：在测试集上测试模型

1：使用torchvision下载CIFAR10数据集

• 导入torchvision包来辅助下载数据集

import torch
import torchvision
import torchvision.transforms as transforms
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
#下载数据集并对图片进行调整，因为torchvision数据集的输出是PILImage格式，数据域在[0,1]
#我们将其转换成标准数据域[-1,1]的张量格式
#transform 数据转换器
transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])
trainset=torchvision.datasets.CIFAR10(root='./data',train=True,download=True,transform=transform)
# 下载下来的数据放在trainset里面
trainloader=torch.utils.data.DataLoader(trainset,batch_size=4,shuffle=True,num_workers=2)
# DataLoader数据迭代器 将数据封装成DataLoader
# num_workers:两个线程读取数据
# batch_size=4 批处理

testset=torchvision.datasets.CIFAR10(root='./data',train=False,download=True,transform=transform)
testloader=torch.utils.data.DataLoader(testset,batch_size=4,shuffle=False,num_workers=2)
classes=('airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
#输出
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data\cifar-10-python.tar.gz
100.0%
Extracting ./data\cifar-10-python.tar.gz to ./data
Files already downloaded and verified

注意：

可能存在的两个问题：

• windows系统下运行上述代码，并且出现报错信息“BrokenPipeError”时，可以尝试将torch.utils.DataLoader()中的num_workers设置为0
• 下载CIFAR10数据集报错：urllib.error.URLError: ＜urlopen error [SSL: CERTIFICATE_VERIFY_FAILED] certi
• 尽量使用linux系统学习深度学习

展示若干训练集的图片

在此处遇到问题可以访问我之前写的一篇文章

import torch
import torchvision
import torchvision.transforms as transforms
import ssl
import torch.utils.data as Data
ssl._create_default_https_context = ssl._create_unverified_context
#下载数据集并对图片进行调整，因为torchvision数据集的输出是PILImage格式，数据域在[0,1]
#我们将其转换成标准数据域[-1,1]的张量格式
#transform 数据转换器
transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])
trainset=torchvision.datasets.CIFAR10(root='./data',train=True,download=True,transform=transform)
# 下载下来的数据放在trainset里面
trainloader=torch.utils.data.DataLoader(dataset=trainset,batch_size=4,shuffle=True,num_workers=2)
# DataLoader数据迭代器 将数据封装成DataLoader
# num_workers:两个线程读取数据
# batch_size=4 批处理

testset=torchvision.datasets.CIFAR10(root='./data',train=False,download=True,transform=transform)
testloader=torch.utils.data.DataLoader(dataset=testset,batch_size=4,shuffle=False,num_workers=2)
classes=('airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

#展示若干训练集的图片
#导入画图包和numpy
import matplotlib.pyplot as plt
import numpy as np

#构建展示图片的函数
def imShow(img):
    img=img/2+0.5
    #img是tensor类型的数据，tensor类型转换成numpy类型的数据
    npimg=img.numpy()
    plt.imshow(np.transpose(npimg,(1,2,0)))#维度转换成 1 2 0 这三个维度
    plt.show()

#从数据迭代器中读取一张图片
if __name__ == '__main__':
    try:
        dataiter = iter(trainloader)
        images, labels = dataiter.next()

        # 展示图片
        imShow(torchvision.utils.make_grid(images))
        # 使用网格的形式展示图片
        # 打印标签label
        print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
    except Exception as e:
        print(e)
#输出
dog horse   cat   cat

定义卷积神经网络

仿照2.1节中的类来构造此处的类，唯一的区别在于次数采用的三通道 3-channel

import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        #定义两个卷积层
        self.conv1=nn.Conv2d(3,6,5)
        self.conv2=nn.Conv2d(6,16,5)
        #定义池化层
        self.pool = nn.MaxPool2d(2, 2)
        #定义全连接层
        self.fc1=nn.Linear(16*5*5,120)
        self.fc2=nn.Linear(120,84)
        self.fc3=nn.Linear(84,10)

    def forward(self,x):
        x=self.pool(F.relu(self.conv1(x)))
        x=self.pool(F.relu(self.conv2(x)))
        #变换x的形状 以适配全连接层的输入
        x=x.view(-1,16*5*5)
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        return x
net=Net()
print(net)

3: 定义损失函数

采用交叉熵损失函数和随机梯度下降优化器

#交叉熵损失函数和随机梯度下降优化器
import torch.optim as optim
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(net.parameters(),lr=0.001,momentum=0.9)

4: 在训练集上训练模型

采用基于梯度下降的优化算法，都需要很多个轮次的迭代训练

import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torch
import torchvision.transforms as transforms

transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])
trainset=torchvision.datasets.CIFAR10(root='./data',train=True,download=True,transform=transform)
trainloader=torch.utils.data.DataLoader(trainset,batch_size=4,shuffle=True,num_workers=0)
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        #定义两个卷积层
        self.conv1=nn.Conv2d(3,6,5)
        self.conv2=nn.Conv2d(6,16,5)
        #定义池化层
        self.pool = nn.MaxPool2d(2, 2)
        #定义全连接层
        self.fc1=nn.Linear(16*5*5,120)
        self.fc2=nn.Linear(120,84)
        self.fc3=nn.Linear(84,10)

    def forward(self,x):
        x=self.pool(F.relu(self.conv1(x)))
        x=self.pool(F.relu(self.conv2(x)))
        #变换x的形状 以适配全连接层的输入
        x=x.view(-1,16*5*5)
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        return x
net=Net()
print(net)

#交叉熵损失函数和随机梯度下降优化器
import torch.optim as optim
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(net.parameters(),lr=0.001,momentum=0.9)

for epoch in range(2):
    running_loss=0.0
    for i ,data in enumerate(trainloader,0):
        #data 中包含输入图像张量inputs，标签张量labels
        inputs,labels=data

        #首先将优化器梯度归零
        optimizer.zero_grad()

        #输入图像张量进网络，得到输出张量outputs
        outputs=net(inputs)

        #利用网络的输出outputs和标签labels计算损失值
        loss=criterion(outputs,labels)

        #反向传播+参数更新，是标准的代码流程
        loss.backward()
        optimizer.step()

        #打印轮次和损失值
        running_loss+=loss.item()
        if (i+1)%2000==0:
            print('[%d , %5d] loss: %.3f'%(epoch+1,i+1,running_loss/2000))
            running_loss=0.0
print("Finished Training")

• 输出结果

[1 ,  2000] loss: 2.220
[1 ,  4000] loss: 1.859
[1 ,  6000] loss: 1.658
[1 ,  8000] loss: 1.570
[1 , 10000] loss: 1.512
[1 , 12000] loss: 1.436
[2 ,  2000] loss: 1.373
[2 ,  4000] loss: 1.367
[2 ,  6000] loss: 1.340
[2 ,  8000] loss: 1.303
[2 , 10000] loss: 1.312
[2 , 12000] loss: 1.277
Finished Training

• 保存模型

#首先设定模型的保存路径
PATH='./cifar_net.pth'
torch.save(net.state_dict(),PATH)

5：在测试集上测试模型

• 第一步，展示测试集中的若干图片

dataiter=iter(testloader)
images,labels=dataiter.next()

#打印原始图片
imShow(torchvision.utils.make_grid(images))
#打印真实的标签
print('GroundTruth:',' '.join('%5s' %classes[labels[j]] for j in range(4)))

【完整版本代码】

import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torch
import numpy as np
import matplotlib.pyplot as plt
import torchvision.transforms as transforms

transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])
trainset=torchvision.datasets.CIFAR10(root='./data',train=True,download=True,transform=transform)
trainloader=torch.utils.data.DataLoader(trainset,batch_size=4,shuffle=True,num_workers=0)

testset=torchvision.datasets.CIFAR10(root='./data',train=False,download=True,transform=transform)
testloader=torch.utils.data.DataLoader(testset,batch_size=4,shuffle=True,num_workers=0)

classes=('airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

def imShow(img):
    img=img/2+0.5
    #img是tensor类型的数据，tensor类型转换成numpy类型的数据
    npimg=img.numpy()
    plt.imshow(np.transpose(npimg,(1,2,0)))#维度转换成 1 2 0 这三个维度
    plt.show()

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        #定义两个卷积层
        self.conv1=nn.Conv2d(3,6,5)
        self.conv2=nn.Conv2d(6,16,5)
        #定义池化层
        self.pool = nn.MaxPool2d(2, 2)
        #定义全连接层
        self.fc1=nn.Linear(16*5*5,120)
        self.fc2=nn.Linear(120,84)
        self.fc3=nn.Linear(84,10)

    def forward(self,x):
        x=self.pool(F.relu(self.conv1(x)))
        x=self.pool(F.relu(self.conv2(x)))
        #变换x的形状 以适配全连接层的输入
        x=x.view(-1,16*5*5)
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        return x
net=Net()
print(net)

#交叉熵损失函数和随机梯度下降优化器
import torch.optim as optim
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(net.parameters(),lr=0.001,momentum=0.9)

# for epoch in range(2):
#     running_loss=0.0
#     for i ,data in enumerate(trainloader,0):
#         #data 中包含输入图像张量inputs，标签张量labels
#         inputs,labels=data
#
#         #首先将优化器梯度归零
#         optimizer.zero_grad()
#
#         #输入图像张量进网络，得到输出张量outputs
#         outputs=net(inputs)
#
#         #利用网络的输出outputs和标签labels计算损失值
#         loss=criterion(outputs,labels)
#
#         #反向传播+参数更新，是标准的代码流程
#         loss.backward()
#         optimizer.step()
#
#         #打印轮次和损失值
#         running_loss+=loss.item()
#         if (i+1)%2000==0:
#             print('[%d , %5d] loss: %.3f'%(epoch+1,i+1,running_loss/2000))
#             running_loss=0.0
# print("Finished Training")
#
# #保存模型
# #首先设定模型的保存路径
# PATH='./cifar_net.pth'
# torch.save(net.state_dict(),PATH)

dataiter=iter(testloader)
images,labels=dataiter.next()

#打印原始图片
imShow(torchvision.utils.make_grid(images))
#打印真实的标签
print('GroundTruth:',' '.join('%5s' %classes[labels[j]] for j in range(4)))

• 第二步，加载模型并对测试图片进行预测

import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torch
import numpy as np
import matplotlib.pyplot as plt
import torchvision.transforms as transforms

transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])
trainset=torchvision.datasets.CIFAR10(root='./data',train=True,download=True,transform=transform)
trainloader=torch.utils.data.DataLoader(trainset,batch_size=4,shuffle=True,num_workers=0)

testset=torchvision.datasets.CIFAR10(root='./data',train=False,download=True,transform=transform)
testloader=torch.utils.data.DataLoader(testset,batch_size=4,shuffle=True,num_workers=0)

classes=('airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

def imShow(img):
    img=img/2+0.5
    #img是tensor类型的数据，tensor类型转换成numpy类型的数据
    npimg=img.numpy()
    plt.imshow(np.transpose(npimg,(1,2,0)))#维度转换成 1 2 0 这三个维度
    plt.show()

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        #定义两个卷积层
        self.conv1=nn.Conv2d(3,6,5)
        self.conv2=nn.Conv2d(6,16,5)
        #定义池化层
        self.pool = nn.MaxPool2d(2, 2)
        #定义全连接层
        self.fc1=nn.Linear(16*5*5,120)
        self.fc2=nn.Linear(120,84)
        self.fc3=nn.Linear(84,10)

    def forward(self,x):
        x=self.pool(F.relu(self.conv1(x)))
        x=self.pool(F.relu(self.conv2(x)))
        #变换x的形状 以适配全连接层的输入
        x=x.view(-1,16*5*5)
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        return x
# net=Net()
# print(net)

#交叉熵损失函数和随机梯度下降优化器
import torch.optim as optim
criterion=nn.CrossEntropyLoss()
# optimizer=optim.SGD(net.parameters(),lr=0.001,momentum=0.9)

# for epoch in range(2):
#     running_loss=0.0
#     for i ,data in enumerate(trainloader,0):
#         #data 中包含输入图像张量inputs，标签张量labels
#         inputs,labels=data
#
#         #首先将优化器梯度归零
#         optimizer.zero_grad()
#
#         #输入图像张量进网络，得到输出张量outputs
#         outputs=net(inputs)
#
#         #利用网络的输出outputs和标签labels计算损失值
#         loss=criterion(outputs,labels)
#
#         #反向传播+参数更新，是标准的代码流程
#         loss.backward()
#         optimizer.step()
#
#         #打印轮次和损失值
#         running_loss+=loss.item()
#         if (i+1)%2000==0:
#             print('[%d , %5d] loss: %.3f'%(epoch+1,i+1,running_loss/2000))
#             running_loss=0.0
# print("Finished Training")
#
# #保存模型
# #首先设定模型的保存路径
PATH='./cifar_net.pth'
# torch.save(net.state_dict(),PATH)

dataiter=iter(testloader)
images,labels=dataiter.next()

#打印原始图片
imShow(torchvision.utils.make_grid(images))
#打印真实的标签
print('GroundTruth:',' '.join('%5s' %classes[labels[j]] for j in range(4)))

#第二步，加载模型并对测试图片进行预测
#首先实例化模型的类对象
net=Net()
#加载训练阶段保存好的模型的状态字典
net.load_state_dict(torch.load(PATH))

#利用模型对图片进行预测
outputs=net(images)

#共有10个类别，采用模型计算出的概率最大的作为预测的类别
_,predicted=torch.max(outputs,1)
print("predicted:",predicted)

#打印预测标签的结果
print("Predicted:",' '.join('%5s' % classes[predicted[j]] for j in range(4)))

• 输出

GroundTruth:  ship  frog  bird automobile
predicted: tensor([0, 2, 8, 1])
Predicted: airplane  bird  ship automobile

• 训练好的模型在全部测试集上的表现

#在全部测试集上的表现
correct=0
total=0
with torch.no_grad():
    for data in testloader:
        images,labels=data
        outputs=net(images)
        _,predicted=torch.max(outputs.data,1)
        total+=labels.size(0)
        correct+=(predicted==labels).sum().item()
print("Accuracy of the network on the 10000 test images:%d %%"%(100*correct/total))
#输出
 Accuracy of the network on the 10000 test images:56 %

• 分析：对于拥有10个类被的数据集，随机猜测的准确率是10%，模型达到了53%，说明模型学到了真实的东西。
  上面计算的是模型在总体测试集上的准确率，为了更加细致多看一些模型在哪些类别上表现更好，在哪些类别上表现更差，可以对每个类别的准确率进行计算。

#在全部测试集上的表现
correct=0
total=0
class_correct=[0. for i in range(10)]
class_total=[0 for i in range(10)]
max_index=-1
min_index=1000
with torch.no_grad():
    for data in testloader:
        images,labels=data
        outputs=net(images)
        _,predicted=torch.max(outputs.data,1)
        total+=labels.size(0)
        correct+=(predicted==labels).sum().item()
        for i in range(labels.size(0)):
            class_correct[labels[i]]+=(predicted[i]==labels[i])
            class_total[labels[i]]+=1
print("Accuracy of the network on the 10000 test images:%d %%"%(100*correct/total))
# print(class_total)
# print(class_correct)
#打印不同类别的准确度
for i in range(10):
    print("Accuracy of ",classes[i], ":",100*class_correct[i].item()/class_total[i],"%")
#输出
Accuracy of the network on the 10000 test images:56 %
Accuracy of  airplane : 59.4 %
Accuracy of  automobile : 70.2 %
Accuracy of  bird : 30.1 %
Accuracy of  cat : 38.6 %
Accuracy of  deer : 59.1 %
Accuracy of  dog : 35.4 %
Accuracy of  frog : 70.7 %
Accuracy of  horse : 68.3 %
Accuracy of  ship : 69.2 %
Accuracy of  truck : 67.6 %

在GPU上训练模型

为了真正利用Pytorch中Tensor的优秀属性，加速模型的训练，可以将训练过程转移到GPU上进行。
首先，定义设备，如果CUDA是可用的则被定义成GPU，否则被定义成CPU
将模型放在GPU上训练分两步走：
1：将模型转移到GPU上
2：将数据转移到GPU上

device=torch.device('cuda:0' if torch.cuda.is_available() else "cpu")
print(device)

#当训练模型的时候，只需要将模型转移到GPU上满天星将输入的图片和标签页转移到GPU上即可
net.to(device)

#将输入的图片张量和标签张量转移到GPU上
inputs,labels=data[0].to(device),data[1].to(device)

【小节总结】

学习了分类器的任务和数据样式

• 将不同图像进行分类的神经网络分类器，对输入的图片进行判断并完成分类
• 采用CIFAR10数据集作为原始图片数据，CIFAR10数据集拥有10个类别的33232彩色图片

学习了训练分类器的步骤

• 使用torchvision下载CIFAR10数据集
• 定义卷积神经网络
• 定义损失函数
• 在训练集上训练模型
• 在测试集上测试模型

学习了在GPU上训练模型

• 首先需要定义设备，CPU和GPU二选一
  device=torch.device('cuda:0' if torch.cuda.is_available() else "cpu")
• 然后将模型转移到GPU上去
  net.to(device)
• 最后在迭代训练的过程中，每一步都将图片和标签张量转移到GPU上去
  inputs,labels=data[0].to(device),data[1].to(device)