迁移学习教程

译者：片刻

校对者：cluster

作者: Sasank Chilamkurthy

在本教程中，您将学习如何使用迁移学习来训练您的网络。您可以在 cs231n 笔记 上阅读更多关于迁移学习的信息

引用这些笔记：

在实践中，很少有人从头开始训练整个卷积网络(随机初始化），因为拥有足够大小的数据集是相对罕见的。相反，通常在非常大的数据集(例如 ImageNet，其包含具有1000个类别的120万个图像）上预先训练 ConvNet，然后使用 ConvNet 对感兴趣的任务进行初始化或用作固定特征提取器。

如下是两个主要的迁移学习场景：

  • Finetuning the convnet: 我们使用预训练网络初始化网络，而不是随机初始化，就像在imagenet 1000数据集上训练的网络一样。其余训练看起来像往常一样。(此微调过程对应引用中所说的初始化)
  • ConvNet as fixed feature extractor: 在这里，我们将冻结除最终完全连接层之外的所有网络的权重。最后一个全连接层被替换为具有随机权重的新层，并且仅训练该层。(此步对应引用中的固定特征提取器)
  1. # License: BSD
  2. # Author: Sasank Chilamkurthy
  4. from __future__ import print_function, division
  6. import torch
  7. import torch.nn as nn
  8. import torch.optim as optim
  9. from torch.optim import lr_scheduler
  10. import numpy as np
  11. import torchvision
  12. from torchvision import datasets, models, transforms
  13. import matplotlib.pyplot as plt
  14. import time
  15. import os
  16. import copy
  18. plt.ion()   # interactive mode

加载数据

我们将使用 torchvision 和 torch.utils.data 包来加载数据。

我们今天要解决的问题是训练一个模型来对 蚂蚁 和 蜜蜂 进行分类。我们有大约120个训练图像，每个图像用于 蚂蚁 和 蜜蜂。每个类有75个验证图像。通常，如果从头开始训练，这是一个非常小的数据集。由于我们正在使用迁移学习，我们应该能够合理地泛化。

该数据集是 imagenet 的一个非常小的子集。

注意

从 此处 下载数据并将其解压缩到当前目录。

  1. # Data augmentation and normalization for training
  2. # Just normalization for validation
  3. data_transforms = {
  4.     'train': transforms.Compose([
  5.         transforms.RandomResizedCrop(224),
  6.         transforms.RandomHorizontalFlip(),
  7.         transforms.ToTensor(),
  8.         transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
  9.     ]),
  10.     'val': transforms.Compose([
  11.         transforms.Resize(256),
  12.         transforms.CenterCrop(224),
  13.         transforms.ToTensor(),
  14.         transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
  15.     ]),
  16. }
  18. data_dir = 'data/hymenoptera_data'
  19. image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),
  20.                                           data_transforms[x])
  21.                   for x in ['train', 'val']}
  22. dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4,
  23.                                              shuffle=True, num_workers=4)
  24.               for x in ['train', 'val']}
  25. dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
  26. class_names = image_datasets['train'].classes
  28. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

可视化一些图像

让我们可视化一些训练图像，以便了解数据增强。

  1. def imshow(inp, title=None):
  2.     """Imshow for Tensor."""
  3.     inp = inp.numpy().transpose((1, 2, 0))
  4.     mean = np.array([0.485, 0.456, 0.406])
  5.     std = np.array([0.229, 0.224, 0.225])
  6.     inp = std * inp + mean
  7.     inp = np.clip(inp, 0, 1)
  8.     plt.imshow(inp)
  9.     if title is not None:
  10.         plt.title(title)
  11.     plt.pause(0.001)  # pause a bit so that plots are updated
  14. # Get a batch of training data
  15. inputs, classes = next(iter(dataloaders['train']))
  17. # Make a grid from batch
  18. out = torchvision.utils.make_grid(inputs)
  20. imshow(out, title=[class_names[x] for x in classes])

迁移学习教程 - 图1

训练模型

现在, 让我们编写一个通用函数来训练模型. 这里, 我们将会举例说明:

  • 调度学习率
  • 保存最佳的学习模型

下面函数中, scheduler 参数是 torch.optim.lr_scheduler 中的 LR scheduler 对象.

  1. def train_model(model, criterion, optimizer, scheduler, num_epochs=25):
  2.     since = time.time()
  4.     best_model_wts = copy.deepcopy(model.state_dict())
  5.     best_acc = 0.0
  7.     for epoch in range(num_epochs):
  8.         print('Epoch {}/{}'.format(epoch, num_epochs - 1))
  9.         print('-' * 10)
  11.         # Each epoch has a training and validation phase
  12.         for phase in ['train', 'val']:
  13.             if phase == 'train':
  14.                 scheduler.step()
  15.                 model.train()  # Set model to training mode
  16.             else:
  17.                 model.eval()   # Set model to evaluate mode
  19.             running_loss = 0.0
  20.             running_corrects = 0
  22.             # Iterate over data.
  23.             for inputs, labels in dataloaders[phase]:
  24.                 inputs = inputs.to(device)
  25.                 labels = labels.to(device)
  27.                 # zero the parameter gradients
  28.                 optimizer.zero_grad()
  30.                 # forward
  31.                 # track history if only in train
  32.                 with torch.set_grad_enabled(phase == 'train'):
  33.                     outputs = model(inputs)
  34.                     _, preds = torch.max(outputs, 1)
  35.                     loss = criterion(outputs, labels)
  37.                     # backward + optimize only if in training phase
  38.                     if phase == 'train':
  39.                         loss.backward()
  40.                         optimizer.step()
  42.                 # statistics
  43.                 running_loss += loss.item() * inputs.size(0)
  44.                 running_corrects += torch.sum(preds == labels.data)
  46.             epoch_loss = running_loss / dataset_sizes[phase]
  47.             epoch_acc = running_corrects.double() / dataset_sizes[phase]
  49.             print('{} Loss: {:.4f} Acc: {:.4f}'.format(
  50.                 phase, epoch_loss, epoch_acc))
  52.             # deep copy the model
  53.             if phase == 'val' and epoch_acc > best_acc:
  54.                 best_acc = epoch_acc
  55.                 best_model_wts = copy.deepcopy(model.state_dict())
  57.         print()
  59.     time_elapsed = time.time() - since
  60.     print('Training complete in {:.0f}m {:.0f}s'.format(
  61.         time_elapsed // 60, time_elapsed % 60))
  62.     print('Best val Acc: {:4f}'.format(best_acc))
  64.     # load best model weights
  65.     model.load_state_dict(best_model_wts)
  66.     return model

可视化模型预测

用于显示少量图像预测的通用功能

  1. def visualize_model(model, num_images=6):
  2.     was_training = model.training
  3.     model.eval()
  4.     images_so_far = 0
  5.     fig = plt.figure()
  7.     with torch.no_grad():
  8.         for i, (inputs, labels) in enumerate(dataloaders['val']):
  9.             inputs = inputs.to(device)
  10.             labels = labels.to(device)
  12.             outputs = model(inputs)
  13.             _, preds = torch.max(outputs, 1)
  15.             for j in range(inputs.size()[0]):
  16.                 images_so_far += 1
  17.                 ax = plt.subplot(num_images//2, 2, images_so_far)
  18.                 ax.axis('off')
  19.                 ax.set_title('predicted: {}'.format(class_names[preds[j]]))
  20.                 imshow(inputs.cpu().data[j])
  22.                 if images_so_far == num_images:
  23.                     model.train(mode=was_training)
  24.                     return
  25.         model.train(mode=was_training)

微调卷积网络

加载预训练模型并重置最终的全连接层。

  1. model_ft = models.resnet18(pretrained=True)
  2. num_ftrs = model_ft.fc.in_features
  3. model_ft.fc = nn.Linear(num_ftrs, 2)
  5. model_ft = model_ft.to(device)
  7. criterion = nn.CrossEntropyLoss()
  9. # Observe that all parameters are being optimized
  10. optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)
  12. # Decay LR by a factor of 0.1 every 7 epochs
  13. exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)

训练和评估

CPU上需要大约15-25分钟。但是在GPU上，它只需不到一分钟。

  1. model_ft = train_model(model_ft, criterion, optimizer_ft, exp_lr_scheduler,
  2.                        num_epochs=25)

Out:

  1. Epoch 0/24
  2. ----------
  3. train Loss: 0.6022 Acc: 0.6844
  4. val Loss: 0.1765 Acc: 0.9412
  6. Epoch 1/24
  7. ----------
  8. train Loss: 0.4156 Acc: 0.8238
  9. val Loss: 0.2380 Acc: 0.9216
  11. Epoch 2/24
  12. ----------
  13. train Loss: 0.5010 Acc: 0.7951
  14. val Loss: 0.2571 Acc: 0.8954
  16. Epoch 3/24
  17. ----------
  18. train Loss: 0.7152 Acc: 0.7705
  19. val Loss: 0.2060 Acc: 0.9346
  21. Epoch 4/24
  22. ----------
  23. train Loss: 0.5779 Acc: 0.8033
  24. val Loss: 0.4542 Acc: 0.8889
  26. Epoch 5/24
  27. ----------
  28. train Loss: 0.5653 Acc: 0.7951
  29. val Loss: 0.3167 Acc: 0.8824
  31. Epoch 6/24
  32. ----------
  33. train Loss: 0.4948 Acc: 0.8074
  34. val Loss: 0.3238 Acc: 0.8758
  36. Epoch 7/24
  37. ----------
  38. train Loss: 0.3712 Acc: 0.8361
  39. val Loss: 0.2284 Acc: 0.9020
  41. Epoch 8/24
  42. ----------
  43. train Loss: 0.2982 Acc: 0.8730
  44. val Loss: 0.3488 Acc: 0.8497
  46. Epoch 9/24
  47. ----------
  48. train Loss: 0.2491 Acc: 0.8934
  49. val Loss: 0.2405 Acc: 0.8889
  51. Epoch 10/24
  52. ----------
  53. train Loss: 0.3498 Acc: 0.8238
  54. val Loss: 0.2435 Acc: 0.8889
  56. Epoch 11/24
  57. ----------
  58. train Loss: 0.3042 Acc: 0.8648
  59. val Loss: 0.3021 Acc: 0.8627
  61. Epoch 12/24
  62. ----------
  63. train Loss: 0.2500 Acc: 0.8852
  64. val Loss: 0.2340 Acc: 0.8954
  66. Epoch 13/24
  67. ----------
  68. train Loss: 0.3246 Acc: 0.8730
  69. val Loss: 0.2236 Acc: 0.9020
  71. Epoch 14/24
  72. ----------
  73. train Loss: 0.2976 Acc: 0.8566
  74. val Loss: 0.2928 Acc: 0.8562
  76. Epoch 15/24
  77. ----------
  78. train Loss: 0.2733 Acc: 0.8934
  79. val Loss: 0.2370 Acc: 0.8954
  81. Epoch 16/24
  82. ----------
  83. train Loss: 0.3502 Acc: 0.8361
  84. val Loss: 0.2792 Acc: 0.8824
  86. Epoch 17/24
  87. ----------
  88. train Loss: 0.2215 Acc: 0.8975
  89. val Loss: 0.2790 Acc: 0.8497
  91. Epoch 18/24
  92. ----------
  93. train Loss: 0.3929 Acc: 0.8484
  94. val Loss: 0.2648 Acc: 0.8824
  96. Epoch 19/24
  97. ----------
  98. train Loss: 0.3227 Acc: 0.8607
  99. val Loss: 0.2643 Acc: 0.8693
  101. Epoch 20/24
  102. ----------
  103. train Loss: 0.3816 Acc: 0.8484
  104. val Loss: 0.2395 Acc: 0.9085
  106. Epoch 21/24
  107. ----------
  108. train Loss: 0.2904 Acc: 0.8975
  109. val Loss: 0.2399 Acc: 0.8889
  111. Epoch 22/24
  112. ----------
  113. train Loss: 0.3375 Acc: 0.8648
  114. val Loss: 0.2380 Acc: 0.9020
  116. Epoch 23/24
  117. ----------
  118. train Loss: 0.2107 Acc: 0.9139
  119. val Loss: 0.2251 Acc: 0.9085
  121. Epoch 24/24
  122. ----------
  123. train Loss: 0.3243 Acc: 0.8525
  124. val Loss: 0.2545 Acc: 0.8824
  126. Training complete in 1m 7s
  127. Best val Acc: 0.941176
  1. visualize_model(model_ft)

迁移学习教程 - 图2

ConvNet 作为固定特征提取器

在这里，我们需要冻结除最后一层之外的所有网络。我们需要设置 requires_grad == False 冻结参数，以便在 backward() 中不计算梯度。

您可以在 此处 的文档中阅读更多相关信息。

  1. model_conv = torchvision.models.resnet18(pretrained=True)
  2. for param in model_conv.parameters():
  3.     param.requires_grad = False
  5. # Parameters of newly constructed modules have requires_grad=True by default
  6. num_ftrs = model_conv.fc.in_features
  7. model_conv.fc = nn.Linear(num_ftrs, 2)
  9. model_conv = model_conv.to(device)
  11. criterion = nn.CrossEntropyLoss()
  13. # Observe that only parameters of final layer are being optimized as
  14. # opposed to before.
  15. optimizer_conv = optim.SGD(model_conv.fc.parameters(), lr=0.001, momentum=0.9)
  17. # Decay LR by a factor of 0.1 every 7 epochs
  18. exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)

训练和评估

在CPU上，与前一个场景相比，这将花费大约一半的时间。这是预期的，因为不需要为大多数网络计算梯度。但是，前向传递需要计算梯度。

  1. model_conv = train_model(model_conv, criterion, optimizer_conv,
  2.                          exp_lr_scheduler, num_epochs=25)

Out:

  1. Epoch 0/24
  2. ----------
  3. train Loss: 0.5666 Acc: 0.6967
  4. val Loss: 0.2794 Acc: 0.8824
  6. Epoch 1/24
  7. ----------
  8. train Loss: 0.5590 Acc: 0.7582
  9. val Loss: 0.1473 Acc: 0.9477
  11. Epoch 2/24
  12. ----------
  13. train Loss: 0.4187 Acc: 0.8156
  14. val Loss: 0.3534 Acc: 0.8693
  16. Epoch 3/24
  17. ----------
  18. train Loss: 0.5248 Acc: 0.7459
  19. val Loss: 0.1848 Acc: 0.9477
  21. Epoch 4/24
  22. ----------
  23. train Loss: 0.4315 Acc: 0.8115
  24. val Loss: 0.1640 Acc: 0.9477
  26. Epoch 5/24
  27. ----------
  28. train Loss: 0.3948 Acc: 0.8238
  29. val Loss: 0.1609 Acc: 0.9542
  31. Epoch 6/24
  32. ----------
  33. train Loss: 0.3359 Acc: 0.8648
  34. val Loss: 0.1734 Acc: 0.9608
  36. Epoch 7/24
  37. ----------
  38. train Loss: 0.3681 Acc: 0.8443
  39. val Loss: 0.1715 Acc: 0.9477
  41. Epoch 8/24
  42. ----------
  43. train Loss: 0.4034 Acc: 0.8361
  44. val Loss: 0.1602 Acc: 0.9477
  46. Epoch 9/24
  47. ----------
  48. train Loss: 0.2983 Acc: 0.8811
  49. val Loss: 0.1561 Acc: 0.9542
  51. Epoch 10/24
  52. ----------
  53. train Loss: 0.4516 Acc: 0.7992
  54. val Loss: 0.1660 Acc: 0.9477
  56. Epoch 11/24
  57. ----------
  58. train Loss: 0.3516 Acc: 0.8484
  59. val Loss: 0.1551 Acc: 0.9542
  61. Epoch 12/24
  62. ----------
  63. train Loss: 0.3592 Acc: 0.8238
  64. val Loss: 0.1525 Acc: 0.9477
  66. Epoch 13/24
  67. ----------
  68. train Loss: 0.2982 Acc: 0.8648
  69. val Loss: 0.1772 Acc: 0.9542
  71. Epoch 14/24
  72. ----------
  73. train Loss: 0.3352 Acc: 0.8484
  74. val Loss: 0.1583 Acc: 0.9542
  76. Epoch 15/24
  77. ----------
  78. train Loss: 0.2981 Acc: 0.8770
  79. val Loss: 0.2133 Acc: 0.9412
  81. Epoch 16/24
  82. ----------
  83. train Loss: 0.2778 Acc: 0.8811
  84. val Loss: 0.1934 Acc: 0.9542
  86. Epoch 17/24
  87. ----------
  88. train Loss: 0.3678 Acc: 0.8156
  89. val Loss: 0.1846 Acc: 0.9477
  91. Epoch 18/24
  92. ----------
  93. train Loss: 0.3520 Acc: 0.8197
  94. val Loss: 0.1577 Acc: 0.9542
  96. Epoch 19/24
  97. ----------
  98. train Loss: 0.3342 Acc: 0.8402
  99. val Loss: 0.1734 Acc: 0.9542
  101. Epoch 20/24
  102. ----------
  103. train Loss: 0.3649 Acc: 0.8361
  104. val Loss: 0.1554 Acc: 0.9412
  106. Epoch 21/24
  107. ----------
  108. train Loss: 0.2948 Acc: 0.8566
  109. val Loss: 0.1878 Acc: 0.9542
  111. Epoch 22/24
  112. ----------
  113. train Loss: 0.3047 Acc: 0.8811
  114. val Loss: 0.1760 Acc: 0.9477
  116. Epoch 23/24
  117. ----------
  118. train Loss: 0.3363 Acc: 0.8648
  119. val Loss: 0.1660 Acc: 0.9542
  121. Epoch 24/24
  122. ----------
  123. train Loss: 0.2745 Acc: 0.8770
  124. val Loss: 0.1853 Acc: 0.9542
  126. Training complete in 0m 34s
  127. Best val Acc: 0.960784
  1. visualize_model(model_conv)
  3. plt.ioff()
  4. plt.show()

迁移学习教程 - 图3

脚本总运行时间: (1分54.087秒)

Download Python source code: transfer_learning_tutorial.pyDownload Jupyter notebook: transfer_learning_tutorial.ipynb

由Sphinx-Gallery生成的图库