ResNet18迁移学习CIFAR10分类任务（附python代码）

我还能再学！

已于 2023-02-07 21:10:53 修改

阅读量1.8k

点赞数 2

文章标签：迁移学习深度学习人工智能

于 2023-02-07 17:39:37 首次发布

本文链接：https://blog.csdn.net/weixin_52200494/article/details/128922335

版权

实验项目名称：ResNet18迁移学习CIFAR10分类任务
实验目的：利用卷积神经网络ResNet18对CIFAR10数据集进行学习与测试，使网络能够完成高准确率的分类任务，最后爬取网页图片进行实际测试。
实验原理：
ResNet网络介绍
深度残差网络（Deep residual network, ResNet）由何恺明等人于2015年首次提出，于2016年获得CVPR best paper。

GoogLeNet，VGG等神经网络随着网络深度不断提升，会出现梯度消失，梯度爆炸以及网络退化等问题。ResNet提出残差结构模块并使用Batch Normalization。

Batch Normalization的目的就是使feature map满足均值为0，方差为1的分布规律。批归一化层位于连接层后，非线性激活函数之前，可以有效解决梯度消失与梯度爆炸的问题。

残差结构使用了shortcut连接方式，人为地让神经网络某些层跳过下一层神经元的连接，隔层相连，弱化每层之间的强联系，其原理图如图3.1.1所示。映射x→H（x）难以学习，通过使H（x）=F(x)+x，F（x）就是输入与输出之间的残差，将学习任务转变为学习映射x→F(x)。

ResNet在上百层都有很好的表现，但是当达到上千层了之后仍然会出现退化现象。
损失函数
交叉熵损失（cross entropy)：用来判定实际的输出与期望的输出的接近程度。其数学计算公式如下，其中概率分布p为期望输出，概率分布q为实际输出。

由于希望输出为one-hot向量，所以计算可简化为：
图像预处理
CIFAR10数据集共10个类别（飞机，小轿车，鸟，猫，鹿，狗，青蛙，马，船，卡车），图片为3*32*32大小，共50000张训练图片以及10000张测试图片。由于ResNet18网络input为3*224*224的图片，故利用torchvision的transforms模块将3*32*32的原图像resize成3*224*224。
实验内容
训练集，验证集，测试集
将CIFAR10数据集的测试样本进行1：1随机划分出验证集与测试集，从而训练集50000张图片，验证集，测试集各5000张图片，训练集：验证集：测试集=10:1:1。
利用50000张训练样本进行首轮训练
超参数设计如下表：

超参

值

epoch

12

batch_size

32

learning rate

0.001

优化

随机梯度下降

Momentum

0.9
loss变化情况
train_acc变化情况

验证集正确率变化情况

验证集正确率可达94.78%。笔者后续进行了调参处理进行进一步优化训练，验证集正确率可达95.7%并无过拟合现象，但验证集准确率高并不意味着模型就更优，故在此不多加赘述。
实验结果
测试集测试模型效果

爬取网图进行识别任务

利用requests爬取狗，猫，鸟三类图片，随机选取部分图片进行测试，基本准确分类出图片类别。列举的三张图分别是狗的侧脸照，猫信息较少图片噪声大的照片以及与鸟特征相对差异较大的鹦鹉照片，得出分类结果均正确，故分类器分类效果泛化能力较强。

Python代码实现

download dataset.py

import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./dataset/train', train=True,download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./dataset/test', train=False,download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

def imshow(img):
    img = img / 2 + 0.5
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()


dataiter = iter(trainloader)
images, labels = dataiter.next()

imshow(torchvision.utils.make_grid(images))
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

train.py

import torch.optim as optim
import torch.nn as nn
import torch
import torchvision.transforms as transforms
import torchvision
import os
import scipy.io as scio
import numpy as np
import time
from torchvision import models

os.environ["CUDA_VISIBLE_DEVICES"] = "0"
transform = transforms.Compose(
    [transforms.RandomResizedCrop(224),
        transforms.ToTensor(),
        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./dataset/train', train=True, download=False, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True, num_workers=2)


net = models.resnet18(pretrained=True)    
inchannel = net.fc.in_features
net.fc = nn.Linear(inchannel, 10)
print(net)
net.cuda()


resume="./ResNet/model/lr_0.001epoch_11_iters_1499.model"
if resume is not None:
    print('Resuming, initializing using weight from {}.'.format(resume))
    net.load_state_dict(torch.load(resume))

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
lr = 0.001

all_loss = []
all_acc = []
all_train_acc = []
print("start training.....")
for epoch in range(12):
    net.train()
    running_loss = 0.0
    train_acc = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        inputs = inputs.cuda()
        labels = labels.cuda()

        optimizer.zero_grad()

        outputs = net(inputs)

        loss = criterion(outputs, labels)

        loss.backward()
        optimizer.step()

        running_loss += loss.item()

        train_acc += (outputs.argmax(1) == labels).sum().item()
        if (i + 1) % 500 == 0:
            print('[%d, %5d] loss: %.5f train_acc: %2f' %
                  (epoch + 1, i + 1, running_loss / 500, train_acc / 500 / 32))
            all_loss.append(running_loss / 500)
            all_train_acc.append(train_acc)
            running_loss = 0.0
            train_acc = 0.0

            # save model
            net.eval()
            net.cpu()
            save_model_dir = "./ResNet/model"
            if os.path.exists(save_model_dir) is False:
                os.mkdir(save_model_dir)
            save_model_filename = "lr_" + str(lr) + "epoch_" + str(epoch) + "_iters_" + str(i) + ".model"
            save_model_path = os.path.join(save_model_dir, save_model_filename)
            torch.save(net.state_dict(), save_model_path)
            # save loss
            all_loss_total = np.array(all_loss)
            save_loss_dir = "./ResNet/loss"
            if os.path.exists(save_loss_dir) is False:
                os.mkdir(save_loss_dir)
            loss_filename_path = "lr_" + str(lr) + "epoch_" + str(epoch) + "_iters_" + str(i) + ".mat"
            save_loss_path = os.path.join(save_loss_dir, loss_filename_path)
            scio.savemat(save_loss_path, {'loss_total': all_loss_total})
            # save train_acc
            all_train_acc_total = np.array(all_train_acc)
            save_train_acc_dir = "./ResNet/train_acc"
            if os.path.exists(save_train_acc_dir) is False:
                os.mkdir(save_train_acc_dir)
            train_acc_filename_path = "lr_" + str(lr) + "epoch_" + str(epoch) + "_iters_" + str(i) + ".mat"
            save_train_acc_path = os.path.join(save_train_acc_dir, train_acc_filename_path)
            scio.savemat(save_train_acc_path, {'train_acc_total': all_train_acc_total})
            net.train()
            net.cuda()
            print("time:{}".format(time.ctime()))

net.eval()
net.cpu()
# save final model
save_model_dir = "./ResNet/model"
save_model_filename = "lr_" + str(lr) + "epochs_" + str(epoch + 1) + "final.model"
save_model_path = os.path.join(save_model_dir, save_model_filename)
torch.save(net.state_dict(), save_model_path)

print('Finished Training')

val.py

import torch
import torchvision
import torch.nn as nn
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
from torchvision import models
import glob
import os
import scipy.io as scio

def imshow(img):
    img = img / 2 + 0.5
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()
transform = transforms.Compose(
    [transforms.Resize(256),
     transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
testset = torchvision.datasets.CIFAR10(root='./dataset/test', train=False,download=False, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,shuffle=False, num_workers=2)

all_acc = []
num = 0
net = models.resnet18()
inchannel = net.fc.in_features
net.fc = nn.Linear(inchannel, 10)
#net.load_state_dict(torch.load("./ResNet/model/lr_0.001epoch_22_iters_499.model"))
path = "./ResNet/model"
for model_path in glob.glob(path+'/*.model'):
    num += 1
    net.load_state_dict(torch.load(model_path))


    correct = 0
    total = 0
    with torch.no_grad():
        for i, data in enumerate(testloader, 0):
            if i < 1250:
                images, labels = data
                images = images.cuda()
                labels = labels.cuda()
                net.eval()
                net = net.cuda()
                outputs = net(images)
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()

    print('Accuracy of the network on the 5000 test images: %d %%' % (
        100 * correct / total))
    # save_acc
    acc = correct / total
    all_acc.append(acc)
    all_acc_total = np.array(all_acc)
    save_acc_dir = "./ResNet/val_acc"
    if os.path.exists(save_acc_dir) is False:
        os.mkdir(save_acc_dir)
    acc_filename_path = "num_" + str(num) + ".mat"
    save_acc_path = os.path.join(save_acc_dir, acc_filename_path)
    scio.savemat(save_acc_path, {'val_acc_total': all_acc_total})

visualization.py

import scipy.io as scio
import matplotlib.pyplot as plt
loss_path = ".\loss\lr_0.0001epoch_11_iters_1499.mat"
data = scio.loadmat(loss_path)
loss_data = data["loss_total"]
x = range(len(loss_data[0]))
y = loss_data[0]
plt.ylabel('loss')
plt.xlabel('times')
plt.plot(x, y, '.-')
plt.grid()

如有错误的地方，还请指正！有疑惑的同学可以在评论区留言，无论能否解决，笔者看到一定回复。