13.2. 微调
Open the notebook in Colab
Open the notebook in Colab
Open the notebook in Colab

在前面的一些章节中,我们介绍了如何在只有6万张图像的Fashion-MNIST训练数据集上训练模型。 我们还描述了学术界当下使用最广泛的大规模图像数据集ImageNet,它有超过1,000万的图像和1,000类的物体。 然而,我们平常接触到的数据集的规模通常在这两者之间。

假设我们想识别图片中不同类型的椅子,然后向用户推荐购买链接。 一种可能的方法是首先识别 100 把普通椅子,为每把椅子拍摄 1000 张不同角度的图像,然后在收集的影像数据集上训练一个分类模型。 尽管这个椅子数据集可能大于 Fashion-MNIST 数据集,但实例数量仍然不到 ImageNet 中的十分之一。 这可能会导致这个椅子数据集上适合 ImageNet 的复杂模型过度拟合。 此外,由于训练示例数量有限,训练模型的准确性可能无法满足实际要求。

为了解决上述问题,一个显而易见的解决方案是收集更多的数据。 但是,收集和标记数据可能需要大量的时间和金钱。 例如,为了收集 ImageNet 数据集,研究人员从研究资金中花费了数百万美元。 尽管目前的数据收集成本已大幅降低,但这一成本仍不能忽视。

另一种解决方案是应用 迁移学习(transfer learning) 将从 源数据集 学到的知识迁移到 目标数据集。 例如,尽管 ImageNet 数据集中的大多数图像与椅子无关,但在此数据集上训练的模型可能会提取更常规的图像特征,这有助于识别边缘、纹理、形状和对象合成。 这些类似的功能也可能有效地识别椅子。

13.2.1. 步骤

在本节中,我们将介绍迁移学习中的常见技巧 : 微调(fine-tuning)。如 图13.2.1 所示,微调包括以下四个步骤:

  1. 在源数据集(例如 ImageNet 数据集)上预训练神经网络模型,即 源模型

  2. 创建一个新的神经网络模型,即 目标模型。这将复制源模型上的所有模型设计及其参数,但输出层除外。我们假定这些模型参数包含从源数据集中学到的知识,这些知识也将适用于目标数据集。我们还假设源模型的输出图层与源数据集的标签密切相关;因此不在目标模型中使用该图层。

  3. 向目标模型添加输出图层,其输出数量是目标数据集中的类别数。然后随机初始化该层的模型参数。

  4. 在目标数据集(如椅子数据集)上训练目标模型。输出图层将从头开始进行训练,而所有其他图层的参数将根据源模型的参数进行微调。

../_images/finetune.svg

图13.2.1 微调。

当目标数据集比源数据集小得多时,微调有助于提高模型的泛化能力。

13.2.2. 热狗识别

让我们通过具体案例演示微调:热狗识别。 我们将在一个小型数据集上微调 ResNet 模型,该数据集已在 ImageNet 数据集上进行了预训练。 这个小型数据集包含数千张包含热狗和不包含热狗的图像,我们将使用微调模型来识别图像中是否包含热狗。

%matplotlib inline
import os
from mxnet import gluon, init, np, npx
from mxnet.gluon import nn
from d2l import mxnet as d2l

npx.set_np()
%matplotlib inline
import os
import torch
import torchvision
from torch import nn
from d2l import torch as d2l

13.2.2.1. 获取数据集

我们使用的热狗数据集来源于网络。该数据集包含 1400 张包含热狗的正面类图像以及包含其他食物的尽可能多的负面级图像。两个课程的 1000 张图片用于训练,其余的则用于测试。

解压下载的数据集后,我们获得了两个文件夹 hotdog/trainhotdog/test。这两个文件夹都有 hotdognot-hotdog 个子文件夹,其中任何一个文件夹都包含相应类的图像。

#@save
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...
#@save
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 = gluon.data.vision.ImageFolderDataset(
    os.path.join(data_dir, 'train'))
test_imgs = gluon.data.vision.ImageFolderDataset(
    os.path.join(data_dir, 'test'))
train_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'train'))
test_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'test'))

下面显示了前 8 个正面示例和最后 8 张负面图片。 正如你所看到的,图像的大小和纵横比各有不同。

hotdogs = [train_imgs[i][0] for i in range(8)]
not_hotdogs = [train_imgs[-i - 1][0] for i in range(8)]
d2l.show_images(hotdogs + not_hotdogs, 2, 8, scale=1.4);
../_images/output_fine-tuning_368659_30_0.png
hotdogs = [train_imgs[i][0] for i in range(8)]
not_hotdogs = [train_imgs[-i - 1][0] for i in range(8)]
d2l.show_images(hotdogs + not_hotdogs, 2, 8, scale=1.4);
../_images/output_fine-tuning_368659_33_0.png

在训练期间,我们首先从图像中裁切随机大小和随机长宽比的区域,然后将该区域缩放为 \(224 \times 224\) 输入图像。 在测试过程中,我们将图像的高度和宽度都缩放到 256 像素,然后裁剪中央 \(224 \times 224\) 区域作为输入。 此外,对于三个 RGB(红、绿和蓝)颜色通道,我们 标准化 每个通道。 具体而言,通道的平均值将从该通道的每个值中减去,然后将结果除以该通道的标准差。

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

train_augs = gluon.data.vision.transforms.Compose([
    gluon.data.vision.transforms.RandomResizedCrop(224),
    gluon.data.vision.transforms.RandomFlipLeftRight(),
    gluon.data.vision.transforms.ToTensor(), normalize])

test_augs = gluon.data.vision.transforms.Compose([
    gluon.data.vision.transforms.Resize(256),
    gluon.data.vision.transforms.CenterCrop(224),
    gluon.data.vision.transforms.ToTensor(), normalize])
# 使用三个RGB通道的均值和标准偏差,以标准化每个通道
normalize = torchvision.transforms.Normalize([0.485, 0.456, 0.406],
                                             [0.229, 0.224, 0.225])

train_augs = torchvision.transforms.Compose([
    torchvision.transforms.RandomResizedCrop(224),
    torchvision.transforms.RandomHorizontalFlip(),
    torchvision.transforms.ToTensor(), normalize])

test_augs = torchvision.transforms.Compose([
    torchvision.transforms.Resize(256),
    torchvision.transforms.CenterCrop(224),
    torchvision.transforms.ToTensor(), normalize])

13.2.2.2. 定义和初始化模型

我们使用在 ImageNet 数据集上预训练的 Resnet-18 作为源模型。 在这里,我们指定 pretrained=True 以自动下载预训练的模型参数。 如果你首次使用此模型,则需要互联网连接才能下载。

pretrained_net = gluon.model_zoo.vision.resnet18_v2(pretrained=True)

预训练的源模型实例包含两个变量:featuresoutput。 前者包含除输出层以外的模型的所有层,后者是模型的输出层。 此划分的主要目的是促进对除输出层以外所有层的模型参数进行微调。 源模型的变量 output 如下所示。

pretrained_net.output
Dense(512 -> 1000, linear)
pretrained_net = torchvision.models.resnet18(pretrained=True)

预训练的源模型实例包含许多要素图层和一个输出图层 fc。 此划分的主要目的是促进对除输出层以外所有层的模型参数进行微调。 下面给出了源模型的变量 fc

pretrained_net.fc
Linear(in_features=512, out_features=1000, bias=True)

在 ResNet 的全局平均池化后,完全连接的层汇集转换为 ImageNet 数据集的 1000 个类输出。 之后,我们构建一个新的神经网络作为目标模型。 它的定义方式与预训练源模型的定义方式相同,只是最终图层中的输出数量被设置为目标数据集中的类数(而不是1000个)。

在下面的代码中,目标模型实例 finetune_net 的变量特征中的模型参数被初始化为源模型相应层的模型参数。 由于功能中的模型参数是在 ImageNet 数据集上预训练的,并且足够好,因此通常只需要较小的学习率即可微调这些参数。

变量输出中的模型参数是随机初始化的,通常需要更高的学习率才能从头开始训练。 假设 Trainer 实例中的学习率为,我们将迭代中变量输出中模型参数的学习率设置为 10。

在下面的代码中,初始化目标模型实例 finetune_net 输出层之前的模型参数,以对源模型中相应层的参数进行建模。 由于这些模型参数是通过 ImageNet 上的预训练获得的,因此它们很有效, 所以我们只需使用较小的学习率进行 微调 这样的预训练参数。 相比之下,输出层中的模型参数是随机初始化的,通常需要更高的学习率,从头开始学习。 这里,我们设基本学习率为 \(\eta\),迭代输出层学习率为 \(10\eta\)

finetune_net = gluon.model_zoo.vision.resnet18_v2(classes=2)
finetune_net.features = pretrained_net.features
finetune_net.output.initialize(init.Xavier())
# 输出层中的学习率比其他层的学习率大十倍
finetune_net.output.collect_params().setattr('lr_mult', 10)
finetune_net = torchvision.models.resnet18(pretrained=True)
finetune_net.fc = nn.Linear(finetune_net.fc.in_features, 2)
nn.init.xavier_uniform_(finetune_net.fc.weight);

13.2.2.3. 微调模型

首先,我们定义了一个训练函数 train_fine_tuning,该函数使用微调,因此可以多次调用。

def train_fine_tuning(net, learning_rate, batch_size=128, num_epochs=5):
    train_iter = gluon.data.DataLoader(train_imgs.transform_first(train_augs),
                                       batch_size, shuffle=True)
    test_iter = gluon.data.DataLoader(test_imgs.transform_first(test_augs),
                                      batch_size)
    devices = d2l.try_all_gpus()
    net.collect_params().reset_ctx(devices)
    net.hybridize()
    loss = gluon.loss.SoftmaxCrossEntropyLoss()
    trainer = gluon.Trainer(net.collect_params(), 'sgd', {
        'learning_rate': learning_rate,
        'wd': 0.001})
    d2l.train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs,
                   devices)
# 如果 `param_group=True`,输出层中的模型参数将使用十倍的学习率
def train_fine_tuning(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()
    loss = nn.CrossEntropyLoss(reduction="none")
    if param_group:
        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)
    d2l.train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs,
                   devices)

我们使用较小的学习率,通过微调预训练获得的模型参数。

train_fine_tuning(finetune_net, 0.01)
loss 0.302, train acc 0.910, test acc 0.929
365.8 examples/sec on [gpu(0), gpu(1)]
../_images/output_fine-tuning_368659_79_1.svg
train_fine_tuning(finetune_net, 5e-5)
loss 0.196, train acc 0.931, test acc 0.931
834.0 examples/sec on [device(type='cuda', index=0), device(type='cuda', index=1)]
../_images/output_fine-tuning_368659_82_1.svg

为了进行比较,我们定义了一个相同的模型,但是将其所有模型参数初始化为随机值。 由于整个模型需要从头开始训练,因此我们需要使用更大的学习率。

scratch_net = gluon.model_zoo.vision.resnet18_v2(classes=2)
scratch_net.initialize(init=init.Xavier())
train_fine_tuning(scratch_net, 0.1)
loss 0.372, train acc 0.840, test acc 0.861
471.7 examples/sec on [gpu(0), gpu(1)]
../_images/output_fine-tuning_368659_88_1.svg
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.377, train acc 0.835, test acc 0.825
1578.8 examples/sec on [device(type='cuda', index=0), device(type='cuda', index=1)]
../_images/output_fine-tuning_368659_91_1.svg

意料之中,微调模型往往表现更好,因为它的初始参数值更有效。

13.2.3. 小结

  • 迁移学习将从源数据集中学到的知识“迁移”到目标数据集,微调是迁移学习的常见技巧。

  • 除输出层外,目标模型从源模型中复制所有模型设计及其参数,并根据目标数据集对这些参数进行微调。但是,目标模型的输出层需要从头开始训练。

  • 通常,微调参数使用较小的学习率,而从头开始训练输出层可以使用更大的学习率。

13.2.4. 练习

  1. 继续提高 finetune_net 的学习率,模型的准确性如何变化?

  2. 在比较实验中进一步调整 finetune_netscratch_net 的超参数。它们的准确性还有不同吗?

  3. 将输出层 finetune_net 之前的参数设置为源模型的参数,在训练期间不要更新它们。模型的准确性如何变化?你可以使用以下代码。

finetune_net.features.collect_params().setattr('grad_req', 'null')
for param in finetune_net.parameters():
    param.requires_grad = False
  1. 事实上,ImageNet 数据集中有一个 “热狗” 类。我们可以通过以下代码获取其输出层中的相应权重参数,但是我们怎样才能利用这个权重参数?

weight = pretrained_net.output.weight
hotdog_w = np.split(weight.data(), 1000, axis=0)[713]
hotdog_w.shape
(1, 512)

Discussions

weight = pretrained_net.fc.weight
hotdog_w = torch.split(weight.data, 1, dim=0)[713]
hotdog_w.shape
torch.Size([1, 512])

Discussions