我要评论学习内容：resnet50迁移学习
1.背景介绍
1.1 什么是迁移学习？
在实际应用场景中，由于训练数据集不足，所以很少有人会从头开始训练整个网络。普遍的做法是，在一个非常大的基础数据集上训练得到一个预训练模型，然后使用该模型来初始化网络的权重参数或作为固定特征提取器应用于特定的任务中。
1.2 迁移学习的三种主要场景如下：
-
convnet作为固定特征提取器 ：把在非常大的数据集上预训练的网络作为特征提取器，移除最后一个全连接层，并在新数据集上训练一个线性分类器。
-
微调(convnet) ：不仅是在convnet顶部替换并重新训练分类器，还要通过继续反向传播(backpropagation)来微调预训练网络的权重。可以微调(convnet)所有层，或者出于过拟合(overfitting)的考虑，保持一些早期层固定，只微调网络的一些更高层次的部分。
-
预训练模型(pretrained models)：使用他人发布的预训练网络检查点，以便在新任务上进行微调。
1.3 何时以及如何微调？
你如何决定在新数据集上执行哪种类型的迁移学习？这取决于几个因素，但最重要的两个是新数据集的大小（小或大）以及它与原始数据集的相似性（例如在图像内容和类别方面类似于imagenet，或者非常不同，如显微镜图像）。记住convnet特征在早期层更通用，在后期层更特定于原始数据集，以下是4个常见的经验法则：
1.新数据集小且与原始数据集相似。由于数据量小，微调convnet不是好主意，因为担心过拟合。由于数据与原始数据相似，我们期望convnet的高级特征也与此数据集相关。因此，最好的想法可能是在cnn codes上训练线性分类器。
2.新数据集大且与原始数据集相似。由于我们有更多的数据，我们可以更有信心，如果我们尝试通过整个网络微调，我们不会过拟合。
3.新数据集小但与原始数据集非常不同。由于数据量小，最好只训练线性分类器。由于数据集与原始数据集非常不同，可能最好不要从网络顶部训练分类器，其中包含更多特定于数据集的特征。相反，从网络的早期某处训练svm分类器可能会更有效。
4.新数据集大且与原始数据集非常不同。由于数据集很大，我们可以预期我们可以从头开始训练一个convnet。然而，在实践中，通常仍然有好处使用预训练模型的权重进行初始化。在这种情况下，我们将有足够的数据和信心来微调整个网络。
1.4 迁移学习建议
- 来自预训练模型的约束 。使用预训练模型可能会限制新数据集的架构选择，但一些参数共享允许在不同尺寸的图像上运行网络。
- 学习率(learning rates)。通常对convnet权重使用较小的学习率，以避免过快扭曲相对好的权重。
2.应用实例
本章将使用迁移学习的方法对imagenet数据集中的狼和狗图像进行分类。
2.1数据准备
1. 下载数据集
下载案例所用到的狗与狼分类数据集，数据集中的图像来自于imagenet，每个分类有大约120张训练图像与30张验证图像。使用download接口下载数据集，并将下载后的数据集自动解压到当前目录下。
from download import download
dataset_url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/intermediate/canidae_data.zip"
download(dataset_url, "./datasets-canidae", kind="zip", replace=true)
2. 加载数据集
狼狗数据集提取自imagenet分类数据集，使用mindspore.dataset.imagefolderdataset接口来加载数据集，并进行相关图像增强操作。
首先执行过程定义一些输入：
batch_size = 18 # 批量大小
image_size = 224 # 训练图像空间大小
num_epochs = 5 # 训练周期数
lr = 0.001 # 学习率
momentum = 0.9 # 动量
workers = 4 # 并行线程个数
import mindspore as ms
import mindspore.dataset as ds
import mindspore.dataset.vision as vision
# 数据集目录路径
data_path_train = "./datasets-canidae/data/canidae/train/"
data_path_val = "./datasets-canidae/data/canidae/val/"
# 创建训练数据集
def create_dataset_canidae(dataset_path, usage):
"""数据加载"""
data_set = ds.imagefolderdataset(dataset_path,
num_parallel_workers=workers,
shuffle=true,)
# 数据增强操作
mean = [0.485 * 255, 0.456 * 255, 0.406 * 255]
std = [0.229 * 255, 0.224 * 255, 0.225 * 255]
scale = 32
if usage == "train":
# define map operations for training dataset
trans = [
vision.randomcropdecoderesize(size=image_size, scale=(0.08, 1.0), ratio=(0.75, 1.333)),
vision.randomhorizontalflip(prob=0.5),
vision.normalize(mean=mean, std=std),
vision.hwc2chw()
]
else:
# define map operations for inference dataset
trans = [
vision.decode(),
vision.resize(image_size + scale),
vision.centercrop(image_size),
vision.normalize(mean=mean, std=std),
vision.hwc2chw()
]
# 数据映射操作
data_set = data_set.map(
operations=trans,
input_columns='image',
num_parallel_workers=workers)
# 批量操作
data_set = data_set.batch(batch_size)
return data_set
dataset_train = create_dataset_canidae(data_path_train, "train")
step_size_train = dataset_train.get_dataset_size()
dataset_val = create_dataset_canidae(data_path_val, "val")
step_size_val = dataset_val.get_dataset_size()
3. 数据集可视化
从mindspore.dataset.imagefolderdataset接口中加载的训练数据集返回值为字典，用户可通过 create_dict_iterator 接口创建数据迭代器，使用 next 迭代访问数据集。本章中 batch_size 设为18，所以使用 next 一次可获取18个图像及标签数据。
data = next(dataset_train.create_dict_iterator())
images = data["image"]
labels = data["label"]
print("tensor of image", images.shape)
print("labels:", labels)
对获取到的图像及标签数据进行可视化，标题为图像对应的label名称。
import matplotlib.pyplot as plt
import numpy as np
# class_name对应label，按文件夹字符串从小到大的顺序标记label
class_name = {0: "dogs", 1: "wolves"}
plt.figure(figsize=(5, 5))
for i in range(4):
# 获取图像及其对应的label
data_image = images[i].asnumpy()
data_label = labels[i]
# 处理图像供展示使用
data_image = np.transpose(data_image, (1, 2, 0))
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
data_image = std * data_image + mean
data_image = np.clip(data_image, 0, 1)
# 显示图像
plt.subplot(2, 2, i+1)
plt.imshow(data_image)
plt.title(class_name[int(labels[i].asnumpy())])
plt.axis("off")
plt.show()
2.2训练模型
本章使用resnet50模型进行训练。搭建好模型框架后，通过将pretrained参数设置为true来下载resnet50的预训练模型并将权重参数加载到网络中。
1. 构建resnet50网络
from typing import type, union, list, optional
from mindspore import nn, train
from mindspore.common.initializer import normal
weight_init = normal(mean=0, sigma=0.02)
gamma_init = normal(mean=1, sigma=0.02)
class residualblockbase(nn.cell):
expansion: int = 1 # 最后一个卷积核数量与第一个卷积核数量相等
def __init__(self, in_channel: int, out_channel: int,
stride: int = 1, norm: optional[nn.cell] = none,
down_sample: optional[nn.cell] = none) -> none:
super(residualblockbase, self).__init__()
if not norm:
self.norm = nn.batchnorm2d(out_channel)
else:
self.norm = norm
self.conv1 = nn.conv2d(in_channel, out_channel,
kernel_size=3, stride=stride,
weight_init=weight_init)
self.conv2 = nn.conv2d(in_channel, out_channel,
kernel_size=3, weight_init=weight_init)
self.relu = nn.relu()
self.down_sample = down_sample
def construct(self, x):
"""residualblockbase construct."""
identity = x # shortcuts分支
out = self.conv1(x) # 主分支第一层：3*3卷积层
out = self.norm(out)
out = self.relu(out)
out = self.conv2(out) # 主分支第二层：3*3卷积层
out = self.norm(out)
if self.down_sample is not none:
identity = self.down_sample(x)
out += identity # 输出为主分支与shortcuts之和
out = self.relu(out)
return out
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```
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,
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
# 堆叠残差网络
for _ in range(1, block_nums):
layers.append(block(in_channel, channel))
return nn.sequentialcell(layers)
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):
x = self.conv1(x)
x = self.norm(x)
x = self.relu(x)
x = self.max_pool(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
x = self.avg_pool(x)
x = self.flatten(x)
x = self.fc(x)
return x
def _resnet(model_url: str, block: type[union[residualblockbase, residualblock]],
layers: list[int], num_classes: int, pretrained: bool, pretrianed_ckpt: str,
input_channel: int):
model = resnet(block, layers, num_classes, input_channel)
if pretrained:
# 加载预训练模型
download(url=model_url, path=pretrianed_ckpt, replace=true)
param_dict = load_checkpoint(pretrianed_ckpt)
load_param_into_net(model, param_dict)
return model
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)
2. 固定特征进行训练
使用固定特征进行训练的时候，需要冻结除最后一层之外的所有网络层。通过设置 requires_grad == false 冻结参数，以便不在反向传播中计算梯度。
import mindspore as ms
import matplotlib.pyplot as plt
import os
import time
net_work = resnet50(pretrained=true)
# 全连接层输入层的大小
in_channels = net_work.fc.in_channels
# 输出通道数大小为狼狗分类数2
head = nn.dense(in_channels, 2)
# 重置全连接层
net_work.fc = head
# 平均池化层kernel size为7
avg_pool = nn.avgpool2d(kernel_size=7)
# 重置平均池化层
net_work.avg_pool = avg_pool
# 冻结除最后一层外的所有参数
for param in net_work.get_parameters():
if param.name not in ["fc.weight", "fc.bias"]:
param.requires_grad = false
# 定义优化器和损失函数
opt = nn.momentum(params=net_work.trainable_params(), learning_rate=lr, momentum=0.5)
loss_fn = nn.softmaxcrossentropywithlogits(sparse=true, reduction='mean')
def forward_fn(inputs, targets):
logits = net_work(inputs)
loss = loss_fn(logits, targets)
return loss
grad_fn = ms.value_and_grad(forward_fn, none, opt.parameters)
def train_step(inputs, targets):
loss, grads = grad_fn(inputs, targets)
opt(grads)
return loss
# 实例化模型
model1 = train.model(net_work, loss_fn, opt, metrics={"accuracy": train.accuracy()})
2.3训练和评估
开始训练模型，与没有预训练模型相比，将节约一大半时间，因为此时可以不用计算部分梯度。保存评估精度最高的ckpt文件于当前路径的./bestcheckpoint/resnet50-best-freezing-param.ckpt。
import mindspore as ms
import matplotlib.pyplot as plt
import os
import time
dataset_train = create_dataset_canidae(data_path_train, "train")
step_size_train = dataset_train.get_dataset_size()
dataset_val = create_dataset_canidae(data_path_val, "val")
step_size_val = dataset_val.get_dataset_size()
num_epochs = 5
# 创建迭代器
data_loader_train = dataset_train.create_tuple_iterator(num_epochs=num_epochs)
data_loader_val = dataset_val.create_tuple_iterator(num_epochs=num_epochs)
best_ckpt_dir = "./bestcheckpoint"
best_ckpt_path = "./bestcheckpoint/resnet50-best-freezing-param.ckpt"
import mindspore as ms
import matplotlib.pyplot as plt
import os
import time
# 开始循环训练
print("start training loop ...")
best_acc = 0
for epoch in range(num_epochs):
losses = []
net_work.set_train()
epoch_start = time.time()
# 为每轮训练读入数据
for i, (images, labels) in enumerate(data_loader_train):
labels = labels.astype(ms.int32)
loss = train_step(images, labels)
losses.append(loss)
# 每个epoch结束后，验证准确率
acc = model1.eval(dataset_val)['accuracy']
epoch_end = time.time()
epoch_seconds = (epoch_end - epoch_start) * 1000
step_seconds = epoch_seconds/step_size_train
print("-" * 20)
print("epoch: [%3d/%3d], average train loss: [%5.3f], accuracy: [%5.3f]" % (
epoch+1, num_epochs, sum(losses)/len(losses), acc
))
print("epoch time: %5.3f ms, per step time: %5.3f ms" % (
epoch_seconds, step_seconds
))
if acc > best_acc:
best_acc = acc
if not os.path.exists(best_ckpt_dir):
os.mkdir(best_ckpt_dir)
ms.save_checkpoint(net_work, best_ckpt_path)
print("=" * 80)
print(f"end of validation the best accuracy is: {best_acc: 5.3f}, "
f"save the best ckpt file in {best_ckpt_path}", flush=true)
2.4 可视化模型预测
使用固定特征得到的best.ckpt文件对对验证集的狼和狗图像数据进行预测。若预测字体为蓝色即为预测正确，若预测字体为红色则预测错误。
import matplotlib.pyplot as plt
import mindspore as ms
def visualize_model(best_ckpt_path, val_ds):
net = resnet50()
# 全连接层输入层的大小
in_channels = net.fc.in_channels
# 输出通道数大小为狼狗分类数2
head = nn.dense(in_channels, 2)
# 重置全连接层
net.fc = head
# 平均池化层kernel size为7
avg_pool = nn.avgpool2d(kernel_size=7)
# 重置平均池化层
net.avg_pool = avg_pool
# 加载模型参数
param_dict = ms.load_checkpoint(best_ckpt_path)
ms.load_param_into_net(net, param_dict)
model = train.model(net)
# 加载验证集的数据进行验证
data = next(val_ds.create_dict_iterator())
images = data["image"].asnumpy()
labels = data["label"].asnumpy()
class_name = {0: "dogs", 1: "wolves"}
# 预测图像类别
output = model.predict(ms.tensor(data['image']))
pred = np.argmax(output.asnumpy(), axis=1)
# 显示图像及图像的预测值
plt.figure(figsize=(5, 5))
for i in range(4):
plt.subplot(2, 2, i + 1)
# 若预测正确，显示为蓝色；若预测错误，显示为红色
color = 'blue' if pred[i] == labels[i] else 'red'
plt.title('predict:{}'.format(class_name[pred[i]]), color=color)
picture_show = np.transpose(images[i], (1, 2, 0))
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
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, dataset_val)
发表评论