pytorch学习(十)—训练并测试CNN网络

作者: 侠之大者_7d3f | 来源:发表于2018-12-27 16:40 被阅读1次

pytorch学习(十)—训练并测试CNN网络
Task3 字符识别模型
人工智能安全第一次作业
pytorch学习(六)—定义一个CNN网络
Pytorch学习记录-卷积神经网络CNN
Pytorch +CNN训练
pytorch学习(八)—构建CNN网络(下)
Tensorflow语法基础(3)-mnist
深度学习笔记（十一）—— 目标检测
CV-字符识别模型

前言

学习pytorch已经一周了，pytorch官网的示例代码基本上都敲了一遍，关于tensor的使用，数据集，网络定义等。和之前学习caffe痛苦的经历相比，pytorch对常用的操作都进行了封装，只要安装流程做即可。在之前的学习基础上，本章节内容将在CIFAR10数据集上训练一个简单的CNN网络。

目的

基于CIFAR-10数据集，训练一个简单CNN网络。
保存训练好的模型，测试

开发/实验环境

Ubuntu 18.04
pytorch 1.0
Anaconda3, python3.6
pycharm

CIFAR数据集

http://www.cs.toronto.edu/~kriz/cifar.html

The CIFAR-10 and CIFAR-100 are labeled subsets of the 80 million tiny images dataset. They were collected by Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton.

CIFAR数据集可分为CIFAR10, CIFAR100。 CIFAR-10是指包含10个种类， CIFAR-100包含100个种类。

CIFAR-10

The CIFAR-10 dataset consists of 60000 32x32 colour images in 10 classes, with 6000 images per class. There are 50000 training images and 10000 test images.

特点：

32x32 彩色图像
10个类别
总共60000张图像
50000张训练样本 + 10000张测试样本
每个类别有6000张图像， 10 x 6000 = 60000

10个类别：

airplane
automobile
bird
cat
deer
dog
frog
horse
ship
truck

image.png

下载地址

image.png
链接
CIFAR-10 python version
CIFAR-10 Matlab version
CIFAR-10 binary version (suitable for C programs)
Tips
不需要手动下载, 使用pytorch中的Dataset API自动下载即可

实验过程

准备数据集

这一步骤在pytorch中非常方便，pytorch已经为我们准备好了常见的数据集合，只需要导入即可。

数据集在torchvision.dataset 包里面

import torch
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt
import numpy as np

torchvision.dataset.CFAIR10 是一个类，通过实例化该类的一个对象，就可以操作数据集。
参数：
root -----数据集下载后保存的路径
train-----训练or测试
download----是否需要自动下载
transform----对图像进行变换，一般需要对原始图像进行ToTensor()， Normalize()变换

之后，使用DataLoader类对数据集进行包装，目的是为了方便读取和使用，比如可以min_batch读取，采用多线程。

# --------------------准备数据集------------------
# Dataset, DataLoader
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), std =(0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)

testset = torchvision.datasets.CIFAR10(root='./data',train=False,
                                       transform=transform, download=True)

trainloader = DataLoader(dataset=trainset, batch_size=4, shuffle=True, num_workers=4)
testloader = DataLoader(dataset=testset, batch_size=4, shuffle=True, num_workers=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)))

随机显示一个min_batch的图像，batch=4

image.png

标签：

image.png

至此，数据集就准备OK,下面开始定义一个网络。

定义CNN网络

简单起见，采用LeNet网络，将第一个卷积层的输入通道改为3，因为CIFAR-10是彩色3通道图像。

#定义一个简单的网络
# LeNet -5
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=6, kernel_size=5)
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5)
        self.fc1 = nn.Linear(in_features=16 * 5 * 5,out_features=120)
        self.fc2 = nn.Linear(in_features=120, out_features=84)
        self.fc3 = nn.Linear(in_features=84, out_features=10)

    def forward(self, x):
        x = self.pool1(F.relu(self.conv1(x)))
        x = self.pool1(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)              # reshape tensor
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

设置网络的优化、迭代方法，训练网络

CNN网络训练本质上就是对一个目标函数(损失函数)求最小的问题，在数学中，对于一般的凸函数，优化方法有梯度下降法、牛顿法等。(除此之外还有启发式搜索，比如遗传算法等)。对于神经网络的训练，常用的优化方法为随机梯度下降法SGD。

定义损失函数，优化方法
采用交叉熵损失函数
采用SGD随机梯度下降法进行优化(带动量项)

# 定义损失函数，优化方法
# 采用Cross-Entropy loss,  SGD with moment
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

进行迭代优化,训练
之前学习caffe时候，终于搞清楚2个概念。
Iter------一次迭代，是指一个min_batch的一次forward+backward

Epoch------迭代完所有的训练数据(1次)，称为一个epoch

这里总共跑20个epoch。

# 训练网络
# 迭代epoch
for epoch in range(20):

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

        # zeros the paramster gradients
        optimizer.zero_grad()       # ???

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

        # print statistics
        running_loss += loss.item()  # tensor.item()  获取tensor的数值
        if i % 2000 == 1999:
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))  # 每2000次迭代，输出loss的平均值
            running_loss = 0.0

print('Finished Training')

训练过程：

1.png

2.png

3.png

可以看到，loss值不断下降。因为本人采用CPU，所以地只跑了20个epoch。

保存模型

# --------保存模型-----------
torch.save(net, './model/model_cfair10_2.pth')    # 保存整个模型，体积比较大
# torch.save(net.state_dict(), './model/model_cfair10.pth')

image.png

测试模型

import torch
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image

CIFAR-10总共包含10个类别：

CFAIR10_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'forg', 'horse', 'ship', 'truck']

载入一张图像，RBG,要属于上述类别的某一类，不然识别不出来

# load a image
image = Image.open('/xxxx/image/dog.jpg')

对图像进行相同的变换：

transform = transforms.Compose(
    [transforms.Resize((32, 32)),
     transforms.ToTensor(),
     transforms.Normalize(
         mean=(0.5, 0.5, 0.5),
         std=(0.5, 0.5, 0.5)
     )])

image_transformed = transform(image)
print(image_transformed.size())

需要注意的地方
CNN网络的输入为4D Tensor (NxCxHxW), 转换之后的图像需要变换为4D
torsor1.unsqueeze(0) 即可增加一个维度，这样输入的tensor为： 1x3x32x32

#
transform = transforms.Compose(
    [transforms.Resize((32, 32)),
     transforms.ToTensor(),
     transforms.Normalize(
         mean=(0.5, 0.5, 0.5),
         std=(0.5, 0.5, 0.5)
     )])

image_transformed = transform(image)
print(image_transformed.size())


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=6, kernel_size=5)
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5)
        self.fc1 = nn.Linear(in_features=16 * 5 * 5,out_features=120)
        self.fc2 = nn.Linear(in_features=120, out_features=84)
        self.fc3 = nn.Linear(in_features=84, out_features=10)

    def forward(self, x):
        x = self.pool1(F.relu(self.conv1(x)))
        x = self.pool1(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)              # reshape tensor
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x


net = torch.load('./model/model_cfair10.pth')
# print(net)

image_transformed = image_transformed.unsqueeze(0)
output = net(image_transformed)
predict_value, predict_idx = torch.max(output, 1)  # 求指定维度的最大值，返回最大值以及索引

plt.figure()
plt.imshow(np.array(image))
plt.title(CFAIR10_names[predict_idx])
plt.axis('off')

plt.show()

测试结果：