Pytorch学习系列之三 ：动手实现一个图像分类卷积神经网络

概述

对于本教程，我们将使用CIFAR10数据集，它包含十个类别：‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。CIFAR-10 中的图像尺寸为32x32，也就是RGB的3层颜色通道，每层通道内的尺寸为32x32。

训练一个图像分类器
我们将按次序的做如下几步：

1，使用torchvision加载并且归一化CIFAR10的训练和测试数据集
2，定义一个卷积神经网络
3，定义一个损失函数
4，在训练样本数据上训练网络
5，在测试样本数据上测试网络

案例代码及注释 (精髓在于注释)

import torch
import torchvision
import torchvision.transforms as transforms

‘’’$ Notice: torchvision 数据集的输出是范围在[0,1]之间的 PILImage，我们将他们转换成归一化范围为[-1,1]之间的张量 Tensors。
$ transforms.ToTensor()能把灰度范围从[0,255]变为[0,1]。
$ transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))则能把[0,1]映射到[-1,1]区间。
‘’’

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

testset = torchvision.datasets.CIFAR10(root=’./data’, train=False,
download=True, transform=transform)
print(“训练集：”,trainset)
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’)

print(classes)

‘’‘展示其中的一些训练图片。’’’
import matplotlib.pyplot as plt
import numpy as np

定义一个显示图像的方法

def imshow(img):
img = img / 2 + 0.5 # unnormalize,将[-1,1]还原到[0,1]区间
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()

#get some random training images（trainloader中定义的批大小为4，所以这里会显示4张图像）
dataiter = iter(trainloader)
images, labels = dataiter.next()

显示图像

imshow(torchvision.utils.make_grid(images))

print labels

print(’ ‘.join(’%5s’ % classes[labels[j]] for j in range(4)))

‘’‘定义一个卷积神经神经网络，接收3通道的图片’’’
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module): #继承自nn.Module
def init(self):
super(Net, self).init()
‘’’# 3 input image channel, 6 output channels, 5x5 square convolution
# kernel’’’
self.conv1 = nn.Conv2d(3, 6, 5)#输入图像为3通道，输出通道为6， 卷积核大小是5x5
self.pool = nn.MaxPool2d(2, 2) # 2x2池化
self.conv2 = nn.Conv2d(6, 16, 5) # 输入图像为6，输出通道为16， 卷积核大小是5x5
‘’’
Linear(in_features, out_features)
in_features指的是输入的二维张量的大小，即输入的[batch_size, size]中的size。   
out_features指的是输出的二维张量的大小，即输出的二维张量的形状为[batch_size，output_size]，
当然，它也代表了该全连接层的神经元个数。   
从输入输出的张量的shape角度来理解，相当于一个输入为[batch_size, in_features]的张量变换成了[batch_size, out_features]的输出张量。
‘’’
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
‘’‘这里是参数说明，解释上面的数字是如何确定出来的。
1）首先输入的图像是3x32x32(CxHxW),要经过卷积层conv1 = nn.Conv2d(3, 6, 5)，输出为6x28x28（CxHxW），采用的是nopadding模式，所以输出图像大小变小了(ksize-1),32-4=28.
2) 再经过一个2x2 maxPooling池化,输出为6x14x14（CHW）.
3）经过第二个卷积层conv2 = nn.Conv2d(6, 16, 5)，输出为 16x10x10（CHW），采用的是nopadding模式，所以输出图像大小变小了(ksize-1),14-4=10.
4) 再经过一个2x2 maxPooling池化，输出为16x5x5（CHW）.
5) 经过第一个全连接层self.fc1 = nn.Linear(16 x5 x 5, 120)，输入为16x5x5个神经元，输出为120个神经元。
6）经过第一个激活函数层，输出仍为120个神经元。
7）经过第二个全连接层，输入为120个神经元，输出为84个神经元
8）经过第二个激活函数层，输出仍为84个神经元。
9）最后再经过一个输出层，输入为84个神经元，输出为10个结果（神经元）(对应数据集中的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 x 5 x 5)
    x = F.relu(self.fc1(x))
    x = F.relu(self.fc2(x))
    x = self.fc3(x)
    return x

net = Net()

‘’‘定义一个损失函数和优化器 让我们使用分类交叉熵Cross-Entropy 作损失函数，动量SGD做优化器。
momentum SGD其实是梯度变化阻尼器的原理，让训练时候梯度的变化更加平滑，加快训练过程。
‘’’
import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

‘’‘训练网络，只需要在数据迭代器上循环将输入的训练数据传给网络和优化器。’’’
for epoch in range(20): # loop over the dataset multiple times

running_loss = 0.0
for i, data in enumerate(trainloader, 0):
    # get the inputs
    inputs, labels = data

    # zero the parameter gradients，一定要清零，防止梯度一直叠加
    optimizer.zero_grad()

    # forward + backward + optimize
    outputs = net(inputs)#forward
    loss = criterion(outputs, labels)#计算loss
    loss.backward()#backward
    optimizer.step()#更新参数

    # print statistics
    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’)

‘’‘看看网络在整个数据集上的表现’’’
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))

文章代码整合

'''我们将按次序的做如下几步：
#1,使用torchvision加载并且归一化CIFAR10的训练和测试数据集
#2,定义一个卷积神经网络
#3,定义一个损失函数
#4,在训练样本数据上训练网络
#5,在测试样本数据上测试网络
'''


import torch
import torchvision
import torchvision.transforms as transforms

'''$ Notice: torchvision 数据集的输出是范围在[0,1]之间的 PILImage，我们将他们转换成归一化范围为[-1,1]之间的张量 Tensors。
   $ transforms.ToTensor()能把灰度范围从[0,255]变为[0,1]。
   $ transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))则能把[0,1]映射到[-1,1]区间。
'''

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

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
print("训练集：",trainset)
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')

print(classes)

'''展示其中的一些训练图片。'''
import matplotlib.pyplot as plt
import numpy as np


# 定义一个显示图像的方法
def imshow(img):
    img = img / 2 + 0.5     # unnormalize,将[-1,1]还原到[0,1]区间
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()
    
# get some random training images（trainloader中定义的批大小为4，所以这里会显示4张图像）
dataiter = iter(trainloader)
images, labels = dataiter.next()

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



'''定义一个卷积神经神经网络，接收3通道的图片'''
import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):    #继承自nn.Module
    def __init__(self):
        super(Net, self).__init__()
        '''# 3 input image channel, 6 output channels, 5x5 square convolution
        # kernel'''
        self.conv1 = nn.Conv2d(3, 6, 5)#输入图像为3通道，输出通道为6， 卷积核大小是5x5
        self.pool = nn.MaxPool2d(2, 2) # 2x2池化
        self.conv2 = nn.Conv2d(6, 16, 5) # 输入图像为6，输出通道为16， 卷积核大小是5x5
        '''
        Linear(in_features, out_features)
        in_features指的是输入的二维张量的大小，即输入的[batch_size, size]中的size。   
        out_features指的是输出的二维张量的大小，即输出的二维张量的形状为[batch_size，output_size]，
        当然，它也代表了该全连接层的神经元个数。   
        从输入输出的张量的shape角度来理解，相当于一个输入为[batch_size, in_features]的张量变换成了[batch_size, out_features]的输出张量。
        '''
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
        '''这里是参数说明，解释上面的数字是如何确定出来的。
        1）首先输入的图像是3*32*32(C*H*W),要经过卷积层conv1 = nn.Conv2d(3, 6, 5)，输出为6*28*28（C*H*W），采用的是nopadding模式，所以输出图像大小变小了(ksize-1),32-4=28.
        2) 再经过一个2x2 maxPooling池化,输出为6*14*14（C*H*W）.
        3）经过第二个卷积层conv2 = nn.Conv2d(6, 16, 5)，输出为 16*10*10（C*H*W），采用的是nopadding模式，所以输出图像大小变小了(ksize-1),14-4=10.
        4) 再经过一个2x2 maxPooling池化，输出为16*5*5（C*H*W）.
        5) 经过第一个全连接层self.fc1 = nn.Linear(16 * 5 * 5, 120)，输入为16*5*5个神经元，输出为120个神经元。
        6）经过第一个激活函数层，输出仍为120个神经元。
        7）经过第二个全连接层，输入为120个神经元，输出为84个神经元
        8）经过第二个激活函数层，输出仍为84个神经元。
        9）最后再经过一个输出层，输入为84个神经元，输出为10个结果（神经元）(对应数据集中的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()


'''定义一个损失函数和优化器 让我们使用分类交叉熵Cross-Entropy 作损失函数，动量SGD做优化器。
momentum SGD其实是梯度变化阻尼器的原理，让训练时候梯度的变化更加平滑，加快训练过程。
'''
import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)


'''训练网络，只需要在数据迭代器上循环将输入的训练数据传给网络和优化器。'''
for epoch in range(20):  # loop over the dataset multiple times

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs
        inputs, labels = data

        # zero the parameter gradients，一定要清零，防止梯度一直叠加
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)#forward
        loss = criterion(outputs, labels)#计算loss
        loss.backward()#backward
        optimizer.step()#更新参数

        # print statistics
        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')





'''看看网络在整个数据集上的表现'''
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))

推荐：https://www.pytorch123.com/ThirdSection/TransferLearning/