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

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

什么是“预训练模型”？什么是“迁移学习”？（必做）
预训练模型
预训练模型可以把迁移学习很好地用起来。这和小孩读书一样，一开始语文、数学、化学都学，读书、网上游戏等，在脑子里积攒了很多。当他学习计算机时，实际上把他以前学到的所有知识都带进去了。如果他以前没上过中学，没上过小学，突然学计算机就不懂这里有什么道理。这和我们预训练模型一样，预训练模型就意味着把人类的语言知识，先学了一个东西，然后再代入到某个具体任务，就顺手了，就是这么一个简单的道理。

1.为什么要做预训练模型

• 首先，预训练模型是一种迁移学习的应用，利用几乎无限的文本，学习输入句子的每一个成员的上下文相关的表示，它隐式地学习到了通用的语法语义知识。
• 第二，它可以将从开放领域学到的知识迁移到下游任务，以改善低资源任务，对低资源语言处理也非常有利。
• 第三，预训练模型在几乎所有NLP任务中都取得了目前最佳的成果。
• 最后，这个预训练模型+微调机制具备很好的可扩展性，在支持一个新任务时，只需要利用该任务的标注数据进行微调即可，一般工程师就可以实现。

不管是图片识别还是自然语言处理，模型都朝着越来越臃肿，越来越大的方向发展。 每训练一个大的模型，都会消耗掉数小时甚至数天的时间。我们并不希望浪费太多的时间在训练上，所以拿到一个预训练模型就十分重要了。 基于预训练模型，我们能够用较少的模型，较快的速度得到一个适合于我们自己数据的新模型，而且这个模型效果也不会很差。
所以预训练的核心价值就是：

手头只有小数据集，也能得到一个好模型； 训练速度大大提升，不用从零开始训练。

迁移学习
1.什么是迁移学习

迁移学习，顾名思义，就是要进行迁移。放到人工智能和机器学习的学科里，迁移学习是一种学习的思想和模式。
首先机器学习是人工智能的一大类重要方法，也是目前发展最迅速、效果最显著的方法。机器学习解决的是让机器自主地从数据中获取知识，从而应用于新的问题中。迁移学习作为机器学习的一个重要分支，侧重于将已经学习过的知识迁移应用于新的问题中。
迁移学习的核心问题是，找到新问题和原问题之间的相似性，才可顺利地实现知识的迁移。
例子：

在我们一开始说的天气问题中，那些北半球的天气之所以相似，是因为它们的地理位置相似；
而南北半球的天气之所以有差异，也是因为地理位置有根本不同。
其实我们人类对于迁移学习这种能力，是与生俱来的。
比如，我们如果已经会打乒乓球，就可以类比着学习打网球。再比如，我们如果已经会下中国象棋，就可以类比着下国际象棋。
因为这些活动之间，往往有着极高的相似性。生活中常用的“举一反三”、“照猫画虎”就很好地体现了迁移学习的思想。

迁移学习的定义：迁移学习，是指利用数据、任务、或模型之间的相似性，将在旧领域学习过的模型，应用于新领域的一种学习过程。

2.为什么需要迁移学习

• 大数据与少标注之间的矛盾。

  我们正处在一个大数据时代，每天每时，社交网络、智能交通、视频监控、行业物流等，都产生着海量的图像、文本、语音等各类数据。数据的增多，使得机器学习和深度学习模型可以依赖于如此海量的数据，持续不断地训练和更新相应的模型，使得模型的性能越来越好，越来越适合特定场景的应用。然而，这些大数据带来了严重的问题：总是缺乏完善的数据标注。

• 大数据与弱计算之间的矛盾。

  大数据，就需要大设备、强计算能力的设备来进行存储和计算。然而，大数据的大计算能力，是” 有钱人” 才能玩得起的游戏。比如Google，Facebook，Microsoft，这些巨无霸公司有着雄厚的计算能力去利用这些数据训练模型。
  例如，ResNet 需要很长的时间进行训练。Google TPU 也都是有钱人的才可以用得起的。绝大多数普通用户是不可能具有这些强计算能力的。这就引发了大数据和弱计算之间的矛盾。在这种情况下，普通人想要利用这些海量的大数据去训练模型完成自己的任务，基本上不太可能。那么如何让普通人也能利用这些数据和模型？

• 普适化模型与个性化需求之间的矛盾。

机器学习的目标是构建一个尽可能通用的模型，使得这个模型对于不同用户、不同设备、不同环境、不同需求，都可以很好地进行满足。这是我们的美好愿景。这就是要尽可能地提高机器学习模型的泛化能力，使之适应不同的数据情形。基于这样的愿望，我们构建了多种多样的普适化模型，来服务于现实应用。

比如导航模型，可以定位及导航所有的路线。但是不同的人有不同的需求。比如有的人喜欢走高速，有的人喜欢走偏僻小路，这就是个性化需求。并且，不同的用户，通常都有不同的隐私需求。这也是构建应用需要着重考虑的。

所以目前的情况是，我们对于每一个通用的任务都构建了一个通用的模型。这个模型可以解决绝大多数的公共问题。但是具体到每个个体、每个需求，都存在其唯一性和特异性，一个普适化的通用模型根本无法满足。那么，能否将这个通用的模型加以改造和适配，使其更好地服务于人们的个性化需求？

• 特定应用的需求。

机器学习已经被广泛应用于现实生活中。在这些应用中，也存在着一些特定的应用，它们面临着一些现实存在的问题。

比如推荐系统的冷启动问题。一个新的推荐系统，没有足够的用户数据，如何进行精准的推荐?一个崭新的图片标注系统，没有足够的标签，如何进行精准的服务？

现实世界中的应用驱动着我们去开发更加便捷更加高效的机器学习方法来加以解决。
3.迁移学习的解决

• 大数据与少标注：迁移数据标注

  单凭借少量的标注数据，无法准确地训练高可用度的模型。为了解决这个问题，直观的想法是：多增加一些标注数据。但是不依赖于人工，如何增加标注数据？利用迁移学习的思想，我们可以寻找一些与目标数据相近的有标注的数据，从而利用这些数据来构建模型，增加我们目标数据的标注。

• 大数据与弱计算：模型迁移

不可能所有人都有能力利用大数据快速进行模型的训练。利用迁移学习的思想，我们可以将那些大公司在大数据上训练好的模型，迁移到我们的任务中。针对于我们的任务进行微调，从而我们也可以拥有在大数据上训练好的模型。更进一步，我们可以将这些模型针对我们的任务进行自适应更新，从而取得更好的效果。

• 普适化模型与个性化需求：自适应学习

为了解决个性化需求的挑战，我们利用迁移学习的思想，进行自适应的学习。考虑到不同用户之间的相似性和差异性，我们对普适化模型进行灵活的调整，以便完成我们的任务。

• 特定应用的需求：相似领域知识迁移

为了满足特定领域应用的需求，我们可以利用上述介绍过的手段，从数据和模型方法上进行迁移学习。
以上用表格概括入下：
4.迁移学习过程
从实践的角度来看, 整个迁移学习过程可以概括如下:

• 选择预训练模型

从大量的预训练模型，可以选择一个适合你要解决的问题的。如果你正在使用Tensorflow2.x，你可以在tf.keras.applications下立即使用一系列模型，例如VGG、InceptionV3和ResNet5。

• 根据大小相似性矩阵进行分类

在下图中你用矩阵来控制选择，这个矩阵是根据数据集的大小，以及预训练模型被训练之后的数据集的相似性，来对计算机视觉问题进行分类的。根据经验，如果每个类的图像少于1000个，则认为是小数据集。就数据集的相似性而言，常识占了上风。例如，如果是识别猫和狗，那么ImageNet将是一个类似的数据集，因为它有猫和狗的图像。然而，如果是识别癌细胞，ImageNet就不行了。

• 微调模型

这里可以使用大小和相似性矩阵来指导你的选择，然后参考前面提到的重用预训练模型的三个策略。见下图。

• 象限1
  大数据集，但不同于预训练模型的数据集。这种情况将会让你使用策略1。因为有一个大数据集，你就可以从零开始训练一个模型。尽管数据集不同，但在实践中，利用模型的体系结构和权重，通过预训练模型对初始化模型仍然是很有帮助的；
• 象限2
  大数据集与类似于预训练模型的数据集。在这里任何选项都有效，可能最有效的是策略2。由于我们有一个大数据集，过度拟合不应该是个问题，所以我们可以尽可能多地学习。然而，由于数据集是相似的，我们可以通过利用以前的知识来节省大量的训练工作。因此，仅对卷积基的分类器和顶层进行训练就足够了。
• 象限3
  小数据集，不同于预训练模型的数据集，这里唯一适合的就是策略2。很难在训练和冻结的层数之间平衡。如果你涉及的太深入，那么模型就会过度拟合；如果你仅停留在模型的表面，那么你就不会学到任何有用的东西。也许，你需要比象限2更深入，并且需要考虑数据增强技术。
• 象限4
  小数据集，但类似于预训练模型的数据集。你只需删除最后一个全连接层（输出层），并且执行预训练模型作为固定的特征提取器，然后使用结果特征来训练新的分类器。

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

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/18850, loss: 8.48462
[Evaluate] dev_score: 0.05820, dev_loss: 12.02463
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.73244, dev_loss: 0.82423
best accuracy performence has been updated: 0.71544 --> 0.73660
[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.8365/0.6027

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-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（必做）

心得体会

本次实验使用torchvision.models里的resnet模型训练了cifar10数据集，这个预训练的模型参数量比较大，训练时间好长啊。本次实验对Resnet18的网络结构有了更深的了解，学习了预训练模型和迁移学习，比较了使用预训练模型与不使用预训练模型的差别，对于LeNet、AlexNet、VGG、GoogLeNet、ResNet之间的差别进行了了解。

参考

4、迁移学习和预训练模型
预训练模型迁移学习（Transfer Learning）
深度学习——ResNet超详细讲解，详解层数计算、各层维度计算
经典的卷积神经网络：LeNet，AlexNet，GoogLeNet，VGG，ResNet