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

目录

基于ResNet18网络完成图像分类任务

数据处理

数据集介绍

数据读取

 构造Dataset类

模型构建

 模型训练

 模型评价

模型预测

思考题

1.阅读

 2.评价

总结：

ref：

---

基于ResNet18网络完成图像分类任务

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

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

数据处理

数据集介绍

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

内置数据集：

from torchvision.datasets import cifar

cifar.CIFAR10(root='./cifar',download=True)

 或者 直接下载数据集

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

数据读取

在本实验中，将原始训练集拆分成了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='D:\\qq\\1916645844\\FileRecv\\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)

执行结果： 

 可视化观察其中的一张样本图像和对应的标签：

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')

 执行结果：

 

 构造Dataset类

构造一个CIFAR10Dataset类：

import torch
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='C:\\Users\\86188\\PycharmProjects\\pythonProject8\\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='C:\\Users\\86188\\PycharmProjects\\pythonProject8\\cifar-10-batches-py')
dev_dataset = CIFAR10Dataset(folder_path='C:\\Users\\86188\\PycharmProjects\\pythonProject8\\cifar-10-batches-py')
test_dataset = CIFAR10Dataset(folder_path='C:\\Users\\86188\\PycharmProjects\\pythonProject8\\cifar-10-batches-py')

模型构建

使用ResNet18进行图像分类实验，torchvision.models.resnet18()

from torchvision.models import resnet18
 
resnet18_model = resnet18()

 问题一：什么是“预训练模型”，什么是“迁移模型”

在一个原始任务或数据集上预先训练一个初始的模型，然后在目标任务或数据集上使用该模型，针对目标任务的特性，对该初始模型进行精调，从而达到提高目标任务的目的，而预先训练这个初始模型的过程就叫预训练模型。直接点说训练以执行大量数据上的特定任务时给出的一组训练结果比较好的权重值。

迁移学习（Transfer Learning）就是一个预训练的模型被重新定义在另一个任务中，通俗来讲就是学会举一反三的能力，通过运用已有的知识来学习新的知识，其核心是找到已有知识和新知识之间的相似性，通过这种相似性的迁移达到迁移学习的目的。世间万事万物皆有共性，如何合理地找寻它们之间的相似性，进而利用这个桥梁来帮助学习新知识，是迁移学习的核心问题。

问题二：比较使用预训练模型和不使用预训练模型的效果

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

使用预训练模型

主要有两种方法：

• 特征提取
• 微调模型

特征提取就是去除之前训练好的网络的分类器，在卷积基之上运行新数据，训练新的分类器。

用于特征提取的卷积基是需要被冻结的，而微调则是将顶部的几层解冻，将解冻的几层和新增的部分，如全连接层联合训练。之所以称之为微调，是因为我们只略微调整了复用的模型的更加抽象的表示部分，使得模型与当前求解问题更加相关。

 

具体参考：

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

 模型训练

复用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")

这里使用到的RunnerV3类，Accuracy()函数

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"

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 = []  # 一个epoch记录一次loss
        self.train_step_losses = []  # 一个step记录一次loss
        self.dev_losses = []
 
        # 记录全局最优指标
        self.best_score = 0
 
    def train(self, train_loader, dev_loader=None, **kwargs):
        # 将模型切换为训练模式
        self.model.train()
 
        # 传入训练轮数，如果没有传入值则默认为0
        num_epochs = kwargs.get("num_epochs", 0)
        # 传入log打印频率，如果没有传入值则默认为100
        log_steps = kwargs.get("log_steps", 100)
        # 评价频率
        eval_steps = kwargs.get("eval_steps", 0)
 
        # 传入模型保存路径，如果没有传入值则默认为"best_model.pdparams"
        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!')
 
        # 运行的step数目
        global_step = 0
 
        # 进行num_epochs轮训练
        for epoch in range(num_epochs):
            # 用于统计训练集的损失
            total_loss = 0
            for step, data in enumerate(train_loader):
                X, y = data
                X = X.cuda()
                y = y.cuda()
                # 获取模型预测
                logits = self.model(X)
                logits = logits.cuda()
                y = y.to(dtype=torch.int64)
                loss = self.loss_fn(logits, y)  # 默认求mean
                total_loss += loss
 
                # 训练过程中，每个step的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
 
            # 当前epoch 训练loss累计值
            trn_loss = (total_loss / len(train_loader)).item()
            # epoch粒度的训练loss保存
            self.train_epoch_losses.append(trn_loss)
 
        print("[Train] Training done!")
 
    # 模型评估阶段，使用'paddle.no_grad()'控制不计算和存储梯度
    @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
            X = X.cuda()
            y = y.cuda()
            # 计算模型输出
            logits = self.model(X)
            logits = logits.cuda()
            # 计算损失函数
            y=y.to(dtype=torch.int64)
            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()
 
        # 记录验证集loss
        if global_step != -1:
            self.dev_losses.append((global_step, dev_loss))
            self.dev_scores.append(dev_score)
 
        return dev_score, dev_loss
 
    # 模型评估阶段，使用'paddle.no_grad()'控制不计算和存储梯度
    @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)

 训练结果：

[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!

 模型评价

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

# 加载最优模型
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.8530/0.6026

模型预测

同样地，也可以使用保存好的模型，对测试集中的数据进行模型预测，观察模型效果：

# 获取测试集中的一个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层并没有计算在内； 这里我们关注50-layer和101-layer这两列，可以发现，它们唯一的不同在于conv4_x，ResNet50有6个block，而ResNet101有23个block，查了17个block，也就是17 x 3 = 51层。

在使用了ResNet的结构后，可以发现层数不断加深导致的训练集上误差增大的现象被消除了，ResNet 网络的训练误差会随着层数增大而逐渐减小，并且在测试机上的表现也会变好，在ResNet推出后不久，Google就借鉴了ResNet的精髓，提出了 Inception V4和 Inception-ResNet-V2，并通过融合这两个模型，在 ILSVRC数据集上取得了惊人的 3.08%的错误率。可见，ResNet及其思想对卷积神经网络研究的贡献确实非常显著，具有很强的推广性。

layer3和layer4结构和layer2相同，无非就是通道数变多，输出尺寸变小；

ResNet18、34、50、101和152都是基于Basicblock，结构非常相似，差别只在于每个layer的block数。

每个版本的区别如下：

 2.评价

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

前面实验也简单总结过：

LeNet是卷积神经网络最早的领头者LeCun在1998年提出，用于解决手写数字识别的视觉任务。当年美国大多数银行就是用它来识别支票上面的手写数字的，它是早期卷积神经网络中最有代表性的实验系统之一。自那时起，CNN的最基本的架构就定下来了：卷积层、池化层、全连接层。

之后有了LenNet-5，共有7层（不包括输入层），每层都包含不同数量的训练参数。

 LeNet-5第一层：卷积层C1
C1层是卷积层，形成6个特征图谱。卷积的输入区域大小是5x5，每个特征图谱内参数共享，即每个特征图谱内只使用一个共同卷积核，卷积核有5x5个连接参数加上1个偏置共26个参数。卷积区域每次滑动一个像素，这样卷积层形成的每个特征图谱大小是(32-5)/1+1=28x28。C1层共有26x6=156个训练参数，有(5x5+1)x28x28x6=122304个连接。

LeNet-5第二层：池化层S2
S2层是一个下采样层（为什么是下采样？利用图像局部相关性的原理，对图像进行子抽样，可以减少数据处理量同时保留有用信息）。C1层的6个28x28的特征图谱分别进行以2x2为单位的下抽样得到6个14x14（（28-2）/2+1）的图。每个特征图谱使用一个下抽样核。5x14x14x6=5880个连接。

LeNet-5第三层：卷积层C3
C3层是一个卷积层，卷积和和C1相同，不同的是C3的每个节点与S2中的多个图相连。C3层有16个10x10（14-5+1）的图，每个图与S2层的连接的方式如下表所示：

LeNet-5第四层：池化层S4
S4是一个下采样层。C3层的16个10x10的图分别进行以2x2为单位的下抽样得到16个5x5的图。5x5x5x16=2000个连接。连接的方式与S2层类似。

LeNet-5第五层：全连接层C5
C5层是一个全连接层。由于S4层的16个图的大小为5x5，与卷积核的大小相同，所以卷积后形成的图的大小为1x1。这里形成120个卷积结果。每个都与上一层的16个图相连。所以共有(5x5x16+1)x120 = 48120个参数，同样有48120个连接。

LeNet-5第六层：全连接层F6
F6层是全连接层。F6层有84个节点，对应于一个7x12的比特图，该层的训练参数和连接数都是(120 + 1)x84=10164。

LeNet-5第七层：全连接层Output
Output层也是全连接层，共有10个节点，分别代表数字0到9，如果节点i的输出值为0，则网络识别的结果是数字i。采用的是径向基函数（RBF）的网络连接方式。假设x是上一层的输入，y是RBF的输出，则RBF输出的计算方式是：

LeNet5特征能够总结为如下几点：
1）卷积神经网络使用三个层作为一个系列： 卷积，池化，非线性；
2）使用卷积提取空间特征；
3）使用映射到空间均值下采样（subsample）；
4）双曲线（tanh）或S型（sigmoid）形式的非线性；
5）多层神经网络（MLP）作为最后的分类器；
6）层与层之间的稀疏连接矩阵避免大的计算成本。

AlexNet之前，神经网络一般都使用sigmoid或tanh作为激活函数，这类函数在自变量非常大或者非常小时，函数输出基本不变，称之为饱和函数，为了提高训练速度，AlexNet使用了修正线性函数ReLU，它是一种非饱和函数，与 sigmoid 和tanh 函数相比，ReLU分片的线性结构实现了非线性结构的表达能力，梯度消失现象相对较弱，有助于训练更深层的网络。

VGGNet常用的有VGG16、VGG19两种类型。VGG16拥有13个卷积层（核大小均为3*3），5个最大池化层，3个全连接层。VGG19拥有16个卷积层（核大小均为3*3），5个最大池化层，3个全连接层。

GoogleNet 网络是14年由 Google 团队提出，斩获该年 ImageNet 竞赛中 Classification Task（分类任务）第一名。

网络特点

• 引入了 Inception 结构（融合不同尺度的特征信息）
• 使用 1*1 的卷积核进行降维以及映射处理

结构：

 

ResNet出现于2015年，在2015年ImageNet的分类任务上取得了第一名的好成绩，它的出现相对于较早的ALexNet，VGGNet，GoogleNet等特征提取网络来说具有着历史性的突破。

残差 网络ResNet它的基础就是残差块，比如下两种常见的残差块。

然后对单残差块进行处理，如加入汇聚也就是池化，批量化归一等各种操作。

ResNet沿用了VGG完整的3×3卷积层设计。 残差块里首先有2个有相同输出通道数的3×3卷积层。 每个卷积层后接一个批量规范化层和ReLU激活函数。 然后我们通过跨层数据通路，跳过这2个卷积运算，将输入直接加在最后的ReLU激活函数前。 这样的设计要求2个卷积层的输出与输入形状一样，从而使它们可以相加。 如果想改变通道数，就需要引入一个额外的1×1卷积层来将输入变换成需要的形状后再做相加运算。

在上几次次的前馈神经网络实验看出盲目的加深网络的深度不但不会提高检测的准确率，反而会使得网络难以训练，是因为在反向传播调整参数时会出现梯度爆炸或者梯度消失，使得网络的训练过程难以收敛，残差网络的出现则正好改变了现状，采用ResNet网络进行特征提取时，网络的深度可以得到极大的增加，从最初的十几层，增加到现在的151层，并且不会产生过拟合现象。上面实验中发现残差连接后，模型收敛曲线更平滑，模型的效果也会更好。

总结：

使用思维导图全面总结CNN

借用下面博客的一张思维导图，感觉总结得很好，有文字，还有图片，仔细得描述就不赘述了，上面也总结了很多类型得网络。

ref：

NNDL 实验5（上） - HBU_DAVID - 博客园

 NNDL 实验5（下） - HBU_DAVID - 博客园

6. 卷积神经网络 — 动手学深度学习 2.0.0-beta1 documentation

7. 现代卷积神经网络 — 动手学深度学习 2.0.0-beta1 documentation

【思维导图】01-卷积神经网络笔记_苍颜小峰的博客-CSDN博客