Impara Addestramento del Modello | Reti Neurali in PyTorch

Preparazione all'Addestramento

Prima di tutto, è necessario assicurarsi che il modello, la funzione di perdita e l'ottimizzatore siano definiti correttamente. Analizziamo ciascun passaggio:

Funzione di perdita: per la classificazione, è possibile utilizzare CrossEntropyLoss, che si aspetta valori continui grezzi (logits) come input e applica automaticamente softmax;
Ottimizzatore: è possibile utilizzare l'ottimizzatore Adam per aggiornamenti efficienti dei gradienti.

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)

In PyTorch, la funzione di perdita cross-entropy combina log-softmax e negative log-likelihood (NLL) in un'unica funzione di perdita:

dove:

z_y è il logit corrispondente alla classe corretta;
C è il numero totale di classi.

È inoltre importante suddividere i dati in set di addestramento e validazione (idealmente dovrebbe esistere anche un set di test separato). Poiché il dataset è relativamente piccolo (1143 righe), utilizziamo una suddivisione 80% e 20%. In questo caso, il set di validazione fungerà anche da set di test.

Inoltre, i risultanti array NumPy devono essere convertiti in tensori, poiché i modelli PyTorch richiedono input in formato tensore per i calcoli.

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)

Ciclo di Addestramento

Il ciclo di addestramento prevede i seguenti passaggi per ogni epoca:

Passaggio in avanti: passaggio delle caratteristiche di input attraverso il modello per generare le predizioni;
Calcolo della perdita: confronto delle predizioni con i valori reali utilizzando la funzione di perdita;
Passaggio all'indietro: calcolo dei gradienti rispetto ai parametri del modello tramite retropropagazione;
Aggiornamento dei parametri: modifica dei parametri del modello utilizzando l'ottimizzatore;
Monitoraggio del progresso: stampa periodica della perdita per osservare la convergenza.

Come si può notare, il processo di addestramento è simile a quello della regressione lineare.


              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()

Osservazione della Convergenza

Oltre all'addestramento del modello, si registra anche la perdita di addestramento ad ogni epoca e la si rappresenta graficamente nel tempo. Come mostrato nel grafico, la perdita di addestramento inizialmente diminuisce rapidamente e poi si stabilizza gradualmente intorno all'epoca 60. Oltre questo punto, la perdita diminuisce a un ritmo molto più lento, suggerendo che il modello abbia probabilmente convergito. Pertanto, utilizzare circa 40 epoche per questo modello sarebbe sufficiente.

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 2

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Suggested prompts:

Can you explain why we use CrossEntropyLoss for classification tasks?

How do I know if my model is overfitting or underfitting during training?

What should I do if my training loss doesn't decrease as expected?

Awesome!

Completion rate improved to 5

Scorri per mostrare il menu