Gradient Accumulation

Gradientenakkumulation ist eine Trainingstechnik, bei der mehrere kleine Batches, sogenannte Microbatches, den Vorwärtslauf und die Backpropagation durchlaufen. Ihre Gradienten werden addiert, und erst danach werden die Modellgewichte aktualisiert. Das Update nähert einen Schritt mit einem Batch an, der so groß ist wie alle Microbatches zusammen, während die GPU jeweils nur die Aktivierungen eines Microbatches speichern muss. So kann ein Gerät mit begrenztem Speicher mit der in einer Konfiguration vorgesehenen Batchgröße trainieren, ohne die Bildauflösung zu verringern oder das Modell zu verkleinern. Die effektive Batchgröße entspricht der Microbatch-Größe multipliziert mit der Anzahl der Akkumulationsschritte und der Anzahl der Geräte. Microbatches mit jeweils 4 Bildern, die über 8 Schritte auf 4 GPUs akkumuliert werden, entsprechen daher einem Batch mit 128 Bildern.

Funktionsweise der Gradientenakkumulation#

In PyTorch und den meisten anderen Frameworks addiert jeder Aufruf von backward() neue Gradienten zu den bereits in den Parametern gespeicherten, statt sie zu ersetzen. Die Akkumulation nutzt dieses Verhalten direkt: Für jeden Microbatch werden der Vorwärts- und Rückwärtslauf ausgeführt. Sobald die festgelegte Anzahl an Microbatches erreicht ist, wird der Optimierer einmal aufgerufen. Anschließend werden die Gradienten gelöscht und das nächste Fenster beginnt:

Die meisten Verlustfunktionen mitteln über die Beispiele eines Batches. Daher wird der Verlust jedes Microbatches durch die Anzahl der Schritte geteilt, damit die aufsummierten Gradienten einen Durchschnitt ergeben. Mit dieser Skalierung erzeugen vier Microbatches mit jeweils 8 Beispielen denselben Gradienten wie ein Batch mit 32 Beispielen:

import torch
from torch import nn

torch.manual_seed(0)
model = nn.Linear(16, 1)
x, y = torch.randn(32, 16), torch.randn(32, 1)
loss_fn = nn.MSELoss()

# Reference: one batch of 32 samples
loss_fn(model(x), y).backward()
batch_grad = model.weight.grad.clone()
model.zero_grad()

# Four micro-batches of 8: backward() adds into .grad, and dividing each loss by 4 turns the sum into a mean
steps = 4
for x_micro, y_micro in zip(x.chunk(steps), y.chunk(steps)):
    (loss_fn(model(x_micro), y_micro) / steps).backward()

print("Matches the full-batch gradient:", torch.allclose(model.weight.grad, batch_grad, atol=1e-6))
print(f"Largest difference: {(model.weight.grad - batch_grad).abs().max():.1e}")

Ausgegeben wird Matches the full-batch gradient: True mit einer größten Differenz von 1.6e-07. Sie entsteht durch Rundung bei Gleitkommazahlen, wenn dieselben Zahlen in einer anderen Reihenfolge addiert werden.

Worin sich die Akkumulation von einem großen Batch unterscheidet#

Die Übereinstimmung gilt für Verlustfunktionen, die über unabhängige Beispiele mitteln, und geht in drei häufigen Fällen verloren:

• Batch-Normalisierung: Berechnet Mittelwert und Varianz für jeden Microbatch einzeln. Statistiken aus 4 Bildern sind daher ungenauer als Statistiken aus 128 Bildern.
• Sequenzen variabler Länge: Wenn ein Sprachmodell seinen Verlust über die Tokens jedes Microbatches mittelt, erhalten Microbatches mit wenigen Tokens dasselbe Gewicht wie lange.
• Gradienten-Clipping: Sollte einmal auf den akkumulierten Gradienten angewendet werden, unmittelbar vor dem Optimierungsschritt. Das Clipping jedes Microbatches verändert das Ergebnis.

Hugging Face und Unsloth behoben im Oktober 2024 die Abweichung bei der Tokenanzahl für die Feinabstimmung großer Sprachmodelle (LLMs), indem sie den aufsummierten Verlust durch die Gesamtzahl der Tokens im gesamten Akkumulationsfenster teilten. Die Akkumulation beschleunigt das Training außerdem nicht: Dieselbe Anzahl von Beispielen durchläuft das Netzwerk weiterhin nacheinander in Microbatches, und kleine Microbatches nutzen die GPU weniger effizient. Beim verteilten Training bietet PyTorchs DistributedDataParallel einen Kontext no_sync(), der die Gradient-All-Reduktion für jeden Microbatch außer dem letzten überspringt und so Kommunikation einspart. Eine größere effektive Batchgröße erfordert normalerweise eine höhere Lernrate: Forschende von Facebook trainierten ResNet-50 in einer Stunde auf ImageNet mit Batches aus 8.192 Bildern auf 256 GPUs. Dazu skalierten sie die Lernrate linear mit der Batchgröße und erhöhten sie schrittweise während der Aufwärmphase.

Verwandte Verfahren#

• Gradienten-Checkpointing: Berechnet Aktivierungen während der Backpropagation erneut, statt sie zu speichern. Das spart innerhalb jedes Microbatches Speicher, erfordert aber zusätzliche Rechenleistung.
• Gemischte Genauigkeit: Speichert Aktivierungen in 16-Bit-Formaten und schafft so Platz für größere Microbatches. Der Loss-Scaler skaliert die Gradienten nach dem letzten Microbatch einmal zurück.
• Pipeline-Parallelität: Teilt jeden Batch in Microbatches auf, die auf unterschiedlichen GPUs durch die Modellstufen laufen. Ihre Gradienten werden vor einem einzigen Optimierungsschritt akkumuliert.

Beim Training von Ultralytics YOLO26 werden Gradienten standardmäßig akkumuliert: Im Trainingsmodus führt der Trainer nach jeweils round(nbs / batch) Batches einen Optimierungsschritt aus. Bei den Standardwerten batch=16 und der nominalen Batchgröße nbs=64 werden somit vier Batches pro Update verarbeitet; mit batch=8 sind es acht. Während der Aufwärmphase steigt der Wert schrittweise von eins an. Außerdem wird die Gewichtszerfallsrate mit batch × accumulation / nbs skaliert. Dadurch gelten die standardmäßigen Hyperparameter für eine Batchgröße von 64 Bildern auch auf einer GPU, die jeweils nur wenige Bilder speichern kann.