Backpropagation

Backpropagation, kurz für „Rückwärtsausbreitung von Fehlern“, ist ein Algorithmus, der berechnet, welchen Anteil jedes Gewichts in einem neuronalen Netz am Fehler einer Vorhersage hatte. Ausgehend von der Verlustfunktion wendet er schichtweise die Kettenregel rückwärts in Richtung Eingabe an und verwendet jedes Zwischenergebnis erneut. So liefert ein einziger Rückwärtsdurchlauf den Gradienten für jedes Gewicht – unabhängig davon, ob das Modell Tausende oder Milliarden Parameter hat. Anschließend nutzt ein Optimierer diese Gradienten, um die Gewichte zu aktualisieren. Damit ist Backpropagation der Lernschritt hinter praktisch jedem Deep-Learning-Modell. Rumelhart, Hinton und Williams machten das Verfahren 1986 mit ihrem Nature-Artikel Learning representations by back-propagating errors für neuronale Netze bekannt.

So funktioniert Backpropagation#

Das Training mit einem Batch umfasst zwei Durchläufe. Beim Vorwärtsdurchlauf werden die Eingaben durch jede Schicht geleitet, die Zwischenaktivierungen gespeichert und schließlich der Verlust berechnet. Der Rückwärtsdurchlauf beginnt beim Verlust und durchläuft die Schichten in umgekehrter Reihenfolge. Jede Schicht erhält den Gradienten des Verlusts bezüglich ihrer Ausgabe, den sogenannten vorgelagerten Gradienten, und multipliziert ihn mit ihren eigenen lokalen Ableitungen. So entstehen zwei Ergebnisse: der Gradient für die Gewichte der Schicht, der für den Optimierer gespeichert wird, und der Gradient bezüglich der Eingabe der Schicht, der zum vorgelagerten Gradienten für die darunterliegende Schicht wird.

Da jede Schicht nur ihren vorgelagerten Gradienten und die gespeicherten Aktivierungen benötigt, wird keine Ableitung jemals zweimal berechnet. In der automatischen Differentiation ist Backpropagation die Differentiation des Rechengraphen des Netzwerks im Rückwärtsmodus. PyTorch erstellt diesen Graphen während des Vorwärtsdurchlaufs und durchläuft ihn rückwärts, wenn loss.backward() aufgerufen wird. Bei einem Netzwerk mit zwei Gewichten lässt sich das Ergebnis von autograd in PyTorch mit der von Hand aufgeschriebenen Kettenregel überprüfen:

import torch

# A two-weight network: prediction = w2 * tanh(w1 * x)
x, target = torch.tensor(1.5), torch.tensor(0.5)
w1 = torch.tensor(0.8, requires_grad=True)
w2 = torch.tensor(-1.2, requires_grad=True)

# Forward pass, keeping the hidden activation h for the backward pass
h = torch.tanh(w1 * x)
loss = (w2 * h - target) ** 2

# Backward pass: autograd applies the chain rule from the loss back to each weight
loss.backward()

# The same chain rule by hand, reusing the upstream gradient dL/dy for both weights
dL_dy = 2 * (w2 * h - target)
dL_dw2 = dL_dy * h
dL_dw1 = dL_dy * w2 * (1 - h**2) * x
print(f"autograd: dL/dw1 = {w1.grad:.4f}, dL/dw2 = {w2.grad:.4f}")
print(f"by hand:  dL/dw1 = {dL_dw1:.4f}, dL/dw2 = {dL_dw2:.4f}")

Beide Zeilen geben dL/dw1 = 1.6475, dL/dw2 = -2.5016 aus. Die von Hand geschriebene Variante berechnet dL_dy einmal und verwendet das Ergebnis für beide Gewichte erneut. Dieselbe Wiederverwendung ermöglicht es autograd, Netzwerke mit Milliarden Gewichten zu verarbeiten. Backpropagation durch die Zeit (BPTT) ist derselbe Algorithmus, angewendet auf ein rekurrentes neuronales Netz, das über seine Zeitschritte hinweg entrollt wird.

Backpropagation und der Optimierer#

Backpropagation berechnet nur Gradienten und verändert keine Gewichte. Ein Optimierungsalgorithmus wie stochastischer Gradientenabstieg (SGD) oder Adam wandelt diese Gradienten in Gewichtsaktualisierungen um, die mit der Lernrate skaliert werden. PyTorch addiert das Ergebnis jedes Rückwärtsdurchlaufs zu den bereits bei den Gewichten gespeicherten Gradienten. So kann ein Optimierungsschritt mehrere Batches zusammenfassen:

Das Training mit Ultralytics YOLO nutzt diese Gradientenakkumulation, um eine nominelle Batchgröße von 64 Bildern (nbs=64) zu erreichen: Nach der Aufwärmphase führt ein Lauf mit batch=16 für jeden Batch die Backpropagation aus, wendet den Optimierer aber erst nach jeweils vier Batches an, nachdem der kombinierte Gradient auf eine Norm von 10 begrenzt wurde.

Verschwindende und explodierende Gradienten#

Beim Rückwärtsdurchlauf werden lokale Ableitungen Schicht für Schicht miteinander multipliziert. Daher kann die Größe des Gradienten mit zunehmender Tiefe geometrisch schrumpfen oder wachsen. Sind die meisten Faktoren kleiner als 1, wie bei gesättigten Sigmoid-Einheiten, erhalten die frühesten Schichten fast kein Signal. Das ist das Problem des verschwindenden Gradienten. Sind die meisten Faktoren größer als 1, führt das Problem des explodierenden Gradienten zu enormen Updates und NaN-Verlusten. Aktivierungsfunktionen aus der ReLU-Familie, eine skalierte Gewichtsinitialisierung, Batch-Normalisierung und die Skip-Verbindungen von Residualnetzwerken halten die Gradientenbeträge über Hunderte von Schichten hinweg stabil.

Rechen- und Speicherbedarf#

Jede Aktivierung, die eine lokale Ableitung benötigt, muss vom Vorwärtsdurchlauf bis zu ihrer Verwendung im Rückwärtsdurchlauf im Speicher bleiben. Daher wächst der Speicherbedarf beim Training mit der Batchgröße, der Eingabeauflösung und der Tiefe. Für das Training wird deutlich mehr Speicher benötigt als für die Inferenz. Beim Gradient-Checkpointing werden nur einige Aktivierungen gespeichert und die übrigen während des Rückwärtsdurchlaufs neu berechnet. Das spart Speicher auf Kosten zusätzlicher Rechenleistung. Bei gemischter Genauigkeit liegen die meisten Aktivierungen in 16-Bit-Formaten vor, die halb so viel Speicher wie 32-Bit-Gleitkommazahlen belegen. Der Rückwärtsdurchlauf benötigt etwa doppelt so viel Rechenleistung wie der Vorwärtsdurchlauf, da jede Schicht Gradienten sowohl für ihre Gewichte als auch für ihre Eingaben berechnet. Deshalb setzen Schätzungen auf Grundlage von Skalierungsgesetzen pro Trainings-Token und Parameter etwa 6 Gleitkommaoperationen an: 2 im Vorwärtsdurchlauf und 4 im Rückwärtsdurchlauf.