动手学深度学习（Pytorch版）代码实践 -计算机视觉-37微调

37微调

在这里插入图片描述

import os
import torch
import torchvision
from torch import nn
import liliPytorch as lp
import matplotlib.pyplot as plt
from d2l import torch as d2l

# 获取数据集
d2l.DATA_HUB['hotdog'] = (d2l.DATA_URL + 'hotdog.zip',
                         'fba480ffa8aa7e0febbb511d181409f899b9baa5')

data_dir = d2l.download_extract('hotdog')
#Downloading ../data\hotdog.zip from http://d2l-data.s3-accelerate.amazonaws.com/hotdog.zip...

# 分别读取训练和测试数据集中的所有图像文件
train_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'train'))
test_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'test'))
# ImageFolder 会递归地读取指定目录下的所有图像文件。
# print(train_imgs.classes)#一个类名列表 # ['hotdog', 'not-hotdog']
# print(train_imgs.class_to_idx) # 一个字典，类名映射到类索引 # {'hotdog': 0, 'not-hotdog': 1}
# print(train_imgs.imgs) # 一个包含所有图像路径和对应类索引的列表
# 例如：[('../data\\hotdog\\train\\hotdog\\0.png', 0), ('../data\\hotdog\\train\\hotdog\\1.png', 0)
#       , ('../data\\hotdog\\train\\not-hotdog\\999.png', 1)]
# 显示了前8个正类样本图片和最后8张负类样本图片

# hotdogs = [train_imgs[i][0] for i in range(8)] #train_imgs[i] 返回一个元组 (image, label)，
# # 其中 image 是图像张量，label 是对应的标签。[0] 只提取图像张量。

# not_hotdogs = [train_imgs[-i - 1][0] for i in range(8)] # 索引从 -1 到 -8

# d2l.show_images(hotdogs + not_hotdogs, 2, 8, scale=1.4)
# plt.show() # 显示图片

# 使用RGB通道的均值和标准差，以标准化每个通道
normalize = torchvision.transforms.Normalize(
    [0.485, 0.456, 0.406], [0.229, 0.224, 0.225])

train_augs = torchvision.transforms.Compose([
    #从图像中裁切随机大小和随机长宽比的区域，然后将该区域缩放为224 * 224
    torchvision.transforms.RandomResizedCrop(224),
    torchvision.transforms.RandomHorizontalFlip(),
    torchvision.transforms.ToTensor(),
    normalize])

test_augs = torchvision.transforms.Compose([
    torchvision.transforms.Resize([256, 256]),
    torchvision.transforms.CenterCrop(224), # 裁剪中央224 * 224
    torchvision.transforms.ToTensor(),
    normalize])

# 定义和初始化模型
# 使用在ImageNet数据集上预训练的ResNet-18作为源模型
pretrained_net = torchvision.models.resnet18(pretrained=True)

# 源模型实例包含许多特征层和一个输出层fc
print(pretrained_net.fc)
# Linear(in_features=512, out_features=1000, bias=True)

finetune_net = pretrained_net
# 改变输出层fc
finetune_net.fc = nn.Linear(finetune_net.fc.in_features, 2)
# 参数初始化
nn.init.xavier_uniform_(finetune_net.fc.weight)


def train_batch_ch13(net, X, y, loss, trainer, devices):
    """使用多GPU训练一个小批量数据。
    参数：
    net: 神经网络模型。
    X: 输入数据，张量或张量列表。
    y: 标签数据。
    loss: 损失函数。
    trainer: 优化器。
    devices: GPU设备列表。
    返回：
    train_loss_sum: 当前批次的训练损失和。
    train_acc_sum: 当前批次的训练准确度和。
    """
    # 如果输入数据X是列表类型
    if isinstance(X, list):
        # 将列表中的每个张量移动到第一个GPU设备
        X = [x.to(devices[0]) for x in X]
    else:
        X = X.to(devices[0])# 如果X不是列表，直接将X移动到第一个GPU设备
    y = y.to(devices[0])# 将标签数据y移动到第一个GPU设备
    net.train() # 设置网络为训练模式
    trainer.zero_grad()# 梯度清零
    pred = net(X) # 前向传播，计算预测值
    l = loss(pred, y) # 计算损失
    l.sum().backward()# 反向传播，计算梯度
    trainer.step() # 更新模型参数
    train_loss_sum = l.sum()# 计算当前批次的总损失
    train_acc_sum = d2l.accuracy(pred, y)# 计算当前批次的总准确度
    return train_loss_sum, train_acc_sum# 返回训练损失和与准确度和


def train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs,
               devices=d2l.try_all_gpus()):
    """训练模型在多GPU
    参数：
    net: 神经网络模型。
    train_iter: 训练数据集的迭代器。
    test_iter: 测试数据集的迭代器。
    loss: 损失函数。
    trainer: 优化器。
    num_epochs: 训练的轮数。
    devices: GPU设备列表，默认使用所有可用的GPU。
    """
    # 初始化计时器和训练批次数
    timer, num_batches = d2l.Timer(), len(train_iter)
    # 初始化动画器，用于实时绘制训练和测试指标
    animator = lp.Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0, 1],
                           legend=['train loss', 'train acc', 'test acc'])
    # 将模型封装成 DataParallel 模式以支持多GPU训练，并将其移动到第一个GPU设备
    net = nn.DataParallel(net, device_ids=devices).to(devices[0])
    # 训练循环，遍历每个epoch
    for epoch in range(num_epochs):
        # 初始化指标累加器，metric[0]表示总损失，metric[1]表示总准确度，
        # metric[2]表示样本数量，metric[3]表示标签数量
        metric = lp.Accumulator(4)
        # 遍历训练数据集
        for i, (features, labels) in enumerate(train_iter):
            timer.start()  # 开始计时
            # 训练一个小批量数据，并获取损失和准确度
            l, acc = train_batch_ch13(net, features, labels, loss, trainer, devices)
            metric.add(l, acc, labels.shape[0], labels.numel())   # 更新指标累加器
            timer.stop()  # 停止计时
            # 每训练完五分之一的批次或者是最后一个批次时，更新动画器
            if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
                animator.add(epoch + (i + 1) / num_batches,
                             (metric[0] / metric[2], metric[1] / metric[3], None))
        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter) # 在测试数据集上评估模型准确度
        animator.add(epoch + 1, (None, None, test_acc))# 更新动画器
    # 打印最终的训练损失、训练准确度和测试准确度
    print(f'loss {metric[0] / metric[2]:.3f}, train acc '
          f'{metric[1] / metric[3]:.3f}, test acc {test_acc:.3f}')
    # 打印每秒处理的样本数和使用的GPU设备信息
    print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec on '
          f'{str(devices)}')


def train_fine_tuning(net, learning_rate, batch_size=128, num_epochs=5,param_group=True):
    """
    参数：
    net: 神经网络模型。
    learning_rate: 学习率。
    batch_size: 每个小批量的大小，默认为128。
    num_epochs: 训练的轮数，默认为5。
    param_group: 是否对不同层使用不同的学习率，默认为True。
    """
    train_iter = torch.utils.data.DataLoader(torchvision.datasets.ImageFolder(
        os.path.join(data_dir, 'train'), transform=train_augs),
        batch_size=batch_size, shuffle=True)  # 创建训练数据集的迭代器
    
    test_iter = torch.utils.data.DataLoader(torchvision.datasets.ImageFolder(
        os.path.join(data_dir, 'test'), transform=test_augs),
        batch_size=batch_size)  # 创建测试数据集的迭代器

    devices = d2l.try_all_gpus()  # 获取所有可用的GPU设备
    loss = nn.CrossEntropyLoss(reduction="none")   # 定义损失函数
    # 如果使用参数组
    if param_group:
        # 获取除最后全连接层外的所有参数
        # 列表params_1x，包含除最后一层全连接层外的所有参数。
        params_1x = [param for name, param in net.named_parameters()
                     if name not in ["fc.weight", "fc.bias"]]
        # 定义优化器，分别为不同的参数组设置不同的学习率
        trainer = torch.optim.SGD([{'params': params_1x},
                                   {'params': net.fc.parameters(),
                                    'lr': learning_rate * 10}],
                                  lr=learning_rate, weight_decay=0.001)
    else:
        # 如果不使用参数组，为所有参数设置相同的学习率
        trainer = torch.optim.SGD(net.parameters(), lr=learning_rate,
                                  weight_decay=0.001)
    # 调用训练函数，开始训练
    train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs, devices)
    
train_fine_tuning(finetune_net, 5e-5)
# loss 0.211, train acc 0.927, test acc 0.938
# 456.7 examples/sec on [device(type='cuda', index=0)]


"""
为了进行比较，我们定义了一个相同的模型，但是将其所有模型参数初始化为随机值。
由于整个模型需要从头开始训练，因此我们需要使用更大的学习率。
"""
scratch_net = torchvision.models.resnet18()
scratch_net.fc = nn.Linear(scratch_net.fc.in_features, 2)
train_fine_tuning(scratch_net, 5e-4, param_group=False)
# loss 0.338, train acc 0.842, test acc 0.859
# 457.7 examples/sec on [device(type='cuda', index=0)]

plt.show() #显示图片