Lære Trening av Modellen

Forberedelse til trening

Først må du sørge for at modellen, tapsfunksjonen og optimalisereren er korrekt definert. La oss gå gjennom hvert steg:

Tapsfunksjon: for klassifisering kan du bruke CrossEntropyLoss, som forventer rå kontinuerlige verdier (logits) som input og automatisk anvender softmax;
Optimaliserer: du kan bruke Adam-optimalisereren for effektive gradientoppdateringer.

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 kryssentropitap log-softmax og negativ log-sannsynlighet (NLL) tap i én enkelt tapsfunksjon:

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

hvor:

z_y er logitten som tilsvarer riktig klasse;
C er totalt antall klasser.

Det er også viktig å dele dataene inn i trenings- og valideringssett (ideelt sett bør det også finnes et eget testsett). Siden datasettet er relativt lite (1143 rader), bruker vi en 80% til 20% fordeling. I dette tilfellet vil valideringssettet også fungere som testsett.

Les mer

80% til trening og 20% til testing er ofte passende for mange scenarier. For større datasett, som de med millioner av rader, kan selv en mindre prosentandel satt av til testsettet (10% eller mindre) være tilstrekkelig for å oppnå en pålitelig ytelsesevaluering. For svært små datasett (f.eks. mindre enn tusen rader) er det derimot avgjørende å sikre at testsettet er stort nok (25-30%) for å gi en meningsfull vurdering av modellens ytelse.

Videre bør de resulterende NumPy-arrayene konverteres til tensorkonstruksjoner, ettersom PyTorch-modeller krever tensor-inndata for 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)

Treningssløyfe

Treningssløyfen innebærer følgende steg for hver epoke:

Fremoverpassering: send inndatafunksjonene gjennom modellen for å generere prediksjoner;
Tap-beregning: sammenlign prediksjonene med fasiten ved hjelp av tapsfunksjonen;
Bakoverpassering: beregn gradienter med hensyn til modellparametrene ved bruk av tilbakepropagering;
Parameteroppdatering: juster modellparametrene ved hjelp av optimaliseringsalgoritmen;
Overvåking av fremdrift: skriv ut tapet periodisk for å observere konvergens.

Som du ser, ligner treningsprosessen på den for lineær regresjon.


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

Merk

Å kalle model(input) kaller automatisk på forward()-metoden til modellen. Dette er fordi nn.Module overstyrer __call__-metoden, som internt kaller forward(). Det anbefales å bruke model(input) i stedet for model.forward(input), da førstnevnte sikrer at eventuelle hooks eller tilleggsfunksjonalitet (f.eks. model.train() eller model.eval()) blir korrekt anvendt.

Observere konvergens

I tillegg til å trene modellen, registrerer vi også trenings-tapet ved hver epoke og visualiserer det over tid. Som vist i grafen, synker trenings-tapet raskt i starten og stabiliserer seg gradvis rundt epoke 60. Etter dette punktet synker tapet mye saktere, noe som tyder på at modellen sannsynligvis har konvergert. Derfor vil det være tilstrekkelig å bruke omtrent 40 epoker for denne modellen.

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 18

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Sveip for å vise menyen