Stochastic Gradient Descent (SGD)

Stochastischer Gradientenabstieg (SGD) ist ein Optimierungsalgorithmus, der ein Modell trainiert, indem er dessen Gewichte wiederholt anhand des Gradienten des Trainingsdatensatzes für eine kleine zufällige Stichprobe aktualisiert, statt den gesamten Datensatz zu verwenden. Der Gradient jeder Stichprobe ist eine verrauschte, aber unverzerrte Schätzung des Gradienten für den gesamten Datensatz. Deshalb kann SGD in der Zeit, die ein einzelner aufwendiger Schritt des vollständigen Gradientenabstiegs benötigt, viele günstige Aktualisierungen vornehmen. Das Verfahren geht auf Robbin und Monros stochastisches Näherungsverfahren von 1951 zurück und ist mit Momentum weiterhin ein gängiger Optimierer für faltende neuronale Netze (CNNs).

So funktioniert SGD#

Bei jedem SGD-Schritt wird ein Mini-Batch B verwendet, der Gradient des Verlusts darauf mit Backpropagation berechnet und jedes Gewicht ein kleines Stück entgegen der Richtung dieses Gradienten verschoben: w ← w − η·∇L_B(w), wobei η die Lernrate ist. Genau genommen verwendet SGD ein Beispiel pro Schritt. Frameworks für Deep Learning wenden das Verfahren jedoch auf Mini-Batches mit Dutzenden bis Tausenden Beispielen an. In der Praxis sind „SGD“ und „Mini-Batch-Gradientenabstieg“ daher Synonyme. Eine größere Batchgröße ergibt einen weniger verrauschten Gradienten und eine bessere Hardwareauslastung, allerdings mit weniger Aktualisierungen pro Epoche.

Beim Training werden die Daten zu Beginn jeder Epoche gemischt, in Mini-Batches durchlaufen und nach jedem Batch wird ein Schritt ausgeführt. Das Anpassen einer Geraden an 1.000 verrauschte Punkte veranschaulicht den gesamten Ablauf:

import torch

torch.manual_seed(0)

# 1,000 noisy samples of y = 3x + 2
x = torch.randn(1000, 1)
y = 3 * x + 2 + 0.1 * torch.randn(1000, 1)

model = torch.nn.Linear(1, 1)
optimizer = torch.optim.SGD(model.parameters(), lr=0.05, momentum=0.9)

for epoch in range(5):
    # Reshuffle every epoch, then update the weights once per 32-sample mini-batch
    for idx in torch.randperm(1000).split(32):
        loss = torch.nn.functional.mse_loss(model(x[idx]), y[idx])
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f"epoch {epoch}: w = {model.weight.item():.3f}, b = {model.bias.item():.3f}, loss = {loss.item():.4f}")

Nach zwei Epochen und insgesamt 64 Aktualisierungen erreicht das Gewicht 3.081 und der Bias 2.012. In den nächsten drei Epochen schwankt das Gewicht weiter zwischen 2.967 und 3.003, statt sich einzupendeln, da jeder Mini-Batch-Gradient Stichprobenrauschen enthält. Der Verlust des letzten Batches bleibt bei etwa 0.01, der Varianz des zu y addierten Rauschens.

Lernrate, Rauschen und Batchgröße#

Bei einer konstanten Lernrate schwankt SGD in einem Bereich um das Minimum, dessen Größe mit der Lernrate und dem Gradientenrauschen zunimmt. Die Theorie der stochastischen Approximation garantiert eine Konvergenz nur, wenn die Lernrate gegen null abnimmt. Daher wird sie beim praktischen Training im Laufe der Zeit durch stufenweise Absenkung oder Cosinus-Zeitpläne verringert, meist nach einer kurzen Aufwärmphase. Das Gradientenrauschen kleiner Batches lenkt SGD außerdem zu flachen Minima, die besser generalisieren als die scharfen Minima, die beim Training mit großen Batches häufig entstehen – eine implizite Form der Regularisierung.

Batchgröße und Lernrate beeinflussen sich gegenseitig. Eine proportionale Erhöhung der Lernrate mit der Batchgröße und eine Aufwärmphase von fünf Epochen ermöglichten es ResNet-50, mit Mini-Batches von 8.192 Bildern in einer Stunde auf ImageNet zu trainieren, ohne an Genauigkeit einzubüßen.

Momentum und Nesterov-Momentum#

In einem langen, schmalen Tal der Verlustfunktion zeigt der Gradient überwiegend quer zum Tal. Einfaches SGD pendelt daher zwischen den Wänden hin und her und kommt auf dem Talboden nur langsam voran. Momentum führt eine laufende Geschwindigkeit, v ← μ·v + g, und macht Schritte entlang dieser Geschwindigkeit, w ← w − η·v. So bauen gleichbleibende Gradientenrichtungen Geschwindigkeit auf, während sich wechselnde Richtungen gegenseitig aufheben. μ = 0,9 ist der übliche Standardwert. Beim Nesterov-Momentum wird der Gradient nach einem vorausschauenden Schritt entlang der Geschwindigkeit berechnet, wodurch das Überschwingen weiter gedämpft wird. PyTorch-SGD implementiert beides und wendet weight_decay an, indem λ·w zum Gradienten addiert wird. Bei SGD ist das gleichbedeutend mit einer L2-Strafe auf die Gewichte.

SGD im Vergleich zu anderen Optimierern#

• Batch-Gradientenabstieg: Berechnet für jede Aktualisierung den exakten Gradienten über den gesamten Datensatz. Daher ergibt jede Epoche einen einzigen Schritt, und der Speicherbedarf steigt mit der Größe des Datensatzes.
• Adam: Weist jedem Parameter anhand der laufenden Mittelwerte seiner Gradienten und quadrierten Gradienten eine eigene Schrittweite zu und speichert pro Parameter zwei Zustandswerte – gegenüber einem bei SGD mit Momentum. Adam kommt anfangs schneller voran und reagiert weniger empfindlich auf die Lernrate, während gut abgestimmtes SGD mit Momentum bei CNNs häufig eine vergleichbare oder bessere Endgenauigkeit erreicht. AdamW, eine Variante mit entkoppeltem Gewichtszerfall, ist der Standardoptimierer für Transformer.
• Muon: Orthogonalisiert die Momentum-Aktualisierung jeder Gewichtsmatrix als Ganzes und wurde für das Training großer Sprachmodelle hochskaliert.

Das Training von Ultralytics YOLO erstellt SGD von PyTorch mit Nesterov-Momentum, wenn optimizer="SGD" gesetzt ist, und verwendet standardmäßig lr0=0.01 sowie momentum=0.937. Der Standardwert von optimizer="auto" ignoriert lr0 und wählt für Läufe mit mehr als 10.000 Iterationen MuSGD, eine Mischung aus SGD- und Muon-Aktualisierungen, und für kürzere Läufe AdamW.

Wo SGD eingesetzt wird#

SGD mit Momentum wurde zum Training der meisten wegweisenden ImageNet-CNNs verwendet. Die ursprünglichen ResNet-Modelle nutzten Momentum 0,9, einen Gewichtszerfall von 0,0001 und Mini-Batches mit 256 Bildern. Die Lernrate begann bei 0,1 und wurde immer dann durch 10 geteilt, wenn sich der Fehler nicht weiter verringerte. Außerhalb des Deep Learning passen scikit-learns SGDClassifier und SGDRegressor lineare Modelle wie die logistische Regression und lineare Support-Vektor-Maschinen mit SGD an. Ihre Methode partial_fit trainiert Datensätze, die zu groß für den Arbeitsspeicher sind, Stück für Stück.