PyTorch 転移学習チュートリアルと例

トランスファーラーニングとは何ですか?

転移学習 トレーニングされたモデルを使用して別の関連タスクを解決する手法です。 これは、特定の問題を解決する際に得られた知識を保存し、同じ知識を使用して別の異なる、しかし関連する問題を解決する機械学習の研究方法です。 これにより、以前に学習したタスクから収集された情報が再利用されるため、効率が向上します。

ネットワーク モデルのトレーニングには大量のデータが必要となるため、トレーニング時間を短縮するために他のネットワーク モデルの重みを使用することが一般的です。 トレーニング時間を短縮するには、他のネットワークとその重みを使用し、最後の層を変更して問題を解決します。 利点は、最後の層をトレーニングするために小さなデータセットを使用できることです。

次に、この PyTorch 転移学習チュートリアルでは、PyTorch で転移学習を使用する方法を学びます。

データセットの読み込み

データセットの読み込み

出典: エイリアン vs. プレデター Kaggle

Transfer Learning PyTorch の使用を開始する前に、使用するデータセットを理解する必要があります。 この転移学習 PyTorch の例では、約 700 枚の画像からエイリアンとプレデターを分類します。 この手法では、トレーニングに大量のデータは必要ありません。 データセットはからダウンロードできます Kaggle: エイリアン vs. プレデター。

転移学習を使用するにはどうすればよいですか?

ここでは、PyTorch で深層学習のための転移学習を使用する方法を段階的に説明します。

ステップ 1) データをロードする

最初のステップは、データをロードし、ネットワーク要件に一致するように画像に変換を行うことです。

torchvision.dataset のあるフォルダーからデータをロードします。 モジュールはフォルダー内で反復処理を行い、トレーニングと検証のためにデータを分割します。 変換プロセスでは、画像を中心から切り取り、水平反転を実行し、正規化し、最後にディープ ラーニングを使用してテンソルに変換します。

from __future__ import print_function, division
import os
import time
import torch
import torchvision
from torchvision import datasets, models, transforms
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

data_dir = "alien_pred"
input_shape = 224
mean = [0.5, 0.5, 0.5]
std = [0.5, 0.5, 0.5]

#data transformation
data_transforms = {
   'train': transforms.Compose([
       transforms.CenterCrop(input_shape),
       transforms.ToTensor(),
       transforms.Normalize(mean, std)
   ]),
   'validation': transforms.Compose([
       transforms.CenterCrop(input_shape),
       transforms.ToTensor(),
       transforms.Normalize(mean, std)
   ]),
}

image_datasets = {
   x: datasets.ImageFolder(
       os.path.join(data_dir, x),
       transform=data_transforms[x]
   )
   for x in ['train', 'validation']
}

dataloaders = {
   x: torch.utils.data.DataLoader(
       image_datasets[x], batch_size=32,
       shuffle=True, num_workers=4
   )
   for x in ['train', 'validation']
}

dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'validation']}

print(dataset_sizes)
class_names = image_datasets['train'].classes

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

PyTorch 転移学習のデータセットを視覚化してみましょう。 視覚化プロセスは、トレーニング データローダーとラベルから画像の次のバッチを取得し、matplot で表示します。

images, labels = next(iter(dataloaders['train']))

rows = 4
columns = 4
fig=plt.figure()
for i in range(16):
   fig.add_subplot(rows, columns, i+1)
   plt.title(class_names[labels[i]])
   img = images[i].numpy().transpose((1, 2, 0))
   img = std * img + mean
   plt.imshow(img)
plt.show()
画像のバッチ
画像のバッチ

ステップ 2) モデルの定義

この中の 深層学習 このプロセスでは、torchvision モジュールの ResNet18 を使用します。

torchvision.models を使用して、事前トレーニング済みの重みを True に設定して resnet18 をロードします。 その後、レイヤーをフリーズして、これらのレイヤーがトレーニングできないようにします。 また、ニーズに合わせて、最後のレイヤーを Linear レイヤー (2 クラス) に変更します。 また、マルチクラス損失関数には CrossEntropyLoss を使用し、以下の PyTorch 転移学習の例に示すように、オプティマイザーには学習率 0.0001 と運動量 0.9 の SGD を使用します。

## Load the model based on VGG19
vgg_based = torchvision.models.vgg19(pretrained=True)

## freeze the layers
for param in vgg_based.parameters():
   param.requires_grad = False

# Modify the last layer
number_features = vgg_based.classifier[6].in_features
features = list(vgg_based.classifier.children())[:-1] # Remove last layer
features.extend([torch.nn.Linear(number_features, len(class_names))])
vgg_based.classifier = torch.nn.Sequential(*features)

vgg_based = vgg_based.to(device)

print(vgg_based)

criterion = torch.nn.CrossEntropyLoss()
optimizer_ft = optim.SGD(vgg_based.parameters(), lr=0.001, momentum=0.9)

出力モデルの構造

VGG(
  (features): Sequential(
	(0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(1): ReLU(inplace)
	(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(3): ReLU(inplace)
	(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
	(5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(6): ReLU(inplace)
	(7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(8): ReLU(inplace)
	(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
	(10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(11): ReLU(inplace)
	(12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(13): ReLU(inplace)
	(14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(15): ReLU(inplace)
	(16): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(17): ReLU(inplace)
	(18): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
	(19): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(20): ReLU(inplace)
	(21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(22): ReLU(inplace)
	(23): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(24): ReLU(inplace)
	(25): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(26): ReLU(inplace)
	(27): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
	(28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(29): ReLU(inplace)
	(30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(31): ReLU(inplace)
	(32): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(33): ReLU(inplace)
	(34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
	(35): ReLU(inplace)
	(36): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (classifier): Sequential(
	(0): Linear(in_features=25088, out_features=4096, bias=True)
	(1): ReLU(inplace)
	(2): Dropout(p=0.5)
	(3): Linear(in_features=4096, out_features=4096, bias=True)
	(4): ReLU(inplace)
	(5): Dropout(p=0.5)
	(6): Linear(in_features=4096, out_features=2, bias=True)
  )
)

ステップ 3) モデルのトレーニングとテスト

転移学習の関数の一部を使用します。 PyTorch チュートリアル モデルのトレーニングと評価に役立ちます。

def train_model(model, criterion, optimizer, num_epochs=25):
   since = time.time()

   for epoch in range(num_epochs):
       print('Epoch {}/{}'.format(epoch, num_epochs - 1))
       print('-' * 10)

       #set model to trainable
       # model.train()

       train_loss = 0

       # Iterate over data.
       for i, data in enumerate(dataloaders['train']):
           inputs , labels = data
           inputs = inputs.to(device)
           labels = labels.to(device)

           optimizer.zero_grad()
          
           with torch.set_grad_enabled(True):
               outputs  = model(inputs)
               loss = criterion(outputs, labels)

           loss.backward()
           optimizer.step()

           train_loss += loss.item() * inputs.size(0)

           print('{} Loss: {:.4f}'.format(
               'train', train_loss / dataset_sizes['train']))
          
   time_elapsed = time.time() - since
   print('Training complete in {:.0f}m {:.0f}s'.format(
       time_elapsed // 60, time_elapsed % 60))

   return model

def visualize_model(model, num_images=6):
   was_training = model.training
   model.eval()
   images_so_far = 0
   fig = plt.figure()

   with torch.no_grad():
       for i, (inputs, labels) in enumerate(dataloaders['validation']):
           inputs = inputs.to(device)
           labels = labels.to(device)

           outputs = model(inputs)
           _, preds = torch.max(outputs, 1)

           for j in range(inputs.size()[0]):
               images_so_far += 1
               ax = plt.subplot(num_images//2, 2, images_so_far)
               ax.axis('off')
               ax.set_title('predicted: {} truth: {}'.format(class_names[preds[j]], class_names[labels[j]]))
               img = inputs.cpu().data[j].numpy().transpose((1, 2, 0))
               img = std * img + mean
               ax.imshow(img)

               if images_so_far == num_images:
                   model.train(mode=was_training)
                   return
       model.train(mode=was_training)

最後に、この PyTorch での転移学習の例では、エポック数を 25 に設定してトレーニング プロセスを開始し、トレーニング プロセスの後に評価してみましょう。 各トレーニング ステップで、モデルは入力を受け取り、出力を予測します。 その後、予測された出力が損失を計算する基準に渡されます。 次に、損失はバックプロップ計算を実行して勾配を計算し、最後に重みを計算して autograd でパラメーターを最適化します。

視覚化モデルでは、トレーニングされたネットワークが画像のバッチを使用してテストされ、ラベルが予測されます。 次に、matplotlib を使用して視覚化します。

vgg_based = train_model(vgg_based, criterion, optimizer_ft, num_epochs=25)

visualize_model(vgg_based)

plt.show()

ステップ 4) 結果

最終結果は、92% の精度を達成しました。

Epoch 23/24
----------
train Loss: 0.0044
train Loss: 0.0078
train Loss: 0.0141
train Loss: 0.0221
train Loss: 0.0306
train Loss: 0.0336
train Loss: 0.0442
train Loss: 0.0482
train Loss: 0.0557
train Loss: 0.0643
train Loss: 0.0763
train Loss: 0.0779
train Loss: 0.0843
train Loss: 0.0910
train Loss: 0.0990
train Loss: 0.1063
train Loss: 0.1133
train Loss: 0.1220
train Loss: 0.1344
train Loss: 0.1382
train Loss: 0.1429
train Loss: 0.1500
Epoch 24/24
----------
train Loss: 0.0076
train Loss: 0.0115
train Loss: 0.0185
train Loss: 0.0277
train Loss: 0.0345
train Loss: 0.0420
train Loss: 0.0450
train Loss: 0.0490
train Loss: 0.0644
train Loss: 0.0755
train Loss: 0.0813
train Loss: 0.0868
train Loss: 0.0916
train Loss: 0.0980
train Loss: 0.1008
train Loss: 0.1101
train Loss: 0.1176
train Loss: 0.1282
train Loss: 0.1323
train Loss: 0.1397
train Loss: 0.1436
train Loss: 0.1467
Training complete in 2m 47s

終了すると、モデルの出力は以下の matplot で視覚化されます。

Matplot で視覚化
Matplot で視覚化

まとめ

それでは、すべてをまとめてみましょう! 最初の要素は、PyTorch がグロであることです。wing 初心者または研究目的のための深層学習フレームワーク。 高い計算時間、ダイナミック グラフ、GPU サポートを提供し、完全に書かれています。 Python 。 独自のネットワーク モジュールを簡単に定義し、簡単な反復でトレーニング プロセスを実行できます。 PyTorch が初心者にとって深層学習を見つけるのに理想的であることは明らかであり、プロの研究者にとっては、計算時間が短縮され、動的グラフを支援する非常に便利な autograd 関数により非常に役立ちます。