《昇思 25 天学习打卡营第 11 天

《昇思 25 天学习打卡营第 11 天 | ResNet50 图像分类》

活动地址：https://xihe.mindspore.cn/events/mindspore-training-camp
签名：Sam9029

计算机视觉-图像分类，很感兴趣

且今日精神颇佳，一个字，学啊

上一节（ResNet50 迁移学习）直接应用了 ResNet50 模型却没有解释概念

这一节解释，虽然提前去了解了，还是温习一下

ResNet 网络: ResNet50 网络是 2015 年由微软实验室的何恺明提出，获得 ILSVRC2015 图像分类竞赛第一名。主要的特征如下：

残差学习(最重要的概念)：ResNet50 的核心思想是引入了“残差学习”框架。在深度网络中，如果层数太多，网络的训练可能会变得困难，因为每增加一层，网络的性能反而可能下降。残差学习通过添加跳过（skip connections）或快捷连接（shortcut connections）解决了这个问题，允许网络学习残差函数，而不是直接学习未映射的特征表示。

层叠结构：ResNet50 包含 50 层深的网络结构，这些层被组织成多个残差块（residual blocks）。每个残差块包含两个卷积层，后面跟着批量归一化（Batch Normalization）和 ReLU 激活函数。

批量归一化：ResNet50 在每个卷积层之后使用批量归一化，这有助于加速收敛速度，同时减少对初始化的敏感性。

恒等快捷连接：在每个残差块中，输入通过一个恒等快捷连接（identity shortcut connection）直接添加到块的输出。这保证了在网络训练过程中，梯度可以有效地流动到较浅的层。

性能：由于其设计，ResNet50 在多个标准数据集（如 ImageNet 和 COCO）上表现出色，成为了许多计算机视觉任务的基准模型。

意思是啥呢？

看完了也不是很懂，但只要明白一个概念，就是很厉害，比起传统的卷积化神经网络模型，resNet50 性能和识别误差都更小。

传统的卷积神经网络都是将一系列的卷积层和池化层堆叠得到的，但当网络堆叠到一定深度时，就会出现退化问题。

ResNet 网络模型就提出了残差网络结构(Residual Network)来减轻退化问题，使用 ResNet 网络可以实现搭建较深的网络结构（突破 1000 层）

使用实践

学习完概念，当然少不了实践拉，这次使用 CIFAR-10数据集 来进行图像分类的模型训练

下载数据集

from download import download

url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz"

download(url, "./datasets-cifar10-bin", kind="tar.gz", replace=True)

CIFAR-10 数据集主要是一些 airplane、automobile、bird、cat、deer、dog、frog、horse、ship、truck，可查看（datasets-cifar10-bin/cifar-10-batches-bin/batches.meta.text）

然后是一些数据增强操作，略过

构建 ResNet50 网络模型

残差网络结构(Residual Network)是 ResNet 网络的主要亮点，ResNet 使用残差网络结构后可有效地减轻退化问题，实现更深的网络结构设计，提高网络的训练精度。

构建残差网络结构

请添加图片描述

这里的原理概念太难懂了，直接说主要特征和使用

残差网络结构主要由两种:

一种是 Building Block，适用于较浅的 ResNet 网络，如 ResNet18 和 ResNet34；

另一种是 Bottleneck，适用于层数较深的 ResNet 网络，如 ResNet50、ResNet101 和 ResNet152。

这一节使用 ResNet50 来构建图像识别模型所以，我注重记录一下 Bottleneck 网络的构建

class ResidualBlock(nn.Cell):
    expansion = 4  # 最后一个卷积核的数量是第一个卷积核数量的4倍

    def __init__(self, in_channel: int, out_channel: int,
                 stride: int = 1, down_sample: Optional[nn.Cell] = None) -> None:
        super(ResidualBlock, self).__init__()

        self.conv1 = nn.Conv2d(in_channel, out_channel,
                               kernel_size=1, weight_init=weight_init)
        self.norm1 = nn.BatchNorm2d(out_channel)
        self.conv2 = nn.Conv2d(out_channel, out_channel,
                               kernel_size=3, stride=stride,
                               weight_init=weight_init)
        self.norm2 = nn.BatchNorm2d(out_channel)
        self.conv3 = nn.Conv2d(out_channel, out_channel * self.expansion,
                               kernel_size=1, weight_init=weight_init)
        self.norm3 = nn.BatchNorm2d(out_channel * self.expansion)

        self.relu = nn.ReLU()
        self.down_sample = down_sample

    def construct(self, x):

        identity = x  # shortscuts分支

        out = self.conv1(x)  # 主分支第一层：1*1卷积层
        out = self.norm1(out)
        out = self.relu(out)
        out = self.conv2(out)  # 主分支第二层：3*3卷积层
        out = self.norm2(out)
        out = self.relu(out)
        out = self.conv3(out)  # 主分支第三层：1*1卷积层
        out = self.norm3(out)

        if self.down_sample is not None:
            identity = self.down_sample(x)

        out += identity  # 输出为主分支与shortcuts之和
        out = self.relu(out)

        return out

定义`make_layer`实现残差块的构建

这个函数的作用在于构建一个由多个残差块组成的网络层，是 ResNet 网络构建深度残差网络的基础

def make_layer(last_out_channel, block: Type[Union[ResidualBlockBase, ResidualBlock]],
               channel: int, block_nums: int, stride: int = 1):
    down_sample = None  # shortcuts分支

    if stride != 1 or last_out_channel != channel * block.expansion:
        # 创建下采样层：
        down_sample = nn.SequentialCell([
            nn.Conv2d(last_out_channel, channel * block.expansion,
            # 使用1x1卷积进行通道数的调整和下采样, 紧接着是批量归一化层。
                      kernel_size=1, stride=stride, weight_init=weight_init),
            nn.BatchNorm2d(channel * block.expansion, gamma_init=gamma_init)
        ])

    layers = []
    layers.append(block(last_out_channel, channel, stride=stride, down_sample=down_sample))

    in_channel = channel * block.expansion
    # 循环创建剩余的残差块并添加到layers列表
    for _ in range(1, block_nums):

        layers.append(block(in_channel, channel))

    return nn.SequentialCell(layers)

定义 `ResNet网络模型`

最重要的步骤，定义 ResNet 模型类型函数

from mindspore import load_checkpoint, load_param_into_net

class ResNet(nn.Cell):
    def __init__(self, block: Type[Union[ResidualBlockBase, ResidualBlock]],
                 layer_nums: List[int], num_classes: int, input_channel: int) -> None:
        super(ResNet, self).__init__()

        self.relu = nn.ReLU()
        # 第一个卷积层，输入channel为3（彩色图像），输出channel为64
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, weight_init=weight_init)
        self.norm = nn.BatchNorm2d(64)
        # 最大池化层，缩小图片的尺寸
        self.max_pool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same')
        # 各个残差网络结构块定义
        self.layer1 = make_layer(64, block, 64, layer_nums[0])
        self.layer2 = make_layer(64 * block.expansion, block, 128, layer_nums[1], stride=2)
        self.layer3 = make_layer(128 * block.expansion, block, 256, layer_nums[2], stride=2)
        self.layer4 = make_layer(256 * block.expansion, block, 512, layer_nums[3], stride=2)
        # 平均池化层
        self.avg_pool = nn.AvgPool2d()
        # flattern层
        self.flatten = nn.Flatten()
        # 全连接层
        self.fc = nn.Dense(in_channels=input_channel, out_channels=num_classes)

    def construct(self, x):

        # // ... 省略

        return x

然后定义 _resnet 函数加载使用 ResNet 网络模型类
再使用 _resnet 函数构建 resnet50 网络模型

def resnet50(num_classes: int = 1000, pretrained: bool = False):
    """ResNet50模型"""
    resnet50_url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/models/application/resnet50_224_new.ckpt"
    resnet50_ckpt = "./LoadPretrainedModel/resnet50_224_new.ckpt"
    return _resnet(resnet50_url, ResidualBlock, [3, 4, 6, 3], num_classes,
                   pretrained, resnet50_ckpt, 2048)

模型训练

# 定义ResNet50网络
network = resnet50(pretrained=True)

# 全连接层输入层的大小
in_channel = network.fc.in_channels
fc = nn.Dense(in_channels=in_channel, out_channels=10)
# 重置全连接层
network.fc = fc

# 设置学习率
num_epochs = 5
lr = nn.cosine_decay_lr(min_lr=0.00001, max_lr=0.001, total_step=step_size_train * num_epochs,
    step_per_epoch=step_size_train, decay_epoch=num_epochs)
# 定义优化器和损失函数
# // ... 省略

# 定义训练函数
def train(data_loader, epoch): //epoch 即 num_epoch
    # // ... 省略

# 定义预测函数
def evaluate(data_loader):
    # // ... 省略

# 开始循环训练
print("Start Training Loop ...")

for epoch in range(num_epochs):
    curr_loss = train(data_loader_train, epoch) # 训练
    curr_acc = evaluate(data_loader_val) # 预测


    print("Epoch: [%3d/%3d], Average Train Loss: [%5.3f], Accuracy: [%5.3f]" % (
        epoch+1, num_epochs, curr_loss, curr_acc
    ))

    # 保存当前预测准确率最高的模型
    # // ... 省略

使用可视化模型预测

定义 visualize_model 来检验我们训练的 ResNet 微调模型在图像分类方面的效果

import matplotlib.pyplot as plt


def visualize_model(best_ckpt_path, dataset_val):
    num_class = 10  # 对狼和狗图像进行二分类
    net = resnet50(num_class)
    # 加载模型参数
    param_dict = ms.load_checkpoint(best_ckpt_path)
    ms.load_param_into_net(net, param_dict)
    # 加载验证集的数据进行验证
    data = next(dataset_val.create_dict_iterator())
    images = data["image"]
    labels = data["label"]
    # 预测图像类别
    output = net(data['image'])
    pred = np.argmax(output.asnumpy(), axis=1)

    # 图像分类
    classes = []

    with open(data_dir + "/batches.meta.txt", "r") as f:
        for line in f:
            line = line.rstrip()
            if line:
                classes.append(line)

    # 显示图像及图像的预测值
    plt.figure()
    for i in range(6):
        plt.subplot(2, 3, i + 1)
        # 若预测正确，显示为蓝色；若预测错误，显示为红色
        color = 'blue' if pred[i] == labels.asnumpy()[i] else 'red'
        plt.title('predict:{}'.format(classes[pred[i]]), color=color)
        picture_show = np.transpose(images.asnumpy()[i], (1, 2, 0))
        mean = np.array([0.4914, 0.4822, 0.4465])
        std = np.array([0.2023, 0.1994, 0.2010])
        picture_show = std * picture_show + mean
        picture_show = np.clip(picture_show, 0, 1)
        plt.imshow(picture_show)
        plt.axis('off')

    plt.show()


# 使用测试数据集进行验证
visualize_model(best_ckpt_path=best_ckpt_path, dataset_val=dataset_val)

模型的预测结果，由章节解释 5 次训练就可以达到 70% 的准确率，

Epoch: [ 5/ 5], Average Train Loss: [0.745], Accuracy: [0.742], 差不多由 74%

当然想要继续提升，所需要的训练次数就会成倍的上升，训练成本也会添加，好在教程有说，80 次的 epochs 下就能达到理想的预测效果，

所有我实际测试一下，看看 80 的 ecochs 准确率是多少

实际测试日志输出

从 10:42:29开始训练

# 第二次 5次训练时--就达到了 80%，多3次epoch 提升 10%
Epoch: [  5/ 80], Average Train Loss: [0.516], Accuracy: [0.802]

# 8次训练--达到了 81%，多3次epoch 提升 1%
Epoch: [  8/ 80], Average Train Loss: [0.429], Accuracy: [0.817]

# 8次训练--达到了 83%，多16次epoch 提升 3%, 这个提升就有些慢了，看来提升准确率很不容易
Epoch: [ 21/ 80], Average Train Loss: [0.211], Accuracy: [0.837]

# 40次训练--达到了 84%，多35次epoch 提升 4%，预测一下 80次的时候会到90%，看可不可以，希望不要打脸
Epoch: [ 40/ 80], Average Train Loss: [0.077], Accuracy: [0.847]


# 49-51次训练--准确率进行了 过山车 波动，下降之后又回升了
Epoch: [ 49/ 80], Average Train Loss: [0.056], Accuracy: [0.850]
Epoch: [ 50/ 80], Average Train Loss: [0.057], Accuracy: [0.847]
Epoch: [ 51/ 80], Average Train Loss: [0.052], Accuracy: [0.846]



# --------------------------------------------------
Epoch: [ 80/ 80], Average Train Loss: [0.033], Accuracy: [0.849]
# --------------------------------------------------
#================================================================================
End of validation the best Accuracy is:  0.851, save the best ckpt file in ./BestCheckpoint/resnet50-best.ckpt

# 呃，80次的epochs 准确率是 84%， 过程最高时 85%

给我整嘛了，还是有好多的东西都不懂，不过也是初略的了解到了在图像识别方面 ResNet 网络模型的应用和突出的优势

所有内容仅为个人理解，若有错误与遗漏还望各位大佬指正

#================================================================================
End of validation the best Accuracy is: 0.851, save the best ckpt file in ./BestCheckpoint/resnet50-best.ckpt

呃，80次的epochs 准确率是 84%，过程最高时 85%


给我整嘛了，还是有好多的东西都不懂，不过也是初略的了解到了在图像识别方面 ResNet 网络模型的应用和突出的优势

> 所有内容仅为个人理解，若有错误与遗漏还望各位大佬指正