Batch Normalization zaehlt zu den wichtigsten Innovationen im Deep Learning der letzten Jahre. Diese Technik normalisiert die Eingaben jeder Schicht waehrend des Trainings und stabilisiert und beschleunigt damit den gesamten Lernprozess neuronaler Netze erheblich.
Batch Normalization – Stabiles Netzwerktraining¶
Batch Normalization (BatchNorm) is among the most important techniques in modern deep learning. It solved fundamental problems with training deep networks and enabled building models with dozens or hundreds of layers. Zeigen wir how it works and why it’s so effective.
Das Problem der Gradienteninstabilitaet¶
Beim Training tiefer neuronaler Netze stossen wir auf ein Phaenomen namens Internal Covariate Shift. Aktivierungen in tieferen Schichten aendern sich waehrend des Trainings dramatisch, was Folgendes verursacht:
- Explodierende/verschwindende Gradienten
- Langsame Konvergenz
- Notwendigkeit sehr sorgfaeltiger Gewichtsinitialisierung
- Empfindlichkeit gegenueber der Wahl der Learning Rate
BatchNorm loest diese Probleme durch Normalisierung der Aktivierungen auf Mini-Batch-Ebene, was die Verteilung der durch das Netz fliessenden Daten stabilisiert.
Wie BatchNorm funktioniert¶
Batch Normalization wendet die folgende Transformation auf jedes Feature in einem Mini-Batch an:
# For each feature x_i in the batch
μ = mean(x_i) # Mean across batch
σ² = variance(x_i) # Variance across batch
x̂_i = (x_i - μ) / √(σ² + ε) # Normalization
y_i = γ * x̂_i + β # Scaling and shift
Parameter γ (gamma) and β (beta) sind lernbar – das Netzwerk kann die optimale Verteilung fuer jede Schicht “lernen”.
Implementierung in PyTorch¶
Die Verwendung von BatchNorm in PyTorch ist sehr einfach:
import torch
import torch.nn as nn
class ConvBlock(nn.Module):
def __init__(self, in_channels, out_channels):
super().__init__()
self.conv = nn.Conv2d(in_channels, out_channels, 3, padding=1)
self.bn = nn.BatchNorm2d(out_channels)
self.relu = nn.ReLU(inplace=True)
def forward(self, x):
x = self.conv(x)
x = self.bn(x) # BatchNorm after convolution, before activation
x = self.relu(x)
return x
# Usage
model = nn.Sequential(
ConvBlock(3, 64),
ConvBlock(64, 128),
ConvBlock(128, 256),
)
Wann und wo BatchNorm anwenden¶
Die Standardplatzierung ist nach der linearen/konvolutionalen Schicht, aber vor der Aktivierungsfunktion. Diese Reihenfolge hat sich in der Praxis bewaehrt, obwohl das urspruengliche Paper die umgekehrte Reihenfolge empfahl.
# Recommended order
x = conv_layer(x)
x = batch_norm(x)
x = activation(x)
# For fully connected layers
class MLPBlock(nn.Module):
def __init__(self, in_features, out_features):
super().__init__()
self.linear = nn.Linear(in_features, out_features)
self.bn = nn.BatchNorm1d(out_features)
self.relu = nn.ReLU()
def forward(self, x):
return self.relu(self.bn(self.linear(x)))
Training- vs. Inferenz-Modus¶
BatchNorm verhaelt sich waehrend des Trainings und der Inferenz unterschiedlich. Waehrend des Trainings verwendet es aktuelle Batch-Statistiken; bei der Inferenz verwendet es laufende Durchschnitte:
model = YourModel()
# Training mode
model.train()
for batch in dataloader:
# BatchNorm uses current batch statistics
output = model(batch)
# Inference mode
model.eval()
with torch.no_grad():
# BatchNorm uses stored running averages
prediction = model(test_input)
BatchNorm vs. Layer Normalization¶
Layer Normalization (LayerNorm) ist eine Alternative, die besonders fuer Sequenzen und Transformer nuetzlich ist:
# BatchNorm - normalization across batch dimension
batch_norm = nn.BatchNorm1d(features)
# LayerNorm - normalization across feature dimension
layer_norm = nn.LayerNorm(features)
# Difference in behavior:
x = torch.randn(batch_size=32, features=128)
# BatchNorm: μ, σ computed across batch_size (32 samples)
bn_out = batch_norm(x)
# LayerNorm: μ, σ computed across features (128 dimensions)
ln_out = layer_norm(x)
Praktische Vorteile von BatchNorm¶
Die Implementierung von BatchNorm bringt mehrere konkrete Vorteile:
- Hoehere Learning Rates – das Netzwerk ist stabiler, wir koennen schneller trainieren
- Geringere Abhaengigkeit von der Initialisierung – BatchNorm “korrigiert” schlechte Initialisierung
- Regularisierungseffekt – Rauschen aus Mini-Batches ersetzt teilweise Dropout
- Schnellere Konvergenz – typischerweise 2-3x weniger Epochen fuer die gleiche Genauigkeit
Moegliche Probleme und Loesungen¶
BatchNorm hat seine Tuecken. Bei sehr kleinen Batch-Groessen (< 4) kann es instabil sein:
# For small batches, use GroupNorm or LayerNorm
import torch.nn as nn
# GroupNorm - divides channels into groups
group_norm = nn.GroupNorm(num_groups=8, num_channels=64)
# For batch_size = 1 (inference)
# BatchNorm automatically switches to stored statistics
model.eval() # Important!
Moderne Varianten¶
Die Entwicklung schreitet mit neuen Techniken wie Batch Renormalization oder FRN (Filter Response Normalization) voran, die spezifische BatchNorm-Probleme in verschiedenen Szenarien loesen.
Zusammenfassung¶
Batch Normalization ist eine Schluesseltechnik fuer das Training tiefer Netze. Sie stabilisiert den Gradientenfluss, ermoeglicht hoehere Learning Rates und beschleunigt die Konvergenz. In CNNs platzieren wir BatchNorm nach der Faltungsschicht vor der Aktivierung; in RNNs und Transformern bevorzugen wir LayerNorm. Vergessen Sie nicht, das Modell waehrend der Inferenz in den eval()-Modus zu schalten, sonst verwendet BatchNorm Statistiken aus dem letzten Batch anstelle gespeicherter laufender Durchschnitte.