# 神经网络与深度学习实验day12-基于ResNet18完成cifar-10图像分类任务

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

• 数据集：CIFAR-10数据集
• 网络：ResNet18模型
• 损失函数：交叉熵损失
• 评价指标：准确率。

### 5.5.1 数据处理

#### 5.5.1.1数据集导入

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:

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='C:/Users/大楠爱吃屁/Desktop/cifar-10-python.tar/cifar-10-python/cifar-10-batches-py',
batch_id=1, mode='train')

print("batch of imgs shape: ", imgs_batch.shape, "batch of labels shape: ", labels_batch.shape)



import matplotlib.pyplot as plt

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



#### 5.5.1.2 划分训练集、验证集、测试集

import torch
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import PIL.Image as Image


class CIFAR10Dataset(Dataset):
def __init__(self, folder_path='C:/Users/大楠爱吃屁/Desktop/cifar-10-python.tar/cifar-10-python/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.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='C:/Users/大楠爱吃屁/Desktop/cifar-10-python.tar/cifar-10-python/cifar-10-batches-py', mode='train')
dev_dataset = CIFAR10Dataset(folder_path='C:/Users/大楠爱吃屁/Desktop/cifar-10-python.tar/cifar-10-python/cifar-10-batches-py', mode='dev')
test_dataset = CIFAR10Dataset(folder_path='C:/Users/大楠爱吃屁/Desktop/cifar-10-python.tar/cifar-10-python/cifar-10-batches-py', mode='test')


### 5.5.2 模型构建

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

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)

if eval_steps:
if self.metric is None:
raise RuntimeError('Error: Metric can not be None!')
raise RuntimeError('Error: dev_loader can not be None!')

global_step = 0

for epoch in range(num_epochs):

total_loss = 0
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()

if eval_steps > 0 and global_step > 0 and \
(global_step % eval_steps == 0 or global_step == (num_training_steps - 1)):

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

self.train_epoch_losses.append(trn_loss)

print("[Train] Training done!")

assert self.metric is not None

self.model.eval()

global_step = kwargs.get("global_step", -1)

total_loss = 0

self.metric.reset()

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_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

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)

import torch

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)

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"


from torchvision.models import resnet18

resnet18_model = resnet18()


### 5.5.3 模型训练

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

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)

lr = 0.001

batch_size = 64

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
eval_steps=eval_steps, save_path="best_model.pdparams")


### 5.5.4 模型评价

# 加载最优模型
# 模型评价
print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))


### 5.5.5 模型预测

#获取测试集中的一个batch的数据
X = X.cpu()
logits = runner.predict(X)
#多分类，使用softmax计算预测概率
pred = F.softmax(logits)
#获取概率最大的类别
pred_class = torch.argmax(pred[2]).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))
plt.imshow(imgs[2].transpose(1,2,0))
plt.savefig('cnn-test-vis.pdf')


## 思考题

### 2. 比较“使用预训练模型”和“不使用预训练模型”的效果。（必做）

resnet = models.resnet18(pretrained=True)

resnet = models.resnet18(pretrained=False)

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

resnet18：
layer1:

layer2:

layer3-4:

layer3和layer4结构和layer2相同，无非就是通道数变多，输出尺寸变小，就不再赘述。

ResNet18和ResNet34的区别：
ResNet18和34都是基于Basicblock，结构非常相似，差别只在于每个layer的block数。

layer1:

layer2:

layer3-4

layer3和layer4结构和layer2相同，无非就是通道数变多，输出尺寸变小，就不再赘述。

ResNet50和ResNet101和ResNet152的区别：
ResNet50、101和152都是基于Basicblock，结构非常相似，差别只在于每个layer的block数。

2.1 首先说一下LeNet:

1998年，Yan LeCun第一次将LeNet卷积神经网络应用到图像分类上，在手写数字识别任务中取得了巨大成功。LeNet通过连续使用卷积和池化层的组合提取图像特征，从而完成数字识别。

LeNet作为卷积神经网络的鼻祖，无论是开创性还是影响力都是巨大的，一直供后人学习着，作为深度学习的“Hello World”，因为是LeNet是CNN的创始者，所以在很多方面LeNet存在着很多缺点，比如不能解决图片输入尺寸过大的问题，当输入的图片过大时，他表现得效果不尽人意。

2.2浅谈一下AlexNet

AlexNet与LeNet相比，具有更深的网络结构，包含5层卷积和3层全连接，同时使用了如下三种方法改进模型的训练过程：

1. 数据增广：深度学习中常用的一种处理方式，通过对训练随机加一些变化，比如平移、缩放、裁剪、旋转、翻转或者增减亮度等，产生一系列跟原始图片相似但又不完全相同的样本，从而扩大训练数据集。通过这种方式，可以随机改变训练样本，避免模型过度依赖于某些属性，能从一定程度上抑制过拟合。
2. 使用Dropout抑制过拟合
3. 使用ReLU激活函数减少梯度消失现象

AlexNet的成功归结于几个方面：①扩充了数据集的大小，使用数据增强；② 激活函数 ReLU 对抗梯度消失；③ Dropout 避免过拟合；④LRN 的使用；⑤ 双GPU并行计算提升计算速度。AlexNet提出的relu激活函数目前仍在使用，drop-out已经用的比较少了而且不太好用。不过AlexNet网络的深度还不是特别的深入，但相对于LeNet已经有了很多的创新点。

2.3谈VGGNet
VGG是当前最流行的CNN模型之一，2014年由Simonyan和Zis。serman提出，其命名来源于论文作者所在的实验室Visual Geometry Group。AlexNet模型通过构造多层网络，取得了较好的效果，但是并没有给出深度神经网络设计的方向。VGG通过使用一系列大小为3x3的小尺寸卷积核和pooling层构造深度卷积神经网络，并取得了较好的效果。VGG模型因为结构简单、应用性极强而广受研究者欢迎，尤其是它的网络结构设计方法，为构建深度神经网络提供了方向。

2.5谈ResNet

2015年何恺明推出的ResNet在ISLVRC和COCO上横扫所有选手，获得冠军。ResNet在网络结构上做了大创新，而不再是简单的堆积层数，ResNet在卷积神经网络的新思路，绝对是深度学习发展历程上里程碑式的事件。

ResNet主要解决的问题，就是在深度网络中的退化的问题。在深度学习的领域中，常规网络的堆叠并不会是越深效果则越好，在超过一定深度以后，准确度开始下降，并且由于训练集的准确度也在降低，证明了不是由于过拟合的原因。并且创新性的给出了残差网络的实现，能够很好的起到优化训练的结果。ResNet是当前的主流网络，在VGG基础上提升了长度，加入了res-block结构。整个ResNet不使用dropout，全部使用BN，但是吧，对于现在已经有的transformer来说，ResNet好像又不厉害了（但是确实牛），感觉是长江后浪推前浪。

CNN思维导图

## References：

• 3
点赞
• 43
收藏
觉得还不错? 一键收藏
• 打赏
• 2
评论
02-19 726
03-29 911
04-23 2万+
06-22 1万+
09-04 3万+
04-16 492
04-19 875
04-16 1044

### “相关推荐”对你有帮助么？

• 非常没帮助
• 没帮助
• 一般
• 有帮助
• 非常有帮助

¥1 ¥2 ¥4 ¥6 ¥10 ¥20

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。