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

# Eingabeform: (N, C, H, W)
# 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

# Eingabeform: (N, C, D, H, W)
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

bn = nn.BatchNorm2d(64)

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

# PyTorchs momentum ist das Gegenteil des üblichen Verständnisses:
# 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
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

# num_groups: in wie viele Gruppen die Kanäle aufgeteilt werden (muss num_channels gleichmäßig teilen)
# 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

# InstanceNorm2d: normalisiert H×W für jedes (N, C)
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

# batch_size >= 16, CNN-Bildaufgaben → BatchNorm2d
# 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
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

dropout2d = nn.Dropout2d(p=0.3)

# 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

# Eingabe: (N, C, D, H, W), das gesamte (D, H, W)-Feature-Volumen wird verworfen
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

# Vollständig verbundene Schichten (breite versteckte Schichten): höheres Dropout
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

# Wird mit SELU verwendet (selbstnormalisierendes Netzwerk SELU + AlphaDropout)
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
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

# Verwende diesen Code, um zu überprüfen, dass BN und Dropout in den korrekten Modi funktionieren
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)

# Conv → BN → ReLU
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)

# Conv → ReLU → BN
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.Sequential(
    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)

# Hinweis: BN selbst hat einen Regularisierungseffekt; wenn BN bereits in einem CNN vorhanden ist, wird Dropout in Faltungsschichten nicht benötigt
# 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

class FeedForward(nn.Module):
    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.Sequential(
    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

class ConvNet(nn.Module):
    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
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

class ConvBNBlock(nn.Module):
    """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
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

# ── momentum (der Parameter, der am häufigsten angepasst werden muss) ─────────────────
# 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

# ── p entsprechend dem Ausmaß des Overfittings anpassen ───────────────────────────
# 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

# Fehler: model.eval() wird während der Evaluierung nicht aufgerufen
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

# Korrekt: Modi vor der Evaluierung explizit umschalten
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

# Redundant: Der Bias von Conv wird durch BN's beta aufgehoben, wodurch Parameter verschwendet werden
nn.Conv2d(64, 128, 3, padding=1, bias=True),   # Standardmäßig True
nn.BatchNorm2d(128),

Korrekter Code

# Korrekt: bias deaktivieren, wenn auf Conv BN folgt
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

# Fehler: BN kann die Varianz nicht berechnen, wenn batch=1; das Training wird NaN oder inf erzeugen
# 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

# Lösung 1: Stattdessen GroupNorm verwenden
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

# Problem: Dropout ändert die Varianz der Aktivierungswerte während des Trainings
# 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

# Lösung 1: Zuerst BN, danach Dropout
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

# Beim Transferlernen sollten beim Einfrieren des Backbones die vortrainierten laufenden Statistiken der BN nicht aktualisiert werden
# 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

# Korrekte Lösung: Auch die BN-Schichten des Backbones in den eval-Modus versetzen
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
Weitere Erweiterungen