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》(https://arxiv.org/abs/1512.03385)，了解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 数据处理

5.5.1.1 数据集介绍

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

将数据集文件进行解压：

# 解压数据集
# 初次运行时将注释取消，以便解压文件
# 如果已经解压过，不需要运行此段代码，否则由于文件已经存在，解压时会报错
!tar -xvf /home/aistudio/data/data9154/cifar-10-python.tar.gz -C /home/aistudio/datasets/

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)

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

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.3 构造Dataset类

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

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='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进行图像分类实验。

torchvision.models.resnet18()

from torchvision.models import resnet18
 
resnet18_model = resnet18(pretrained=True)

什么是“预训练模型”？

预训练模型是深度学习架构，已经过训练以执行大量数据上的特定任务（例如，识别图片中的分类问题）。这种训练不容易执行，并且通常需要大量资源，超出许多可用于深度学习模型的人可用的资源，我就没有大批次ＧＰＵ。在谈论预训练模型时，通常指的是在Imagenet上训练的CNN（用于视觉相关任务的架构）。ImageNet数据集包含超过1400万个图像，其中120万个图像分为1000个类别（大约100万个图像含边界框和注释）。

预训练模型使用方法:
微调fine tune

    1 特征提取

我们可以将预训练模型当做特征提取装置来使用。具体的做法是，将输出层去掉，然后将剩下的整个网络当做一个固定的特征提取机，从而应用到新的数据集中。

    2 采用预训练模型的结构

我们还可以采用预训练模型的结构，但先将所有的权重随机化，然后依据自己的数据集进行训练。

    3 训练特定层，冻结其他层

另一种使用预训练模型的方法是对它进行部分的训练。具体的做法是，将模型起始的一些层的权重保持不变，重新训练后面的层，得到新的权重。在这个过程中，我们可以多次进行尝试，从而能够依据结果找到frozen layers和retrain layers之间的最佳搭配。

什么是“迁移学习”？

1. 什么是迁移学习

迁移学习(Transfer Learning)是一种机器学习方法，就是把为任务 A 开发的模型作为初始点，重新使用在为任务 B 开发模型的过程中。迁移学习是通过从已学习的相关任务中转移知识来改进学习的新任务，虽然大多数机器学习算法都是为了解决单个任务而设计的，但是促进迁移学习的算法的开发是机器学习社区持续关注的话题。 迁移学习对人类来说很常见，例如，我们可能会发现学习识别苹果可能有助于识别梨，或者学习弹奏电子琴可能有助于学习钢琴。

找到目标问题的相似性，迁移学习任务就是从相似性出发，将旧领域(domain)学习过的模型应用在新领域上。
2. 为什么需要迁移学习？

1.     大数据与少标注的矛盾：虽然有大量的数据，但往往都是没有标注的，无法训练机器学习模型。人工进行数据标定太耗时。
2.     大数据与弱计算的矛盾：普通人无法拥有庞大的数据量与计算资源。因此需要借助于模型的迁移。
3.     普适化模型与个性化需求的矛盾：即使是在同一个任务上，一个模型也往往难以满足每个人的个性化需求，比如特定的隐私设置。这就需要在不同人之间做模型的适配。
4.     特定应用（如冷启动）的需求。

3. 迁移学习的基本问题有哪些？

基本问题主要有3个：

•     How to transfer： 如何进行迁移学习？（设计迁移方法）
•     What to transfer： 给定一个目标领域，如何找到相对应的源领域，然后进行迁移？（源领域选择）
•     When to transfer： 什么时候可以进行迁移，什么时候不可以？（避免负迁移）

4.实现

从技术上来说，迁移学习只是一种学习的方式，一种基于以前学习的基础上继续学习的方式。但现在大家讲的最多的还是基于神经网络基础之上的迁移学习。这里我们以卷积神经网络（CNN）为例，做一个简单的介绍。

在CNN中，我们反复的将一张图片的局部区域卷积，减少面积，并提升通道数。

为什么卷积神经网络可以工作？最核心的原因在于：局部一致性。一只猫爪子，你把它放在图片的左下角是一只猫爪子，你把它放到右上角也是一只猫爪子。

那么卷积神经网络的中间层里面到底有什么？

Matthew D. Zeiler和Rob Fergus发表了一篇非常著名的论文，阐述了卷积神经网络到底看到了什么：

Matthew D. Zeiler和Rob Fergus采用了一种与众不同的思路来解读卷积层的内容。

和对卷积层进行简单的成像不同，他们尝试把不同的内容输入到训练好的神经网络，并观察记录卷积核的激活值。并把造成相同卷积核较大激活的内容分组比较。上面的图片中每个九宫格为同一个卷积核对不同图片的聚类。

从上面图片中可以看到，较浅层的卷积层将较为几何抽象的内容归纳到了一起。例如第一层的卷积中，基本就是边缘检测。而在第二层的卷积中，聚类了相似的几何形状，尽管这些几何形状的内容相差甚远。

随着卷积层越来越深，所聚类的内容也越来越具体。例如在第五层里，几乎每个九宫格里都是相同类型的东西。当我们了解这些基础知识后，那么我们有些什么办法可以实现迁移学习？

其实有个最简单易行的方式已经摆在我们面前了：如果我们把卷积神经网络的前n层保留下来，剩下不想要的砍掉怎么样？就像我们可以不需要ct能识别狗，识别猫，但是轮廓的对我们还是很有帮助的。

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

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

ref：

【深度学习】使用预训练模型_DrCrypto的博客-CSDN博客_深度学习预训练模型操作

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

5.5.3 模型训练

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

import torch.nn.functional as F
import torch.optim as opt
from nndl import RunnerV3, Accuracy
 
device = torch.device("cuda" 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")

运行结果：（cpu运行非常非常慢）

cpu
[Train] epoch: 0/30, step: 0/18750, loss: 7.23091
[Train] epoch: 4/30, step: 3000/18750, loss: 0.85450
[Evaluate]  dev score: 0.61040, dev loss: 1.21793
[Evaluate] best accuracy performence has been updated: 0.00000 --> 0.60690
[Train] epoch: 9/30, step: 6000/18750, loss: 0.29281
[Evaluate]  dev score: 0.63330, dev loss: 1.43977
[Evaluate] best accuracy performence has been updated: 0.60690 --> 0.72630
[Train] epoch: 14/30, step: 9000/18750, loss: 0.17818
[Evaluate]  dev score: 0.63760, dev loss: 1.72225
[Evaluate] best accuracy performence has been updated: 0.72630 --> 0.73210
[Train] epoch: 19/30, step: 12000/18750, loss: 0.02657
[Evaluate]  dev score: 0.64530, dev loss: 1.90356
[Evaluate] best accuracy performence has been updated: 0.73210 --> 0.74690
[Train] epoch: 24/30, step: 15000/18750, loss: 0.04895
[Evaluate]  dev score: 0.64760, dev loss: 2.00299
[Train] epoch: 28/30, step: 18000/18750, loss: 0.02457
[Evaluate]  dev score: 0.64930, dev loss: 2.08239
[Evaluate] best accuracy performence has been updated: 0.74690 --> 0.78220
[Evaluate]  dev score: 0.63370, dev loss: 2.09273
[Train] Training done!

补充代码，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"

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 = []  # 一个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
                # 获取模型预测
                logits = self.model(X)
                y = torch.tensor(y, 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()
                # 梯度归零
                self.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

            # 计算模型输出
            logits = self.model(X)
            y = torch.tensor(y, 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):
        model_state_dict = torch.load(model_path)

5.5.4 模型评价

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

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

运行结果：

[Test] accuracy/loss: 0.8932/0.9786

5.5.5 模型预测

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

#获取测试集中的一个batch的数据
X, label = next(iter(test_loader))
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))
imgs, labels = load_cifar10_batch(folder_path='cifar10\cifar-10-batches-py', mode='test')
plt.imshow(imgs[2].transpose(1,2,0))
plt.savefig('cnn-test-vis.pdf')

运行结果：

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

思考题

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

1.resnet意义

随着网络的加深，出现了训练集准确率下降的现象，即“网络退化”。

深度残差网络，它允许网络尽可能的加深。

2.resnet结构

这两种结构分别针对resnet34（左图）和resnet50/101/152（右图），一般称整个结构为一个”building block“。其中右图又称为”bottleneck design”，目的一目了然，就是为了降低参数的数目。

看右图，输入是一个3×3×256的特征，第一个步骤用64个1x1的卷积把256维channel降到64维，然后在最后通过1x1卷积恢复到256个channel，整体上用的参数数目：1x1x256x64 + 3x3x64x64 + 1x1x64x256 = 69632，而不使用bottleneck的话参考左图，输入假设是3x3x256，第一步经过256个卷积核3×3×256，第二部再经过256个卷积核3×3×256。所以参数数目: 3x3x256x256x2 = 1179648，差了16.94倍。

表1，Resnet不同的结构

表格中提到了五种深度的ResNet，分别是18，34，50，101，152。表格的最左侧是说明无论是深度为多少的ResNet都将网络分成了五部分。分别是：conv1，conv2_x,conv3_x,conv4_x,conv5_x。而仔细观察图，可以得出一下几个结论。

•     从50-layer之后，conv2——conv5都是采取三层块结构以减小计算量和参数数量                 说明   50-layer以后开始采用BottleBlock
•     从50-layer之后，层数的加深仅仅体现在conv4_x这一层中，也就是output size为14×14的图像

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

​

LeNet

LeNet5诞生于1994年，是最早的卷积神经网络之一，并且推动了深度学习领域的发展。

• 主要用来进行手写字符的识别与分类
• 确立了CNN的结构，现在神经网络中的许多内容在LeNet的网络结构中都能看到

结构：

LeNet5 这个网络虽然很小，但是它包含了深度学习的基本模块：卷积层，池化层，全链接层。是其它深度学习模型的基础。 

AlexNet

结构图：

特点：

AlexNet是在LeNet的基础上加深了网络的结构，学习更丰富更高维的图像特征。AlexNet的特点：

•     更深的网络结构
•     使用层叠的卷积层，即卷积层+卷积层+池化层来提取图像的特征
•     使用Dropout抑制过拟合
•     使用数据增强Data Augmentation抑制过拟合
•     使用Relu替换之前的sigmoid的作为激活函数
•     多GPU训练

VGG

VGG 最大的特点就是它在之前的网络模型上，通过比较彻底地采用 3x3 尺寸的卷积核来堆叠神经网络，从而加深整个神经网络的层级。

VGG在AlexNet基础上做了改进，整个网络全部使用了同样大小的3*3卷积核尺寸和2*2最大池化尺寸，网络结果简洁。一系列VGG模型的结构图

VGG论文给出了一个非常振奋人心的结论：卷积神经网络的深度增加和小卷积核的使用对网络的最终分类识别效果有很大的作用。

唯一的不足是，在进行反向传播时，中间的卷积层可能会导致占用更多的内存。

GoogLeNet

网络特点

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

ResNet 

ResNet是在Alexnet的基础上发展优化而来，残差神经网络的一大优势就是恒等映射。

残差神经网络相较于VGG等神经网络最大的优势在于他引入了恒等映射从而通过计算残差来解决由层数过高产生的退化问题。

所谓残差表现在这张图里就是F(x)

•  F(x) = H(x) + x
•  其中H(x)就是对于输入X的一个恒等映射
•  X就是通过已经捷径(shortcut)得到了原始值
•  如果添加的层可以被构建为恒等映射，更深模型的训练误差应该不会大于他对应的更浅版本。
•  如果恒等映射是最优的，求解器可能简单地将多个非线性连接的权重推向零来接近恒等映射
•  在实际情况下，恒等映射不太可能是最优的，但是有助于对问题进行预处理，如果最优函数比零映射更接近恒等映射，则求解器应该更容易找到关于恒等映射的抖动，而不是将函数作为新函数来学习。

总结

使用思维导图全面总结CNN（必做）

本次实验实现了基于ResNet18完成cifar-10图像分类任务，cifar-10是经典的数据集，但量比较大，用cpu跑的，训练时间很长，很慢，等了很久。除此之外，对本次实验印象较深的就是对经典的CNN: LeNet、AlexNet、VGG、GoogLeNet、ResNet进行评价了解。

参考&推荐：

NNDL 实验六 卷积神经网络（5）使用预训练resnet18实现CIFAR-10分类_HBU_David的博客-CSDN博客_models.resnet18(pretrained=true)

 迁移学习（Transfer）_Sonhhxg_柒的博客-CSDN博客_迁移学习

什么是迁移学习？_Xavier Jiezou的博客-CSDN博客_迁移学习

预训练模型_lucca的博客-CSDN博客_预训练模型是什么意思

resnet详解_「已注销」的博客-CSDN博客_resnet

深度学习经典网络（4）ResNet深度残差网络结构详解_青衫憶笙的博客-CSDN博客_残差结构

深度学习——ResNet超详细讲解，详解层数计算、各层维度计算_图南zzz的博客-CSDN博客_深度学习层数