[Tutoriel PyTorch ④] FORMATION D'UN CLASSIFICATEUR
introduction
Ceci est le 4ème volet de PyTorch Tutoriel officiel après Dernière fois. Cette fois, nous allons procéder avec FORMATION D'UN CLASSIFIER.
Classification des classes d'apprentissage
La dernière fois a vu comment définir un réseau neuronal pour calculer les pertes et mettre à jour les poids du réseau. Cette fois, nous examinerons le problème de classification à l'aide de données d'image. PyTorch fournit une bibliothèque torchvision pour la gestion des données d'image. torchvision est également fourni avec des jeux de données d'image de base tels que Imagenet, CIFAR-10 et MNIST. Ce didacticiel utilise le jeu de données CIFAR-10.
CIFAR-10
Le CIFAR-10 est une image couleur 32x32 pixels avec 3 canaux RVB dans la forme (3,32,32). Les cours sont classés en 10 catégories: "Avion", "Voiture", "Oiseau", "Chat", "Cerf", "Chien", "Grenouille", "Cheval", "Bateau", "Camion" ..
Apprentissage de la classification des images
Voyons le flux d'apprentissage avec CIFAR-10. Apprendre à classer les images implique les étapes suivantes dans l'ordre:
- Utilisez torchvision pour charger et normaliser l'ensemble de données de formation et de test CIFAR10
- Définition du réseau neuronal convolutif
- Définir la fonction de perte et l'algorithme d'optimisation
- Apprenez avec les données d'entraînement
- Vérifiez le résultat appris avec les données de test
1. Chargement et normalisation de CIFAR-10
Il est pratique d'utiliser ** Dataset ** et ** DataLoader ** pour charger des données avec PyTorch. L'ensemble de données contient l'image et l'étiquette de réponse correcte (une donnée d'apprentissage). DataLoader Un utilitaire pour acquérir à plusieurs reprises des données d'entraînement (données de test).
import torch
import torchvision
import torchvision.transforms as transforms
#Définition de la transformation
#Convertir en Tensor avec ToTensor
#Standardisation( X - 0.5) / 0.5
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
#Ensemble de données de formation
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
#Chargeur de données d'entraînement
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=False, num_workers=2)
#Jeu de données de test
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
#Chargeur de données de test
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
#Liste des classifications
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
Tout d'abord, la transformation définit la méthode de conversion de l'ensemble de données. Compose connecte plusieurs transformations en séquence. Ici, nous exécutons ToTensor et Normalize. ToTensor convertit les données d'image en Tensor. Dans ToTensor, les valeurs RVB sont représentées par le type de fload [0, 1]. Normaliser calcule (X --0,5) / 0,5 et convertit la plage RVB en [-1, 1].
Certaines images sont affichées avec le code suivant. Puisque le batch_size du trainloader est 4, 4 images sont traitées ensemble.
import matplotlib.pyplot as plt
import numpy as np
#Fonction pour afficher une image
def imshow(img):
img = img / 2 + 0.5 #Revenir à la normalisation
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
#Obtenir des images à partir des données d'entraînement (aléatoires)
dataiter = iter(trainloader)
images, labels = dataiter.next()
#Afficher l'image
imshow(torchvision.utils.make_grid(images))
#Afficher l'étiquette
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
frog truck truck deer
2. Définition du réseau neuronal convolutif
Copiez le réseau de neurones du didacticiel de réseau de neurones précédent et modifiez-le pour obtenir une image à 3 canaux (plutôt que l'image à 1 canal définie).
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
3. Définir la fonction de perte et l'algorithme d'optimisation
Dans les problèmes de classification, la fonction de perte utilise principalement la fonction d'erreur d'entropie croisée. Pour les problèmes de classification binaire, torch.nn.BCEWithLogitsLoss Pour les problèmes de classification multiclasse, torch.nn.CrossEntropyLoss Est souvent utilisé. Cette fois, nous avons 10 classifications d'étiquettes (classification multi-classes), nous allons donc utiliser CrossEntropyLoss. L'algorithme d'optimisation doit être la «méthode probabiliste de descente de gradient» (SGD) la plus élémentaire.
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
4. Apprenez avec les données d'entraînement
Parcourez le chargeur de données et diffusez les données d'entraînement sur le réseau pour optimiser les paramètres.
for epoch in range(2): #Boucle à plusieurs reprises
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
#Obtenez des données d'entraînement
inputs, labels = data
#Initialiser le dégradé
optimizer.zero_grad()
#Passer des données à travers un réseau neuronal et calculer la propagation vers l'avant
outputs = net(inputs)
#Calcul d'erreur
loss = criterion(outputs, labels)
#Calcul de rétropropagation
loss.backward()
#Calcul du poids
optimizer.step()
#Afficher le statut
running_loss += loss.item()
if i % 2000 == 1999: # 2,000 données chacun
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
L'apprentissage sera terminé dans environ 2 minutes.
[1, 2000] loss: 2.153
[1, 4000] loss: 1.830
[1, 6000] loss: 1.654
[1, 8000] loss: 1.556
[1, 10000] loss: 1.524
[1, 12000] loss: 1.511
[2, 2000] loss: 1.441
[2, 4000] loss: 1.380
[2, 6000] loss: 1.384
[2, 8000] loss: 1.358
[2, 10000] loss: 1.335
[2, 12000] loss: 1.320
Finished Training
5. Vérifiez les résultats tirés des données de test
Vérifiez le résultat appris avec les données de test. Jetons un coup d'œil à certaines des données de test.
dataiter = iter(testloader)
images, labels = dataiter.next()
# print images
imshow(torchvision.utils.make_grid(images))
print('Données des enseignants: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
Données de l'enseignant: avion de bateau de bateau de chat
Voyons comment le modèle (classificateur) qui a formé ces quatre images juge. Transmettez les données de test au réseau formé et vous obtiendrez les résultats.
outputs = net(images)
print(outputs[0,:])
tensor([-1.0291, -3.1352, 0.5837, 3.7728, -1.3638, 3.4090, 0.4094, 0.3352,
-0.6388, -1.4808], grad_fn=<SliceBackward>)
Le poids de chaque étiquette (10 pièces) est renvoyé en sortie.
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
for j in range(4)))
Obtenez l'indice maximum avec max. Si vous spécifiez deux valeurs de retour pour max, l'index avec la valeur maximale est renvoyé en premier et l'index avec la valeur maximale est renvoyé en second.
Predicted: cat ship ship plane
Il a été confirmé que cela correspond aux données des enseignants.
Vérifions le résultat avec toutes les données de test.
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total))
Accuracy of the network on the 10000 test images: 52 %
Avec 10 000 données de test, le taux de réponse correcte était de 52%. Si vous n'avez pas appris, c'est 1/10 (10%), donc vous pouvez apprendre quelque chose, mais ce n'est pas très précis. Regardons le taux de réponse correct pour chaque étiquette.
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i].item()
class_total[label] += 1
for i in range(10):
print('Accuracy of %5s : %2d %%' % (
classes[i], 100 * class_correct[i] / class_total[i]))
Accuracy of plane : 65 %
Accuracy of car : 51 %
Accuracy of bird : 33 %
Accuracy of cat : 22 %
Accuracy of deer : 39 %
Accuracy of dog : 64 %
Accuracy of frog : 66 %
Accuracy of horse : 70 %
Accuracy of ship : 53 %
Accuracy of truck : 61 %
Il semble qu'il y ait des cas comme le chat que je n'ai pas beaucoup appris.
Apprendre sur GPU
Enfin, regardons l'apprentissage sur le GPU. Si vous disposez d'un environnement compatible GPU, vous pouvez l'utiliser pour entraîner votre réseau neuronal. Si vous utilisez Google Colaboratory, vous pouvez utiliser le GPU en sélectionnant "Runtime" ⇒ "Change Runtime Type" ⇒ "GPU".
Vous pouvez vérifier l'utilisation du GPU avec le code suivant.
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Assume that we are on a CUDA machine, then this should print a CUDA device:
print(device)
Si l'appareil est "cuda", vous pouvez utiliser le GPU. Si vous utilisez un GPU, vous devez écrire du code pour transférer le modèle vers le GPU.
net.to(device)
De même, les données d'entraînement doivent être transférées vers le GPU.
inputs, labels = inputs.to(device), labels.to(device)
J'ai vérifié le temps nécessaire pour étudier ce tutoriel sur Google Colaboratory Si vous n'utilisez pas de GPU: 2 minutes 10 secondes Lors de l'utilisation du GPU: 1 minute 40 secondes était. Si les dimensions des données d'apprentissage ne sont pas si complexes, l'effet semble faible.
À la fin
C'est le contenu du quatrième tutoriel de PyTorch, "FORMATION D'UN CLASSIFIER". J'ai pu comprendre le flux de base de l'apprentissage.
La prochaine fois, j'aimerais continuer avec le cinquième tutoriel "APPRENDRE PYTORCH AVEC précision".
Histoire
2020/04/29 Première édition publiée