Leer Training van het Model

Voorbereiden op Training

Zorg er eerst voor dat het model, de verliesfunctie en de optimizer correct zijn gedefinieerd. Doorloop de volgende stappen:

Verliesfunctie: voor classificatie kan CrossEntropyLoss worden gebruikt, die ruwe continue waarden (logits) als invoer verwacht en automatisch softmax toepast;
Optimizer: de Adam-optimizer kan worden gebruikt voor efficiënte gradiëntupdates.

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 combineert cross-entropy verlies zowel log-softmax als negative log-likelihood (NLL) verlies in één verliesfunctie:

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

waarbij:

z_y de logit is die overeenkomt met de juiste klasse;
C het totaal aantal klassen is.

Het is ook belangrijk om de data te splitsen in trainings- en validatiesets (idealiter is er ook een aparte testset). Omdat de dataset relatief klein is (1143 rijen), gebruiken we een 80% tot 20% verdeling. In dit geval fungeert de validatieset ook als testset.

Meer Leren

80% voor training en 20% voor testen is vaak geschikt voor veel scenario's. Voor grotere datasets, zoals die met miljoenen records, kan zelfs een kleiner percentage voor de testset (10% of minder) voldoende zijn voor een betrouwbare prestatie-evaluatie. Bij zeer kleine datasets (bijvoorbeeld minder dan duizend records) is het echter cruciaal dat de testset groot genoeg is (25-30%) om een zinvolle beoordeling van de modelprestaties te bieden.

Bovendien dienen de resulterende NumPy-arrays te worden omgezet naar tensors, aangezien PyTorch-modellen tensorinvoer vereisen voor berekeningen.

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)

Trainingslus

De trainingslus omvat de volgende stappen voor elk epoch:

Voorwaartse stap: voer de invoerkenmerken door het model om voorspellingen te genereren;
Bepaling van het verlies: vergelijk de voorspellingen met de werkelijke waarden met behulp van de verliesfunctie;
Achterwaartse stap: bereken de gradiënten ten opzichte van de modelparameters via backpropagation;
Parameterupdate: pas de modelparameters aan met behulp van de optimizer;
Voortgang monitoren: druk periodiek het verlies af om de convergentie te observeren.

Zoals te zien is, lijkt het trainingsproces op dat van lineaire regressie.


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

Opmerking

Het aanroepen van model(input) roept automatisch de forward()-methode van het model aan. Dit komt doordat nn.Module de __call__-methode overschrijft, die intern forward() aanroept. Het wordt aanbevolen om model(input) te gebruiken in plaats van model.forward(input), omdat de eerste methode ervoor zorgt dat eventuele hooks of extra functionaliteiten (zoals model.train() of model.eval()) correct worden toegepast.

Convergentie observeren

Naast het trainen van het model registreren we ook het trainingsverlies bij elk epoch en visualiseren we dit in de tijd. Zoals te zien is in de grafiek, daalt het trainingsverlies aanvankelijk snel en stabiliseert het geleidelijk rond epoch 60. Na dit punt neemt het verlies veel langzamer af, wat suggereert dat het model waarschijnlijk geconvergeerd is. Daarom is het gebruik van ongeveer 40 epochs voor dit model voldoende.

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 1. Hoofdstuk 18

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Veeg om het menu te tonen