NNDL 实验六 卷积神经网络（5）使用预训练resnet18实现CIFAR-10分类

目录

5.5 实践：基于ResNet18网络完成图像分类任务

5.5.1 数据处理

5.5.1.1 数据集介绍

5.5.1.2 数据读取

5.5.1.3 构造Dataset类

5.5.2 模型构建

5.5.3 模型训练

5.5.4 模型评价

5.5.5 模型预测

思考题

1.阅读《Deep Residual Learning for Image Recognition》，了解5种深度的ResNet（18,34,50,101和152），并简单谈谈自己的看法。（选做）

2.用自己的话简单评价：LeNet、AlexNet、VGG、GoogLeNet、ResNet（选做）

总结

ref

---

5.5 实践：基于ResNet18网络完成图像分类任务

在本实践中，我们实践一个更通用的图像分类任务。

图像分类（Image Classification）是计算机视觉中的一个基础任务，将图像的语义将不同图像划分到不同类别。很多任务也可以转换为图像分类任务。比如人脸检测就是判断一个区域内是否有人脸，可以看作一个二分类的图像分类任务。

这里，我们使用的计算机视觉领域的经典数据集：CIFAR-10数据集，网络为ResNet18模型，损失函数为交叉熵损失，优化器为Adam优化器，评价指标为准确率。

5.5.1 数据处理

5.5.1.1 数据集介绍

CIFAR-10数据集包含了10种不同的类别、共60,000张图像，其中每个类别的图像都是6000张，图像大小均为32×32像素。CIFAR-10数据集的示例如 图5.15 所示。

5.5.1.2 数据读取

在本实验中，将原始训练集拆分成了train_set、dev_set两个部分，分别包括40 000条和10 000条样本。将data_batch_1到data_batch_4作为训练集，data_batch_5作为验证集，test_batch作为测试集。
最终的数据集构成为：

• 训练集：40 000条样本。
• 验证集：10 000条样本。
• 测试集：10 000条样本。

读取一个batch数据的代码如下所示：

import os
import pickle
import numpy as np

def load_cifar10_batch(folder_path, batch_id=1, mode='train'):
    if mode == 'test':
        file_path = os.path.join(folder_path, 'test_batch')
    else:
        file_path = os.path.join(folder_path, 'data_batch_'+str(batch_id))

    #加载数据集文件
    with open(file_path, 'rb') as batch_file:
        batch = pickle.load(batch_file, encoding = 'latin1')

    imgs = batch['data'].reshape((len(batch['data']),3,32,32)) / 255.
    labels = batch['labels']

    return np.array(imgs, dtype='float32'), np.array(labels)

imgs_batch, labels_batch = load_cifar10_batch(folder_path='cifar10/cifar-10-batches-py',
                                                batch_id=1, mode='train')

 查看数据的维度：

#打印一下每个batch中X和y的维度
print ("batch of imgs shape: ",imgs_batch.shape, "batch of labels shape: ", labels_batch.shape)

 结果：

可视化观察其中的一张样本图像和对应的标签，代码如下所示：

%matplotlib inline
import matplotlib.pyplot as plt

image, label = imgs_batch[2], labels_batch[1]
print("The label in the picture is {}".format(label))
plt.figure(figsize=(3, 3))
plt.imshow(image.transpose(1,2,0))
plt.savefig('cnn-car.pdf')

 结果：

5.5.1.3 构造Dataset类

构造一个CIFAR10Dataset类，其将继承自paddle.io.DataSet类，可以逐个数据进行处理。代码实现如下：

from torch.utils.data import Dataset, DataLoader
import torchvision.transforms as transforms
import PIL.Image as Image


class CIFAR10Dataset(Dataset):
    def __init__(self, folder_path='cifar10/cifar-10-batches-py', mode='train'):
        if mode == 'train':
            # 加载batch1-batch4作为训练集
            self.imgs, self.labels = load_cifar10_batch(folder_path=folder_path, batch_id=1, mode='train')
            for i in range(2, 5):
                imgs_batch, labels_batch = load_cifar10_batch(folder_path=folder_path, batch_id=i, mode='train')
                self.imgs, self.labels = np.concatenate([self.imgs, imgs_batch]), np.concatenate(
                    [self.labels, labels_batch])
        elif mode == 'dev':
            # 加载batch5作为验证集
            self.imgs, self.labels = load_cifar10_batch(folder_path=folder_path, batch_id=5, mode='dev')
        elif mode == 'test':
            # 加载测试集
            self.imgs, self.labels = load_cifar10_batch(folder_path=folder_path, mode='test')
        self.transform = transforms.Compose([
            transforms.Resize((224, 224)), transforms.RandomHorizontalFlip(p=0.5), transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])

    def __getitem__(self, idx):
        img, label = self.imgs[idx], self.labels[idx]
        img = img.transpose(1, 2, 0)
        img = Image.fromarray(np.uint8(img))
        img = self.transform(img)
        return img, label

    def __len__(self):
        return len(self.imgs)


train_dataset = CIFAR10Dataset(folder_path='cifar10/cifar-10-batches-py', mode='train')
dev_dataset = CIFAR10Dataset(folder_path='cifar10/cifar-10-batches-py', mode='dev')
test_dataset = CIFAR10Dataset(folder_path='cifar10/cifar-10-batches-py', mode='test')

5.5.2 模型构建

使用飞桨高层API中的Resnet18进行图像分类实验。

from torchvision.models import resnet18
resnet18_model = resnet18()

pytorch提供了torchvision.models包，这个包包含了alexnet、resnet等常用的网络结构，并且提供了预训练模型，可以通过简单调用来读取网络结构和预训练模型。

什么是“预训练模型”？什么是“迁移学习”？

迁移学习是一种学习的思想和模式，是指利用数据、任务、或模型之间的相似性，将在旧领域学习过的模型应用于新领域的一种学习过程。我们知道，神经网络需要用数据来训练，它从数据中获得信息，进而把它们转换成相应的权重。这些权重能够被提取出来，迁移到其他的神经网络中，我们"迁移"了这些学来的特征，就不需要从零开始训练一个神经网络了 。

预训练模型是一个已经训练好的保存下来的网络，该网络之前在一个大型的数据集上进行了训练，如图像相关的网络在ImageNet数据上进行了训练。

比较“使用预训练模型”和“不使用预训练模型”的效果。

• resnet = models.resnet18(pretrained=True)
• resnet = models.resnet18(pretrained=False)

pytorch学习笔记之加载预训练模型_AI算法札记的博客-CSDN博客_pytorch加载预训练模型

【深度学习】使用预训练模型_DrCrypto的博客-CSDN博客_使用预训练模型的最后一层输出层进行下游任务,在训练时会更新所有层的参数吗?

5.5.3 模型训练

复用RunnerV3类，实例化RunnerV3类，并传入训练配置。
使用训练集和验证集进行模型训练，共训练30个epoch。
在实验中，保存准确率最高的模型作为最佳模型。代码实现如下：

import torch.nn.functional as F
import torch.optim as opt

# 指定运行设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
# 学习率大小
lr = 0.01
# 批次大小
batch_size = 64
# 加载数据
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
dev_loader = DataLoader(dev_dataset, batch_size=batch_size)
test_loader = DataLoader(test_dataset, batch_size=batch_size)
# 定义网络
model = resnet18_model
model.to(device)
# 定义优化器，这里使用Adam优化器以及l2正则化策略，相关内容在7.3.3.2和7.6.2中会进行详细介绍
optimizer = opt.SGD(model.parameters(), lr=lr, momentum=0.9)
# 定义损失函数
loss_fn = F.cross_entropy
# 定义评价指标
metric = Accuracy()
# 实例化RunnerV3
runner = RunnerV3(model, optimizer, loss_fn, metric)
# 启动训练
log_steps = 3000
eval_steps = 3000
runner.train(train_loader, dev_loader, num_epochs=30, log_steps=log_steps,
             eval_steps=eval_steps, save_path="best_model.pdparams")

结果： 

cuda:0
[Train] epoch: 0/30, step: 0/18750, loss: 7.14830
[Train] epoch: 4/30, step: 3000/18750, loss: 2.36001
[Evaluate]  dev score: 0.09800, dev loss: 3.10366
[Evaluate] best accuracy performence has been updated: 0.00000 --> 0.09800
[Train] epoch: 9/30, step: 6000/18750, loss: 2.21330
[Evaluate]  dev score: 0.10140, dev loss: 9.16427
[Evaluate] best accuracy performence has been updated: 0.09800 --> 0.10140
[Train] epoch: 14/30, step: 9000/18750, loss: 2.35430
[Evaluate]  dev score: 0.09870, dev loss: 19.61911
[Train] epoch: 19/30, step: 12000/18750, loss: 2.11356
[Evaluate]  dev score: 0.10140, dev loss: 5.13086
[Train] epoch: 24/30, step: 15000/18750, loss: 2.20977
[Evaluate]  dev score: 0.09520, dev loss: 8.99302
[Train] epoch: 28/30, step: 18000/18750, loss: 2.11808
[Evaluate]  dev score: 0.09890, dev loss: 11.44818
[Evaluate]  dev score: 0.09800, dev loss: 15.53502
[Train] Training done!

在本实验中，使用了第7章中介绍的Adam优化器进行网络优化，如果使用SGD优化器，会造成过拟合的现象，在验证集上无法得到很好的收敛效果。可以尝试使用第7章中其他优化策略调整训练配置，达到更高的模型精度。

5.5.4 模型评价

使用测试数据对在训练过程中保存的最佳模型进行评价，观察模型在测试集上的准确率以及损失情况。代码实现如下：

# 加载最优模型
runner.load_model('best_model.pdparams')
# 模型评价
score, loss = runner.evaluate(test_loader)
print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))

结果：

5.5.5 模型预测

同样地，也可以使用保存好的模型，对测试集中的数据进行模型预测，观察模型效果，具体代码实现如下：

#获取测试集中的一个batch的数据
X, label = next(iter(test_loader))
X=X.cuda()
logits = runner.predict(X)
#多分类，使用softmax计算预测概率
pred = F.softmax(logits)
#获取概率最大的类别
pred_class = torch.argmax(pred[2]).cpu().numpy()
print(label[2].numpy())
label = label[2].numpy()
#输出真实类别与预测类别
print("The true category is {} and the predicted category is {}".format(label, pred_class))
#可视化图片
plt.figure(figsize=(2, 2))
imgs, labels = load_cifar10_batch(folder_path='cifar10/cifar-10-batches-py', mode='test')
plt.imshow(imgs[2].transpose(1,2,0))
plt.show()

 结果：

8
The true category is 8 and the predicted category is 8

思考题

1.阅读《Deep Residual Learning for Image Recognition》，了解5种深度的ResNet（18,34,50,101和152），并简单谈谈自己的看法。（选做）

通过引入深度残差学习框架解决了退化问题。让这些层拟合残差映射，而不是希望每几个堆叠的层直接拟 合期望的基础映射。形式上，将期望的基础映射表示为 H(x)，我们将 堆叠的非线性层拟合另一个映射 F(x) = H(x) − x。原始的映射重写为 F(x) + x。我们假设残差映射比原始的、未参考的映射更容易优化。在 极端情况下，如果一个恒等映射是最优的，那么将残差置为零比通过 一堆非线性层来拟合恒等映射更容易。

2.用自己的话简单评价：LeNet、AlexNet、VGG、GoogLeNet、ResNet（选做）

LeNet：

 LeNet-5是由LeCun设计的5层卷积神经网络，最初主要应用于手写数字识别。它整体的结构是：2个卷积层（每个卷积后接了池化层），1个卷积层（没有池化层），1个全连接层，以及softmax层（输出层）。一般来说，我们会把卷积和池化当作是网络中的一层。LeNet-5的输入一般都是尺寸较小，并且灰度的图像。如果想处理更高分辨率图像的话，就需要叠加更多的卷积层，增加模型的容量。所以，LeNet-5主要受限于算力资源。随着后续算力的发展，基于叠加卷积层的方式，LeNet-5衍生出了各种不同的经典卷积神经网络结构。

AlexNet：

AlextNet跟LeNet网络结构相似，只是因为叠加了更多的卷积层使得网络更深了。此外，在卷积层也使用了更多的过滤器。它含有8层网络，整体的结构是：5个卷积层（每个卷积都接了池化层），2个全连接层，以及softmax层。同时使用了如下方法改进模型的训练过程：数据增广；使用Dropout抑制过拟合；使用ReLU激活函数减少梯度消失现象（梯度消失和梯度爆炸）；使用GPU训练；局部响应归一化；重叠池化层。
VGG：

 它的整体结构：13个卷积层，2个全连接层，以及softmax层。其中，在所有的卷积层中，都使用3*3的过滤器。vggnet严格使用3*3小尺寸卷积和池化层构造深度CNN，取得较好的效果。小卷积能减少参数，方便堆叠卷积层来增加深度（加深了网络，减少了卷积）。即vggnet=更深的Alex net+conv(3*3)

GoogLeNet：

GoogLeNet的整体结构：3个卷积层，9个Inception子模块，以及softmax层。其中，每个Inception子模块包含了2个特殊的卷积层。所以，GoogLeNet一共有22层网络。

为了避免网络过深导致的巨大参数量，GoogLeNet使用了1*1的卷积操作，并且在网络最后使用了全局的平均池化来代替全连接层。网络的参数量大约是AlexNet的1/10。GoogLeNet的表现证明了神经网络拼的不是参数量，而是网络的深度。 

ResNet：

Resnet从避免梯度消失或爆炸的角度，使用残差连接结构使网络可以更深，共5个版本

总结

使用思维导图全面总结CNN

ref

深度学习论文阅读图像分类篇（五）：ResNet《Deep Residual Learning for Image Recognition》