PyTorch Batch-Normalisierung und Dropout
Batch-Normalisierung und Dropout sind zwei der wichtigsten Regularisierungs- und Stabilisierungstechniken beim Training tiefer neuronaler Netze. Erstere löst das Problem der internen Kovariatenverschiebung während des Trainings und macht tiefere Netzwerke trainierbar; Letzteres verhindert Overfitting durch zufälliges Verwerfen von Neuronen und verbessert die Generalisierung des Modells. Beide werden üblicherweise zusammen verwendet und sind Standardkomponenten moderner neuronaler Netze.
1. Batch-Normalisierung
1.1 Grundprinzipien
Während des Trainings tiefer Netzwerke werden kleine Änderungen der Parameter der vorherigen Schicht mit zunehmender Tiefe der Schichten kontinuierlich verstärkt, wodurch sich die Eingabeverteilung nachfolgender Schichten ständig ändert — dieses Phänomen wird alsinterne Kovariatenverschiebung bezeichnet. Batch-Normalisierung löst dieses Problem, indem sie die Ausgabe jeder Schicht standardisiert und die Aktivierungswerte zwangsweise zurück in eine stabile Verteilung zieht.
Normalisierungsformel:
\[\hat{x}_i = \frac{x_i - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}}\]
\[y_i = \gamma \hat{x}_i + \beta\]
wobei:
- \(\mu_B\), \(\sigma_B^2\) sind der Mittelwert und die Varianz des aktuellen Batches
- \(\epsilon\) ist eine kleine Konstante, um Division durch null zu verhindern (Standard
1e-5) - \(\gamma\) und \(\beta\) sind lernbare Skalierungs- und Verschiebungsparameter, die es dem Netzwerk ermöglichen, die endgültige Verteilungsform selbst zu bestimmen
Vorteile der Batch-Normalisierung:
- Ermöglicht größere Lernraten, was das Training beschleunigt
- Verringert die Empfindlichkeit gegenüber der Initialisierung, wodurch das Training stabiler wird
- Hat einen gewissen Regularisierungseffekt, wodurch die Abhängigkeit von Dropout verringert wird
- Lindert verschwindende/explodierende Gradienten, wodurch tiefere Netzwerke trainierbar werden
1.2 BatchNorm1d / 2d / 3d
PyTorch bietet drei Versionen basierend auf den Eingabedimensionen, mit identischer Verwendung, die sich nur in der Form der Daten unterscheiden, die sie verarbeiten.
BatchNorm1d: für vollständig verbundene Schichten / Sequenzdaten
Beispiel
import torch.nn as nn
# Eingabeform: (N, C) oder (N, C, L)
# N=batch_size, C=Anzahl der Features/Kanäle, L=Sequenzlänge
bn1d = nn.BatchNorm1d(
num_features=128, # Anzahl der Features/Kanäle
eps=1e-5, # kleine Konstante, um Division durch Null zu verhindern (Standard 1e-5)
momentum=0.1, # Momentum für gleitenden Durchschnitt (Standard: 0.1)
affine=True, # ob gamma und beta gelernt werden sollen (Standard: True)
track_running_stats=True, # ob laufender Mittelwert/Varianz verfolgt werden sollen (Standard: True)
)
# wird nach vollständig verbundenen Schichten verwendet
x = torch.randn(32, 128) # (batch=32, features=128)
out = bn1d(x)
print(out.shape) # torch.Size([32, 128])
# Sequenzdaten (z. B. nach 1D-Faltung)
x_seq = torch.randn(32, 128, 50) # (batch, channels, seq_len)
out_seq = bn1d(x_seq)
print(out_seq.shape) # torch.Size([32, 128, 50])
BatchNorm2d: für Feature-Maps von CNN-Bildern
Beispiel
# Unabhängig für jeden Kanal C normalisieren
bn2d = nn.BatchNorm2d(num_features=64) # 64 Kanäle
x = torch.randn(32, 64, 28, 28) # (Batch, Kanäle, Höhe, Breite)
out = bn2d(x)
print(out.shape) # torch.Size([32, 64, 28, 28])
BatchNorm3d: für 3D-Faltung (Video / medizinische Bildgebung)
Beispiel
bn3d = nn.BatchNorm3d(num_features=32)
x = torch.randn(4, 32, 16, 32, 32) # (Batch, Kanäle, Tiefe, h, w)
out = bn3d(x)
print(out.shape) # torch.Size([4, 32, 16, 32, 32])
Lernbare Parameter anzeigen
Beispiel
print(f"weight (gamma) Form: {bn.weight.shape}") # torch.Size([64])
print(f"bias (beta) Form: {bn.bias.shape}") # torch.Size([64])
print(f"running_mean Form: {bn.running_mean.shape}") # torch.Size([64])
print(f"running_var Form: {bn.running_var.shape}") # torch.Size([64])
# running_mean / running_var sind keine trainierbaren Parameter
# Sie sind Statistiken des gleitenden Durchschnitts, die während der Inferenz verwendet werden
print(f"Anzahl trainierbarer Parameter: {sum(p.numel() for p in bn.parameters())}") # 128(64×2)
Bedeutung des momentum-Parameters
Beispiel
# running_mean = (1 - momentum) × running_mean + momentum × batch_mean
# d. h., je größer das Momentum, desto größer das Gewicht der Statistiken des aktuellen Batch
# Standard 0.1: normalerweise angemessen
# bei kleiner Batch-Größe, erwägen Sie, es herunterzuregeln: momentum=0.01, um instabile Statistiken zu vermeiden
bn = nn.BatchNorm2d(64, momentum=0.01)
# momentum=None: verwendet kumulativen gleitenden Durchschnitt (CMA), geeignet für sehr kleine Batches
bn = nn.BatchNorm2d(64, momentum=None)
1.3 LayerNorm Layer-Normalisierung
PaarNormalisiere alle Merkmale einer einzelnen StichprobeEs hängt nicht vom Batch ab, geeignet für Szenarien mit kleinen oder variablen Batch-Größen.Die Standard-Normalisierungsmethode für Transformer。
BatchNorm:在 batch 维度计算均值/方差(跨样本,同通道) LayerNorm:在特征维度计算均值/方差(同样本,跨特征)
Beispiel
import torch.nn as nn
# ── Für vollständig verbundene / Transformer ────────────────────────
# normalized_shape: Normalisierung über die letzten paar Dimensionen
ln = nn.LayerNorm(normalized_shape=512)
x = torch.randn(32, 10, 512) # (batch, seq_len, embed_dim)
out = ln(x)
print(out.shape) # torch.Size([32, 10, 512])
# ── Über mehrere Dimensionen normalisieren ───────────────────────────────
ln_2d = nn.LayerNorm([64, 28, 28]) # über die drei Dimensionen C, H, W normalisieren
x = torch.randn(8, 64, 28, 28)
out = ln_2d(x)
# ── Typische Verwendung in Transformer ──────────────────────
class TransformerBlock(nn.Module):
def __init__(self, embed_dim, num_heads, ff_dim):
super().__init__()
self.attn = nn.MultiheadAttention(embed_dim, num_heads, batch_first=True)
self.ff = nn.Sequential(
nn.Linear(embed_dim, ff_dim),
nn.GELU(),
nn.Linear(ff_dim, embed_dim),
)
self.norm1 = nn.LayerNorm(embed_dim) # ← nach jedem Sublayer normalisieren
self.norm2 = nn.LayerNorm(embed_dim)
def forward(self, x):
attn_out, _ = self.attn(x, x, x)
x = self.norm1(x + attn_out) # Residual + Normalisierung
x = self.norm2(x + self.ff(x))
return x
1.4 GroupNorm Gruppen-Normalisierung
Teile die Kanäle in mehrere Gruppen aufgroup, und normalisiere innerhalb jeder Gruppe. Es ist nicht von der Batch-Größe abhängig und übertrifft BatchNorm in Szenarien mit kleinen Batches (z. B. Objekterkennung, medizinische Bildsegmentierung).
Beispiel
# Sonderfall: num_groups=1 ist äquivalent zu LayerNorm
# num_groups=num_channels ist äquivalent zu InstanceNorm
gn = nn.GroupNorm(
num_groups=32, # Anzahl der Gruppen (üblicherweise: 8, 16, 32)
num_channels=256, # Anzahl der Kanäle
eps=1e-5,
affine=True,
)
x = torch.randn(4, 256, 56, 56) # Kleiner Batch (4 Bilder), 256 Kanäle
out = gn(x)
print(out.shape) # torch.Size([4, 256, 56, 56])
# GroupNorm ist vollständig unbeeinflusst, wenn batch=1 (z. B. Inferenz auf einem einzelnen Bild)
x_single = torch.randn(1, 256, 56, 56)
out_single = gn(x_single) # Funktioniert normal
1.5 InstanceNorm Instanznormalisierung
PaarJeder Kanal jedes BeispielsUnabhängig normalisiert, ohne Einbeziehung der Batch-Dimension. Häufig verwendet beiBildstilübertragung— bewahrt die eigenen Stilinformationen jedes Bildes und verhindert, dass Statistiken anderer Bilder im Batch interferieren.
Beispiel
in2d = nn.InstanceNorm2d(
num_features=64,
affine=False, # Standardmäßig False (lernt gamma/beta nicht)
)
x = torch.randn(8, 64, 128, 128)
out = in2d(x)
print(out.shape) # torch.Size([8, 64, 128, 128])
1.6 Vergleich von Normalisierungsmethoden
| Methode | Normalisierungsdimension | Batch-Abhängigkeit | Anwendbare Szenarien |
|---|---|---|---|
BatchNorm |
Batch-übergreifend (gleicher Kanal) | Starke Abhängigkeit | CNN-Bildklassifizierung (großer Batch) |
LayerNorm |
Feature-übergreifend (gleiches Sample) | Keine Abhängigkeit | Transformer、NLP、RNN |
GroupNorm |
Kanäle innerhalb der Gruppe (gleiches Sample) | Keine Abhängigkeit | Objekterkennung, Segmentierung mit kleinen Batches |
InstanceNorm |
Räumliche Dimension (gleiches Sample und gleicher Kanal) | Keine Abhängigkeit | Bildstilübertragung, generative Modelle |
Kurzreferenz für Auswahlvorschläge
# Transformer / BERT / GPT → LayerNorm
# batch_size < 8, Objekterkennung/Segmentierung → GroupNorm(num_groups=32)
# Bildstilübertragung / CycleGAN → InstanceNorm2d
2. Dropout
2.1 Grundprinzipien
Dropout setzt während des Trainings die Ausgaben einiger Neuronen zufällig auf 0 (mit Wahrscheinlichkeitp), wodurch das Netzwerk gezwungen wird, sich nicht auf ein einzelnes Neuron zu verlassen, und dadurch robustere, verteilte Merkmalsrepräsentationen erlernt und Überanpassung wirksam verhindert.
Während des Trainings:
\[y_i = \begin{cases} 0 & \text{mit Wahrscheinlichkeit } p \\ \dfrac{x_i}{1-p} & \text{mit Wahrscheinlichkeit } 1-p \end{cases}\]
Beibehaltene Neuronen werden mit \(\frac{1}{1-p}\) skaliert, um den Erwartungswert unverändert zu halten (d. h. Inverted Dropout).
Während der Inferenz: Dropout wird automatisch deaktiviert, alle Neuronen nehmen normal an der Berechnung teil, was dem Ensemble-Durchschnitt mehrerer Teilnetzwerke entspricht.
训练时示意(p=0.5): 输入: [1.0, 2.0, 3.0, 4.0, 5.0] 掩码: [ 1, 0, 1, 0, 1 ] ← 随机生成 输出: [2.0, 0.0, 6.0, 0.0, 10.0] ← 保留的值乘以 1/(1-0.5)=2 推理时: 输出: [1.0, 2.0, 3.0, 4.0, 5.0] ← 原样输出
2.2 Dropout / Dropout2d / Dropout3d
Dropout: wird für vollständig verbundene Schichten verwendet
Beispiel
import torch.nn as nn
dropout = nn.Dropout(p=0.5) # p: Wahrscheinlichkeit, auf 0 zu setzen
x = torch.ones(2, 10)
print("Trainingsmodus:")
dropout.train()
print(dropout(x)) # Etwa 50% der Werte sind 0, beibehaltene Werte sind 2.0
print("\n"Evaluierungsmodus:")
dropout.eval()
print(dropout(x)) # Alle 1.0, Dropout deaktiviert
Beispielausgabe:
训练模式:
tensor([[2., 0., 2., 0., 2., 0., 0., 2., 2., 0.],
[0., 2., 0., 2., 0., 2., 2., 0., 0., 2.]])
评估模式:
tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])
Dropout2d: für CNN-Feature-Maps (vollständiger Kanal-Drop)
Dropout2dVerwirft zufällig ganze Kanäle, d. h., alle räumlichen Positionen eines Kanals werden gemeinsam auf null gesetzt. Dies ist für Faltungsmerkmale besser geeignet als punktweises Dropout, weil Aktivierungen benachbarter Pixel stark korreliert sind, wodurch punktweises Verwerfen weniger effektiv ist.
Beispiel
# Eingabe: (N, C, H, W)
x = torch.ones(4, 16, 8, 8) # 4 Bilder, 16 Kanäle
out = dropout2d(x)
print(out.shape) # torch.Size([4, 16, 8, 8])
# Überprüfen: gesamter Kanal wird verworfen
# Kanal-Drop-Status für das 0. Bild (ungleich null = beibehaltener Kanal, alle null = verworfener Kanal)
kept_channels = (out[0].sum(dim=(1, 2)) != 0).sum().item()
print(f"Bild 0 behielt {kept_channels}/16 Kanäle")
Dropout3d: verwendet für 3D-Faltung
Beispiel
dropout3d = nn.Dropout3d(p=0.2)
x = torch.ones(2, 8, 16, 16, 16)
out = dropout3d(x)
print(out.shape) # torch.Size([2, 8, 16, 16, 16])
Empfehlungen zur Wahl des p-Werts
Beispiel
nn.Dropout(p=0.5) # Klassischer Wert, Standard für versteckte Schichten
# Vollständig verbundene Schichten (schmale versteckte Schichten) oder kleine Netzwerke: niedrigeres Dropout
nn.Dropout(p=0.2) # Underfitting vermeiden
# Dropout2d für Faltungsschichten: generell niedriger
nn.Dropout2d(p=0.1) # Faltungsschichten haben bereits eine gewisse Regularisierungswirkung
# Dropout vor dem Klassifikationskopf (z. B. EfficientNet / ViT)
nn.Dropout(p=0.3) # Normalerweise zwischen 0.2 und 0.5
# Transformer-Attention / FFN-Dropout
nn.Dropout(p=0.1) # BERT-Standardwert, Transformer verwenden normalerweise kleinere Werte
2.3 AlphaDropout
Speziell entwickelt fürSELU-Aktivierungsfunktionpasst die Dropout-Variante automatisch den Mittelwert und die Varianz nach dem Droppen von Neuronen an und bewahrt dabei die selbstnormalisierende Eigenschaft.
Beispiel
class SelfNormalizingNet(nn.Module):
def __init__(self, in_dim, hidden_dim, num_classes):
super().__init__()
self.net = nn.Sequential(
nn.Linear(in_dim, hidden_dim),
nn.SELU(),
nn.AlphaDropout(p=0.1), # ← Wird mit SELU verwendet
nn.Linear(hidden_dim, hidden_dim),
nn.SELU(),
nn.AlphaDropout(p=0.1),
nn.Linear(hidden_dim, num_classes),
)
def forward(self, x):
return self.net(x)
Hinweis:AlphaDropout ist nur sinnvoll bei Verwendung der SELU-Aktivierungsfunktion; bei anderen Aktivierungsfunktionen verwenden Sie direkt reguläres Dropout.
3. Trainingsmodus und Evaluationsmodus
Das Verhalten von BatchNorm und Dropout während des Trainings und der Evaluationist völlig unterschiedlich, und sie müssen korrekt umgeschaltet werden; dies ist einer der häufigsten Fehler von Anfängern.
Vergleich der Verhaltensunterschiede
| Komponente | model.train() |
model.eval() |
|---|---|---|
| BatchNorm | Normalisiert unter Verwendung von Mittelwert/Varianz des aktuellen Batches;Aktualisiert running_mean/var | Normalisiert unter Verwendung von running_mean/var;Keine Aktualisierung |
| Dropout | Setzt zufällig auf null (mit Wahrscheinlichkeit p) | Deaktiviert, alle Neuronen geben normal aus |
Korrekte Verwendung
Beispiel
import torch.nn as nn
model = nn.Sequential(
nn.Linear(128, 256),
nn.BatchNorm1d(256),
nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(256, 10),
)
# ── Trainingsphase ──────────────────────────────────────
model.train() # ← In den Trainingsmodus wechseln (Standardzustand)
for inputs, labels in train_loader:
optimizer.zero_grad()
outputs = model(inputs) # BN verwendet Batch-Statistiken, Dropout verwirft zufällig
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# ── Evaluierungs-/Validierungsphase ─────────────────────────────────
model.eval() # ← In den Evaluierungsmodus wechseln (sehr wichtig!)
with torch.no_grad(): # Außerdem die Gradientenberechnung deaktivieren
for inputs, labels in val_loader:
outputs = model(inputs) # BN verwendet laufende Statistiken, Dropout ist deaktiviert
# ...
# ── Inferenz auf einem einzelnen Bild ──────────────────────────────────
model.eval()
with torch.inference_mode(): # Schneller als no_grad, nur für die Inferenz
output = model(single_input.unsqueeze(0))
pred = output.argmax(1).item()
Überprüfen, ob der Moduswechsel korrekt ist
Beispiel
x = torch.randn(8, 128)
model.train()
out_train_1 = model(x)
out_train_2 = model(x)
print("Trainingsmodus: zweimal dieselbe Ausgabe?", torch.allclose(out_train_1, out_train_2))
# False ← Dropout-Maske unterscheidet sich jedes Mal, Ausgaben unterscheiden sich (normal)
model.eval()
out_eval_1 = model(x)
out_eval_2 = model(x)
print("Evaluierungsmodus: zweimal dieselbe Ausgabe?", torch.allclose(out_eval_1, out_eval_2))
# True ← Dropout ist deaktiviert, BN verwendet feste Statistiken, Ausgabe ist deterministisch (normal)
4. Platzierung im Netzwerk
Platzierung von BatchNorm
Es gibt zwei Lehrmeinungen zur Platzierung von BatchNorm, die beide in der Praxis verwendet werden:
Schule 1: Vor der Aktivierungsfunktion (Originalarbeit)
nn.Sequential(
nn.Conv2d(32, 64, 3, padding=1),
nn.BatchNorm2d(64), # BN vor Aktivierung
nn.ReLU(inplace=True),
)
Schule 2: Nach der Aktivierungsfunktion (einige Studien deuten auf bessere Leistung hin)
nn.Sequential(
nn.Conv2d(32, 64, 3, padding=1),
nn.ReLU(inplace=True),
nn.BatchNorm2d(64), # BN nach Aktivierung
)
Praktischer Hinweis:Folgen Sie dem Design der Arbeit, auf die Sie sich beziehen; wenn es keine besondere Anforderung gibt, ist Conv → BN → ReLU gängiger.
Platzierung von Dropout
Vollständig verbundene Netzwerke: nach der Aktivierungsfunktion
nn.Linear(512, 256),
nn.ReLU(),
nn.Dropout(0.5), # Nach ReLU
nn.Linear(256, 128),
nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(128, 10), # Normalerweise kein Dropout vor der Ausgabeschicht
)
CNN: nach BN (wenn BN verwendet wird, kann Dropout weggelassen werden)
# Dropout wird normalerweise nur vor vollständig verbundenen Schichten oder dem Klassifikationskopf hinzugefügt
nn.Sequential(
nn.Conv2d(64, 128, 3, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True),
# Normalerweise kein Dropout hier (BN bietet bereits Regularisierung)
)
Transformer: innerhalb von FFN- und Attention-Schichten
def __init__(self, d_model, d_ff, dropout=0.1):
super().__init__()
self.net = nn.Sequential(
nn.Linear(d_model, d_ff),
nn.GELU(),
nn.Dropout(dropout), # Dropout innerhalb des FFN hinzufügen
nn.Linear(d_ff, d_model),
nn.Dropout(dropout), # Vor der Ausgabe noch einmal hinzufügen
)
def forward(self, x):
return self.net(x)
Sollten BN und Dropout zusammen verwendet werden?
Vollständig verbundene Netzwerke: können zusammen verwendet werden
nn.Linear(512, 256),
nn.BatchNorm1d(256),
nn.ReLU(),
nn.Dropout(0.3), # BN + Dropout koexistieren, üblich und effektiv
nn.Linear(256, 10),
)
Faltungsnetzwerke: normalerweise eines von beiden wählen oder Dropout nur am Head verwenden.
Grund: BNs Normalisierungsoperation und Dropout können ein Problem der "Varianzverschiebung" verursachen. Das heißt, während des Trainings ändert Dropout die Varianz der Aktivierungswerte, während der Inferenz ist Dropout deaktiviert, was dazu führt, dass die Statistiken, die BN während der Inferenz sieht, nicht mit denen während des Trainings übereinstimmen.
Empfohlene Vorgehensweise:
Option A: Nur BN in Faltungsschichten verwenden und nur Dropout in vollständig verbundenen/Klassifikations-Heads
Beispiel
def __init__(self, num_classes):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.BatchNorm2d(64), # Faltungsteil: nur BN
nn.ReLU(inplace=True),
nn.Conv2d(64, 128, 3, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True),
nn.AdaptiveAvgPool2d(1),
)
self.classifier = nn.Sequential(
nn.Flatten(),
nn.Linear(128, 256),
nn.ReLU(),
nn.Dropout(0.5), # Vollständig verbundener Teil: nur Dropout
nn.Linear(256, num_classes),
)
def forward(self, x):
return self.classifier(self.features(x))
5. Vollständige Netzwerkbeispiele
Beispiel 1: Vollständig verbundenes Klassifikationsnetzwerk (BN + Dropout)
Beispiel
import torch.nn as nn
class MLPClassifier(nn.Module):
"""
Vollständig verbundener Klassifikator mit BatchNorm1d und Dropout
Geeignet für Klassifikationsaufgaben mit tabellarischen Daten
"""
def __init__(self, in_dim, hidden_dims, num_classes, dropout=0.5):
super().__init__()
layers = []
prev_dim = in_dim
for hidden_dim in hidden_dims:
layers += [
nn.Linear(prev_dim, hidden_dim),
nn.BatchNorm1d(hidden_dim),
nn.ReLU(inplace=True),
nn.Dropout(dropout),
]
prev_dim = hidden_dim
layers.append(nn.Linear(prev_dim, num_classes))
self.net = nn.Sequential(*layers)
def forward(self, x):
return self.net(x)
model = MLPClassifier(
in_dim=784,
hidden_dims=[512, 256, 128],
num_classes=10,
dropout=0.4
)
# Ausgabeform überprüfen
x = torch.randn(32, 784)
model.eval()
print(model(x).shape) # torch.Size([32, 10])
Beispiel 2: CNN-Bildklassifikation (hauptsächlich BN)
Beispiel
"""Standard-Faltungsblock: Conv → BN → ReLU"""
def __init__(self, in_ch, out_ch, stride=1):
super().__init__()
self.block = nn.Sequential(
nn.Conv2d(in_ch, out_ch, 3, stride=stride, padding=1, bias=False),
nn.BatchNorm2d(out_ch), # bias=False: BNs Beta dient bereits als Bias
nn.ReLU(inplace=True),
)
def forward(self, x):
return self.block(x)
class SmallCNN(nn.Module):
"""Kleines CNN für CIFAR-10"""
def __init__(self, num_classes=10):
super().__init__()
self.features = nn.Sequential(
ConvBNBlock(3, 32), # 32×32 → 32×32
ConvBNBlock(32, 64, stride=2), # 32×32 → 16×16
ConvBNBlock(64, 128, stride=2), # 16×16 → 8×8
ConvBNBlock(128, 256, stride=2), # 8×8 → 4×4
nn.AdaptiveAvgPool2d(1), # 4×4 → 1×1
)
self.classifier = nn.Sequential(
nn.Flatten(),
nn.Linear(256, 128),
nn.ReLU(),
nn.Dropout(0.5), # Dropout nur in vollständig verbundenen Schichten verwenden
nn.Linear(128, num_classes),
)
def forward(self, x):
return self.classifier(self.features(x))
model = SmallCNN(num_classes=10)
x = torch.randn(16, 3, 32, 32)
model.eval()
print(model(x).shape) # torch.Size([16, 10])
Beispiel 3: Vollständige Trainingsschleife
Beispiel
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import CosineAnnealingLR
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
EPOCHS = 50
model = SmallCNN(num_classes=10).to(DEVICE)
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
scheduler = CosineAnnealingLR(optimizer, T_max=EPOCHS)
def run_epoch(model, loader, optimizer=None, train=True):
if train:
model.train() # ← BN verwendet Batch-Statistiken, Dropout wird aktiviert
else:
model.eval() # ← BN verwendet laufende Statistiken, Dropout wird deaktiviert
total_loss, correct = 0.0, 0
ctx = torch.enable_grad() if train else torch.no_grad()
with ctx:
for imgs, labels in loader:
imgs, labels = imgs.to(DEVICE), labels.to(DEVICE)
if train:
optimizer.zero_grad()
outputs = model(imgs)
loss = criterion(outputs, labels)
if train:
loss.backward()
optimizer.step()
total_loss += loss.item() * imgs.size(0)
correct += (outputs.argmax(1) == labels).sum().item()
n = len(loader.dataset)
return total_loss / n, correct / n
best_acc = 0.0
for epoch in range(1, EPOCHS + 1):
train_loss, train_acc = run_epoch(model, train_loader, optimizer, train=True)
val_loss, val_acc = run_epoch(model, val_loader, train=False)
scheduler.step()
print(f"Epoche {epoch:2d}/{EPOCHS} | "
f"Training {train_loss:.4f}/{train_acc:.4f} | "
f"Validierung {val_loss:.4f}/{val_acc:.4f}")
if val_acc > best_acc:
best_acc = val_acc
torch.save(model.state_dict(), 'best.pth')
6. Leitfaden für Hyperparameter-Tuning
BatchNorm-Parameter-Tuning
Beispiel
# Der Standardwert 0.1 funktioniert in den meisten Fällen
# batch_size ist sehr klein (< 8) → Statistiken sind instabil → momentum verringern
nn.BatchNorm2d(64, momentum=0.01)
# Viele Trainingsschritte, stabile Datenverteilung → Momentum kann angemessen erhöht werden
nn.BatchNorm2d(64, momentum=0.2)
# ── affine=False (gamma/beta nicht lernen) ───────────────
# Wird selten verwendet, normalerweise den Standardwert True beibehalten
# Es sei denn, Sie möchten ausdrücklich nicht, dass BN die Skalierung und den Offset der Features ändert
nn.BatchNorm2d(64, affine=False)
# ── track_running_stats=False ──────────────────────
# Jede Inferenz verwendet außerdem die aktuellen Batch-Statistiken (Trainings- und Inferenzverhalten sind konsistent)
# Geeignet für spezielle Szenarien wie Online-Learning und Streaming-Daten
nn.BatchNorm2d(64, track_running_stats=False)
Dropout-Tuning-Strategien
Beispiel
# Trainingsgenauigkeit viel höher als Validierungsgenauigkeit (starke Überanpassung) → p erhöhen
# Trainingsgenauigkeit und Validierungsgenauigkeit liegen nah beieinander, aber beide niedrig (Unteranpassung) → p verringern oder Dropout entfernen
# ── Referenz für empfohlene p-Werte ───────────────────────────────
p_values = {
'Große vollständig verbundene Hidden-Layer (> 1024)': 0.5,
'Mittlere vollständig verbundene Hidden-Layer (256~1024)': 0.3,
'Kleine vollständig verbundene Hidden-Layer (< 256)': 0.2,
'CNN-Konvolutionsschichten (Dropout2d)': 0.1,
'Vor dem Klassifikationskopf': 0.3,
'Transformer FFN': 0.1,
'Transformer-Attention': 0.1,
}
# ── Dynamisches Dropout (angepasst, während das Training fortschreitet) ──────────────────
# In manchen Praktiken ist p früh im Training klein und wird später erhöht (Regularisierung verstärken, wenn das Modell komplexer wird)
class DynamicDropoutNet(nn.Module):
def __init__(self, initial_p=0.1):
super().__init__()
self.dropout = nn.Dropout(initial_p)
self.fc = nn.Linear(256, 10)
def set_dropout(self, p):
self.dropout.p = p
def forward(self, x):
return self.fc(self.dropout(x))
model = DynamicDropoutNet(initial_p=0.1)
# In der Trainingsmitte Dropout erhöhen
model.set_dropout(0.4)
7. Häufige Fehler und Vorsichtsmaßnahmen
Fehler 1: Vergessen, in den eval()-Modus zu wechseln
Falscher Code
model.train() # Standardzustand
for imgs, labels in val_loader:
with torch.no_grad():
outputs = model(imgs) # Dropout verwirft weiterhin zufällig! BN aktualisiert weiterhin!
# Ergebnisse sind nicht deterministisch, die Genauigkeit ist künstlich niedrig, und running_mean/var wird verfälscht
Korrekter Code
model.eval()
with torch.no_grad():
outputs = model(imgs) # Deterministische Ausgabe
Fehler 2: Bias zu einer Conv-Schicht hinzufügen und dann BN verwenden
Falscher Code
nn.Conv2d(64, 128, 3, padding=1, bias=True), # Standardmäßig True
nn.BatchNorm2d(128),
Korrekter Code
nn.Conv2d(64, 128, 3, padding=1, bias=False), # ← bias=False
nn.BatchNorm2d(128),
Fehler 3: Verwendung von BatchNorm mit batch size=1
Falscher Code
# Inferenz mit einem einzelnen Sample ist in Ordnung (verwendet laufende Statistiken), aber Training mit einem einzelnen Sample stürzt ab
model.train()
x = torch.randn(1, 64, 32, 32)
out = bn2d(x) # ← batch=1 im Trainingsmodus führt zu einem Fehler oder erzeugt NaN
Lösung
nn.GroupNorm(num_groups=32, num_channels=64)
# Lösung 2: LayerNorm verwenden
nn.LayerNorm([64, 32, 32])
# Lösung 3: Während der Inferenz zu eval() wechseln, hat keinen Einfluss auf BN
model.eval()
out = bn2d(x) # batch=1 im Inferenzmodus ist völlig normal
Fehler 4: Dropout verursacht Varianzverschiebung in BN
Problem
# Während der Inferenz ist Dropout deaktiviert, und BN verwendet den running_var zur Trainingszeit (der den Effekt von Dropout enthält)
# Statistiken stimmen nicht überein, Inferenzergebnisse sind verzerrt
nn.Sequential(
nn.Conv2d(64, 128, 3),
nn.Dropout2d(0.5), # ← Dropout in Faltungsschichten verwenden
nn.BatchNorm2d(128), # ← Die von BN gesehene Varianz wird durch Dropout verändert
)
Lösung
nn.Sequential(
nn.Conv2d(64, 128, 3),
nn.BatchNorm2d(128), # Zuerst BN (nicht von Dropout beeinflusst)
nn.ReLU(),
nn.Dropout2d(0.1), # Dropout danach
)
# Lösung 2: Nur BN in Faltungsschichten und nur Dropout in vollständig verbundenen Schichten verwenden (sehr empfohlen)
Fehler 5: Vergessen, eingefrorene BN-Schichten in den eval-Modus zu versetzen
Falscher Code
# Andernfalls verfälscht die neue Datenverteilung die vortrainierten Statistiken
# Fehler: Parameter sind eingefroren, aber die running_mean/var der BN werden weiterhin aktualisiert
model = models.resnet50(weights='IMAGENET1K_V2')
for param in model.parameters():
param.requires_grad = False # Nur die lernbaren Parameter werden eingefroren; BN-Statistiken werden weiterhin aktualisiert
Korrekter Code
def freeze_bn(model):
for module in model.modules():
if isinstance(module, (nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d)):
module.eval() # running_mean/var korrigieren
for param in module.parameters():
param.requires_grad = False
model = models.resnet50(weights='IMAGENET1K_V2')
freeze_bn(model) # Alle BN einfrieren
model.fc = nn.Linear(model.fc.in_features, 10) # Nur die neue FC-Schicht ist trainierbar
Schnelle Diagnose-Checkliste
| Phänomen | Mögliche Ursache | Prüfpunkt |
|---|---|---|
| Loss schwankt unvorhersehbar | [model.eval()] vergessenmodel.eval() |
Bestätigen, dass [model.eval()] vor der Evaluierung aufgerufen wirdeval() |
| Große Lücke zwischen Trainings-/Validierungsgenauigkeit | Dropout pDropout p zu groß |
Versuchen Sie, p zu verringernpoder Dropout entfernen |
| Training NaN/inf | BatchNorm mit batch=1 verwendet | Zu GroupNorm oder LayerNorm wechseln |
| Schlechte Transfer-Learning-Leistung | BN running stats verfälscht | Rufen Sie [.eval()] für Backbone-BN-Schichten aufeval() |
| Instabile Modell-Inferenzergebnisse | Während der Inferenz nicht zu eval() gewechselteval() |
Vor der Inferenz muss [model.eval()] aufgerufen werdenmodel.eval() |
| Übermäßige Anzahl an Conv-Parametern | Conv+BN hat den Bias nicht deaktiviert | Setze [bias=False]bias=False |