Adam Optimizer

Der Adam-Optimierer, kurz für Adaptive Moment Estimation, ist ein Optimierungsalgorithmus zum Trainieren neuronaler Netze, der jedem Parameter eine eigene adaptive Schrittweite zuweist. Er wurde von Kingma und Ba in Adam: Eine Methode zur stochastischen Optimierung vorgestellt und erweitert den stochastischen Gradientenabstieg (SGD) um gleitende Mittelwerte vergangener Gradienten und ihrer Quadrate. Frühe Trainingsfortschritte und fehlertolerante Standardeinstellungen machten Adam zum häufigsten Startoptimierer im Deep Learning. Die Variante AdamW ist die Standardwahl für das Training von Transformern und großen Sprachmodellen.

So funktioniert Adam#

Beim Training wird eine Verlustfunktion minimiert, indem jeder Gewichtungsparameter wiederholt entgegen seinem Gradienten angepasst wird. Einfaches SGD multipliziert jeden Gradienten mit derselben Lernrate. Adam speichert zwei zusätzliche Werte pro Parameter und aktualisiert sie bei jedem Schritt t anhand des aktuellen Gradienten g:

1. Erstes Moment (Impuls): m = β1·m + (1 − β1)·g, ein exponentiell abklingender Mittelwert der Gradienten, der die Aktualisierung in einer beständigen Richtung hält.
2. Zweites Moment: v = β2·v + (1 − β2)·g², ein abklingender Mittelwert der quadrierten Gradienten, der erfasst, wie groß die Gradienten eines Parameters üblicherweise sind.
3. Bias-Korrektur: m̂ = m / (1 − β1^t) und v̂ = v / (1 − β2^t), die den Umstand ausgleichen, dass beide Mittelwerte bei null beginnen.
4. Aktualisierung: θ = θ − lr · m̂ / (√v̂ + ε).

Die Standardwerte aus der Veröffentlichung, die auch PyTorchs torch.optim.Adam verwendet, sind lr = 0.001, β1 = 0.9, β2 = 0.999 und ε = 1e-8. Die Division durch √v̂ normalisiert jeden Schritt anhand der typischen Gradientengröße des Parameters. Dadurch bleiben die Schritte nahe an der Lernrate, egal ob die Gradienten sehr klein oder sehr groß sind. In verrauschten Richtungen werden die Schritte kleiner, wenn sich positive und negative Gradienten innerhalb von m̂ gegenseitig aufheben. Das folgende Codebeispiel vergleicht den ersten Schritt von SGD und Adam bei zwei Parametern, deren Gradienten sich um den Faktor 1.000 unterscheiden:

import torch

# Two parameters whose gradients differ in scale by 1,000x
scale = torch.tensor([1000.0, 1.0])

for name, optimizer_cls in [("SGD", torch.optim.SGD), ("Adam", torch.optim.Adam)]:
    w = torch.zeros(2, requires_grad=True)
    optimizer = optimizer_cls([w], lr=0.001)

    loss = (scale * w).sum()  # gradient is [1000, 1]
    loss.backward()
    optimizer.step()
    print(f"{name} first step: {[round(v, 4) for v in w.tolist()]}")

SGD verschiebt den ersten Parameter auf -1.0 und den zweiten auf -0.001. Der Unterschied von 1.000 entspricht den Gradienten. Adam verschiebt beide genau um die Lernrate von -0.001, da sein normalisierter Schritt von Richtung und Beständigkeit des Gradienten abhängt und nicht von seiner absoluten Größe.

Adam und AdamW#

Adam wendet in der üblichen Implementierung eine Gewichtsabnahme als Form der Regularisierung an, indem eine L2-Strafe zum Gradienten addiert wird. Diese Strafe wird dann zusammen mit allem anderen durch √v̂ geteilt, sodass Gewichte mit großen Gradienten kaum regularisiert werden. Die von Loshchilov und Hutter entwickelte entkoppelte Gewichtsabnahme löst dieses Problem, indem sie die Gewichte bei jedem Schritt direkt und getrennt von der adaptiven Aktualisierung verkleinert. In den Experimenten der Veröffentlichung verbesserte das resultierende AdamW die Generalisierung von Adam bei der Bildklassifizierung und ist als torch.optim.AdamW verfügbar.

Adam und SGD im Vergleich#

SGD mit Impuls verwendet eine globale Lernrate und speichert einen Puffer pro Parameter. Adam speichert zwei, also 8 Byte pro Parameter bei 32-Bit-Genauigkeit. Bei einem Modell mit 7 Milliarden Parametern ergibt das 56 GB für den Optimiererzustand. Adam erzielt gewöhnlich schneller frühe Fortschritte, reagiert weniger empfindlich auf die Lernrate und trainiert Transformer erheblich zuverlässiger als SGD. Gut abgestimmtes SGD erreicht bei konvolutionalen Bildmodellen oft eine ebenso hohe oder höhere endgültige Genauigkeit. Wilson et al. stellten fest, dass adaptive Verfahren bei den von ihnen untersuchten Bildklassifizierungs- und Sprachaufgaben häufig schlechter generalisierten als SGD.

Das Training von Ultralytics YOLO spiegelt diesen Kompromiss wider: Die Standardeinstellung optimizer="auto" wählt AdamW mit einer an die Klassenanzahl angepassten anfänglichen Lernrate für Läufe mit bis zu 10.000 Iterationen und wechselt bei längeren Zeitplänen zu MuSGD, einer Kombination aus SGD und Muon. Wenn du den Optimierer ausdrücklich festlegst, musst du auch die Lernrate festlegen, da die Standardeinstellung lr0=0.01 für SGD geeignet ist und zehnmal höher liegt als die übliche Adam-Lernrate.

from ultralytics import YOLO

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

# Mit AdamW und einer für Adam geeigneten anfänglichen Lernrate trainieren
results = model.train(data="coco8.yaml", epochs=5, optimizer="AdamW", lr0=0.001)

Wenn YOLO26 mit einem Optimierer aus der Adam-Familie trainiert, legt das Argument momentum (Standardwert 0.937) β1 fest, während β2 unverändert bei 0.999 bleibt.

Adam und verwandte Optimierer#

• AdaGrad: Teilt jeden Schritt durch die Wurzel aus allen zuvor quadrierten Gradienten. Dadurch werden die Schrittweiten immer kleiner. Das eignet sich für spärlich besetzte Merkmale, verlangsamt aber lange Trainingsläufe.
• RMSProp: Ersetzt die laufende Summe von AdaGrad durch einen exponentiell abklingenden Mittelwert quadrierter Gradienten. Adam ist im Wesentlichen RMSProp mit Impuls und Bias-Korrektur.
• Muon: Ein Optimierer für die zweidimensionalen Gewichtungsmatrizen verborgener Schichten. Er orthogonalisiert jede Impulsaktualisierung mit Newton–Schulz-Iterationen und speichert einen Zustands-Puffer pro Parameter, also halb so viel Optimiererzustand wie Adam.