Week2 彩色图像CIFAR10图像识别

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊 | 接辅导、项目定制
• 🚀 文章来源：K同学的学习圈子

CIFAR10是CIFAR-10是一个更接近普适物体的彩色图像数据集。CIFAR-10 是由Hinton 的学生Alex Krizhevsky 和Ilya Sutskever 整理的一个用于识别普适物体的小型数据集。一共包含10 个类别的RGB 彩色图片：飞机（ airplane ）、汽车（ automobile ）、鸟类（ bird ）、猫（ cat ）、鹿（ deer ）、狗（ dog ）、蛙类（ frog ）、马（ horse ）、船（ ship ）和卡车（ truck ）。每个图片的尺寸为32 × 32 ，每个类别有6000个图像，数据集中一共有50000 张训练图片和10000 张测试图片。

与MNIST 数据集中目比， CIFAR-10 真高以下不同点
(1)、CIFAR-10 是3 通道的彩色RGB 图像，而MNIST 是灰度图像。
(2)、CIFAR-10 的图片尺寸为32 × 32 ， 而MNIST 的图片尺寸为28 × 28 ，比MNIST 稍大。
(3)、相比于手写字符， CIFAR-10 含有的是现实世界中真实的物体，不仅噪声很大，而且物体的比例、特征都不尽相同，这为识别带来很大困难。
下面本文以CIFAR10数据集为例实现一个两层卷积神经网络的简单模型。
本人电脑配置
Python 3.8.0
Pytorch 1.8.1
torchvision 0.9.1 + cu10.2

前期准备

1. 设置GPU

在这里想要说明一点是，如果电脑有显卡，在装pytorch时需要安装gpu版本的，可参考网上其他博主，不能直接“pip install torch”，否则会默认安装CPU版本。

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision
from torch.optim.lr_scheduler import ReduceLROnPlateau
# device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)

2. 导入数据

使用dataset下载CIFAR数据集，并划分好训练集与测试集；使用dataloader加载数据，并设置好基本的batch_size。
下载数据到主目录的文件夹的data文件夹里

# import data, the dataset is cifar10
train_ds = torchvision.datasets.CIFAR10('data', 
                                        train=True, 
                                        transform=torchvision.transforms.ToTensor(),
                                        download=True)
test_ds = torchvision.datasets.CIFAR10('data',
                                       train=False,
                                       transform=torchvision.transforms.ToTensor(),
                                       download=True)
batch_size = 32
train_dl = torch.utils.data.DataLoader(train_ds,
                                       batch_size=batch_size,
                                       shuffle=True)
test_dl = torch.utils.data.DataLoader(test_ds,
                                      batch_size=batch_size)

构建网络模型

1. 搭建模型

构建两层卷积、两层全连接的神经网络。在倒数第二层后面添加了Droupout操作，以防止过拟合

# construct the CNN network
import torch.nn.functional as F
number_classes = 10
class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3)
        self.pool1 = nn.MaxPool2d(kernel_size=2)
        self.conv2 = nn.Conv2d(64, 64,kernel_size=3)
        self.pool2 = nn.MaxPool2d(kernel_size=2)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3)
        self.pool3 = nn.MaxPool2d(kernel_size=2)
        # classifier
        self.fc1 = nn.Linear(512, 256)
        self.dropout = nn.Dropout(p=0.5)
        self.fc2 = nn.Linear(256, number_classes)
    def forward(self, x):
        x = self.pool1(F.relu(self.conv1(x)))
        x = self.pool2(F.relu(self.conv2(x)))
        x = self.pool3(F.relu(self.conv3(x)))
        x = torch.flatten(x, start_dim=1)
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

2. 可视化模型

利用torchinfo包查看模型的结构并计算模型每一层的参数量，显示出来的结果如下。

from torchinfo import summary
model = Model().to(device)
summary(model)

==============================================
Layer (type:depth-idx)                   Param
==============================================
Model                                    --
├─Conv2d: 1-1                            1,792
├─MaxPool2d: 1-2                         --
├─Conv2d: 1-3                            36,92
├─MaxPool2d: 1-4                         --
├─Conv2d: 1-5                            73,85
├─MaxPool2d: 1-6                         --
├─Linear: 1-7                            131,3
├─Dropout: 1-8                           --
├─Linear: 1-9                            2,570
==============================================
Total params: 246,474
Trainable params: 246,474
Non-trainable params: 0
==============================================

3. 编写训练函数

设置损失函数，这里采用的交叉熵损失函数，设置优化器为SGD优化，同时在其中加入了动量，也是为了防止过拟合。

# train model
# parameters
loss_fn       = nn.CrossEntropyLoss()
learning_rate = 1e-2
# opt           = torch.optim.SGD(model.parameters(), lr=learning_rate)
opt           = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=0.78)#add mommentum
scheduler=torch.optim.lr_scheduler.ExponentialLR(opt, gamma=0.8)
# train
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    train_loss, train_acc = 0, 0
    for X, y in dataloader:
        X, y = X.to(device), y.to(device)
        # calculate the error
        pred = model(X)
        loss = loss_fn(pred, y)
        # backward
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # recording accuracy and loss value
        train_acc += (pred.argmax(1)==y).type(torch.float).sum().item()
        train_loss += loss.item()
    scheduler.step()
    train_acc /= size
    train_loss /= num_batches
    return train_acc, train_loss

4. 编写测试函数

当不进行训练时，停止梯度更新，节省计算内存消耗。

def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    test_loss, test_acc = 0, 0
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)
            # calculate loss
            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)
            test_loss += loss.item()
            test_acc += (target_pred.argmax(1)==target).type(torch.float).sum().item()
    test_acc /= size
    test_loss /= num_batches
    return test_acc, test_loss

5. 主函数

设置迭代epoch次数，这里设定为100，并记录训练误差、精度，测试误差、精度。同时为了保存模型，选取训练过程中测试集上精度最大的模型进行保存。

# start to train
epochs = 100
best_acc = 0.0
train_loss = []
train_acc = []
test_loss = []
test_acc = []
for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)
    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)
    if epoch_test_acc >= best_acc:
        best_acc = epoch_test_acc
        print('save model')
        torch.save(model.state_dict(), 'model.pth')
    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('Done')

结果总结

1、由于CIFAR10数据比较复杂，当采用原文中的设置进行100次迭代时，发生了过拟合现象，即训练精度达到1，测试误差先减小后不断增大，效果如下

2、改进措施：在优化器中添加了动量，添加了学习率逐渐下降的机制，以及在网络模型的第一个全连接层后面添加Droupout机制，在改进之后，发现训练过程稳定下来了

3、对过拟合问题进行改进后，发现测试集的精度稳定在70%左右，这应该是两层神经网络达到的上限了，想要提高精度，可增加卷积神经网络的宽度和深度。