微调(fine-tuning)

奉系坤阀

已于 2024-01-21 20:34:11 修改

阅读量969

点赞数

分类专栏： DeepLearning 文章标签：人工智能深度学习机器学习迁移学习微调 fine-tuning 数据增广

于 2024-01-21 20:26:38 首次发布

本文链接：https://blog.csdn.net/m0_56312629/article/details/135721254

版权

DeepLearning 专栏收录该内容

37 篇文章 5 订阅

订阅专栏

一、微调

1、为什么需要微调

Fashion-MNIST有6万张图像，学术界当下使用最广泛的大规模图像数据集ImageNet有超过1000万的图像和1000类的物体。然而，我们平常接触到的数据集的规模通常在这两者之间。

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

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

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

其实总结一下就是：我们想将复杂模型用在数量较少的简单数据上面，因为复杂的模型可能有助于提取更多的特征，但是如果直接使用复杂模型在简单数据集上进行训练的话，很有可能导致过拟合，因此我们使用在复杂数据集上训练过的权重在简单数据集上再次训练（微调）。

2、微调的步骤

微调（fine-tuning）是迁移学习的常见步骤，微调包括以下四个步骤。

在源数据集（例如ImageNet数据集）上预训练神经网络模型，即源模型。
创建一个新的神经网络模型，即目标模型。这将复制源模型上的所有模型设计及其参数（输出层除外）。我们假定这些模型参数包含从源数据集中学到的知识，这些知识也将适用于目标数据集。我们还假设源模型的输出层与源数据集的标签密切相关；因此不在目标模型中使用该层。
向目标模型添加输出层，其输出数是目标数据集中的类别数。然后随机初始化该层的模型参数。
在目标数据集（如椅子数据集）上训练目标模型。输出层将从头开始进行训练，而所有其他层的参数将根据源模型的参数进行微调。

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

二、代码实现

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

import os
import torch
import torchvision
from torch import nn
from d2l import torch as d2l

1、获取数据集

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

解压下载的数据集，我们获得了两个文件夹`hotdog/train`和`hotdog/test`。这两个文件夹都有`hotdog`（有热狗）和`not-hotdog`（无热狗）两个子文件夹，子文件夹内都包含相应类的图像。

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

data_dir = d2l.download_extract('hotdog')
print(data_dir)

..\data\hotdog

2、读取图像

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

print(os.path.join(data_dir, 'train'))
train_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'train'))
test_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'test'))
print(train_imgs[0])
print(train_imgs[999])
print(train_imgs[1000])
print(train_imgs[1999])
print(train_imgs.classes)
print(train_imgs.class_to_idx)

..\data\hotdog\train
(<PIL.Image.Image image mode=RGB size=122x144 at 0x217A3E10C70>, 0)
(<PIL.Image.Image image mode=RGB size=180x268 at 0x217A3E107F0>, 0)
(<PIL.Image.Image image mode=RGB size=133x183 at 0x217A3E10C10>, 1)
(<PIL.Image.Image image mode=RGB size=91x141 at 0x217A3E10AF0>, 1)
['hotdog', 'not-hotdog']
{'hotdog': 0, 'not-hotdog': 1}

torchvision.datasets.ImageFolder()

       torchvision.datasets.ImageFolder是PyTorch中用于加载图像数据集的类，它假定图像数据按照类别分组存储在文件夹中。

       ImageFolder类提供了一种方便的方式来加载和处理这种按类别组织的图像数据集。它会自动将每个类别的图像分配一个标签，并提供了对图像数据进行预处理和转换的选项。

       使用ImageFolder类加载图像数据集通常需要两个参数：

root：数据集的根目录，包含按类别分组的子文件夹。
transform（可选）：对图像数据进行预处理和转换的操作。

       ImageFolder类会自动根据子文件夹的名称为每个类别分配一个标签，并提供了方便的接口来访问图像数据和标签信息。可以通过dataset.classes属性获取所有类别的名称，通过dataset.class_to_idx属性获取类别与标签的对应关系。

下面显示了前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)

array([<AxesSubplot:>, <AxesSubplot:>, <AxesSubplot:>, <AxesSubplot:>,
       <AxesSubplot:>, <AxesSubplot:>, <AxesSubplot:>, <AxesSubplot:>,
       <AxesSubplot:>, <AxesSubplot:>, <AxesSubplot:>, <AxesSubplot:>,
       <AxesSubplot:>, <AxesSubplot:>, <AxesSubplot:>, <AxesSubplot:>],
      dtype=object)

3、数据增广

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

# 使用RGB通道的均值和标准差，以标准化每个通道
normalize = torchvision.transforms.Normalize(
    [0.485, 0.456, 0.406], [0.229, 0.224, 0.225])   # [0.485, 0.456, 0.406]和[0.229, 0.224, 0.225]是在ImageNet数据集上计算得出的均值和标准差

train_augs = torchvision.transforms.Compose([
    torchvision.transforms.RandomResizedCrop(224),  # 随机裁剪（随机大小和长宽比），然后缩放到224×224
    torchvision.transforms.RandomHorizontalFlip(),  # 随机上下翻转
    torchvision.transforms.ToTensor(),
    normalize])

test_augs = torchvision.transforms.Compose([
    torchvision.transforms.Resize([256, 256]),      # 将图像的宽和高缩放到256×256
    torchvision.transforms.CenterCrop(224),         # 裁剪图像中央224×224区域
    torchvision.transforms.ToTensor(),
    normalize])

torchvision.transforms.Normalize()

       在图像处理中，归一化（Normalization）是一种常见的预处理步骤，用于将图像数据缩放到一个合适的范围，以便更好地适应深度学习模型的训练。一种常见的归一化方法是将图像的每个像素值减去均值，然后除以标准差。

       在PyTorch中，torchvision.transforms.Normalize用于执行这种归一化操作，它需要两个参数：

mean：一个包含三个元素的列表或元组，表示图像在每个通道上的均值。
std：一个包含三个元素的列表或元组，表示图像在每个通道上的标准差。

       对于数据[0.485, 0.456, 0.406]和[0.229, 0.224, 0.225]，它们是在ImageNet数据集上计算得出的经验值。ImageNet是一个大规模的图像分类数据集，包含超过100万张图像和1000个类别。这些值是通过对ImageNet数据集中所有图像的像素值进行计算得出的。

       通过将图像数据集归一化到这些均值和标准差，可以使输入的图像数据分布接近于标准正态分布，有助于提高模型的训练效果和收敛速度。

       需要注意的是，使用torchvision.transforms.Normalize进行归一化时，通常需要先将图像数据从整数范围（例如[0, 255]）转换为浮点数范围（例如[0.0, 1.0]），然后再应用归一化操作。

torchvision.transforms.Resize()

       torchvision.transforms.Resize是PyTorch中的一个数据转换函数，用于调整图像的大小。

       该函数可以将输入的图像调整为指定的大小。它通常用于数据预处理或数据增强的过程中，以适应模型的输入要求或统一数据集中图像的尺寸。

       Resize函数的主要参数包括：

size：一个整数或元组，指定调整后的图像大小。如果是一个整数，则调整后的图像将是一个正方形，边长为该整数。如果是一个元组，可以指定图像的宽度和高度。
interpolation：插值方法的名称，用于调整图像的大小。默认为PIL.Image.BILINEAR。

torchvision.transforms.RandomResizedCrop()

       torchvision.transforms.RandomResizedCrop是PyTorch中的一个数据转换函数，它用于随机裁剪和调整图像的大小。

       该函数可以在图像上进行随机裁剪，并将裁剪后的图像调整为指定的大小。它通常用于数据增强（data augmentation）的过程中，以增加训练数据的多样性，提高模型的泛化能力。

       RandomResizedCrop函数的主要参数包括：

size：一个整数或元组，指定裁剪后的图像大小。如果是一个整数，则裁剪后的图像将是一个正方形，边长为该整数。如果是一个元组，可以指定图像的宽度和高度。
scale：一个范围在(0, 1]之间的浮点数或元组。指定随机裁剪的尺度范围。如果是一个浮点数，则裁剪尺度的范围为[0.08, 1.0]乘以给定的浮点数。如果是一个元组，则裁剪尺度的范围为包含两个浮点数的元组。
ratio：一个范围在(0, 1]之间的浮点数或元组。指定随机裁剪的宽高比范围。如果是一个浮点数，则宽高比的范围为[3/4, 4/3]乘以给定的浮点数。如果是一个元组，则宽高比的范围为包含两个浮点数的元组。
interpolation：插值方法的名称，用于调整图像的大小。默认为PIL.Image.BILINEAR。

torchvision.transforms.CenterCrop()

       torchvision.transforms.CenterCrop是PyTorch中的一个数据转换函数，用于对图像进行中心裁剪。

       该函数可以从输入的图像中心位置开始裁剪出指定大小的图像区域。它通常用于数据预处理或数据增强的过程中，以提取感兴趣的图像区域或将图像调整为模型所需的输入大小。

       CenterCrop函数的主要参数包括：

size：一个整数或元组，指定裁剪后的图像大小。如果是一个整数，则裁剪后的图像将是一个正方形，边长为该整数。如果是一个元组，可以指定图像的宽度和高度。

       需要注意的是，中心裁剪会从图像的中心位置开始裁剪。如果裁剪的目标大小大于原始图像的尺寸，那么裁剪将不会进行，而是返回原始图像。

torchvision.transforms.Compose()

       torchvision.transforms.Compose是PyTorch中的一个数据转换函数，用于将多个数据转换操作组合成一个序列。

       该函数允许用户将多个数据转换操作按顺序组合起来，以便在数据预处理或数据增强的过程中一次性应用多个转换操作。

       Compose函数的主要参数是一个转换操作列表，其中每个元素都是一个数据转换函数。转换操作按照列表中的顺序依次应用。

4、定义和初始化模型

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

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

Downloading: "https://download.pytorch.org/models/resnet18-f37072fd.pth" to C:\Users\32343/.cache\torch\hub\checkpoints\resnet18-f37072fd.pth
100.0%

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

print(pretrained_net)
print(pretrained_net.fc)

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=512, out_features=1000, bias=True)
)
Linear(in_features=512, out_features=1000, bias=True)

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

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

成员变量`output`的参数是随机初始化的，通常需要更高的学习率才能从头开始训练。假设`Trainer`实例中的学习率为 $\eta$ ，我们将成员变量`output`中参数的学习率设置为 $10\eta$ 。

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)

Parameter containing:
tensor([[-0.0457, -0.0440, -0.0474,  ..., -0.0762, -0.0579, -0.0520],
        [ 0.0756, -0.0640,  0.0198,  ..., -0.0638,  0.0664, -0.0262]],
       requires_grad=True)

5、定义训练函数

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

# 如果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)

关于net.named_parameters()的用法可参考：Pytorch神经网络的参数管理-CSDN博客文章浏览阅读230次。本文介绍了Pytorch中参数的访问与初始化，主要是权重与偏置参数的访问与初始化https://blog.csdn.net/m0_56312629/article/details/135058101 关于权重衰减(weight-decay)的用法可参考：

权重衰减(Weight Decay)-CSDN博客文章浏览阅读154次。本文讲了权重衰减（权重衰退）的数学原理和具体使用方法_权重衰减https://blog.csdn.net/m0_56312629/article/details/135034852 我们使用较小的学习率，通过微调预训练获得的模型参数。

train_fine_tuning(finetune_net, 5e-5)

loss 0.220, train acc 0.915, test acc 0.939
999.1 examples/sec on [device(type='cuda', index=0), device(type='cuda', index=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.374, train acc 0.839, test acc 0.843
1623.8 examples/sec on [device(type='cuda', index=0), device(type='cuda', index=1)]

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

三、总结

迁移学习将从源数据集中学到的知识迁移到目标数据集，微调是迁移学习的常见技巧。
除输出层外，目标模型从源模型中复制所有模型设计及其参数，并根据目标数据集对这些参数进行微调。但是，目标模型的输出层需要从头开始训练。
通常，微调参数使用较小的学习率，而从头开始训练输出层可以使用更大的学习率。

奉系坤阀

关注

0
点赞
踩
21

收藏

觉得还不错? 一键收藏
1
评论
微调(fine-tuning)

本文介绍了迁移学习常用的方式——微调(fine-tuning)，微调可以从预训练的权重上获得一定的先验知识，提高模型收敛速度并且有利于特征的提取。
复制链接

扫一扫

专栏目录

微调(fine-tuning)

一、微调

1、为什么需要微调

2、微调的步骤

二、代码实现

1、获取数据集

2、读取图像

3、数据增广

4、定义和初始化模型

5、定义训练函数

三、总结

“相关推荐”对你有帮助么？