Learning Rate

Die Lernrate ist der Hyperparameter, der bestimmt, wie weit sich die Gewichte eines Modells bei jedem Trainingsschritt verschieben. Beim Gradientenabstieg wird der Gradient der Verlustfunktion berechnet. Er zeigt in die Richtung, in der der Verlust am stärksten zunimmt. Anschließend wird jedes Gewicht nach der Formel w ← w − η × Gradient aktualisiert, wobei η (Eta) die Lernrate ist. Schrittweite ist ein Synonym, und im Code heißt sie meist lr. Mit einer gut gewählten Lernrate konvergiert ein neuronales Netz schnell zu einer guten Lösung. Eine schlecht gewählte Lernrate lässt das Training divergieren oder nur schleppend vorankommen. Deshalb bezeichnet Leslie Smiths Aufsatz über zyklische Lernraten die Lernrate als den wichtigsten zu optimierenden Hyperparameter für tiefe Netze.

Zu hoch, zu niedrig oder genau richtig#

Die Lernrate bestimmt den Kompromiss zwischen Geschwindigkeit und Stabilität:

• Zu hoch: Jeder Schritt springt über das Minimum hinaus. Der Verlust schwankt, springt oder steigt, bis er zu NaN wird, und das Training divergiert.
• Zu niedrig: Die Gewichte bewegen sich bei jedem Schritt kaum. Der Verlust sinkt langsam, bis zur Konvergenz sind viel mehr Epochen erforderlich, und ein Lauf mit festem Budget endet mit Underfitting.
• Gut gewählt: Der Verlust sinkt stetig und pendelt sich nahe einem Minimum ein.

Das folgende PyTorch-Skript minimiert den Verlust w² ausgehend vom selben Startpunkt mit vier Lernraten:

import torch

# Minimize loss = w**2 (lowest at w = 0) from the same start with four learning rates
for lr in (0.01, 0.1, 0.9, 1.1):
    w = torch.tensor(5.0, requires_grad=True)
    optimizer = torch.optim.SGD([w], lr=lr)
    path = []
    for step in range(20):
        optimizer.zero_grad()
        loss = w**2
        loss.backward()
        optimizer.step()  # w = w - lr * gradient
        path.append(w.item())
    print(f"lr={lr}: first steps {[round(v, 2) for v in path[:3]]}, after 20 steps w={path[-1]:.3f}")

Bei 0.01 bewegt sich das Gewicht in 20 Schritten nur von 5 auf 3.338; bei 0.1 erreicht es 0.058. Bei 0.9 wechselt es bei jedem Schritt das Vorzeichen (−4.0, 3.2, −2.56), konvergiert aber trotzdem auf 0.058. Bei 1.1 überschreitet jeder Schritt das Ziel stärker, und das Gewicht wächst auf 191.688. Der Gradientenabstieg bleibt bei einer quadratischen Funktion nur stabil, solange die Lernrate kleiner als 2 geteilt durch die Krümmung der Verlustfunktion, also ihre zweite Ableitung, ist. Die Krümmung von w² beträgt 2, daher liegt die Grenze hier genau bei 1.0; eine Lernrate von 0.5 führt in einem Schritt zum Minimum. In einem realen Netz bestimmt die steilste Richtung des Verlusts dieselbe Art von Grenze. Deshalb kann eine Lernrate, die für ein Modell oder eine Batch-Größe funktioniert, bei einem anderen divergieren.

Lernratenpläne#

Während des Trainings wird die Lernrate selten von Anfang bis Ende beibehalten. Ein Lernratenplan verändert sie im Zeitverlauf:

• Aufwärmphase: Beginnt mit einer niedrigen Lernrate und erhöht sie während der ersten Epochen oder Iterationen schrittweise. Dadurch destabilisieren die großen, unregelmäßigen Gradienten der ersten Iterationen das Training nicht.
• Stufenweiser Abfall: Die Lernrate wird zu festgelegten Epochen oder bei einem Plateau des Validierungsverlusts um einen festen Faktor, oft 10, verringert.
• Linearer und kosinusförmiger Abfall: Die Lernrate wird gleichmäßig bis auf einen niedrigen Endwert gesenkt. Kosinus-Annealing folgt einer halben Kosinuswelle. Bei der Variante mit Warm-Restarts springt die Lernrate zu Beginn jedes neuen Zyklus wieder auf den hohen Wert zurück.
• Zyklische und Ein-Zyklus-Richtlinien: Während des Trainings wird die Lernrate zwischen einem unteren und einem oberen Grenzwert angepasst.

Große Schritte zu Beginn bewegen die Gewichte schnell in einen guten Bereich, und kleine Schritte am Ende lassen sie sich in einem Minimum einpendeln, statt darum herumzuschwingen. YOLO26 Training in Ultralytics beginnt bei lr0, wärmt sich über warmup_epochs auf (standardmäßig 3) und sinkt linear auf lr0 * lrf oder folgt einer Kosinuskurve mit cos_lr=True. Beim Standardwert optimizer="auto" wählt der Trainer sowohl den Optimierer als auch dessen anfängliche Lernrate selbst: MuSGD mit 0.01 bei Läufen mit mehr als 10,000 Iterationen, andernfalls AdamW mit einer an die Klassenanzahl angepassten Lernrate. lr0 kommt daher nur zum Einsatz, wenn der Optimierer ausdrücklich festgelegt wird:

from ultralytics import YOLO

# Ein vortrainiertes YOLO26-Nano-Modell laden
model = YOLO("yolo26n.pt")

# # Bei einem explizit angegebenen Optimierer gilt lr0; die Lernrate sinkt entlang einer Kosinuskurve auf lr0 * lrf
results = model.train(data="coco8.yaml", epochs=10, optimizer="SGD", lr0=0.01, lrf=0.01, cos_lr=True)

Einen Anfangswert auswählen#

Übliche Anfangswerte sind 0.01 bis 0.1 für stochastischen Gradientenabstieg (SGD) mit Momentum und 0.001 für den Adam-Optimierer, den im Adam-Artikel vorgeschlagenen Standardwert. Beim Feinabstimmen eines vortrainierten Modells wird eine niedrigere Lernrate als beim Training von Grund auf verwendet, da große Schritte die Merkmale überschreiben würden, die Transferlernen ermöglichen.

Der Lernratenbereichstest aus demselben Artikel über zyklische Lernraten, der in fastai als Lernraten-Finder enthalten ist, findet in einem kurzen Lauf einen geeigneten Wert. Er erhöht die Lernrate nach jedem Mini-Batch und zeichnet dabei den Verlust auf. Der brauchbare Bereich liegt dort, wo der Verlust am schnellsten sinkt, bevor er explodiert.

Lernrate und verwandte Begriffe#

• Optimierungsalgorithmus: Die Aktualisierungsregel, die die Lernrate verwendet. Adaptive Optimierer wie Adam skalieren den Schritt jedes Gewichts anhand seiner eigenen Gradientenhistorie, multiplizieren aber weiterhin jeden Schritt mit einer globalen Lernrate.
• Momentum: Ein separater Hyperparameter, der einen Anteil der vorherigen Aktualisierung zur aktuellen addiert. Dadurch wird der Verlauf geglättet und die effektive Schrittgröße in beständigen Richtungen erhöht.
• Gewichtszerfall: Ein Regularisierung-Term, der die Gewichte bei jedem Schritt selbst gegen null verkleinert, während der Lernratenzerfall die Schrittgröße mit der Zeit reduziert.
• Batchgröße: Die Anzahl der Beispiele, über die jeder Gradient gemittelt wird. Größere Batches ergeben weniger verrauschte Gradienten und vertragen höhere Lernraten. Die Regel der linearen Skalierung multipliziert die Lernrate mit k, wenn die Batchgröße um den Faktor k wächst.