Batch Size

Die Batchgröße gibt an, wie viele Trainingsbeispiele ein Modell verarbeitet, bevor es seine Modellgewichte aktualisiert. Anstatt den gesamten Trainingsdatensatz auf einmal durch ein neuronales Netzwerk laufen zu lassen, wird das Training in Batches aufgeteilt. Für jeden Batch erstellt das Modell Vorhersagen, die von der Verlustfunktion bewertet werden; die Backpropagation berechnet die Gradienten, und der Optimierer führt einen Schritt aus. Die Batchgröße ist ein Hyperparameter, der gleichzeitig drei Dinge bestimmt: wie viel GPU-Speicher das Training benötigt, wie lange jede Epoche dauert und wie stark die einzelnen Gradientenschätzungen rauschen.

Wie sich die Batchgröße auf das Training auswirkt#

Jeder Batch liefert dem Optimierungsalgorithmus eine Schätzung des Gradienten über den gesamten Datensatz. Je größer der Batch, desto genauer wird die Schätzung. Der folgende PyTorch-Code misst diese Genauigkeit direkt, indem er die Gradienten einzelner Beispiele für viele zufällige Batches jeder Größe mittelt:

import torch

torch.manual_seed(0)

# Per-sample gradients of a squared-error loss for 10,000 samples
x = torch.randn(10_000)
y = 2 * x + torch.randn(10_000)
w = torch.tensor(0.0)
per_sample_grads = 2 * (w * x - y) * x

# Estimate the gradient from 1,000 random batches at each batch size
for batch_size in (8, 64, 512):
    idx = torch.randint(0, len(x), (1000, batch_size))
    batch_grads = per_sample_grads[idx].mean(dim=1)
    print(f"batch {batch_size:3d}: gradient std {batch_grads.std():.3f}")

Die Streuung der Gradientenschätzung sinkt von 2.248 bei einer Batchgröße von 8 auf 0.771 bei 64 und 0.267 bei 512. Jede Verachtfachung der Batchgröße reduziert das Rauschen um etwa den Faktor 2,9 – annähernd die Quadratwurzel aus 8. So verhalten sich Mittelwerte unabhängiger Stichproben.

Dieses Rauschen prägt den Kompromiss zwischen kleinen und großen Batches:

• Kleine Batches (zum Beispiel 8 bis 32): Rauschbehaftete Updates und viele Schritte pro Epoche. Das Rauschen wirkt als leichte Regularisierung, die der Verallgemeinerungsfähigkeit von stochastischem Gradientenabstieg (SGD) oft zugutekommt. Kleine Batches passen auf bescheidene Hardware, aber jede Epoche dauert länger, weil die GPU teilweise ungenutzt bleibt.
• Große Batches (zum Beispiel ab 256): Glatte Gradienten, weniger Schritte pro Epoche und hohe Hardwareauslastung. Sehr große Batches konvergieren tendenziell zu scharfen Minima, die schlechter verallgemeinern, wie Keskar et al. zeigten. Da pro Epoche weniger Schritte anfallen, ist außerdem eine proportional höhere Lernrate mit einer Aufwärmphase erforderlich. Nach dieser linearen Skalierungsregel trainierten Goyal et al. ResNet-50 eine Stunde lang auf ImageNet mit einer Batchgröße von 8.192 auf 256 GPUs und erreichten dabei dieselbe Genauigkeit wie beim Training mit kleinen Batches.

Speichergrenzen und Gradientenakkumulation#

Der GPU-Speicher muss die Gewichte des Modells, seinen Optimiererzustand und die Zwischenaktivierungen aufnehmen, die die Backpropagation benötigt. Der Speicherbedarf für Aktivierungen wächst linear mit der Batchgröße und der Bildauflösung. Passt ein Batch nicht in den Speicher, wird das Training mit einem Speichermangel-Fehler (OOM) abgebrochen. Training mit gemischter Genauigkeit halbiert ungefähr den Speicherbedarf für Aktivierungen. Mit der Gradientenakkumulation lässt sich eine größere effektive Batchgröße erreichen, indem Gradienten aus mehreren kleinen Batches vor jedem Gewichtsupdate aufsummiert werden.

Beim Training mit Ultralytics YOLO ist dies bereits integriert: Gradienten werden so lange akkumuliert, bis etwa 64 Bilder verarbeitet wurden – der nominalen Batchgröße nbs. Nach der Aufwärmphase führt der Standardwert batch=16 also alle vier Batches ein Gewichtsupdate aus. Mit batch=-1 wird AutoBatch ausgeführt. Es wählt die größte Batchgröße, die in etwa 60 % des freien CUDA-Speichers passt, und verwendet auf CPU- und Apple-MPS-Geräten ersatzweise eine Batchgröße von 16.

from ultralytics import YOLO

# Lade ein vortrainiertes YOLO26n-Modell
model = YOLO("yolo26n.pt")

# batch=-1 lässt AutoBatch die Batchgröße anhand des verfügbaren GPU-Speichers wählen
# Verwende eine Ganzzahl (batch=16) für eine feste Größe oder eine Dezimalzahl (batch=0.70) für einen Speicheranteil
results = model.train(data="coco8.yaml", epochs=5, batch=-1)

Vor Beginn des Trainings führt AutoBatch das YOLO26-Modell mit Batchgrößen von 1 bis 16 aus (bis zu 64 auf GPUs mit mindestens 16 GB), legt eine Gerade an die gemessene Speichernutzung an und berechnet daraus die Batchgröße, die den Zielanteil erreicht.

Batchgröße und verwandte Begriffe#

• Epoche und Iteration: Eine Epoche ist ein Durchlauf durch den gesamten Datensatz, eine Iteration ein Gewichtsupdate. Die Anzahl der Iterationen pro Epoche entspricht der Datensatzgröße geteilt durch die Batchgröße, aufgerundet. Bei 1.000 Bildern und einer Batchgröße von 100 sind also 10 Iterationen erforderlich.
• Mini-Batch: In den meisten Texten zum Deep Learning ein Synonym für Batch. Streng genommen verwendet der Batch-Gradientenabstieg den gesamten Datensatz pro Update, der stochastische Gradientenabstieg ein einzelnes Beispiel und der Mini-Batch-Gradientenabstieg eine Zwischenmenge. So wird fast jedes moderne Netzwerk trainiert.
• Batch-Normalisierung: Eine Schicht, die Aktivierungen anhand des Mittelwerts und der Varianz des aktuellen Batches normalisiert. Bei sehr kleinen Batches sind ihre Statistiken daher unzuverlässig. Die Gruppennormalisierung vermeidet diese Abhängigkeit und erzielte bei einer Batchgröße von 2 auf ImageNet für ResNet-50 einen um 10,6 % niedrigeren Fehler als Batch-Normalisierung.
• Batchgröße bei der Inferenz: Beim Einsatz eines Modells wird mit Batching ein Kompromiss zwischen Inferenzlatenz und Durchsatz eingegangen. Werden Bilder von mehreren Kameras gruppiert, erhöht sich die Anzahl der pro Sekunde verarbeiteten Bilder, während jedes Einzelbild darauf wartet, dass sich sein Batch füllt.