PyTorTutoriel sur l'apprentissage par transfert avec exemples
Evelyn Clarke
⚡ Résumé intelligent
L'apprentissage par transfert réutilise un réseau déjà entraîné sur un grand ensemble de données afin qu'une nouvelle tâche connexe puisse être résolue avec beaucoup moins d'images étiquetées et une fraction du temps d'entraînement initial.
Qu'est-ce que l'apprentissage par transfert ?
Transfert d'apprentissage est une technique qui consiste à utiliser un modèle entraîné pour résoudre une autre tâche connexe. Machine Learning Cette méthode de recherche consiste à capitaliser sur les connaissances acquises lors de la résolution d'un problème particulier et à les réutiliser pour résoudre un autre problème, différent mais connexe. Elle permet ainsi d'améliorer l'efficacité en réutilisant les informations recueillies lors de la tâche précédemment apprise.
Il est courant de réutiliser les poids d'un autre modèle de réseau, car l'entraînement d'un réseau à partir de zéro nécessite une très grande quantité de données. Pour réduire le temps d'entraînement, on utilise un réseau existant et ses poids, puis on modifie la dernière couche pour résoudre le problème spécifique. L'avantage est que cette dernière couche peut être entraînée avec un petit ensemble de données.
Avant d'écrire du PyTorPour connaître le code ch, il est utile de savoir à quelle famille d'apprentissage par transfert appartient votre problème, car cela détermine la quantité de données étiquetées dont vous avez besoin.
Types d’apprentissage par transfert
La littérature scientifique divise cette technique en trois familles. Le choix de celle qui s'applique à votre cas dépend de la nature du problème, et non du cadre théorique utilisé.
| Type | Domaine source | Target domaine | Utilisation typique |
|---|---|---|---|
| Inductif | Étiqueté | Étiqueté, mais tâche différente | Réorientation d'une infrastructure ImageNet vers un problème à deux classes Alien vs Predator |
| Transductrice | Étiqueté | Non étiqueté, même tâche, distribution de données différente | Adaptation de domaine, comme le passage d'un modèle de photos de studio à des photos prises avec un téléphone portable. |
| Non supervisé | Non étiqueté | Non étiqueté | Clusterréduction de dimensionnalité ou étiquetage de chaque enregistrement, lorsque cela est impraticable. |
L'exemple présenté dans ce tutoriel est un apprentissage par transfert inductif. VGG19 arrive avec des connaissances étiquetées d'ImageNet, et il est ensuite appliqué à un problème étiqueté à deux classes qu'il n'a jamais rencontré auparavant.
Fonctionnalité Extraction vs réglage fin
Une fois un réseau pré-entraîné choisi, il existe deux manières de l'adapter. La différence réside simplement dans le nombre de couches que l'on autorise à continuer d'apprendre.
| Aspect | Fonctionnalité extracproduction | Réglage fin |
|---|---|---|
| Couches qui s'entraînent | Seul le classificateur remplacé | Le classificateur plus certains ou tous les blocs convolutionnels |
| requires_grad sur le backbone | Faux | C'est vrai pour les blocs mis à jour |
| Données nécessaires | Petites, souvent quelques centaines d'images par classe | Plus importants, généralement des milliers |
| Coût de la formation | Niveau le plus bas, fonctionne sur un processeur | Plus le prix est élevé, plus un GPU devient intéressant à posséder |
| Précision typique | C'est bien lorsque les images source et cible se ressemblent. | Il est généralement préférable que les deux domaines diffèrent. |
Les étapes ci-dessous utilisent la fonctionnalité extracModification : tous les paramètres de VGG19 sont gelés et seule la nouvelle couche linéaire finale apprend. Passer au réglage fin consiste simplement à laisser `requires_grad` à `True` sur les blocs à mettre à jour et à réduire le taux d'apprentissage afin de ne pas altérer les poids empruntés.
Chargement de l'ensemble de données
Avant de commencer à utiliser l'apprentissage par transfert avec PyTorch, vous devez comprendre l'ensemble de données que vous allez utiliser. Dans ce Transfer Learning PyTorPar exemple, vous devrez classifier un extraterrestre et un prédateur parmi près de 700 images. Cette technique ne nécessite pas une grande quantité de données d'entraînement. Vous pouvez télécharger l'ensemble de données depuis [lien manquant]. Kaggle : Alien contre Predator.
La collection est volontairement restreinte, et un échantillon des images qu'elle contient est présenté ci-dessous.
Source: Vs extraterrestres prédateur Kaggle
Prochain article sur PyTorDans ce tutoriel sur l'apprentissage par transfert, vous apprendrez à appliquer l'apprentissage par transfert avec Python.Torch étape par étape.
Comment utiliser l’apprentissage par transfert ?
Voici une procédure étape par étape pour utiliser l'apprentissage par transfert dans le cadre de l'apprentissage profond avec Python.Torch:
Étape 1) Charger les données
La première étape consiste à charger les données et à appliquer certaines transformations aux images afin qu'elles correspondent aux exigences du réseau.
Vous chargerez les données depuis un dossier contenant torchvision.datasets. Le module parcourt ce dossier pour diviser les données en ensembles d'entraînement et de validation. Le pipeline de transformation utilisé ici recadre les images en les centrant, les convertit en tenseur et les normalise. L'apprentissage en profondeur.
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")
Visualisez maintenant l'ensemble de données. Cette étape consiste à utiliser le lot suivant d'images et d'étiquettes provenant du chargeur de données d'entraînement et à les afficher avec Matplotlib.
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()
L'exécution de cet extrait de code dessine une grille de quatre par quatre images d'entraînement, chacune portant le nom de la classe renvoyée par le chargeur.
Étape 2) Définir le modèle
Dans ce processus d'apprentissage profond, vous utiliserez VGG19 du module torchvision.
Vous utiliserez torchvision.models pour charger le modèle vgg19 avec les poids pré-entraînés activés. Ensuite, vous figerez les couches afin qu'elles ne soient plus entraînables. Vous modifierez ensuite la dernière couche par une couche linéaire adaptée au problème, ici deux classes. La fonction de perte utilisée est CrossEntropyLoss, et l'optimiseur est SGD avec un taux d'apprentissage de 0.001 et un momentum de 0.9, comme illustré dans le code Python ci-dessous.TorExemple d'apprentissage par transfert.
## 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)
Note de version : le pré-entraîné=Vrai Cet argument fonctionne toujours, mais il a été remplacé depuis torchvision 0.13 par poids argument, donc les installations plus récentes s'attendent à torchvision.models.vgg19(weights=VGG19_Weights.DEFAULT) et afficher un avertissement de dépréciation dans le cas contraire. Les deux formulaires chargent les mêmes poids ImageNet.
La structure du modèle de sortie
L'impression du modèle renvoie le graphe VGG19 complet. Lisez la dernière ligne du bloc classificateur pour confirmer que la modification a fonctionné : il produit désormais 2 sorties au lieu des 1 000 classes ImageNet.
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) ) )
Étape 3) Former et tester le modèle
Nous utiliserons certaines des fonctions de ceci PyTorTutoriel ch pour nous aider à former et à évaluer notre modèle.
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)
Enfin, dans cet apprentissage par transfert en PyTorPar exemple, commencez l'entraînement avec 25 époques, puis évaluez le réseau. À chaque étape, le modèle reçoit les données d'entrée et prédit la sortie. La prédiction est ensuite transmise au critère de calcul de la perte, la rétropropagation calcule les gradients et l'optimiseur met à jour les poids avec l'algorithme autograd.
Dans la fonction de visualisation, le réseau entraîné est testé avec un lot d'images pour prédire les étiquettes, et le résultat est dessiné avec Matplotlib.
vgg_based = train_model(vgg_based, criterion, optimizer_ft, num_epochs=25) visualize_model(vgg_based) plt.show()
Étape 4) Résultats
La précision enregistrée pour cet entraînement est de 92 %. Le journal imprimé à la fin de l'entraînement affiche la perte cumulée pour les deux dernières époques ainsi que la durée totale de l'entraînement.
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
Les prédictions du modèle sont ensuite visualisées avec Matplotlib, comme indiqué ci-dessous.
Erreurs courantes en matière d'apprentissage par transfert et comment les corriger
La plupart des erreurs dans un script d'apprentissage par transfert sont d'ordre mécanique plutôt que mathématique. Ce sont celles qui empêchent l'exécution du code ci-dessus, et voici leur signification.
- Inadéquation de taille dans la couche finale : La couche linéaire remplacée doit accepter les caractéristiques d'entrée fournies par le classificateur d'origine et produire exactement `len(class_names)` sorties. Afficher le modèle, comme à l'étape 2, est la méthode la plus rapide pour vérifier ces deux valeurs.
- La colonne vertébrale n'a jamais été gelée : Si l'option `requires_grad` reste à `True`, chaque paramètre de VGG19 est mis à jour et l'exécution devient extrêmement lente sur un processeur. Définissez-la sur `False` avant le remplacement du classificateur.
- Incohérence de normalisation : La moyenne et l'écart type utilisés dans transforms.Normalize doivent être identiques lors de l'entraînement et de l'inférence, sinon les prédictions dérivent sans raison apparente.
- Argument de pondération obsolète : Sur torchvision 0.13 et versions ultérieures, pretrained=True génère un avertissement de dépréciation et l'énumération des poids est préférée.
- num_workers sur Windows et des cahiers : Un DataLoader avec num_workers=4 nécessite que son point d'entrée soit protégé ; il faut donc définir num_workers=0 si Python génère une erreur de génération ou de sérialisation.
- Évaluation en mode entraînement : Appelez model.eval() avant le scoring afin que Dropout et BatchNorm se comportent de manière déterministe, puis revenez à model.train() ensuite.
