Apprendre Entraînement du Modèle | Réseaux Neuronaux dans PyTorch

Préparation à l'entraînement

Tout d'abord, il est nécessaire de s'assurer que le modèle, la fonction de perte et l'optimiseur sont correctement définis. Examinons chaque étape :

Fonction de perte : pour la classification, il est possible d'utiliser CrossEntropyLoss, qui attend des valeurs continues brutes (logits) en entrée et applique automatiquement softmax ;
Optimiseur : l'optimiseur Adam peut être utilisé pour des mises à jour efficaces des gradients.

import torch.nn as nn
import torch.optim as optim
# Define the loss function (cross-entropy for multi-class classification)
criterion = nn.CrossEntropyLoss()
# Define the optimizer (Adam with a learning rate of 0.01)
optimizer = optim.Adam(model.parameters(), lr=0.01)

Dans PyTorch, la perte d'entropie croisée combine log-softmax et la perte de log-vraisemblance négative (NLL) en une seule fonction de perte :

où :

z_y est le logit correspondant à la classe correcte ;
C est le nombre total de classes.

Il est également important de diviser les données en ensembles d'entraînement et de validation (idéalement, un ensemble de test séparé devrait aussi exister). Étant donné que le jeu de données est relativement petit (1143 lignes), une répartition de 80 % à 20 % est utilisée. Dans ce cas, l'ensemble de validation servira également d'ensemble de test.

De plus, les tableaux NumPy obtenus doivent être convertis en tensors, car les modèles PyTorch nécessitent des entrées sous forme de tenseurs pour les calculs.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test =  train_test_split(X, y, test_size=0.2, random_state=42)
X_train = torch.tensor(X_train, dtype=torch.float32)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.long)
y_test = torch.tensor(y_test, dtype=torch.long)

Boucle d'entraînement

La boucle d'entraînement comprend les étapes suivantes pour chaque époque :

Propagation avant : passage des caractéristiques d'entrée dans le modèle pour générer des prédictions ;
Calcul de la perte : comparaison des prédictions avec la vérité terrain à l'aide de la fonction de perte ;
Rétropropagation : calcul des gradients par rapport aux paramètres du modèle via la rétropropagation ;
Mise à jour des paramètres : ajustement des paramètres du modèle à l'aide de l'optimiseur ;
Suivi de la progression : affichage périodique de la perte pour observer la convergence.

Comme vous pouvez le constater, le processus d'entraînement est similaire à celui de la régression linéaire.


              12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849
            
import torch.nn as nn
import torch
import torch.optim as optim
import matplotlib.pyplot as plt
import os
os.system('wget https://staging-content-media-cdn.codefinity.com/courses/1dd2b0f6-6ec0-40e6-a570-ed0ac2209666/section_3/model_definition.py 2>/dev/null')
from model_definition import model, X, y
from sklearn.model_selection import train_test_split

# Set manual seed for reproducibility
torch.manual_seed(42)
# Reinitialize model after setting seed
model.apply(lambda m: m.reset_parameters() if hasattr(m, "reset_parameters") else None)

X_train, X_test, y_train, y_test =  train_test_split(X, y, test_size=0.2, random_state=42)
X_train = torch.tensor(X_train, dtype=torch.float32)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.long)
y_test = torch.tensor(y_test, dtype=torch.long)
# Define the loss function (Cross-Entropy for multi-class classification)
criterion = nn.CrossEntropyLoss()
# Define the optimizer (Adam with a learning rate of 0.01)
optimizer = optim.Adam(model.parameters(), lr=0.01)
# Number of epochs
epochs = 100
# Store losses for plotting
training_losses = []
# Training loop
for epoch in range(epochs):
    # Zero out gradients from the previous step
    optimizer.zero_grad()
    # Compute predictions
    predictions = model(X_train) 
    # Compute the loss
    loss = criterion(predictions, y_train) 
    # Compute gradients
    loss.backward()
    # Update parameters
    optimizer.step()
    # Store the loss
    training_losses.append(loss.item())

# Plot the training loss
plt.plot(range(epochs), training_losses, label="Training Loss")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("Training Loss over Epochs")
plt.legend()
plt.show()

Observation de la convergence

En plus de l'entraînement du modèle, la perte d'entraînement est également enregistrée à chaque époque et tracée au fil du temps. Comme le montre le graphique, la perte d'entraînement diminue rapidement au début puis se stabilise progressivement autour de l'époque 60. Au-delà de ce point, la perte diminue beaucoup plus lentement, ce qui suggère que le modèle a probablement convergé. Par conséquent, environ 40 époques suffiraient pour ce modèle.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 2

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Awesome!

Completion rate improved to 5

Glissez pour afficher le menu