《昇思 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 网络模型的应用和突出的优势
> 所有内容仅为个人理解，若有错误与遗漏还望各位大佬指正