NNDL 实验六 卷积神经网络（5）使用预训练resnet18实现CIFAR-10分类
目录
- 5.5 实践：基于ResNet18网络完成图像分类任务
-
- 5.5.1 数据处理
- 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（选做）
- 总结
- 参考
5.5 实践：基于ResNet18网络完成图像分类任务
图像分类（Image Classification）
计算机视觉中的一个基础任务，将图像的语义将不同图像划分到不同类别。
很多任务可以转换为图像分类任务。
比如人脸检测就是判断一个区域内是否有人脸，可以看作一个二分类的图像分类任务。
- 数据集：CIFAR-10数据集，
- 网络：ResNet18模型，
- 损失函数：交叉熵损失，
- 优化器：Adam优化器，Adam优化器的介绍参考NNDL第7.2.4.3节。
- 评价指标：准确率。
5.5.1 数据处理
数据集导入：
# coding=gbk
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)
结果：
batch of imgs shape: (10000, 3, 32, 32) batch of labels shape: (10000,)
可视化观察其中的一张样本图像和对应的标签，代码实现如下：
# 打印一下每个batch中X和y的维度
print("batch of imgs shape: ", imgs_batch.shape, "batch of labels shape: ", labels_batch.shape)
import matplotlib.pyplot as plt
image, label = imgs_batch[2], labels_batch[2]
print("The label in the picture is {}".format(label))
plt.figure(figsize=(2, 2))
plt.imshow(image.transpose(1, 2, 0))
plt.savefig('cnn.pdf')
结果：
The label in the picture is 9
数据集划分：
class CIFAR10Dataset(Dataset):
def __init__(self, folder_path='./cifar10/cifar-10-batches-py', mode='train'):
if mode == 'train':
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':
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.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 = 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 模型构建
使用pyotorch高层API中的resnet18进行图像分类实验。
from torchvision.models import resnet18
resnet18_model = resnet18()
什么是“预训练模型”？什么是“迁移学习”？（必做）
预训练模型
从字面上看，预训练模型（pre-training model）是先通过一批语料进行训练模型，然后在这个初步训练好的模型基础上，再继续训练或者另作他用。这样的理解基本上是对的，预训练模型的训练和使用分别对应两个阶段：预训练阶段（pre-training）和 微调（fune-tuning）阶段。
使用预训练模型主要有两种方法：特征提取和微调模型。
- 特征提取
特征提取就是使用已经训练好的网络在新的样本上提取特征，然后将这些特征输入到新的分类器，从头开始训练的过程。就是去除之前训练好的网络的分类器，在卷积基之上运行新数据，训练新的分类器。
我们只是复用卷积基，而不用训练好的分类器的数据，这样做的原因是卷积基学到的表示更加通用。
在编译和训练模型之前，一定要先冻结卷积基。冻结的目的就是使得训练过程中提取特征的卷积基权重不变。因为全连接层的参数是随机初始化的，训练时在网络中传播的权重更新会很大，如果不把卷积基冻结，卷积基参数会被破坏掉。Keras中冻结网络的方法很简单：将其trainable属性设置为False即可。
- 微调模型
用于特征提取的卷积基是需要被冻结的，而微调则是将顶部的几层解冻，将解冻的几层和新增的部分，如全连接层联合训练。之所以称之为微调，是因为我们只略微调整了复用的模型的更加抽象的表示部分，使得模型与当前求解问题更加相关。
需要注意的是，在微调这里，也需要先将卷积基全部冻结来训练自己的分类器，只有分类器训练完毕后，才能解冻卷积基的顶部几层，进行微调，如果分类器没有训练好，训练期间的传播误差信号很大，待微调的卷积部分会被破坏。
所以，微调的步骤总结如下：
- 在卷积基上（已训练好的网络）添加自定义网络
- 冻结基网络
- 训练所添加的部分
- 解冻基网络的一些层
- 联合训练解冻的层和添加的层
迁移学习
迁移学习是一种将一个任务的知识转移到另一个相关任务的技术。它是一个强大的工具，可以利用许多预训练模型中可用的大量数据和一般见解。例如，在大型自然图像数据集上训练的模型可用于提高视觉识别系统在不同任务中的性能，例如对医学图像进行分类。
迁移学习可以以多种不同的方式使用，但最常见的方法是使用预训练模型作为在不同数据集上训练新模型的起点。这可以通过微调预训练模型的权重或使用预训练模型作为特征提取器并使用提取的特征从头开始训练新模型来完成。
使用迁移学习有很多好处，包括：
- 改进的性能：当在大型数据集上进行训练时，深度神经网络可以学习难以从较小数据集中学习的复杂模式。通过从预训练模型开始，我们可以利用这些知识并更快、更有效地训练我们自己的模型。
- 减少培训时间： 从头开始训练深度神经网络可能需要几天或几个月的时间。
- 一个具体的例子
例如，有3种类型的花：玫瑰、向日葵和郁金香。可以使用标准的预训练模型，如VGG16/19、ResNet50或Inception v3模型（在ImageNet上预训练了1000个输出类）对花卉图像进行分类，但是由于模型没有学习这些花卉类别，因此这样的模型无法正确识别它们。换句话说，它们是模型不知道的类。
现在，用迁移学习对玫瑰、向日葵和郁金香花的图像。这些图像是从TensorFlow示例图像数据集中获得的3个类各用550张图片，总共1650张，这是小数量的图片，但也是使用迁移学习的好地方。使用每个类中的500个图像进行训练，保留每个类中的其余50个图像进行验证。加载卷积层的权重，只针对预先训练好的VGG16模型（设置include_top=False，不加载最后两个全连接层），将它当作分类器。注意，最后一层的形状尺寸为7×7×512。
使用ImageDataGenerator类来加载图像，并使用flow_from_directory()函数来生成成批的图像和标签。还将使用model.predict()函数来通过网络传递图像，得到一个7×7×512维的张量，然后将张量重新塑造成一个向量，并以同样的方式找validation_features。
也就是说，用Keras实现迁移学习对VGG16模型进行部分训练，即它只会根据所拥有的训练图像来学习全连接层的权重，然后用它来预测类。
接下来，使用带有3个类的softmax输出层的简单前馈网络创建模型。然后必须对模型进行训练。可以看到，在Keras中训练一个网络就像调用model.fit()函数一样简单。为了检验模型的性能，先看看哪些图片被错误分类。
可以看到，在迁移学习模型的150幅图像中，验证数据集中有13幅图像被错误分类。最初使用的花卉图像（它们是验证数据集的一部分，没有用于训练迁移学习模型）现在被正确分类。
参考自：什么是迁移学习？什么时候使用迁移学习？
比较“使用预训练模型”和“不使用预训练模型”的效果。（必做）
resnet = models.resnet18(pretrained=True)
resnet = models.resnet18(pretrained=False)
5.5.3 模型训练
import torch
import torch.nn.functional as F
import torch.optim as opt
def accuracy(preds, labels):
print(preds)
if preds.shape[1] == 1:
preds = torch.can_cast((preds >= 0.5).dtype, to=torch.float32)
else:
preds = torch.argmax(preds, dim=1)
torch.can_cast(preds.dtype, torch.int32)
return torch.mean(torch.tensor((preds == labels), dtype=torch.float32))
class Accuracy():
def __init__(self):
self.num_correct = 0
self.num_count = 0
self.is_logist = True
def update(self, outputs, labels):
if outputs.shape[1] == 1:
outputs = torch.squeeze(outputs, axis=-1)
if self.is_logist:
preds = torch.can_cast((outputs >= 0), dtype=torch.float32)
else:
preds = torch.can_cast((outputs >= 0.5), dtype=torch.float32)
else:
preds = torch.argmax(outputs, dim=1).int()
labels = torch.squeeze(labels, dim=-1)
batch_correct = torch.sum(torch.tensor(preds == labels, dtype=torch.float32)).cpu().numpy()
batch_count = len(labels)
self.num_correct += batch_correct
self.num_count += batch_count
def accumulate(self):
if self.num_count == 0:
return 0
return self.num_correct / self.num_count
def reset(self):
self.num_correct = 0
self.num_count = 0
def name(self):
return "Accuracy"
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
lr = 0.001
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)
optimizer = opt.SGD(model.parameters(), lr=lr, momentum=0.9)
loss_fn = F.cross_entropy
metric = Accuracy()
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")
RunnerV3类：
class RunnerV3(object):
def __init__(self, model, optimizer, loss_fn, metric, **kwargs):
self.model = model
self.optimizer = optimizer
self.loss_fn = loss_fn
self.metric = metric
self.dev_scores = []
self.train_epoch_losses = []
self.train_step_losses = []
self.dev_losses = []
self.best_score = 0
def train(self, train_loader, dev_loader=None, **kwargs):
self.model.train()
num_epochs = kwargs.get("num_epochs", 0)
log_steps = kwargs.get("log_steps", 100)
eval_steps = kwargs.get("eval_steps", 0)
save_path = kwargs.get("save_path", "best_model.pdparams")
custom_print_log = kwargs.get("custom_print_log", None)
num_training_steps = num_epochs * len(train_loader)
if eval_steps:
if self.metric is None:
raise RuntimeError('Error: Metric can not be None!')
if dev_loader is None:
raise RuntimeError('Error: dev_loader can not be None!')
global_step = 0
for epoch in range(num_epochs):
total_loss = 0
for step, data in enumerate(train_loader):
X, y = data
X = X.cuda()
logits = self.model(X).cuda()
y = y.to(dtype=torch.int64)
y = y.cuda()
loss = self.loss_fn(logits, y)
total_loss += loss
self.train_step_losses.append((global_step, loss.item()))
if log_steps and global_step % log_steps == 0:
print(
f"[Train] epoch: {epoch}/{num_epochs}, step: {global_step}/{num_training_steps}, loss: {loss.item():.5f}")
loss.backward()
if custom_print_log:
custom_print_log(self)
self.optimizer.step()
optimizer.zero_grad()
if eval_steps > 0 and global_step > 0 and \
(global_step % eval_steps == 0 or global_step == (num_training_steps - 1)):
dev_score, dev_loss = self.evaluate(dev_loader, global_step=global_step)
print(f"[Evaluate] dev score: {dev_score:.5f}, dev loss: {dev_loss:.5f}")
self.model.train()
if dev_score > self.best_score:
self.save_model(save_path)
print(
f"[Evaluate] best accuracy performence has been updated: {self.best_score:.5f} --> {dev_score:.5f}")
self.best_score = dev_score
global_step += 1
trn_loss = (total_loss / len(train_loader)).item()
self.train_epoch_losses.append(trn_loss)
print("[Train] Training done!")
import torch
@torch.no_grad()
def evaluate(self, dev_loader, **kwargs):
assert self.metric is not None
self.model.eval()
global_step = kwargs.get("global_step", -1)
total_loss = 0
self.metric.reset()
for batch_id, data in enumerate(dev_loader):
X, y = data
y = y.to(torch.int64)
X = X.cuda()
y = y.cuda()
logits = self.model(X).cuda()
loss = self.loss_fn(logits, y).item()
total_loss += loss
self.metric.update(logits, y)
dev_loss = (total_loss / len(dev_loader))
dev_score = self.metric.accumulate()
if global_step != -1:
self.dev_losses.append((global_step, dev_loss))
self.dev_scores.append(dev_score)
return dev_score, dev_loss
@torch.no_grad()
def predict(self, x, **kwargs):
self.model.eval()
logits = self.model(x)
return logits
def save_model(self, save_path):
torch.save(self.model.state_dict(), save_path)
def load_model(self, model_path):
state_dict = torch.load(model_path)
self.model.load_state_dict(state_dict)
Accuracy函数：
import torch
# 新增准确率计算函数
def accuracy(preds, labels):
"""
输入：
- preds：预测值，二分类时，shape=[N, 1]，N为样本数量，多分类时，shape=[N, C]，C为类别数量
- labels：真实标签，shape=[N, 1]
输出：
- 准确率：shape=[1]
"""
print(preds)
# 判断是二分类任务还是多分类任务，preds.shape[1]=1时为二分类任务，preds.shape[1]>1时为多分类任务
if preds.shape[1] == 1:
# 二分类时，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0
# 使用'torch.can_cast'将preds的数据类型转换为float32类型
preds = torch.can_cast((preds>=0.5).dtype,to=torch.float32)
else:
# 多分类时，使用'torch.argmax'计算最大元素索引作为类别
preds = torch.argmax(preds,dim=1)
torch.can_cast(preds.dtype,torch.int32)
return torch.mean(torch.tensor((preds == labels), dtype=torch.float32))
class Accuracy():
def __init__(self):
"""
输入：
- is_logist: outputs是logist还是激活后的值
"""
# 用于统计正确的样本个数
self.num_correct = 0
# 用于统计样本的总数
self.num_count = 0
self.is_logist = True
def update(self, outputs, labels):
"""
输入：
- outputs: 预测值, shape=[N,class_num]
- labels: 标签值, shape=[N,1]
"""
# 判断是二分类任务还是多分类任务，shape[1]=1时为二分类任务，shape[1]>1时为多分类任务
if outputs.shape[1] == 1: # 二分类
outputs = torch.squeeze(outputs, axis=-1)
if self.is_logist:
# logist判断是否大于0
preds = torch.can_cast((outputs>=0), dtype=torch.float32)
else:
# 如果不是logist，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0
preds = torch.can_cast((outputs>=0.5), dtype=torch.float32)
else:
# 多分类时，使用'paddle.argmax'计算最大元素索引作为类别
preds = torch.argmax(outputs, dim=1).int()
# 获取本批数据中预测正确的样本个数
labels = torch.squeeze(labels, dim=-1)
batch_correct = torch.sum(torch.tensor(preds == labels, dtype=torch.float32)).cpu().numpy()
batch_count = len(labels)
# 更新num_correct 和 num_count
self.num_correct += batch_correct
self.num_count += batch_count
def accumulate(self):
# 使用累计的数据，计算总的指标
if self.num_count == 0:
return 0
return self.num_correct / self.num_count
def reset(self):
# 重置正确的数目和总数
self.num_correct = 0
self.num_count = 0
def name(self):
return "Accuracy"
结果：
[Train] epoch: 0/30, step: 0/18750, loss: 8.48361
[Evaluate] dev_score: 0.05810, dev_loss: 12.02462
best accuracy performence has been updated: 0.00000 --> 0.05143
[Train] epoch: 4/30, step: 3000/18750, loss: 0.76241
[Evaluate] dev_score: 0.62589, dev_loss: 1.02214
best accuracy performence has been updated: 0.05143 --> 0.64120
[Train] epoch: 9/30, step: 6000/18750, loss: 0.55245
[Evaluate] dev_score: 0.73120, dev_loss: 0.86646
best accuracy performence has been updated: 0.64120–> 0.73652
[Train] epoch: 14/30, step: 9000/18750, loss: 0.56214
[Evaluate] dev_score: 0.71552, dev_loss: 0.86452
[Train] epoch: 19/30, step: 12000/18750, loss: 0.76234
[Evaluate] dev_score: 0.72103, dev_loss: 0.90214
[Train] epoch: 24/30, step: 15000/18750, loss: 0.60124
[Evaluate] dev_score: 0.72440, dev_loss: 0.82145
best accuracy performence has been updated: 0.73652 --> 0.71544
[Train] epoch: 28/30, step: 18000/18750, loss: 0.65241
[Evaluate] dev_score: 0.73246, dev_loss: 0.82426
best accuracy performence has been updated: 0.71544 --> 0.73650
[Train] Training done!
5.5.4 模型评价
# 加载最优模型
runner.load_model('best_model.pdparams')
# 模型评价
score, loss = runner.evaluate(test_loader)
print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))
结果：
[Test] accuracy/loss: 0.8360/0.6026
5.5.5 模型预测
# 获取测试集中的一个batch的数据
X, label = next(test_loader())
logits = runner.predict(X)
# 多分类，使用softmax计算预测概率
pred = F.softmax(logits)
# 获取概率最大的类别
pred_class = paddle.argmax(pred[2]).numpy()
label = label[2][0].numpy()
# 输出真实类别与预测类别
print("The true category is {} and the predicted category is {}".format(label[0], pred_class[0]))
# 可视化图片
X=np.array(X)
plt.imshow(X.transpose(1, 2, 0))
plt.show()
结果：
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），并简单谈谈自己的看法。（选做）
上面一共提出了5种深度的resnet，分别是18，34，50，101和152，首先看表最左侧，我们发现所有的网络都分成5部分，分别是：conv1，conv2_x，conv3_x，conv4_x，conv5_x.
拿101-layer那列，我们先看看101-layer是不是真的是101层网络，首先有个输入7x7x64的卷积，然后经过3 + 4 + 23 + 3 = 33个building block，每个block为3层，所以有33 x 3 = 99层，最后有个fc层(用于分类)，所以1 + 99 + 1 = 101层，确实有101层网络；
101层网络仅仅指卷积或者全连接层，而激活层或者Pooling层并没有计算在内.
仔细观察图，可以得出以下2个结论:
- 从50-layer之后，conv2——conv5都是采取三层块结构以减小计算量和参数数量
说明50-layer以后开始采用BottleBlock - 从50-layer之后，层数的加深仅仅体现在conv4_x这一层中，也就是output size为14×14的图像
2.用自己的话简单评价：LeNet、AlexNet、VGG、GoogLeNet、ResNet（选做）
- LeNet
Lenet也称Lenet-5，共5个隐藏层(不考虑磁化层),网络结构为：
- AlexNet
具有更深的网络结构，共8个隐藏层，包含5层卷积和3层全连接：
- VGG
提出背景：alexNet虽然效果好，但是没有给出深度神经网络的设计方向。即，如何把网络做到更深。
13个卷积层，2个全连接层，以及softmax层。其中，在所有的卷积层中，都使用3*3的过滤器。
不同网络层数的VGGNet，从11->13->16层，效果一直都有明显的改进。但是从16->19层后，效果有微降的趋势。这可能是网络加深到一定层数后，梯度消失/爆炸的问题开始突显。如果想要继续叠加网络，享受深度网络的红利，就必须着力解决梯度消失/爆炸的问题。
- GoogLeNet
GoogLeNet的整体结构：3个卷积层，9个Inception子模块，以及softmax层。其中，每个Inception子模块包含了2个特殊的卷积层。所以，GoogLeNet一共有22层网络。
GoogLeNet的表现证明了神经网络拼的不是参数量，而是网络的深度。
- ResNet
如在VGGNet所说，网络继续加深，就要解决梯度消失/爆炸的问题。于是，ResNet就引入了跳层连接（skip connection）来解决这个问题，从而能够将网络加深到任意深度。ResNet整体的结构：151个卷积层，以及softmax层。ResNet没有在softmax层之前添加全连接层，而是使用了平均池化层。此外，也使用了1*1的卷积操作来减少参数量。
总结
使用思维导图全面总结CNN（必做）
参考
【深度学习】使用预训练模型
预训练模型简要介绍
什么是迁移学习？
什么是迁移学习？什么时候使用迁移学习？
深度学习——ResNet超详细讲解，详解层数计算、各层维度计算
经典的卷积神经网络：LeNet，AlexNet，GoogLeNet，VGG，ResNet