Lære Træning af Modellen | Neurale Netværk i PyTorch

Forberedelse til træning

Først skal du sikre, at modellen, tab-funktionen og optimeringsalgoritmen er korrekt defineret. Gennemgå hvert trin:

Tab-funktion: til klassifikation kan du anvende CrossEntropyLoss, som forventer rå kontinuerlige værdier (logits) som input og automatisk anvender softmax;
Optimeringsalgoritme: Adam-optimeringsalgoritmen kan anvendes for effektive gradientopdateringer.

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)

I PyTorch kombinerer cross-entropy tab både log-softmax og negativ log-likelihood (NLL) tab i én samlet tab-funktion:

hvor:

z_y er logit-værdien svarende til den korrekte klasse;
C er det samlede antal klasser.

Det er også vigtigt at opdele data i trænings- og valideringssæt (ideelt set bør der også eksistere et separat test-sæt). Da datasættet er relativt lille (1143 rækker), anvendes en 80% til 20% opdeling. I dette tilfælde fungerer valideringssættet også som test-sæt.

Desuden skal de resulterende NumPy-arrays konverteres til tensorer, da PyTorch-modeller kræver tensor-input til beregninger.

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)

Træningssløjfe

Træningssløjfen omfatter følgende trin for hver epoke:

Fremadrettet gennemløb: før inputfunktionerne gennem modellen for at generere forudsigelser;
Tab-beregning: sammenlign forudsigelserne med de faktiske værdier ved hjælp af tab-funktionen;
Bagudrettet gennemløb: beregn gradienter i forhold til modelparametrene ved hjælp af backpropagation;
Parameteropdatering: juster modelparametre ved hjælp af optimeringsalgoritmen;
Overvågning af fremgang: udskriv tabet periodisk for at observere konvergens.

Som det kan ses, ligner træningsprocessen den for lineær regression.


              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 af konvergens

Ud over at træne modellen registreres træningstabet ved hver epoke og plottes over tid. Som vist i grafen falder træningstabet i starten hurtigt og stabiliseres derefter gradvist omkring epoke 60. Herefter falder tabet i et langt langsommere tempo, hvilket indikerer, at modellen sandsynligvis er konvergeret. Derfor vil det være tilstrækkeligt at bruge omkring 40 epoker for denne model.

Var alt klart?

Tak for dine kommentarer!

Sektion 3. Kapitel 2

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Awesome!

Completion rate improved to 5

Stryg for at vise menuen