Batch Normalization

Batch Normalization im Überblick

Batch Normalization ist eine Technik, die das Training von neuronalen Netzen stabilisiert und beschleunigt.

Das Problem: Während des Trainings ändern sich die Gewichte ständig. Das bedeutet, dass die Eingaben für jede Schicht sich ständig verschieben – das Netz muss sich ständig neu anpassen.

Die Lösung: Batch Norm normalisiert die Werte nach jeder Schicht auf Mittelwert 0 und Varianz 1. Das hält alles stabil.

Ohne Batch Norm:  Werte driften → instabiles Training → langsam
Mit Batch Norm:   Werte normalisiert → stabiles Training → schnell

Vorteile:

• Höhere Lernraten möglich (schnelleres Training)
• Weniger sensitiv gegenüber Gewichts-Initialisierung
• Leichte Regularisierung (reduziert Overfitting)

Wichtig: In Transformern wird stattdessen Layer Normalization verwendet – das funktioniert unabhängig von der Batch-Größe.

Technisch betrachtet

Berechnung

1. Mittelwert: μ = mean(x)
2. Varianz:    σ² = var(x)
3. Normalisieren: x̂ = (x - μ) / √(σ² + ε)
4. Skalieren:  y = γ · x̂ + β  (lernbare Parameter)

Varianten

• Batch Norm: Normalisiert über den Batch → Standard in CNNs
• Layer Norm: Normalisiert über Features → Standard in Transformern
• Group Norm: Kompromiss → gut bei kleinen Batch-Größen
• RMS Norm: Vereinfachte Layer Norm → verwendet in LLaMA, Mistral

Historischer Kontext

Batch Normalization wurde 2015 von Sergey Ioffe und Christian Szegedy in ihrem Paper “Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift” eingeführt. Die Technik entstand als Antwort auf das Problem des “Internal Covariate Shift”, welches auftritt, wenn sich die Verteilung der Eingaben für eine Schicht während des Trainings ändert. Durch die Normalisierung der Eingaben wurde nicht nur das Training stabiler, sondern auch die Entwicklung tieferer Netzwerke wurde erheblich erleichtert.

Vor- und Nachteile

Vorteile

• Schnelleres Training: Batch Normalization ermöglicht höhere Lernraten, was zu schnelleren Konvergenzen führt.
• Stabilität: Reduziert die Sensitivität gegenüber der Initialisierung der Gewichte und der Wahl der Hyperparameter.
• Regularisierungseffekt: Kann als eine Form der Regularisierung betrachtet werden, die übermäßiges Overfitting verringert.

Nachteile

• Batch-Größe: Die Leistung kann bei sehr kleinen Batch-Größen leiden, da die Schätzung von Mittelwert und Varianz ungenau wird.
• Rechenaufwand: Zusätzliche Berechnungen während des Trainings und der Vorhersage können den Rechenaufwand erhöhen.
• Abhängigkeit von der Batch-Größe: Die Leistung kann variieren, wenn die Batch-Größe während des Trainings und der Inferenz unterschiedlich ist.

Praxisbeispiele

Anwendung in Convolutional Neural Networks (CNNs)

Batch Normalization wird häufig in CNNs eingesetzt, um die Trainingsgeschwindigkeit zu erhöhen und die Leistung zu verbessern. Ein typisches Beispiel ist die Verwendung von Batch Norm zwischen den Convolutional- und den Aktivierungsschichten:

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
        self.bn1 = nn.BatchNorm2d(32)
        self.relu = nn.ReLU()
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3)
        self.bn2 = nn.BatchNorm2d(64)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.conv2(x)
        x = self.bn2(x)
        return x

Anwendung in Recurrent Neural Networks (RNNs)

Obwohl Batch Normalization in RNNs weniger gebräuchlich ist, kann sie dennoch verwendet werden, um die Trainingsstabilität zu erhöhen. Hierbei wird häufig Layer Normalization bevorzugt, da sie besser mit den zeitlichen Abhängigkeiten in RNNs zurechtkommt. Ein Beispiel für die Verwendung von Layer Norm in einem RNN könnte so aussehen:

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(SimpleRNN, self).__init__()
        self.rnn = nn.RNN(input_size, hidden_size)
        self.layer_norm = nn.LayerNorm(hidden_size)

    def forward(self, x):
        out, _ = self.rnn(x)
        out = self.layer_norm(out)
        return out