PyTorch-Verlustfunktionen

Die Verlustfunktion misst die Lücke zwischen den Vorhersagen des Modells und den wahren Werten und dient als zentrale Richtschnur für das Training neuronaler Netze – der Optimierer aktualisiert die Modellparameter durch Minimierung der Verlustfunktion.

PyTorch, in seinemtorch.nnModul, verfügt über mehr als zehn integrierte gängige Verlustfunktionen, die wichtige Aufgabentypen wie Klassifikation, Regression und Ranking abdecken.


1. Grundlagen der Verlustfunktionen

Grundlegende Verwendung

Alle PyTorch-Verlustfunktionen sindnn.ModuleUnterklassen von , mit einheitlicher Verwendung:

Beispiel

import torch
import torch.nn as nn

# 1. Verlustfunktion instanziieren
criterion = nn.CrossEntropyLoss()

# 2. Verlust berechnen (Vorhersagen zuerst, Ground Truth als Zweites)
loss = criterion(predictions, targets)

# 3. Backpropagation
loss.backward()

Shape-Konventionen für Vorhersagewerte

Verschiedene Verlustfunktionen haben unterschiedliche Shape-Anforderungen an Eingaben; dies ist die häufigste Fehlerquelle für Anfänger:

VerlustfunktionShape der Vorhersage (Eingabe)Form des Labels (Ziel)
CrossEntropyLoss(N, C)Rohe Logits(N,)Ganzzahlige Klassenindizes
BCELoss(N,)Wahrscheinlichkeiten nach Sigmoid(N,)0/1-Gleitkommazahlen
BCEWithLogitsLoss(N,)Rohe Logits(N,)0/1-Gleitkommazahlen
MSELoss(N,)Beliebige reelle Zahl(N,)Beliebige reelle Zahl
NLLLoss(N, C)Wahrscheinlichkeiten nach log_softmax(N,)Ganzzahlige Klassenindizes

N = Batch-Größe,C= Anzahl der Klassen


2. Verlustfunktionen für Klassifikationsaufgaben

2.1 CrossEntropyLoss (Kreuzentropie-Verlust)

Die am häufigsten verwendete Multiklassen-Verlustfunktion,führt intern automatisch Softmax + log + Vorzeichenumkehr durch; Softmax muss nicht manuell auf die Modellausgabe angewendet werden.

Mathematische Formel:

Loss = -sum(y_c * log(p_c))

wobei p_c = exp(x_c) / sum_j exp(x_j) die Softmax-Ausgabe ist.

Beispiel

import torch
import torch.nn as nn

criterion = nn.CrossEntropyLoss()

# Modellausgabe: Roh-Logits, Form (batch_size, num_classes)
# Softmax muss nicht im Voraus angewendet werden!
predictions = torch.tensor([
    [2.0, 0.5, 0.3],   # Beispiel 1, wahrscheinlichste Klasse 0
    [0.1, 3.0, 0.2],   # Beispiel 2, wahrscheinlichste Klasse 1
    [0.2, 0.1, 4.0],   # Beispiel 3, wahrscheinlichste Klasse 2
])

# Labels: ganzzahlige Klassenindizes, Form (batch_size,)
targets = torch.tensor([0, 1, 2])

loss = criterion(predictions, targets)
print(f"Loss: {loss.item():.4f}")  # Verlust: 0.1763

Unterstützt weiche Labels (Label Smoothing):

Beispiel

# Label Smoothing, lindert Overfitting, wird häufig in Bildklassifizierungswettbewerben verwendet
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)

# Unterstützt auch die direkte Übergabe von Soft Labels (Wahrscheinlichkeitsverteilungen)
soft_targets = torch.tensor([
    [0.9, 0.05, 0.05],
    [0.05, 0.9, 0.05],
])
predictions = torch.randn(2, 3)
loss = criterion(predictions, soft_targets)

Anwendbare Szenarien:Alle Multiklassen-Aufgaben wie Multiklassen-Klassifizierung (Katze/Hund/Vogel), Bildklassifizierung, Textklassifizierung usw.


2.2 BCELoss (Binärer Kreuzentropie-Verlust)

Speziell verwendet fürbinäre Klassifizierungoderund Multi-Label-KlassifizierungAufgaben. Die Eingabe mussSigmoidWahrscheinlichkeitswerte nach der Verarbeitung (0-1) sein.

Mathematische Formel:

Loss = -[y * log(p) + (1-y) * log(1-p)]

Beispiel

criterion = nn.BCELoss()

# Die Modellausgabe muss zuerst durch Sigmoid laufen, Bereich (0, 1)
raw_output = torch.tensor([2.0, -1.0, 0.5, -3.0])
predictions = torch.sigmoid(raw_output)   # [0.88, 0.27, 0.62, 0.05]

# Labels: Float-Typ 0.0 oder 1.0
targets = torch.tensor([1.0, 0.0, 1.0, 0.0])

loss = criterion(predictions, targets)
print(f"Loss: {loss.item():.4f}")  # Loss: 0.2824

# Multi-Label-Klassifikation (jedes Beispiel kann zu mehreren Klassen gehören)
# Form von predictions: (batch_size, num_labels)
predictions_ml = torch.sigmoid(torch.randn(4, 5))
targets_ml     = torch.randint(0, 2, (4, 5)).float()
loss_ml = criterion(predictions_ml, targets_ml)

BCELossDie Eingabe muss im Bereich (0, 1) liegen. Das Übergeben von rohen Logits führt zu numerischer Instabilität oder sogar NaN. Es wird empfohlen, die verbesserte Version unten zu verwenden,BCEWithLogitsLoss。


2.3 BCEWithLogitsLoss

BCELosswelches eine verbesserte Version von ,ist und intern automatisch Sigmoid ausführt, wodurch eine bessere numerische Stabilität gewährleistet wird und das als erste Wahl empfohlen wird.

Beispiel

criterion = nn.BCEWithLogitsLoss()

# Rohe Logits direkt übergeben, kein manuelles Sigmoid nötig
predictions = torch.tensor([2.0, -1.0, 0.5, -3.0])
targets     = torch.tensor([1.0,  0.0, 1.0,  0.0])

loss = criterion(predictions, targets)
print(f"Loss: {loss.item():.4f}")

# Äquivalent zu (aber mit besserer numerischer Stabilität):
# loss = BCELoss(Sigmoid(predictions), targets)

Mit positiven Stichprobengewichten (Umgang mit Klassenungleichgewicht):

Beispiel

# pos_weight: Gewicht für positive Stichproben; je größer der Wert, desto mehr Aufmerksamkeit wird positiven Stichproben geschenkt
# Zum Beispiel, wenn negative Stichproben 10-mal so zahlreich sind wie positive, setze pos_weight=10
pos_weight = torch.tensor([10.0])
criterion = nn.BCEWithLogitsLoss(pos_weight=pos_weight)

Anwendungsszenarien:Binäre Klassifikation (Spam-Erkennung), Multilabel-Klassifikation (Multilabel-Tagging von Artikeln), Objekterkennung (Vordergrund-/Hintergrund-Erkennung).


2.4 NLLLoss (Negativer Log-Likelihood-Verlust)

Erfordert manuelles Anwenden auf die Modellausgabelog_softmax, was höhere Flexibilität bietet.CrossEntropyLoss = LogSoftmax + NLLLoss。

Beispiel

criterion = nn.NLLLoss()

# log_softmax muss zuerst manuell angewendet werden
raw_output   = torch.randn(4, 3)   # (batch, num_classes)
log_probs    = torch.log_softmax(raw_output, dim=1)

targets = torch.tensor([0, 2, 1, 0])
loss = criterion(log_probs, targets)

Anwendungsfälle:Wenn Log-Wahrscheinlichkeiten in Zwischenschritten benötigt werden (z. B. CTC, Beam Search); in anderen Fällen bevorzugen Sie die Verwendung vonCrossEntropyLoss。


3. Verlustfunktionen für Regressionsaufgaben

3.1 MSELoss (Mittlerer quadratischer Fehler)

Die klassischste Verlustfunktion für Regression, diesehr empfindlich auf große Fehler reagiert(da das Quadrieren die Auswirkungen großer Fehler verstärkt).

Mathematische Formel:

MSELoss = (1/N) * sum((y_i - y_hat_i)^2)

Beispiel

criterion = nn.MSELoss()

predictions = torch.tensor([2.5, 0.5, 2.0, 8.0])
targets     = torch.tensor([3.0, -0.5, 2.0, 7.0])

loss = criterion(predictions, targets)
print(f"MSE Loss: {loss.item():.4f}")  # MSE-Verlust: 0.3750

# Manuelle Überprüfung
manual = ((predictions - targets) ** 2).mean()
print(f"Manuelle Berechnung: {manual.item():.4f}")  # 0.3750

Anwendbare Szenarien:Kontinuierliche Wertregression wie Hauspreisvorhersage und Temperaturvorhersage; funktioniert gut, wenn keine offensichtlichen Ausreißer in den Daten vorhanden sind.


3.2 L1Loss (Mittlerer absoluter Fehler)

PaarRobuster gegenüber Ausreißernweil es den Absolutwert anstelle des Quadrierens verwendet, sodass große Fehler nicht übermäßig verstärkt werden.

Mathematische Formel:

L1Loss = (1/N) * sum(|y_i - y_hat_i|)

Beispiel

criterion = nn.L1Loss()

predictions = torch.tensor([2.5, 0.5, 2.0, 8.0])
targets     = torch.tensor([3.0, -0.5, 2.0, 7.0])

loss = criterion(predictions, targets)
print(f"L1-Verlust: {loss.item():.4f}")  # L1-Verlust: 0.5000

3.3 SmoothL1Loss (Huber-Verlust)

Kombiniert die Vorteile von MSE und L1: Verwendet MSE für kleine Fehler (glatte, stabile Gradienten) und L1 für große Fehler (ausreißerresistent). Es ist der Standardverlust in der Objekterkennung (Faster R-CNN).

Mathematische Formel:

SmoothL1(x) = 0.5*x^2 if |x| < 1, else |x| - 0.5

Beispiel

criterion = nn.SmoothL1Loss()

predictions = torch.tensor([2.5, 0.5, 2.0, 8.0])
targets     = torch.tensor([3.0, -0.5, 2.0, 7.0])

loss = criterion(predictions, targets)
print(f"SmoothL1-Verlust: {loss.item():.4f}")

Vergleich der drei Regressionsverluste:

Beispiel

import torch
import torch.nn as nn

predictions = torch.tensor([0.0, 1.0, 5.0, 10.0])  # Simuliere Fehler unterschiedlicher Größenordnungen
targets     = torch.zeros(4)

for name, fn in [("MSELoss", nn.MSELoss(reduction='none')),
                 ("L1Loss",  nn.L1Loss(reduction='none')),
                 ("SmoothL1",nn.SmoothL1Loss(reduction='none'))]:
    losses = fn(predictions, targets)
    print(f"{name:12s}: {[f'{l:.2f}' for l in losses.tolist()]}")
输出示例:
MSELoss     : ['0.00', '1.00', '25.00', '100.00']   # 大误差被平方放大
L1Loss      : ['0.00', '1.00',  '5.00',  '10.00']   # 线性增长
SmoothL1    : ['0.00', '0.50',  '4.50',   '9.50']   # 中间值

Anwendbare Szenarien:Regressionsaufgaben mit sowohl kleinen Fehlern als auch Ausreißern, wie Bounding-Box-Regression in der Objekterkennung und Tiefenschätzung.


4. Fortgeschrittene Verlustfunktionen

4.1 HuberLoss

SmoothL1LossEine verallgemeinerte Version von , die eine benutzerdefinierte Schwellenwertumschaltung ermöglichtdelta(Standard 1.0).

Beispiel

# delta steuert den Umschaltpunkt zwischen MSE und L1
criterion = nn.HuberLoss(delta=1.5)

predictions = torch.randn(10)
targets     = torch.randn(10)
loss = criterion(predictions, targets)

4.2 KLDivLoss (KL-Divergenz)

Misst den Unterschied zwischen zwei Wahrscheinlichkeitsverteilungen, häufig verwendet inKnowledge Distillationundvariationalem Autoencoder (VAE)。

Mathematische Formel:

KL(P || Q) = sum(P(i) * log(P(i) / Q(i)))

Beispiel

criterion = nn.KLDivLoss(reduction='batchmean')

# Eingabe muss Log-Wahrscheinlichkeiten sein, Ziel sind gewöhnliche Wahrscheinlichkeiten
log_predictions = torch.log_softmax(torch.randn(4, 5), dim=1)
targets         = torch.softmax(torch.randn(4, 5), dim=1)

loss = criterion(log_predictions, targets)
print(f"KL-Divergenz-Verlust: {loss.item():.4f}")

Typische Verwendung bei der Wissensdestillation:

Beispiel

temperature = 4.0  # Temperaturkoeffizient, je größer, desto weicher

# Ausgabe des Teacher-Modells
teacher_logits = torch.randn(32, 10)
# Ausgabe des Student-Modells
student_logits = torch.randn(32, 10)

soft_labels = torch.softmax(teacher_logits / temperature, dim=1)
soft_preds  = torch.log_softmax(student_logits / temperature, dim=1)

distill_loss = nn.KLDivLoss(reduction='batchmean')(soft_preds, soft_labels)
distill_loss *= temperature ** 2  # Gradientenbetrag wiederherstellen

4.3 MarginRankingLoss (Ranking-Verlust)

Bestimmt die relative Reihenfolge zweier Eingaben, häufig verwendet inLearning to RankundÄhnlichkeitslernen。

Beispiel

criterion = nn.MarginRankingLoss(margin=0.5)

# x1 sollte näher am Ziel liegen als x2 (y=1 bedeutet x1 > x2)
x1 = torch.tensor([0.8, 0.3, 0.6])
x2 = torch.tensor([0.2, 0.7, 0.5])
y  = torch.tensor([1.0, -1.0, 1.0])  # 1: x1>x2, -1: x1<x2

loss = criterion(x1, x2, y)

4.4 TripletMarginLoss (Triplet-Verlust)

Wird für metrisches Lernen verwendet, wobeiAnkerundPositivbeispiel (gleiche Klasse)einen geringeren Abstand haben müssen als der zumNegativbeispiel (andere Klasse)Abstand.

Beispiel

criterion = nn.TripletMarginLoss(margin=1.0)

# Jeder Vektor hat die Dimension embedding_dim
anchor   = torch.randn(32, 128)   # Ankerbeispiel
positive = torch.randn(32, 128)   # Positives Beispiel (gleiche Klasse)
negative = torch.randn(32, 128)   # Negatives Beispiel (andere Klasse)

loss = criterion(anchor, positive, negative)
# Ziel: dist(anchor, positive) + margin < dist(anchor, negative)

Anwendbare Szenarien:Gesichtserkennung, Bildsuche, Few-Shot-Learning.


4.5 CTCLoss (Verlust für Sequenzkennzeichnung)

Verwendet fürSequenzaufgaben, bei denen Eingabe- und Ausgabelängen nicht übereinstimmen,wie Spracherkennung (akustische Sequenz -> Textsequenz), Handschrifterkennung.

Beispiel

criterion = nn.CTCLoss(blank=0)  # Index des Blank-Labels

# log_probs: (T, N, C) T=Zeitschritte, N=Batch, C=Anzahl der Klassen
T, N, C = 50, 4, 20
log_probs    = torch.log_softmax(torch.randn(T, N, C), dim=2)
targets      = torch.randint(1, C, (N * 10,))   # Verkettete Zielsequenz
input_lengths  = torch.full((N,), T, dtype=torch.long)
target_lengths = torch.full((N,), 10, dtype=torch.long)

loss = criterion(log_probs, targets, input_lengths, target_lengths)

5. Detaillierte Erklärung des reduction-Parameters

Alle Verlustfunktionen unterstützen denreductionParameter, der steuert, wie Stichprobenverluste aggregiert werden:

Beispiel

predictions = torch.tensor([1.0, 2.0, 3.0, 4.0])
targets     = torch.tensor([1.5, 2.5, 2.0, 5.0])

# Fehler pro Stichprobe: [0.25, 0.25, 1.00, 1.00]

# mean (Standard): Durchschnitt über alle Stichproben
loss_mean = nn.MSELoss(reduction='mean')(predictions, targets)
print(f"mean: {loss_mean.item():.4f}")   # 0.6250

# sum: Summe über alle Samples
loss_sum  = nn.MSELoss(reduction='sum')(predictions, targets)
print(f"sum: {loss_sum.item():.4f}")    # 2.5000

# none: gibt den individuellen Loss jedes Samples zurück (wird oft zur Gewichtung verwendet)
loss_none = nn.MSELoss(reduction='none')(predictions, targets)
print(f"none: {loss_none.tolist()}")     # [0.25, 0.25, 1.0, 1.0]

reduction='none'Praktische Anwendung — Gewichtung verschiedener Samples:

Beispiel

# Samples mit größeren Fehlern höher gewichten (Focal-Loss-Idee)
per_sample_loss = nn.MSELoss(reduction='none')(predictions, targets)
weights = torch.tensor([1.0, 1.0, 2.0, 2.0])   # Gewichte manuell festlegen
weighted_loss = (per_sample_loss * weights).mean()

6. Klassen- und Stichprobengewichte

Klassengewichte (Umgang mit Klassenungleichgewicht)

Wenn bestimmte Klassen im Datensatz nur sehr wenige Beispiele haben, weisen Sie Minderheitsklassen höhere Gewichte zu:

Beispiel

# Angenommen, 3 Klassen: Klasse 0 hat 1000, Klasse 1 hat 100, Klasse 2 hat 50
# Gewicht umgekehrt proportional zur Häufigkeit
class_counts = torch.tensor([1000.0, 100.0, 50.0])
weights = 1.0 / class_counts
weights = weights / weights.sum() * len(weights)  # Normalisieren

criterion = nn.CrossEntropyLoss(weight=weights)

Bestimmte Labels ignorieren

Bei Aufgaben wie der semantischen Segmentierung ist es oft notwendig, Randpixel zu ignorieren (mit Label 255):

Beispiel

# ignore_index: Dieses Label bei der Berechnung des Losses ignorieren
criterion = nn.CrossEntropyLoss(ignore_index=255)

# Szenario der semantischen Segmentierung
predictions = torch.randn(2, 21, 256, 256)   # (N, C, H, W)
targets     = torch.randint(0, 22, (2, 256, 256))
targets[targets == 21] = 255                  # Grenzen mit 255 beschriftet

loss = criterion(predictions, targets)

7. Benutzerdefinierte Verlustfunktionen

Wenn integrierte Verlustfunktionen die Anforderungen nicht erfüllen können, können Sie sie auf zwei Arten anpassen:

Methode 1: Funktional (Einfach)

Beispiel

import torch
import torch.nn.functional as F

def focal_loss(predictions, targets, gamma=2.0, alpha=0.25):
    """
Focal Loss: löst das gravierende Problem des Ungleichgewichts zwischen positiven und negativen Stichproben bei der Objekterkennung
Reduziert die Gewichtung leicht klassifizierbarer Stichproben, sodass sich das Modell auf schwierige Stichproben konzentrieren kann
    """

    ce_loss = F.cross_entropy(predictions, targets, reduction='none')
    pt = torch.exp(-ce_loss)                          # Wahrscheinlichkeit der korrekten Vorhersage
    focal_weight = alpha * (1 - pt) ** gamma          # Schwierige Beispiele erhalten höheres Gewicht
    return (focal_weight * ce_loss).mean()


# Verwenden
predictions = torch.randn(8, 10)
targets     = torch.randint(0, 10, (8,))
loss = focal_loss(predictions, targets)

Methode 2: Unterklassenbildung von nn.Module (Empfohlen)

Beispiel

import torch
import torch.nn as nn

class DiceLoss(nn.Module):
    """
Dice Loss: wird häufig in der Bildsegmentierung verwendet, optimiert direkt den Dice-Koeffizienten
Robuster als CrossEntropy gegenüber Klassenungleichgewicht (z. B. Segmentierung kleiner Objekte)
    """

    def __init__(self, smooth=1.0):
        super().__init__()
        self.smooth = smooth

    def forward(self, predictions, targets):
        # predictions: (N, C, H, W) -> Wahrscheinlichkeiten nach Sigmoid
        # targets: (N, C, H, W) -> one-hot-codierte Labels
        predictions = torch.sigmoid(predictions)

        # Zu (N, -1) abflachen
        pred_flat   = predictions.view(predictions.size(0), -1)
        target_flat = targets.view(targets.size(0), -1).float()

        intersection = (pred_flat * target_flat).sum(dim=1)
        dice = (2.0 * intersection + self.smooth) / (
            pred_flat.sum(dim=1) + target_flat.sum(dim=1) + self.smooth
        )
        return 1 - dice.mean()


class CombinedLoss(nn.Module):
    """
Kombinierter Verlust: CrossEntropy + Dice, der Pixelklassifizierung und Regionenüberlappung ausbalanciert
Übliche Kombination für die Bildsegmentierung
    """

    def __init__(self, ce_weight=0.5, dice_weight=0.5):
        super().__init__()
        self.ce_weight   = ce_weight
        self.dice_weight = dice_weight
        self.ce   = nn.CrossEntropyLoss()
        self.dice = DiceLoss()

    def forward(self, predictions, targets):
        return (self.ce_weight   * self.ce(predictions, targets) +
                self.dice_weight * self.dice(predictions, targets))


# Verwenden
criterion = CombinedLoss(ce_weight=0.4, dice_weight=0.6)

8. Leitfaden zur Auswahl der Verlustfunktion

Nach Aufgabentyp auswählen

AufgabentypEmpfohlene VerlustfunktionHinweise
MehrklassenklassifikationCrossEntropyLossAllgemeinste, bevorzugte Wahl
Mehrklassenklassifikation (Klassenungleichgewicht)CrossEntropyLoss(weight=...)Minderheitsklassen gewichten
Mehrklassenklassifikation (verrauschte Labels)CrossEntropyLoss(label_smoothing=0.1)Verhindert Overfitting
Binäre KlassifikationBCEWithLogitsLossStabiler als BCELoss
Multilabel-KlassifikationBCEWithLogitsLossJedes Label wird unabhängig bewertet
Objekterkennung (Klassifikationskopf)CrossEntropyLoss / Focal LossFocal verwenden, wenn Positiv-Negativ-Stichproben unausgewogen sind
Objekterkennung (Regressionskopf)SmoothL1Loss / GIoULossGängige Praxis
Gewöhnliche RegressionMSELossErste Wahl, wenn keine Ausreißer vorhanden sind
Regression mit AusreißernHuberLoss / SmoothL1LossRobuste Regression
BildsegmentierungCrossEntropyLoss + DiceLossKombinierte Verwendung funktioniert besser
SpracherkennungCTCLossSequenzalignment
Metrisches Lernen / GesichtserkennungTripletMarginLossMerkmalsraum-Distanz lernen
WissensdestillationKLDivLossSoft-Label-Verteilung lernen

Häufige Fehlanwendungen und Hinweise

Beispiel

# Falsch: Softmax manuell vor CrossEntropyLoss angewendet
output = torch.softmax(model(x), dim=1)   # Redundantes softmax
loss   = nn.CrossEntropyLoss()(output, targets)  # Es wird intern erneut angewendet

# Korrekt: Logits direkt übergeben
output = model(x)  # Rohe Logits
loss   = nn.CrossEntropyLoss()(output, targets)


# Falsch: Rohwerte ohne Sigmoid an BCELoss übergeben
loss = nn.BCELoss()(model(x), targets)    # Kann [0,1] überschreiten, numerisch instabil

# Korrekt: BCEWithLogitsLoss verwenden
loss = nn.BCEWithLogitsLoss()(model(x), targets)


# Falsch: Label-Typkonflikt (Integer vs. Float)
targets = torch.tensor([1, 0, 1])                     # Integer-Typ
loss    = nn.BCEWithLogitsLoss()(preds, targets)       # Fehler!

# Richtig: BCEWithLogitsLoss erfordert Float-Labels
targets = torch.tensor([1.0, 0.0, 1.0])               # Float-Typ
loss    = nn.BCEWithLogitsLoss()(preds, targets)       # Richtig


# Falsch: loss wird nicht mit .item() extrahiert, wodurch der Berechnungsgraph weiter wächst und der GPU-Speicher überläuft
total_loss += loss      # loss ist ein Tensor und hält den Berechnungsgraphen

# Richtig: .item() verwenden, um einen Skalar zu extrahieren
total_loss += loss.item()

Vollständiges Trainingsbeispiel

Beispiel

import torch
import torch.nn as nn
import torch.optim as optim

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Modell & Verlustfunktion & Optimierer
model     = MyModel().to(device)
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
optimizer = optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(num_epochs):
    model.train()
    total_loss, correct = 0.0, 0

    for inputs, labels in train_loader:
        inputs = inputs.to(device)
        labels = labels.to(device)

        optimizer.zero_grad()
        outputs = model(inputs)          # Roh-Logits

        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        total_loss += loss.item() * inputs.size(0)    # .item() extrahiert einen Skalar
        correct    += (outputs.argmax(1) == labels).sum().item()

    avg_loss = total_loss / len(train_loader.dataset)
    accuracy = correct / len(train_loader.dataset)
    print(f"Epoch {epoch+1} | Loss: {avg_loss:.4f} | Acc: {accuracy:.4f}")
Andere Erweiterungen