Optimization Algorithm

Ein Optimierungsalgorithmus, kurz Optimierer, ist die Regel, nach der ein Trainingsprozess die Parameter eines Modells anpasst, damit dessen Verlustfunktion sinkt. Beim Deep Learning erhält der Optimierer über die Rückpropagation den Gradienten des Verlusts in Bezug auf jedes Modellgewicht und entscheidet, wie weit und in welche Richtung jedes Gewicht verschoben wird. Zusammen mit der Lernrate bestimmt der Optimierer, wie schnell das Training konvergiert, wie stabil es ist, wie viel Speicher es benötigt und oft auch, wie gut das endgültige Modell generalisiert.

So funktionieren Optimierer#

Fast jeder Optimierer für Deep Learning ist eine Variante des Gradientenabstiegs: Der Gradient g des Verlusts für eine Minibatch wird berechnet, dann werden die Gewichte in kleinen Schritten entgegen seiner Richtung verschoben: w ← w − η·g. Die Optimierer unterscheiden sich darin, was sie vor diesem Schritt mit g machen. Momentum-Verfahren mitteln Gradienten über die Zeit, um in Richtungen, die konstant bleiben, Geschwindigkeit aufzubauen. Adaptive Verfahren teilen den Schritt jedes Parameters durch eine laufende Schätzung der Gradientengröße. Muon orthogonalisiert die Aktualisierung für jede Gewichtsmatrix als Ganzes. Verfahren zweiter Ordnung berücksichtigen außerdem die Krümmung. Dadurch sind die einzelnen Schritte besser abgestimmt, aber ihre Berechnung ist deutlich aufwendiger. Verfahren, die keinen Gradienten benötigen, etwa evolutionäre Algorithmen und Zufallssuche, optimieren durch Ausprobieren von Kandidaten und Beibehalten des besten:

Die Aktualisierungsregel ist besonders wichtig, wenn die Verlustfläche schlecht konditioniert ist und in manchen Richtungen steil, in anderen aber flach verläuft. Werden drei Optimierer im selben Ausgangspunkt in einem schmalen Tal gestartet, zeigt sich der Unterschied:

import torch

# A long, narrow valley: f(w) = w1^2 + 50 * w2^2, with its minimum at (0, 0)
scale = torch.tensor([1.0, 50.0])
optimizers = {
    "SGD": lambda p: torch.optim.SGD(p, lr=0.015),
    "SGD + momentum": lambda p: torch.optim.SGD(p, lr=0.015, momentum=0.9),
    "Adam": lambda p: torch.optim.Adam(p, lr=0.1),
}

for name, make_optimizer in optimizers.items():
    w = torch.tensor([5.0, 1.0], requires_grad=True)
    optimizer = make_optimizer([w])
    # Same loss and starting point for every optimizer; only the update rule differs
    for step in range(100):
        loss = (scale * w**2).sum()
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f"{name:15s} f(w) after 100 steps: {(scale * w**2).sum().item():.6f}")

Einfaches SGD bleibt bei 0.056531 stehen, weil die steile Richtung w2 die Lernrate begrenzt: Jede Rate über 0.02 führt dazu, dass w2 bei jedem Schritt weiter überschießt, und bei 0.021 steigt der Verlust innerhalb von 100 Schritten auf etwa 9,5 Milliarden. Unter dieser Begrenzung ist der Fortschritt in der flachen Richtung w1 langsam. Momentum erreicht 0.000216, indem es in Richtung w1 Geschwindigkeit aufbaut, und Adam erreicht 0.001953, indem es jeder Koordinate eine eigene Schrittgröße zuweist.

Gängige Optimierungsalgorithmen#

• Stochastischer Gradientenabstieg (SGD): Führt Schritte entgegen dem Gradienten der Minibatch aus. Mit einem Momentum von 0.9 wurde damit die Mehrzahl der maßgeblichen Faltungsnetze trainiert; pro Parameter wird ein zusätzlicher Wert gespeichert.
• AdaGrad und RMSProp: Skalieren den Schritt jedes Parameters anhand des Verlaufs seiner quadrierten Gradienten. AdaGrad teilt durch die Wurzel ihrer laufenden Summe, die nur wächst, sodass die Schritte während des gesamten Trainings kleiner werden. RMSProp verwendet stattdessen einen exponentiell abklingenden Durchschnitt, wodurch die Schrittgrößen anpassungsfähig bleiben.
• Adam: Kombiniert Momentum mit einer Skalierung nach Art von RMSProp und korrigiert beide laufenden Durchschnitte für ihren Startwert null. Die Standardwerte – eine Lernrate von 0.001 mit β1 = 0.9 und β2 = 0.999 – funktionieren bei vielen Problemen.
• AdamW: Adam mit entkoppelter Gewichtsabnahme, bei der Gewichte direkt verkleinert werden, statt dies über die adaptive Gradientenskalierung zu tun. AdamW ist der Standardoptimierer für Transformer und große Sprachmodelle (LLMs).
• Muon: Orthogonalisiert die Momentum-Aktualisierung jeder 2D-Gewichtsmatrix mithilfe von Newton–Schulz-Iterationen und verwendet pro Parameter einen einzigen Zustandsbuffer. Moonshot AI skalierte Muon für das Vortraining von LLMs.
• L-BFGS: Ein Quasi-Newton-Verfahren, das anhand der jüngsten Gradienten eine Krümmungsschätzung erstellt. Bei glatten Problemen mit vollständigen Batches konvergiert es in wenigen Schritten. Durch verrauschte Minibatch-Gradienten eignet es sich schlecht für große Netze.

Das Optimiererpaket von PyTorch implementiert all diese Verfahren, einschließlich torch.optim.Muon, sowie Lernratenplaner, die mit jedem davon funktionieren.

Optimierer und verwandte Begriffe#

• Verlustfunktion: Das Ziel, das der Optimierer minimiert, etwa Kreuzentropie bei Klassifizierung oder mittlerer quadratischer Fehler bei Regression.
• Lernratenplaner: Passt während des Trainings die Schrittgröße η mit Aufwärmphase, stufenweiser Absenkung oder Cosinus-Abkühlung an und kann mit jedem Optimierer verwendet werden.
• Hyperparameteroptimierung: Eine übergeordnete Suche nach Einstellungen wie Optimierer, Lernrate und Batchgröße, bei der jeder Kandidat einen vollständigen oder teilweisen Trainingslauf erfordert. Gradientenfreie Verfahren wie bayessche Optimierung und evolutionäre Suche übernehmen diese Aufgabe, da sich ein Validierungswert nicht nach Entscheidungen wie der Wahl des Optimierers ableiten lässt.

Einen Optimierer auswählen#

Optimierer und Lernrate werden gemeinsam ausgewählt, denn jeder Optimierer funktioniert in einem eigenen Wertebereich: SGD mit Momentum beginnt typischerweise zwischen 0.01 und 0.1, Optimierer aus der Adam-Familie bei etwa 0.001. Beim Training mit Ultralytics YOLO wird die Auswahl automatisch getroffen: Der Standardwert optimizer="auto" ignoriert lr0 und wählt für Trainingsläufe mit bis zu 10.000 Iterationen AdamW mit einer an die Klassenzahl angepassten Lernrate. Bei längeren Trainingsplänen kommt MuSGD zum Einsatz, eine Kombination aus SGD und Muon, mit der die veröffentlichten YOLO26-Checkpoints trainiert wurden. Wenn du einen Optimierer angibst, wird lr0 wirksam:

from ultralytics import YOLO

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

# SGD explizit auswählen; lr0 gilt nur, wenn der Optimierer nicht "auto" ist
results = model.train(data="coco8.yaml", epochs=5, optimizer="SGD", lr0=0.01)

Bei optimizer="SGD" aktiviert der Trainer außerdem Nesterov-Momentum. Als Koeffizient wird das Argument momentum verwendet, standardmäßig 0.937.