Du verstehst Gradient Descent vom Bauchgefühl bis zur Praxis: Kostenfunktion, Ableitung, Update-Regel, Lernrate, lokale Minima, Momentum, Batch-Varianten und eine kleine SGD-Pipeline.
Wenn direkte Lösungen zu teuer oder zu unflexibel werden, hilft ein systematischer Abstieg in kleinen Schritten.
Du suchst das günstigste Zugticket für eine längere Reise. Es gibt unzählige Kombinationen aus Uhrzeit, Zugtyp, Umstieg und Sparpreis. Alle Varianten einzeln zu prüfen, wäre mühsam.
ist genau für solche Situationen da: Statt alle Möglichkeiten brutal durchzurechnen, näherst du dich der besten Lösung Schritt für Schritt an.
Beim Modelltraining suchst du Parameter, die den Fehler minimieren. Für einfache lineare Regression gibt es oft eine direkte Lösung. Bei vielen Features oder komplexeren Modellen wird das schnell unpraktisch.
Gradient Descent ersetzt die direkte Lösung durch eine wiederholte Verbesserung: schauen, wo es bergab geht, dann einen kleinen Schritt in diese Richtung machen.
import numpy as np
# Kleine Trainingsdaten mit Intercept-Spalte
X = np.array([
[1, 1],
[1, 2],
[1, 3],
[1, 4]
], dtype=float)
y = np.array([2, 3, 4, 5], dtype=float)
# Direkte Lösung bei kleiner linearer Regression
b_closed_form = np.linalg.inv(X.T @ X) @ X.T @ y
# Iterative Optimierung als Alternative
b = np.zeros(X.shape[1])
alpha = 0.1
n = len(X)
for _ in range(100):
grad = (2 / n) * X.T @ (X @ b - y)
b = b - alpha * grad
print("Direkt:", b_closed_form.round(2))
print("Iterativ:", b.round(2))Was nimmst du mit?
Gradient Descent ist nicht „komplizierter um der Kompliziertheit willen“, sondern ein praktischer Weg, wenn direkte Lösungen zu teuer oder zu unflexibel werden.
Jede Position entspricht einer Parameterwahl, und jede Höhe steht für den aktuellen Fehler des Modells.
Stell dir vor, du stehst mitten im Gebirge. Du siehst nur deine direkte Umgebung. Trotzdem kannst du fühlen, ob der Boden rechts oder links steiler wird.
Genau das macht die Ableitung in der Mathematik: Sie misst die Steigung an deinem aktuellen Punkt.
Bei einem einzelnen Parameter sieht die MSE-Kostenfunktion oft wie eine Schüssel aus. Das ist günstig, weil es nur ein globales Minimum gibt. Wichtig dabei: Die Kostenfunktion fällt nicht vom Himmel. Wir wählen sie bewusst, damit wir messen können, wie schlecht ein Modell gerade ist. Bei linearer Regression ist das oft MSE, bei logistischer Regression später eher Log-Loss.
Die Ableitung sagt dir an jeder Stelle, ob du nach links oder rechts gehen solltest und wie steil der Hang gerade ist. Erst Kostenfunktion, dann Ableitung, dann Update-Schritt: so greift alles ineinander.
Schreibe die Ableitung für die einfache Kostenfunktion J(b) = b². Ergänze die fehlende Zeile und prüfe danach, welchen Wert der Gradient bei b = 3 hat.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
def gradient(b):
return # ??? DEINE LÖSUNG ???
print(gradient(3))Für b² ist die Ableitung besonders kurz: Das Quadrat macht aus dem Exponenten eine Multiplikation mit 2.
def gradient(b):
return 2 * b
print(gradient(3))Erwartete Ausgabe: `6`
import numpy as np
import matplotlib.pyplot as plt
# Beispiel: einfache Kostenfunktion
def J(b):
return b**2
# Ableitung = lokale Steigung
def dJ_db(b):
return 2 * b
b0 = 3
gradient = dJ_db(b0)
b_values = np.linspace(-4, 4, 200)
j_values = J(b_values)
tangent = J(b0) + gradient * (b_values - b0)
plt.figure(figsize=(7, 4))
plt.plot(b_values, j_values, label="J(b) = b²", color="#173262")
plt.plot(b_values, tangent, "--", label=f"Tangente bei b={b0}", color="#631832")
plt.scatter([b0], [J(b0)], color="#631832", s=70)
plt.annotate(f"Gradient = {gradient}", (b0, J(b0)), xytext=(3.1, 10.5))
plt.xlabel("b")
plt.ylabel("J(b)")
plt.title("Kostenfunktion und lokale Steigung")
plt.legend()
plt.grid(alpha=0.2)
plt.show()b = 3. Die Steigung dieser Tangente ist genau der Gradient, den Gradient Descent für seinen nächsten Schritt nutzt.Was nimmst du mit?
Du musst die ganze Landschaft nicht kennen. Für den nächsten Schritt reicht oft die lokale Steigung unter deinen Füßen.
Gradient Descent wiederholt immer dieselbe Logik: Steigung messen, dann einen kontrollierten Schritt abwärts machen.
Im dichten Nebel kannst du nicht direkt ins Tal springen. Du fühlst zuerst den Hang, machst dann einen kleinen Schritt, prüfst erneut die Lage und wiederholst das Ganze.
Genau deshalb ist Gradient Descent ein iterativer Algorithmus: Er arbeitet in vielen kleinen Korrekturen statt in einem einzigen großen Sprung.
Der zentrale Schritt lautet: aktueller Parameter minus Lernrate mal . Das Minuszeichen ist entscheidend, weil der Gradient bergauf zeigt.
Wenn der Gradient null wird, bist du an einer flachen Stelle angekommen. Bei einer konvexen Parabel ist das das Minimum.
Setze die Update-Regel direkt in Code um. Die Schleife läuft drei Schritte lang, und du ergänzt die Zeile, in der der neue Wert von x berechnet wird.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
x = 4.0
alpha = 0.2
for i in range(3):
grad = 2 * x
x = # ??? DEINE LÖSUNG ???
print(round(x, 3))Die Regel lautet: aktueller Wert minus Lernrate mal Gradient.
x = 4.0
alpha = 0.2
for i in range(3):
grad = 2 * x
x = x - alpha * grad
print(round(x, 3))Erwartete Ausgabe: `0.864`
import numpy as np
import matplotlib.pyplot as plt
# Kleine Trainingsdaten mit Intercept-Spalte
X = np.array([
[1, 1],
[1, 2],
[1, 3],
[1, 4]
], dtype=float)
y = np.array([2, 3, 4, 5], dtype=float)
b = np.zeros(X.shape[1])
learning_rate = 0.1
n = len(X)
cost_history = []
for i in range(20):
y_hat = X.dot(b)
gradient = (2 / n) * X.T.dot(y_hat - y)
b = b - learning_rate * gradient
cost = np.mean((X.dot(b) - y) ** 2)
cost_history.append(cost)
print("Gelernte Parameter:", b.round(2))
plt.figure(figsize=(7, 4))
plt.plot(cost_history, marker="o", color="#173262")
plt.xlabel("Iteration")
plt.ylabel("MSE-Kosten")
plt.title("Gradient Descent: Kosten fallen Schritt für Schritt")
plt.grid(alpha=0.2)
plt.show()cost_history zeigt dir danach im Plot, dass die Kosten von Iteration zu Iteration sinken.Was nimmst du mit?
Gradient Descent ist eine Schleife aus Messen und Korrigieren. Der Zauber liegt nicht in einem einzigen Schritt, sondern in der Wiederholung.
Zu klein ist zäh, zu groß wird hektisch. Die Lernrate entscheidet, ob der Abstieg ruhig, langsam oder chaotisch verläuft.
Ein Auto auf einer kurvigen Bergstraße braucht die richtige Geschwindigkeit. Zu langsam kommst du kaum voran. Zu schnell fliegst du aus der Kurve.
Genau so verhält sich die Lernrate im Modelltraining: Sie ist dein Tempo-Regler.
Die α skaliert jeden Schritt. Kleine Werte bedeuten feine, langsame Korrekturen. Große Werte können das Minimum überspringen.
Es gibt keinen universell perfekten Wert. Gute Lernraten hängen von Problem, Daten und Skalierung ab.
neuer Parameter = alter Parameter - α × GradientProbiere aus, wie stark eine größere Lernrate den Schritt verändert. Ergänze die fehlende Rechnung für einen einzigen Update-Schritt und beobachte, wie schnell x Richtung Minimum springt.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
x = 4.0
alpha = 0.5
gradient = 2 * x
x_new = # ??? DEINE LÖSUNG ???
print(x_new)Auch hier gilt dieselbe Regel wie im Modul: alter Wert minus alpha mal Gradient.
x = 4.0
alpha = 0.5
gradient = 2 * x
x_new = x - alpha * gradient
print(x_new)Erwartete Ausgabe: `0.0`
import numpy as np
import matplotlib.pyplot as plt
# Kostenfunktion und Gradient
def J(b):
return b**2
def dJ(b):
return 2*b
b_start = 4.0
learning_rates = [0.05, 0.3, 1.0]
n_iters = 15
plt.figure(figsize=(6, 4))
for lr in learning_rates:
b = b_start
cost_history = []
for i in range(n_iters):
# Kosten berechnen und speichern
cost_history.append(J(b))
# Gradient Descent Schritt
grad = dJ(b)
b = b - lr * grad
plt.plot(range(n_iters), cost_history, marker="o", label=f"lr = {lr}")
plt.xlabel("Iteration")
plt.ylabel("Kosten J(b)")
plt.title("Gradient Descent mit verschiedenen Lernraten")
plt.legend()
plt.grid(True)
plt.show()Was nimmst du mit?
Die Lernrate ist kein Detail, sondern eine der wichtigsten Stellschrauben. Ein gutes Modell kann an einer schlechten Lernrate scheitern.
Nicht jede Fehlerlandschaft ist eine saubere Schüssel. Manchmal gibt es mehrere Täler oder lange flache Zonen.
Im Nebel findest du vielleicht ein kleines Tal und denkst: geschafft. Erst später merkst du, dass hinter einem Hügel ein noch tieferes Tal liegt.
Genau das ist die Schwierigkeit bei nicht-konvexen Problemen: Nicht jede flache Stelle ist das globale Ziel.
Bei linearer Regression mit MSE ist die Landschaft konvex und deshalb angenehm. Bei komplexeren Modellen kann es mehrere lokale Minima und Sattelpunkte geben.
Dann hängt das Ergebnis oft stärker vom Startpunkt und von den Update-Regeln ab.
# In nicht-konvexen Problemen kann der Start relevant werden
b = random_start()
for _ in range(100):
b = b - alpha * grad(b)Was nimmst du mit?
Die Schwierigkeit steckt nicht nur im Algorithmus, sondern auch in der Form der Fehlerlandschaft.
Ein bisschen Trägheit kann helfen, Zickzack-Bewegungen zu glätten und schneller durch enge Täler zu kommen.
Eine Murmel rollt einen Hang hinunter. Ohne Schwung kann sie in kleinen Mulden hängen bleiben oder ständig links und rechts pendeln. Mit Schwung rollt sie flüssiger weiter.
bringt genau diese Trägheit in Gradient Descent hinein.
Beim Momentum wird nicht nur der aktuelle Gradient berücksichtigt, sondern auch ein Teil der vorherigen Bewegung. Bei moderaten Werten werden Updates oft glatter und zielgerichteter.
Typische Werte für γ liegen ungefähr zwischen 0.8 und 0.99. Bei γ = 0 verschwindet der Schwung komplett. Wird γ zu groß, kann das Modell aber über das Tal hinausschießen und zu schwingen beginnen.
velocity = 0
for _ in range(100):
gradient = grad(b)
velocity = gamma * velocity + learning_rate * gradient
b = b - velocityWas nimmst du mit?
Momentum ist keine neue Richtung, sondern eine weichere Art, die Richtung umzusetzen.
Die Varianten unterscheiden sich vor allem darin, wie viele Datenpunkte pro Update in den Gradient einfließen.
Koch 1 liest das ganze Kochbuch, bevor er etwas ändert. Koch 2 probiert nach jeder einzelnen Zutat neu. Koch 3 arbeitet kapitelweise. Genau diese drei Arbeitsstile entsprechen Batch GD, SGD und Mini-Batch.
Keine Variante ist immer „die beste“. Es geht um den passenden Kompromiss zwischen Ruhe, Tempo und Speicher.
Batch GD nutzt alle Daten pro Update: stabil, aber langsam. SGD nutzt einen Punkt: schnell, aber unruhig. sitzt dazwischen.
In der Praxis ist Mini-Batch oft der Standard, weil es Geschwindigkeit und Stabilität gut verbindet.
Gehe drei Trainingspunkte nacheinander durch und aktualisiere das Gewicht nach jedem einzelnen Punkt. Genau dieses Muster steckt hinter der stochastischen Variante von Gradient Descent.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
w = 0.0
alpha = 0.1
samples = [1.0, 2.0, 3.0]
targets = [2.0, 4.0, 6.0]
for x, y in zip(samples, targets):
grad = 2 * x * (w * x - y)
w = # ??? DEINE LÖSUNG ???
print(round(w, 2))SGD nutzt dieselbe Update-Regel wie vorher, nur mit einem einzelnen Datenpunkt pro Schritt.
w = 0.0
alpha = 0.1
samples = [1.0, 2.0, 3.0]
targets = [2.0, 4.0, 6.0]
for x, y in zip(samples, targets):
grad = 2 * x * (w * x - y)
w = w - alpha * grad
print(round(w, 2))Erwartete Ausgabe: `2.26`
import matplotlib.pyplot as plt
# Drei Trainingspunkte: y = 2x
samples = [1.0, 2.0, 3.0]
targets = [2.0, 4.0, 6.0]
w = 0.0
alpha = 0.1
weight_history = [w]
prediction_history = []
for x, y in zip(samples, targets):
prediction = w * x
grad = 2 * x * (prediction - y)
w = w - alpha * grad
prediction_history.append(prediction)
weight_history.append(w)
print(f"x={x:.0f}, Vorhersage={prediction:.2f}, neues Gewicht={w:.2f}")
plt.figure(figsize=(6, 4))
plt.plot(range(len(weight_history)), weight_history, marker="o", color="#173262")
plt.xticks(range(len(weight_history)), ["Start", "nach Punkt 1", "nach Punkt 2", "nach Punkt 3"], rotation=15)
plt.ylabel("Gewicht w")
plt.title("Wie SGD das Gewicht nach jedem Punkt anpasst")
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()Was nimmst du mit?
Nicht nur die Formel, auch die Datenportion pro Update entscheidet über das Verhalten des Trainings.
Am Ende geht es nicht nur um Mathematik, sondern um einen sauberen Workflow mit Scaling, SGD und Bewertung.
Du hast wandern gelernt, die richtige Schrittlänge gefunden und Schwung mitgenommen. Jetzt geht es auf den echten Berg: ein vollständiger Trainingsablauf mit Datenvorbereitung, Modell und Bewertung.
In echten Projekten ist Gradient Descent selten isoliert. Er steckt in einer Pipeline mit Skalierung, Regularisierung und Auswertung.
Bei SGD-basierten Verfahren ist Feature Scaling besonders wichtig. Unterschiedliche Skalen verzerren sonst die Gradienten und machen das Lernen unnötig schwer.
Auch Regularisierung taucht hier wieder auf: In vielen SGD-Modellen kannst du direkt zwischen L2, L1 oder Elastic Net wählen.
Bevor du mit Gradient Descent trainierst, sollten die Eingaben in einer ähnlichen Größenordnung liegen. Sonst verhält es sich wie bei einem Einkaufswagen mit einem riesigen und einem winzigen Rad: Er zieht ständig in eine Richtung.
Ein Beispiel: Wenn ein Merkmal in Euro zwischen 500 und 5.000 liegt, ein anderes aber nur zwischen 0 und 1, dann dominiert das große Merkmal schnell die Schritte des Modells. bringt diese Größenordnungen näher zusammen.
StandardScaler verschiebt ein Merkmal auf Mittelwert 0 und typische Streuung 1. MinMaxScaler drückt Werte meist in einen festen Bereich wie 0 bis 1. Keine Skalierung heißt: Das Modell muss mit sehr unterschiedlich großen Zahlen direkt klarkommen.
Für SGD ist das wichtig, weil die Schritte sonst in einer Richtung zu groß und in einer anderen zu klein werden. Faustregel: StandardScaler ist oft der robuste Standard für lineare Modelle und Gradient Descent. MinMaxScaler ist eher praktisch, wenn du bewusst einen festen Wertebereich brauchst. Genau das schaust du dir in der nächsten Demo an.
from sklearn.linear_model import SGDClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
pipe = Pipeline([
("scaler", StandardScaler()),
("sgd", SGDClassifier(loss="log_loss", penalty="l2", random_state=42))
])Was nimmst du mit?
Gradient Descent ist mehr als eine Formel. In echten Workflows lebt er von guter Vorbereitung, passenden Hyperparametern und sauberer Bewertung.