Gradient Descent: Wie KI lernt

Du bist mit verbundenen Augen in einer hügeligen Landschaft.

Dein einziges Ziel ist es, den tiefsten Punkt im Tal zu erreichen.

Du kannst die gesamte Landschaft nicht sehen. Du siehst nicht, wo das Tal ist. Du kannst nicht dorthin teleportieren.

Was tust du?

Du spürst den Boden unter deinen Füßen. Du erkennst, in welche Richtung es an deinem Standort abwärts geht. Du machst einen Schritt in diese Richtung. Dann spürst du wieder. Schritt wieder. Spüre wieder. Schritt wieder.

Irgendwann erreichst du den Boden.

Genau das ist Gradientenabstieg. Mehr nicht.

Die Grundlagen

Ein Modell hat Gewichte. Die Gewichte steuern seine Vorhersagen. Schlechte Gewichte führen zu schlechten Vorhersagen. Gute Gewichte führen zu guten Vorhersagen.

Es gibt eine Verlustfunktion, die misst, wie schlecht die Vorhersagen sind. Hoher Verlust bedeutet, das Modell liegt falsch. Null Verlust bedeutet, das Modell ist perfekt.

Die Verlustlandschaft ist dieses hügelige Gelände. Jede mögliche Kombination von Gewichtswerten entspricht einem Punkt in der Landschaft. Hohe Punkte sind schlecht. Der Talboden ist das, was du willst.

Gradientenabstieg ist der Algorithmus, der von deinem Startpunkt aus zum tiefsten Punkt in der Landschaft wandert.

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def loss(w):
    return (w - 4) ** 2 + 2

w_values = np.linspace(-2, 10, 200)
loss_values = [loss(w) for w in w_values]

plt.figure(figsize=(8, 4))
plt.plot(w_values, loss_values, 'b-', linewidth=2)
plt.xlabel('Gewicht (w)')
plt.ylabel('Verlust')
plt.title('Die Verlustlandschaft für ein Gewicht')
plt.grid(True, alpha=0.3)
plt.savefig('loss_landscape.png', dpi=100, bbox_inches='tight')
plt.close()
print("Verlustlandschaft gespeichert")

Ein Gewicht. Eine Verlustkurve. Das Minimum liegt bei w=4, wo der Verlust 2 beträgt. Deine Aufgabe ist es, dieses Minimum zu finden, ohne zu wissen, wo es sich befindet.

Der Algorithmus, Schritt für Schritt

def loss(w):
    return (w - 4) ** 2 + 2

def gradient(w):
    return 2 * (w - 4)

w = -1.0
learning_rate = 0.1

print(f"{'Schritt':<6} {'Gewicht':<10} {'Verlust':<10} {'Gradient':<10}")
print("-" * 40)
for step in range(20):
    current_loss = loss(w)
    grad = gradient(w)
    w = w - learning_rate * grad
    if step % 4 == 0:
        print(f"{step:<6} {w:<10.4f} {current_loss:<10.4f} {grad:<10.4f}")

print(f"\nEndgültiges Gewicht: {w:.4f}")
print(f"Endgültiger Verlust: {loss(w):.4f}")

Ausgabe:

Schritt Gewicht Verlust Gradient ---------------------------------------- 0 0.8000 27.0000 -10.0000 4 3.3939 0.6040 -1.2121 8 3.8661 0.0179 -0.2677 12 3.9718 0.0005 -0.0564 16 3.9941 0.0000 -0.0119 Endgültiges Gewicht: 3.9988 Endgültiger Verlust: 0.0000

Startete bei -1.0. Fand 4.0. Nie gesagt bekommen, wo das Minimum war. Einfach dem Gefälle zwanzigmal gefolgt.

Der Gradient bei jedem Schritt zeigt dir die Steigung und Richtung. Du subtrahierst ihn vom Gewicht, weil du bergab gehen willst, entgegengesetzt zur aufwärts gerichteten Steigung.

Lernrate: Die Schrittgröße

Die Lernrate steuert, wie groß jeder Schritt ist. Zu klein und du erreichst das Minimum irgendwann, aber es dauert ewig. Zu groß und du hüpfst am Minimum vorbei und kommst nie zur Ruhe.

def loss(w):
    return (w - 4) ** 2 + 2

def gradient(w):
    return 2 * (w - 4)

learning_rates = [0.01, 0.1, 0.9]
starting_w = -1.0

for lr in learning_rates:
    w = starting_w
    for _ in range(50):
        w = w - lr * gradient(w)
    print(f"lr={lr} endgültiges w={w:.4f} endgültiger Verlust={loss(w):.6f}")

Ausgabe:

lr=0.01 endgültiges w=2.6901 endgültiger Verlust=1.741764 lr=0.1 endgültiges w=3.9988 endgültiger Verlust=0.000000 lr=0.9 endgültiges w=3.4142 endgültiger Verlust=0.341444

lr=0.01: zu langsam, konvergierte nicht in 50 Schritten. lr=0.1: genau richtig, erreichte das Minimum. lr=0.9: zu groß, sprang wiederholt darüber hinaus, endete nahe, aber nicht dort.

Die richtige Lernrate zu wählen ist eines der ersten Dinge, die du beim Trainieren echter Modelle anpasst. Häufige Startwerte: 0.001, 0.01, 0.1. Beginne in diesem Bereich und passe basierend auf dem, was du siehst, an.

Mehrere Gewichte

Ein Gewicht ist eine 1D-Landschaft. Zwei Gewichte sind eine 2D-Oberfläche, wie eine Schale. Eine Million Gewichte sind eine millionendimensionale Oberfläche, die niemand visualisieren kann, aber die gleiche Mathematik gilt.