Gradient Descent

Wie ein Modell lernt — Schritt für Schritt den Berg hinunter

Stell dir vor, du stehst im dichten Nebel auf einem Berg und willst ins Tal. Du siehst nichts — aber du fühlst mit den Füßen, wo es am stärksten bergab geht.

Du machst einen kleinen Schritt in diese Richtung. Dann fühlst du wieder, und wiederholst das. Irgendwann ist es flach — du bist im Tal. Genau so lernt ein Modell.

Analogie:

Stell dir vor, du stehst im dichten Nebel auf einem Berg und willst ins Tal. Du siehst nichts — aber du fühlst mit den Füßen, wo es am stärksten bergab geht.

Du machst einen kleinen Schritt in diese Richtung. Dann fühlst du wieder, und wiederholst das. Irgendwann ist es flach — du bist im Tal. Genau so lernt ein Modell.

Definition:

Gradient Descent ist ein iteratives Optimierungsverfahren. Der Gradient ∇L zeigt die Richtung des steilsten Anstiegs der Verlustfunktion; wir gehen das Negative davon mit Schrittweite η (Lernrate).

θ_{t+1} = θ_t − η · ∇L(θ_t)

Jede Iteration eines Modells — vom winzigen Regressor bis zum Milliarden-Parameter-Netz — folgt dem gleichen Rezept aus drei Bausteinen:

Verlust — die Landkarte des ModellsDie Verlustfunktion L(θ) misst, wie schlecht das Modell mit den aktuellen Parametern θ ist. In der Demo ist sie die bunte Karte: tiefes Blau = niedriger Verlust (gut), Rot = hoher Verlust (schlecht). Lernen heißt: einen niedrigen Punkt auf dieser Karte finden.
Gradient — der Pfeil bergaufDer Gradient ∇L zeigt an jedem Punkt die Richtung des steilsten Anstiegs. Wir wollen aber bergab — also nehmen wir das Negative davon und gehen einen Schritt in diese Richtung. Im 1D-Modus siehst du den Gradient als gelbe Tangente an der Parabel.
Lernrate η — wie groß jeder Schritt istDie Lernrate skaliert den Schritt. Zu klein → das Modell kriecht ewig. Zu groß → der Schritt überspringt das Tal und der Pfad oszilliert oder explodiert sogar. Die Aha-Presets in der Demo zeigen beide Extreme.

Wiederholt man diese drei Bausteine einige tausend bis Millionen Mal, entsteht aus zufälligen Startwerten ein trainiertes Modell. Mehr passiert beim "Lernen" eines neuronalen Netzes im Kern nicht — die ganze Magie steckt darin, dass die Verlustlandschaft hochdimensional ist und der Gradient trotzdem automatisch via Backpropagation berechnet werden kann.

Hier siehst du das Lernen eines Modells live als Bild: die bunte Karte ist die Verlustlandschaft (die Berge und Täler der Fehler eines Modells), der weiße Pfad ist der Optimierer, der ins Tal rollt. Setze einen Startpunkt, wechsle Verlustfunktion oder Optimierer — schon ein anderer Startpunkt oder ein anderer Optimierer kann zu einem ganz anderen Ergebnis führen. Genau das ist der Kern aller modernen KI-Trainings.

Was du auf der Fehler-Landschaft siehst

Diese Demo zeigt, wie ein Modell lernt: Ein Punkt rollt eine Fehler-Landschaft hinab ins Tal. Hier steht, was du auf dem Bild siehst.

Verlustlandschaft (3D)

bereit

Schritt0

Verlust0.000

Bester Verlust—

Distanz zum Min1.69

|Gradient|0.000

Status bereit

Verlust-Verlauf

Klick auf die Karte, um den Verlauf zu starten.

Verlustfunktion

Zwei Täler — Startpunkt entscheidet

Nicht-konvex: zwei gleich tiefe Minima links und rechts der Mitte, dazwischen ein „Hügel". Der Optimierer rollt blind ins nächstgelegene Tal — welches das globale Minimum ist, weiß er nicht. Echte neuronale Netze haben Milliarden solcher Täler nebeneinander; deshalb haben verschiedene Trainings desselben Netzes leicht unterschiedliche Endpunkte.

Optimierer

SGD

Momentum

Adam

SGD — Stochastic Gradient Descent

Die Grundform: θ = θ − η·g. Folgt blind dem aktuellen Gradienten, kein Gedächtnis, kein Schwung. Lehrbuch-Standard und Referenzpunkt — auf glatten Landschaften überraschend gut, in flachen Tälern (Banane) zickzackt er heftig. Heute selten als Default, weil komplexere Landschaften ihn schnell ins Stocken bringen.

Lernrate η: 0.063

Logarithmische Skala 0.001 bis 1.0. Probiere die Extreme!

Lernrate-Schedule

Konstant

Step-Decay

Cosine

In echten Trainings sinkt η über die Zeit. Step-Decay halbiert alle 40 Schritte, Cosine fällt sanft auf null.

Geschwindigkeit: 0.87x

Aha-Presets

Ein Klick setzt Lernrate, macht Reset und startet. Beobachte den Unterschied.

Aus dem Tal ausbrechen

Stuck im lokalen Minimum? Kick stupst nur an, Neustart wirft den Würfel, Bester-von-8 erkundet systematisch.

Drei Optimierer, gleicher Startpunkt, gleiche Lernrate, gleiche Verlustlandschaft. Das einzige, was sich unterscheidet, ist die Rechenregel, mit der jeder Optimierer entscheidet, wohin der nächste Schritt geht. Klick "Start Race" und beobachte die drei Pfade parallel.

Worum geht es in diesem Experiment?

Wir kontrollieren alles bis auf den Optimierer — wie in einem sauberen wissenschaftlichen Experiment mit nur einer Variable. Wenn die drei Pfade trotzdem unterschiedlich aussehen, liegt das ausschließlich an der jeweiligen Update-Regel. Das macht sichtbar, was sonst ein abstraktes Detail in einer Trainings-Konfiguration wäre.

Worauf du achten solltest

SGD: folgt stur dem aktuellen Gradienten. In flachen oder gebogenen Tälern oszilliert er — Schritt für Schritt quer hin und her, statt entlang.
Momentum: speichert vergangene Schritte als „Schwung". Es dauert ein paar Schritte, bis das Schwungrad in Gang kommt — danach beschleunigt es konsistent in eine Richtung.
Adam: skaliert jede Achse individuell — Richtungen, in denen der Gradient stark schwankt, werden gedämpft; ruhige Richtungen werden verstärkt. Wirkt auf der Banane wie eine zielsuchende Rakete.

SGD

L: 1.628·min: —

Momentum

L: 1.628·min: —

Adam

L: 1.628·min: —

Warum die Ergebnisse unterschiedlich sind

Alle drei sehen am gleichen Punkt den gleichen Gradienten — sie verarbeiten ihn aber unterschiedlich. SGD nimmt ihn 1:1. Momentum mittelt ihn mit vergangenen Gradienten (β=0.9), wodurch konsistente Richtungen verstärkt und Hin-und-her-Schwingungen ausgemittelt werden. Adam macht dasselbe wie Momentum, normiert zusätzlich jede Komponente durch die Schwankung der letzten Gradienten — laute Achsen werden gedämpft, ruhige beschleunigt. Diese Mathe-Details bestimmen, ob der Pfad zickzackt, glatt fließt oder das Tal überspringt.

Was das für echtes Training bedeutet

Im Bild sind es drei Striche auf einer Karte — im echten Training sind das Stunden GPU-Zeit, mehrere Prozent Genauigkeit und manchmal der Unterschied zwischen Modell funktioniert und Modell konvergiert nicht. Deshalb ist Adam (und seine Varianten AdamW, Adafactor, Lion …) der Default für tiefe neuronale Netze: er ist robust gegenüber stark unterschiedlich skalierten Parametern, wie sie in echten Netzen mit Millionen Gewichten unvermeidlich entstehen. Die Demo zeigt im Kleinen, was im Großen über das Gelingen eines Trainings entscheidet.

Theorie

Pseudocode

Schritt für Schritt

Flussdiagramm

Der Wanderer im Nebel

Stell dir vor, du stehst im dichten Nebel auf einem Berg und willst ins Tal. Du siehst nichts — aber du fühlst mit den Füßen, wo es am stärksten bergab geht, und gehst einen Schritt in diese Richtung. Wiederhol das, bis es flach ist. Genau das macht Gradient Descent. Es ist die Lernregel, die hinter fast jedem trainierten KI-Modell der letzten 30 Jahre steckt.

Die Mathematik in einer Zeile

Formal: $\theta_{t+1} = \theta_t - \eta \cdot \nabla L(\theta_t)$. In Worten: nimm die aktuellen Parameter $\theta$, berechne den Gradienten $\nabla L$ der Verlustfunktion an dieser Stelle, geh einen Schritt der Länge $\eta$ (Lernrate) entgegen dem Gradienten — denn der Gradient zeigt bergauf, wir wollen aber bergab.

Drei Bausteine

Verlustfunktion L(θ): die „Karte" — wie schlecht ist das Modell mit den Parametern θ?
Gradient ∇L: der Pfeil, der an jedem Punkt bergauf zeigt. Wir gehen das Negative davon.
Lernrate η: die Schrittgröße. Zu klein = ewig lahm. Zu groß = oszilliert oder explodiert.

SGD, Momentum, Adam — drei Geschmacksrichtungen

Reines Gradient Descent (SGD) folgt blind dem Gradienten. Momentum sammelt vergangene Schritte wie eine rollende Kugel mit Schwung — hilft in flachen, langen Tälern. Adam kombiniert Momentum mit einer pro-Parameter-Skalierung anhand der Gradient-Varianz — der heutige Default für tiefe Netze.

Wo es nicht garantiert klappt

Lokale Minima: bei nicht-konvexen Funktionen (mehrere Täler) bleibt der Algorithmus im nächstgelegenen Tal hängen — der Startpunkt entscheidet.
Sattelpunkte: flache Regionen, in denen der Gradient verschwindet, ohne ein echtes Minimum zu sein.
Explosion: bei viel zu großer Lernrate überschießt der Schritt und der Pfad fliegt auseinander.

Spiele in der Demo! Probier die drei Verlustfunktionen (Schüssel = konvex, Zwei Täler = lokale Minima, Banane = flaches Tal) und sieh, wo SGD scheitert und Adam glänzt. Die Aha-Presets („Zu langsam", „Genau richtig", „Explodieren!") zeigen den Lernraten-Effekt in einem Klick.

Deutsch

                      
                        
                          1
                          # Gradient Descent — iterative Optimierung
                        
                      
                        
                          2
                          funktion gradient_descent(L, theta_init, lr, max_steps, tol):
                        
                      
                        
                          3
                              theta = theta_init
                        
                      
                        
                          4
                              m, v = 0, 0   # Optimizer-State (für Momentum/Adam)
                        
                      
                        
                          5
                           
                        
                      
                        
                          6
                              für schritt in 1..max_steps:
                        
                      
                        
                          7
                           
                        
                      
                        
                          8
                                  # 1. Gradient — Richtung des steilsten Anstiegs
                        
                      
                        
                          9
                                  g = gradient(L, theta)
                        
                      
                        
                          10
                           
                        
                      
                        
                          11
                                  # 2. Flach genug? Dann sind wir im Tal
                        
                      
                        
                          12
                                  wenn |g| < tol: brich ab
                        
                      
                        
                          13
                           
                        
                      
                        
                          14
                                  # 3. Optimizer wählt, wie der Gradient zum Schritt wird
                        
                      
                        
                          15
                                  wenn optimizer == "Momentum":
                        
                      
                        
                          16
                                      m = 0.9·m + g                  # Schwung sammeln
                        
                      
                        
                          17
                                      schritt = lr · m
                        
                      
                        
                          18
                                  sonst wenn optimizer == "Adam":
                        
                      
                        
                          19
                                      m = 0.9·m + 0.1·g              # 1. Moment
                        
                      
                        
                          20
                                      v = 0.999·v + 0.001·g²         # 2. Moment (Varianz)
                        
                      
                        
                          21
                                      schritt = lr · m / (√v + ε)
                        
                      
                        
                          22
                                  sonst:                            # reines SGD
                        
                      
                        
                          23
                                      schritt = lr · g
                        
                      
                        
                          24
                           
                        
                      
                        
                          25
                                  # 4. Parameter aktualisieren — ein Schritt bergab
                        
                      
                        
                          26
                                  theta = theta - schritt
                        
                      
                        
                          27
                           
                        
                      
                        
                          28
                              gib theta zurück

1 / 6

🚩 Initialisierung

Setze die Parameter θ auf einen Startwert (in echten Netzen: zufällig). Setze die Optimizer-Hilfsvariablen (Momentum-Speicher m, Varianz-Speicher v für Adam) auf null. Das ist deine Startposition auf der Verlustlandschaft.

funktion gradient_descent(L, theta_init, lr, max_steps, tol):
    theta = theta_init
    m, v = 0, 0   # Optimizer-State (für Momentum/Adam)

Was beschreibt der Gradient einer Verlustfunktion?

Den aktuellen Wert der Verlustfunktion.

Die Richtung des steilsten Anstiegs des Verlusts.

Die optimale Lernrate für den nächsten Schritt.

Die Anzahl der bereits gemachten Iterationen.

1. Was beschreibt der Gradient einer Verlustfunktion?

☐ A) Den aktuellen Wert der Verlustfunktion.
☐ B) Die Richtung des steilsten Anstiegs des Verlusts.
☐ C) Die optimale Lernrate für den nächsten Schritt.
☐ D) Die Anzahl der bereits gemachten Iterationen.

2. Was passiert typischerweise bei einer viel zu großen Lernrate?

☐ A) Das Modell konvergiert besonders schnell zum globalen Minimum.
☐ B) Der Verlust sinkt langsam aber stetig.
☐ C) Der Optimierer überschießt das Minimum, oszilliert oder divergiert sogar.
☐ D) Der Gradient wird automatisch kleiner skaliert.

3. Warum hilft Momentum besonders in langen, flachen Tälern (wie der Rosenbrock-Banane)?

☐ A) Es vergrößert die Lernrate dynamisch.
☐ B) Es sammelt vergangene Gradienten und behält die Richtung bei, sodass es nicht zickzackt.
☐ C) Es ersetzt den Gradienten durch den Mittelwert aller Datenpunkte.
☐ D) Es schaltet automatisch zwischen SGD und Adam um.

4. Garantiert Gradient Descent, das globale Minimum zu finden?

☐ A) Ja, immer — solange die Lernrate klein genug ist.
☐ B) Ja, aber nur mit Adam-Optimierer.
☐ C) Nein. Bei nicht-konvexen Funktionen (z.B. mehreren Tälern) bleibt es im nächstgelegenen lokalen Minimum stecken.
☐ D) Nein, es findet immer nur Sattelpunkte.

Auflösung: 1) B · 2) C · 3) B · 4) C

Gradient Descent

Was ist Gradient Descent?

Analogie:

Definition:

Drei Bausteine, ein Lernschritt

Interaktive Demo

Was du auf der Fehler-Landschaft siehst

Verlustlandschaft (3D)

Race-Mode — drei Optimierer im Direktvergleich