Training des Modells

Vorbereitung auf das Training

Zuerst müssen Sie sicherstellen, dass das Modell, die Verlustfunktion und der Optimierer ordnungsgemäß definiert sind. Gehen wir jeden Schritt durch:

Verlustfunktion: Für die Klassifikation können Sie CrossEntropyLoss verwenden, die rohe kontinuierliche Werte (Logits) als Eingabe erwartet und automatisch softmax anwendet;
Optimierer: Sie können den Adam-Optimierer für effiziente Gradientenaktualisierungen verwenden.

python
9
1
2
3
4
5
6
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 kombiniert der Cross-Entropy-Verlust log-softmax und negative log-likelihood (NLL) Verlust in einer einzigen Verlustfunktion:

wo:

z_y ist das Logit, das der korrekten Klasse entspricht;
C ist die Gesamtanzahl der Klassen.

Es ist auch wichtig, die Daten in Trainings- und Validierungssets zu unterteilen (idealerweise sollte auch ein separates Testset existieren). Da der Datensatz relativ klein ist (1143 Zeilen), verwenden wir eine 80% zu 20% Aufteilung. In diesem Fall dient das Validierungsset auch als Testset.

Außerdem sollten die resultierenden NumPy-Arrays in Tensors umgewandelt werden, da PyTorch-Modelle Tensor-Eingaben für Berechnungen benötigen.

python
9
1
2
3
4
5
6
7
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)

Trainingsschleife

Die Trainingsschleife umfasst die folgenden Schritte für jede Epoche:

Vorwärtsdurchlauf: die Eingabefunktionen durch das Modell leiten, um Vorhersagen zu generieren;
Verlustberechnung: die Vorhersagen mit der Wahrheit vergleichen, indem die Verlustfunktion verwendet wird;
Rückwärtsdurchlauf: Gradienten in Bezug auf die Modellparameter mit Backpropagation berechnen;
Parameteraktualisierung: Modellparameter mit dem Optimierer anpassen;
Fortschritt überwachen: den Verlust regelmäßig ausgeben, um die Konvergenz zu beobachten.

Wie Sie sehen können, ähnelt der Trainingsprozess dem der linearen Regression.

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


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

Beobachtung der Konvergenz

Zusätzlich zum Training des Modells zeichnen wir auch den Trainingsverlust bei jedem Epoch auf und plotten ihn über die Zeit. Wie im Diagramm gezeigt, nimmt der Trainingsverlust zunächst schnell ab und stabilisiert sich dann allmählich um den Epoch 60. Ab diesem Punkt nimmt der Verlust in einem viel langsameren Tempo ab, was darauf hindeutet, dass das Modell wahrscheinlich konvergiert ist. Daher wären für dieses Modell etwa 40 Epochen ausreichend.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 2