PyTorch教程-14.2. 微调

在前面的章节中，我们讨论了如何在只有 60000 张图像的 Fashion-MNIST 训练数据集上训练模型。我们还描述了 ImageNet，这是学术界使用最广泛的大规模图像数据集，它有超过 1000 万张图像和 1000 个对象。然而，我们通常遇到的数据集的大小介于这两个数据集之间。

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

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

另一种解决方案是应用迁移学习，将从源数据集中学到的知识迁移到目标数据集中。例如，尽管 ImageNet 数据集中的大部分图像与椅子无关，但在此数据集上训练的模型可能会提取出更一般的图像特征，这有助于识别边缘、纹理、形状和物体组成。这些相似的特征也可能对识别椅子有效。

14.2.1。脚步

在本节中，我们将介绍迁移学习中的一种常用技术：微调。如图 14.2.1所示，微调包括以下四个步骤：

在源数据集（例如，ImageNet 数据集）上预训练神经网络模型，即源模型。

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

向目标模型添加一个输出层，其输出数量为目标数据集中的类别数量。然后随机初始化该层的模型参数。

在目标数据集（例如椅子数据集）上训练目标模型。输出层将从头开始训练，而所有其他层的参数将根据源模型的参数进行微调。

图 14.2.1微调。

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

14.2.2。热狗识别

让我们通过一个具体案例来演示微调：热狗识别。我们将在一个小型数据集上微调 ResNet 模型，该数据集是在 ImageNet 数据集上预训练的。这个小数据集包含数千张有热狗和没有热狗的图像。我们将使用微调模型从图像中识别热狗。

%matplotlib inline
import os
import torch
import torchvision
from torch import nn
from d2l import torch as d2l

%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()

14.2.2.1。读取数据集

我们使用的热狗数据集取自在线图像。该数据集包含 1400 张包含热狗的正类图像，以及包含其他食物的大量负类图像。两个类别的 1000 张图像用于训练，其余用于测试。

解压下载的数据集后，我们得到两个文件夹 hotdog/train和hotdog/test. 这两个文件夹都有hotdog和 not-hotdog子文件夹，其中任何一个都包含相应类别的图像。

#@save
d2l.DATA_HUB['hotdog'] = (d2l.DATA_URL + 'hotdog.zip',
             'fba480ffa8aa7e0febbb511d181409f899b9baa5')

data_dir = d2l.download_extract('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...

我们创建两个实例来分别读取训练和测试数据集中的所有图像文件。

train_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'train'))
test_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'test'))

train_imgs = gluon.data.vision.ImageFolderDataset(
  os.path.join(data_dir, 'train'))
test_imgs = gluon.data.vision.ImageFolderDataset(
  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);

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);

在训练过程中，我们首先从图像中裁剪出一个随机大小和随机纵横比的随机区域，然后将这个区域缩放到 224×224输入图像。在测试过程中，我们将图像的高度和宽度都缩放到 256 像素，然后裁剪一个中心 224×224区域作为输入。此外，对于三个 RGB（红色、绿色和蓝色）颜色通道，我们逐通道标准化它们的值。具体来说，就是用该通道的每个值减去该通道的平均值，然后除以该通道的标准差。

# Specify the means and standard deviations of the three RGB channels to
# standardize each channel
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, 256]),
  torchvision.transforms.CenterCrop(224),
  torchvision.transforms.ToTensor(),
  normalize])

# Specify the means and standard deviations of the three RGB channels to
# standardize each channel
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])

14.2.2.2。定义和初始化模型

我们使用在 ImageNet 数据集上预训练的 ResNet-18 作为源模型。在这里，我们指定pretrained=True自动下载预训练模型参数。如果是第一次使用这个模型，需要连接互联网才能下载。

pretrained_net = torchvision.models.resnet18(pretrained=True)

预训练源模型实例包含多个特征层和一个输出层fc。这种划分的主要目的是为了便于微调除输出层之外的所有层的模型参数。fc下面给出源模型的成员变量。

pretrained_net.fc

Linear(in_features=512, out_features=1000, bias=True)

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

The pretrained source model instance contains two member variables: features and output. The former contains all layers of the model except the output layer, and the latter is the output layer of the model. The main purpose of this division is to facilitate the fine-tuning of model parameters of all layers but the output layer. The member variable output of source model is shown below.

pretrained_net.output

Dense(512 -> 1000, linear)

作为全连接层，它将 ResNet 最终的全局平均池化输出转化为 ImageNet 数据集的 1000 类输出。然后我们构建一个新的神经网络作为目标模型。它的定义方式与预训练源模型相同，不同之处在于它在最后一层的输出数量设置为目标数据集中的类数（而不是 1000）。

在下面的代码中，目标模型实例的输出层之前的模型参数finetune_net被初始化为源模型中相应层的模型参数。由于这些模型参数是通过在 ImageNet 上进行预训练获得的，因此它们是有效的。因此，我们只能使用较小的学习率来 微调此类预训练参数。相比之下，输出层中的模型参数是随机初始化的，通常需要更大的学习率才能从头开始学习。让基础学习率成为η, 学习率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);

finetune_net = gluon.model_zoo.vision.resnet18_v2(classes=2)
finetune_net.features = pretrained_net.features
finetune_net.output.initialize(init.Xavier())
# The model parameters in the output layer will be iterated using a learning
# rate ten times greater
finetune_net.output.collect_params().setattr('lr_mult', 10)

14.2.2.3。微调模型

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

# If `param_group=True`, the model parameters in the output layer will be
# updated using a learning rate ten times greater
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)

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)

我们将基础学习率设置为一个较小的值，以便微调 通过预训练获得的模型参数。基于前面的设置，我们将使用十倍大的学习率从头开始训练目标模型的输出层参数。

train_fine_tuning(finetune_net, 5e-5)

loss 0.201, train acc 0.930, test acc 0.948
888.0 examples/sec on [device(type='cuda', index=0), device(type='cuda', index=1)]

train_fine_tuning(finetune_net, 0.01)

loss 0.190, train acc 0.931, test acc 0.946
19.3 examples/sec on [gpu(0), gpu(1)]

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

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.382, train acc 0.832, test acc 0.833
1571.7 examples/sec on [device(type='cuda', index=0), device(type='cuda', index=1)]

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.383, train acc 0.833, test acc 0.836
21.0 examples/sec on [gpu(0), gpu(1)]

正如我们所看到的，微调模型在同一时期往往表现更好，因为它的初始参数值更有效。

14.2.3。概括

迁移学习将从源数据集学到的知识迁移到目标数据集。微调是迁移学习的常用技术。

目标模型从源模型中复制所有模型设计及其参数（输出层除外），并根据目标数据集微调这些参数。相比之下，目标模型的输出层需要从头开始训练。

一般微调参数使用较小的学习率，而从头训练输出层可以使用较大的学习率。

14.2.4。练习

不断提高 的学习率finetune_net。模型的准确性如何变化？

在对比实验中进一步调整 和 的超参数finetune_net。 scratch_net它们的准确性仍然不同吗？

将输出层之前的参数设置finetune_net为源模型的参数，并且在训练期间不更新它们。模型的准确性如何变化？您可以使用以下代码。

事实上，ImageNet数据集中有一个“热狗”类。其在输出层对应的权重参数可以通过以下代码获取。我们如何利用这个权重参数？