pytorch训练卷积神经网络进行图片分类(官方教程详细解读)

pytorch训练卷积神经网络进行图片分类(官方教程详细解读)

文章主要内容

[官方文档]
对pytorch针对CIFAR10数据集进行图片分类代码的解读，旨在对每一行代码的作用进行解答，整体过程进行梳理。按官方文档顺序，注释解答每行代码的意图和含义

注释解读

1.读取CIFAR10，并进行标准化

import torch
import torchvision #工具库，包含数据集，模型，图片操作，其他操作等等
import torchvision.transforms as transforms  # 图片操作库
# 按顺序进行变换，[0-255]->[0,1]->[-1,1]
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# 读取CIFAR10训练集并进行标准化后下载到./data中
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=2)

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 = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

• transforms相关含义请查看transforms中三个函数的原理及含义
• torch.utils.data.DataLoader的参数
  • batch_size指每次批量处理的个数，即将图片打包，每个小包有size个，示例中4张图片为一组，用于批量处理。
  • shuffle 数据集是否打乱顺序加载
  • num_workers 线程数

2.查看这些图片

import matplotlib.pyplot as plt  # 画图库
import numpy as np # 数组库

# functions to show an image


def imshow(img):
   # 增强图片对比度，使暗的地方更亮
    img = img / 2 + 0.5     # unnormalize
    # 图片转换为nparrary 
    npimg = img.numpy()
    # 图片显示，此处需要转置，因为pytorch与numpy多维顺序结构问题
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()


# get some random training images
# 迭代器
dataiter = iter(trainloader)
# 图片数组（4张）  标签数组（4个） 
images, labels = dataiter.next()

# show images
# 图片合并显示
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

• img = img / 2 + 0.5 是因为图片转成[-1,1]后，0的地方较多，也就是表现出来比较暗，为了方便显示，通过值调整暗的地方更亮

• np.transpose(npimg, (1, 2, 0)转置的原因见transforms中三个函数的原理及含义 其中有解释

• images中是4张 3个通道(RGB) 的32*32的图片，即size为torch.Size([4, 3, 32, 32])

• labels中是4个标签 类似[2,4,5,1]即4张图片分别对应于classes数组的索引号。size为torch.Size([4])

• torchvision.utils.make_grid作用是合并多个图片按网格结构为一张

3.定义CNN网络

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

## 继承nn.Module的Net类
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        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.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()

• 此网络类比于LeNet-5结构，像nn.Conv2d(3, 6, 5)中的参数根据输入集填写，涉及卷积后与池化后的size，具体含义请查看CNN原理
• 其中各卷积和池化对象的参数，例如self.conv1(x)中x，有4个参数，分别为（batch_size,channel,row,column） 即一次处理的批量个数，通道数，图片size。 本例中为 （4*3*32*32），这也使得最后x处理的最终size为(4*10)即4张图各自对应10个类别的概率
• x.view(-1, 16 * 5 * 5)拉平操作，-1指自动计算，拉平为一维那自动计算为16 * 5 * 5

4.训练模型

# 梯度优化库
import torch.optim as optim
# CrossEntropy损失函数对象
criterion = nn.CrossEntropyLoss()
# 随机梯度下降法，学习率0.001，动量0.9
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
# 训练两次
for epoch in range(2):  # loop over the dataset multiple times

    running_loss = 0.0
    # 枚举enumerate(trainloader, 0) 0指索引从0开始即i从0开始
    for i, data in enumerate(trainloader, 0):
        # inputs:4*3*32*32  labels:4
        inputs, labels = data

        # 清空梯度值
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        # 后向传播，计算各参数梯度下降值
        loss.backward()
        # 执行参数更新
        optimizer.step()

        # 统计每2000个批处理的平均损失值
        running_loss += loss.item()
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

• 随机梯度下降法，学习率与贯性动量问题，请查找模型优化原理方法
• item()是pytorch中的取值操作

5.保存模型参数与测试模型

# 保存模型的状态参数字典
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)
# 创建网络，加载网络模型
net = Net()
net.load_state_dict(torch.load(PATH))

# 加载测试数据

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)
        # 对比相等的地方，相等即为1，不相等为0，加和后取值即正确的个数
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

• torch.no_grad()作用是包含的地方不计算梯度
• torch.max(outputs.data, 1)以列为基准获取最大值，返回值为 最大值的序列和各自基准下对应的索引号
• (predicted == labels).sum().item() 序列按照索引号一一比对，相等赋值1，不相等赋值0。加和取值

可运行的源码已上传至资源，免费下载