Momentum (Optimization)

Momentum ist ein Optimierungsverfahren, das dem gradientenbasierten Training ein Gedächtnis für vorherige Aktualisierungen verleiht. Indem der aktuelle Gradient mit einer abklingenden Historie früherer Gradienten kombiniert wird, erhöht sich die Geschwindigkeit in gleichbleibenden Richtungen und Bewegungen in wechselnde Richtungen werden reduziert. Das hilft Modellen des maschinellen Lernens, ihr Trainingsziel effizienter zu minimieren. Bei der Suchmaschinenoptimierung geht es um die Sichtbarkeit von Websites; bei Momentum geht es um numerische Aktualisierungen der Modellparameter.

So funktioniert Momentum#

Beim Gradientenabstieg bewegt sich ein Modell entgegen dem Gradienten, also entgegen der Richtung, in der seine Verlustfunktion am schnellsten ansteigt, um seine Gewichte anzupassen. Klassisches Momentum, auch Polyak-Momentum oder Heavy-Ball-Verfahren genannt, verleiht dieser Bewegung Trägheit. Boris Polyak führte das Verfahren in seiner Arbeit von 1964 zur Beschleunigung iterativer Verfahren ein.

Der Optimierer verwaltet einen Geschwindigkeitspuffer mit einem akkumulierten Wert pro Parameter. Bei jeder Aktualisierung wird der alte Puffer mit einem Momentum-Koeffizienten multipliziert, der aktuelle Gradient addiert und der resultierende Puffer mit der Lernrate multipliziert und von den Gewichten abgezogen. Bei neuronalen Netzen liefert die Backpropagation diese Gradienten; der Optimierer behält den Puffer zwischen den Aktualisierungen bei.

Momentum ist besonders bei lang gestreckten Verlustflächen nützlich, bei denen die Krümmung quer zu einem Tal stark und entlang seiner Talsohle schwach ist. Gradienten, die wiederholt entlang des Tals zeigen, akkumulieren sich, während sich wechselnde Komponenten quer dazu teilweise aufheben. Beim stochastischen Gradientenabstieg glättet dieses Gedächtnis außerdem die Schwankungen zwischen Mini-Batches. Die Dynamik von Momentum bei quadratischen Verlustfunktionen erklärt sowohl die Beschleunigung als auch die Schwingungen, die nahe einem Minimum auftreten können.

Momentum, Lernrate und verwandte Verfahren#

Der Momentum-Koeffizient, üblicherweise mit Beta oder Mu bezeichnet, liegt meist zwischen null und eins. Bei null erhält man den gewöhnlichen Gradientenabstieg; Werte näher an eins bewahren ältere Gradienten länger. Ein Koeffizient von 0.9 ist ein üblicher Ausgangswert. Bei einem nicht normalisierten Geschwindigkeitspuffer und einem konstanten Gradienten nähert sich die akkumulierte Geschwindigkeit bei 0.9 dem Zehnfachen und bei 0.99 dem Hundertfachen dieses Gradienten. Daher beeinflussen sich Momentum und Lernrate bei der Optimierung von Hyperparametern stark gegenseitig.

Eine zu aggressive Kombination führt zum Überschwingen: Die Aktualisierungen überschreiten wiederholt ein Minimum, wodurch der Verlust oszilliert oder die Optimierung divergiert. Das tritt auch bei glatten quadratischen Zielfunktionen auf. Ein Lernratenplan verändert die Größe der Aktualisierungen während des Trainings, während Momentum bestimmt, wie lange die Richtungsvergangenheit erhalten bleibt.

Zwei eng verwandte Optimierungsalgorithmen nutzen diese Historie auf unterschiedliche Weise:

• Nesterov-Momentum berechnet den Gradienten an einer vorausblickenden Position, die anhand der gespeicherten Geschwindigkeit bestimmt wird. Dadurch kann der Gradient die erwartete Bewegung korrigieren.
• Adam kombiniert einen exponentiell gewichteten Gradientenmittelwert mit einem Mittelwert der quadrierten Gradienten, der die Aktualisierungen für jeden Parameter separat skaliert. Die Einstellung beta1 steuert das Gedächtnis für Gradienten.

Ein minimales PyTorch-Beispiel#

Dieses PyTorch-Beispiel vergleicht identische Startpunkte und Lernraten bei einer lang gestreckten quadratischen Zielfunktion. Die offizielle SGD-Implementierung verwaltet den Momentum-Puffer automatisch.

import torch

# Curvature is 50 times greater along the second coordinate.
scale = torch.tensor([1.0, 50.0])

for momentum in (0.0, 0.9):
    weights = torch.tensor([5.0, 1.0], requires_grad=True)
    optimizer = torch.optim.SGD([weights], lr=0.015, momentum=momentum)

    for step in range(100):
        optimizer.zero_grad()
        loss = (scale * weights.square()).sum()
        loss.backward()
        optimizer.step()

    final_loss = (scale * weights.square()).sum().item()
    print(f"Momentum {momentum}: loss = {final_loss:.6f}")

Nach 100 Aktualisierungen beträgt der Verlust ungefähr 0.056531 ohne Momentum und 0.000216 mit Momentum. Die akkumulierte Richtungsvergangenheit beschleunigt den Fortschritt entlang der flach gekrümmten Koordinate.

Einsatz beim Training für Computer Vision#

Momentum unterstützt das Training faltender neuronaler Netze für die Bildklassifizierung und die Objekterkennung. Das Training mit Ultralytics YOLO aktiviert Nesterov-Momentum, wenn optimizer="SGD" ausgewählt ist; die Einstellung momentum steuert, wie viel der bisherigen Aktualisierungshistorie erhalten bleibt. Die Implementierung des Trainers übergibt diesen Koeffizienten mit nesterov=True an den Optimierer.

Eine wegweisende Anwendung ist das ursprüngliche ResNet-Trainingsverfahren für ImageNet. Diese Modelle verwendeten SGD mit Momentum 0.9, einer Batchgröße von 256, einer Gewichtsabnahme von 0.0001 und einer anfänglichen Lernrate von 0.1, die bei einem Plateau des Fehlers um den Faktor zehn verringert wurde.