Leer Training van het Model | Neurale Netwerken in PyTorch

Voorbereiding op training

Allereerst moet worden gecontroleerd of het model, de verliesfunctie en de optimizer correct zijn gedefinieerd. De stappen zijn als volgt:

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 log-softmax en negative log-likelihood (NLL) verlies in één verliesfunctie:

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), wordt een 80% tot 20% verdeling gebruikt. In dit geval fungeert de validatieset ook als testset.

Daarnaast moeten de resulterende NumPy-arrays 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 propagatie: voer de invoerkenmerken door het model om voorspellingen te genereren;
Berekening van verlies: vergelijk de voorspellingen met de werkelijke waarden met behulp van de verliesfunctie;
Achterwaartse propagatie: 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()

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, neemt het trainingsverlies aanvankelijk snel af 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 3. Hoofdstuk 2

Vraag AI

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

Veeg om het menu te tonen

Voorbereiding op training

Allereerst moet worden gecontroleerd of het model, de verliesfunctie en de optimizer correct zijn gedefinieerd. De stappen zijn als volgt:

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 log-softmax en negative log-likelihood (NLL) verlies in één verliesfunctie:

waarbij:

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

Daarnaast moeten de resulterende NumPy-arrays 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 propagatie: voer de invoerkenmerken door het model om voorspellingen te genereren;
Berekening van verlies: vergelijk de voorspellingen met de werkelijke waarden met behulp van de verliesfunctie;
Achterwaartse propagatie: 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()

Convergentie observeren

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 3. Hoofdstuk 2

Training van het Model

Voorbereiding op training

Trainingslus

Convergentie observeren

Awesome!

Training van het Model

Voorbereiding op training

Trainingslus

Convergentie observeren