Gradientenabstieg: Lernen in kleinen Schritten

In der letzten Lektion hat uns eine Formel die beste Gerade auf einen Schlag geliefert. Ein neuronales Netz mit Millionen von Gewichten hat aber keine solche Formel. Wie kann ein Computer gute Werte für Millionen von Stellschrauben finden, wenn ihm niemand sagen kann, wo die beste Einstellung liegt? Die Antwort ist fast peinlich einfach: Er ertastet, wo es bergab geht, und macht einen kleinen Schritt. Dann noch einen. Probier es zuerst selbst aus, bevor du die Erklärung liest.

Probier es aus

• Wähl eine kleine Lernrate und drück ein paarmal auf Schritt. Beobachte, wie sich die Gerade bei jedem Schritt ein wenig bewegt und die Verlustkurve langsam sinkt.
• Drück auf Ausführen und lass es laufen. Landet die Gerade nahe an der Gerade nach der Methode der kleinsten Quadrate aus der vorigen Lektion?
• Fang mit der größten Lernrate neu an und drück wieder auf „Schritt“. Sieh dir die Verlustkurve an: Statt zu fallen, steigt sie, und die Gerade schwingt wild hin und her. Das ist Divergenz.
• Probier die Lernraten dazwischen aus und finde die größte, bei der der Verlust noch gleichmäßig fällt.

Die Idee in einfachen Worten

Stell dir vor, du stehst in dichtem Nebel an einem Hang. Du willst ins Tal, siehst aber nur einen Meter weit. Eine vernünftige Strategie: mit den Füßen den Boden abtasten, die Richtung finden, in der es am steilsten abwärts geht, einen Schritt dorthin machen und das wiederholen. Die ganze Landschaft siehst du nie, und trotzdem kommst du Schritt für Schritt tiefer.

Beim maschinellen Lernen ist die „Landschaft“ der Fehler des Modells. Jedes mögliche Paar aus Steigung und Achsenabschnitt ist ein Ort auf der Karte, und die Höhe an diesem Ort ist die mittlere quadratische Abweichung aus Lektion 3. Der Talboden ist die beste Gerade. Der Gradientenabstieg ist der Spaziergang im Nebel: irgendwo anfangen, messen, in welche Richtung der Fehler sinkt, die Parameter ein wenig in diese Richtung verschieben und das wiederholen, bis der Fehler nicht mehr fällt.

Warum es funktioniert

Die Richtung des steilsten Anstiegs einer Funktion gibt ihr Gradient an – eine Liste von Ableitungen, eine pro Parameter, die sagt, wie stark der Fehler wachsen würde, wenn man diesen Parameter ein Stück erhöht. Geh in die Gegenrichtung, und der Fehler sinkt. Für jeden Parameter w sieht ein Schritt so aus:

w ← w − η · ∂L/∂w

Dabei ist L der Verlust (der Fehler, den wir minimieren), ∂L/∂w gibt an, wie stark der Verlust auf w reagiert, und η (der griechische Buchstabe Eta) ist die Lernrate, die die Schrittgröße festlegt. Wo der Hang steil ist, werden die Schritte groß; nahe am Boden wird der Hang flacher, und die Schritte schrumpfen von selbst.

Alles hängt von der Lernrate ab. Ist sie zu klein, ist jeder Schritt winzig, und der Weg dauert ewig. Ist sie genau richtig, fällt der Fehler schnell und pendelt sich nahe dem Minimum ein. Ist sie zu groß, schießt jeder Schritt über das Tal hinaus und landet höher am gegenüberliegenden Hang; der nächste Schritt schießt noch weiter hinaus, und der Fehler wächst ohne Grenze. Das nennt man Divergenz, und sie ist der häufigste Grund, warum ein Trainingslauf „explodiert“.

Das Schöne an der Methode: Sie braucht nur eines, nämlich den Gradienten an der aktuellen Position. Eine Formel für die Lösung braucht sie nicht, und sie funktioniert für zwei Parameter genauso wie für zwei Milliarden. Deshalb ist sie der Motor hinter fast jedem neuronalen Netz, auch hinter den Sprachmodellen aus Lektion 12. In der Praxis schätzt man den Gradienten meist auf einem kleinen zufälligen Stapel (Mini-Batch) von Beispielen statt auf allen; das macht jeden Schritt billiger und verrauschter, funktioniert aber erstaunlich gut.

Häufiger Fehler

Wenn der Verlust plötzlich in die Höhe schießt oder zu „NaN“ (Not a Number, keine Zahl) wird, vermuten Anfänger oft einen Fehler im Code. Viel häufiger ist schlicht die Lernrate zu groß. Die Abhilfe ist, sie zu senken, nicht das Modell neu zu schreiben. Der umgekehrte Fehler ist weniger sichtbar: eine Lernrate, die so klein ist, dass der Verlust beim Trainingsende noch fällt, sodass das Modell schlechter aussieht, als es sein könnte. Eine verwandte Falle sind Merkmale mit sehr unterschiedlichen Skalen – etwa das Alter in Jahren neben dem Einkommen in Euro –, die das Tal in eine lange, enge Schlucht verwandeln, in der keine einzelne Lernrate für alle Richtungen passt. Die Merkmale vorher zu skalieren, macht den Weg viel leichter.

Jetzt haben wir beide Hälften des Lernrezepts: eine Bewertung und einen Weg, sie zu verbessern. In der nächsten Lektion setzen wir sie für eine neue Art von Frage ein – nicht „wie viel?“, sondern „welches?“.

import numpy as np
from sklearn.datasets import load_diabetes

X, y = load_diabetes(return_X_y=True, as_frame=True, scaled=False)
bmi = X["bmi"].to_numpy()
z = (bmi - bmi.mean()) / bmi.std()  # standardisierter BMI, wie im Lab
mse = lambda w, b: np.mean((y - (b + w * z)) ** 2)
for lr in [0.01, 0.1, 0.8, 1.1]:
    w, b = 0.0, 0.0  # Start im Ursprung
    for _ in range(5):  # fünf Full-Batch-Schritte
        r = y - (b + w * z)
        w, b = w + lr * 2 * np.mean(r * z), b + lr * 2 * np.mean(r)
    print(f"lr {lr}: loss after 5 steps {mse(w, b):.0f}")
w_best, b_best = np.polyfit(z, y, 1)
print(f"minimum: {mse(w_best, b_best):.0f}")

lr 0.01: loss after 5 steps 24468
lr 0.1: loss after 5 steps 6595
lr 0.8: loss after 5 steps 4043
lr 1.1: loss after 5 steps 159823
minimum: 3890