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.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:
| Verlustfunktion | Shape 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.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
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
# 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
# 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
# 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
# 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 von
CrossEntropyLoss。
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
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
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
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.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
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
# 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
# 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
# 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
# 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
# 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
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
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
# 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
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.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.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
| Aufgabentyp | Empfohlene Verlustfunktion | Hinweise |
|---|---|---|
| Mehrklassenklassifikation | CrossEntropyLoss | Allgemeinste, bevorzugte Wahl |
| Mehrklassenklassifikation (Klassenungleichgewicht) | CrossEntropyLoss(weight=...) | Minderheitsklassen gewichten |
| Mehrklassenklassifikation (verrauschte Labels) | CrossEntropyLoss(label_smoothing=0.1) | Verhindert Overfitting |
| Binäre Klassifikation | BCEWithLogitsLoss | Stabiler als BCELoss |
| Multilabel-Klassifikation | BCEWithLogitsLoss | Jedes Label wird unabhängig bewertet |
| Objekterkennung (Klassifikationskopf) | CrossEntropyLoss / Focal Loss | Focal verwenden, wenn Positiv-Negativ-Stichproben unausgewogen sind |
| Objekterkennung (Regressionskopf) | SmoothL1Loss / GIoULoss | Gängige Praxis |
| Gewöhnliche Regression | MSELoss | Erste Wahl, wenn keine Ausreißer vorhanden sind |
| Regression mit Ausreißern | HuberLoss / SmoothL1Loss | Robuste Regression |
| Bildsegmentierung | CrossEntropyLoss + DiceLoss | Kombinierte Verwendung funktioniert besser |
| Spracherkennung | CTCLoss | Sequenzalignment |
| Metrisches Lernen / Gesichtserkennung | TripletMarginLoss | Merkmalsraum-Distanz lernen |
| Wissensdestillation | KLDivLoss | Soft-Label-Verteilung lernen |
Häufige Fehlanwendungen und Hinweise
Beispiel
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.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}")