Lære Træning af Modellen

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:

\mathcal{L} = - \log{\left( \frac{e^{z_y}}{\sum^C_{j=1}e^{z_j}} \right)}

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 vil valideringssættet også fungere som test-sæt.

Læs mere

80% til træning og 20% til test er ofte passende i mange scenarier. For større datasæt, såsom dem med millioner af poster, kan selv en mindre procentdel tildelt test-sættet (10% eller mindre) være tilstrækkelig for en pålidelig præstationsvurdering. Omvendt, med meget små datasæt (f.eks. mindre end tusind poster), er det afgørende at sikre, at test-sættet er stort nok (25-30%) til at give en meningsfuld vurdering af modellens præstation.

Desuden skal de resulterende NumPy-arrays konverteres til tensors, da PyTorch-modeller kræver tensor-inputs 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æningsloop

Træningsloopet omfatter følgende trin for hver epoke:

Fremadrettet gennemløb: send 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 modelparametrene ved hjælp af optimeringsalgoritmen;
Overvågning af fremdrift: udskriv tabet periodisk for at observere konvergens.

Som det ses, ligner træningsprocessen den, der anvendes ved 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()

Bemærk

Kald på model(input) udfører automatisk modellens forward()-metode. Dette skyldes, at nn.Module overskriver __call__-metoden, som internt kalder forward(). Det anbefales at bruge model(input) i stedet for model.forward(input), da førstnævnte sikrer, at eventuelle hooks eller yderligere funktionaliteter (f.eks. model.train() eller model.eval()) anvendes korrekt.

Observation af konvergens

Ud over at træne modellen registrerer vi også træningstabet ved hver epoke og visualiserer det over tid. Som vist i grafen, falder træningstabet hurtigt i starten og stabiliserer sig gradvist omkring epoke 60. Herefter falder tabet kun meget langsomt, 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 1. Kapitel 18

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

Stryg for at vise menuen