Zuletzt aktualisiert am 05.12.2025 6 Minuten Lesezeit

Gradient Descent

Gradient Descent (deutsch: Gradientenabstieg oder Gradientenverfahren) ist ein grundlegender Optimierungsalgorithmus im maschinellen Lernen. Er wird verwendet, um die Parameter eines Modells so anzupassen, dass der Fehler zwischen Vorhersage und tatsächlichem Ergebnis minimiert wird. Gradient Descent bildet das Fundament für das Training von neuronalen Netzen und vielen anderen Machine-Learning-Algorithmen.

Stell dir vor, du stehst auf einem Berg und möchtest ins Tal gelangen, kannst aber nichts sehen. Du tastest den Boden ab und gehst immer in die Richtung, die am steilsten nach unten führt. Genau so funktioniert Gradient Descent: Der Algorithmus sucht schrittweise nach dem tiefsten Punkt einer Fehlerfunktion.

Wie funktioniert Gradient Descent?

Beim Training eines Machine-Learning-Modells definiert eine Verlustfunktion (Loss Function oder Cost Function), wie gut oder schlecht das Modell performt. Das Ziel ist es, diese Funktion zu minimieren. Gradient Descent erreicht dies durch iterative Anpassung der Modellparameter.

Der Gradient

Der Gradient ist ein mathematisches Konzept aus der Analysis. Er ist ein Vektor, der in die Richtung des steilsten Anstiegs einer Funktion zeigt. Wenn du den Gradienten berechnest und in die entgegengesetzte Richtung gehst (also bergab), bewegst du dich zum Minimum der Funktion.

Mathematisch ausgedrückt: Der Gradient einer Funktion f(x) bezüglich der Parameter x gibt an, wie sich der Funktionswert ändert, wenn du die Parameter leicht veränderst. Diese Information nutzt Gradient Descent, um die Parameter in kleinen Schritten zu optimieren.

Die Lernrate

import numpy as np

# Beispieldaten
X = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 5, 4, 5])

# Parameter initialisieren
w = 0.0  # Gewicht (Steigung)
b = 0.0  # Bias (y-Achsenabschnitt)
lernrate = 0.01
epochs = 1000

# Gradient Descent
for epoch in range(epochs):
    # Vorhersage: y_pred = w * X + b
    y_pred = w * X + b

    # Verlust (Mean Squared Error)
    loss = np.mean((y_pred - y) ** 2)

    # Gradienten berechnen
    dw = (2 / len(X)) * np.sum((y_pred - y) * X)
    db = (2 / len(X)) * np.sum(y_pred - y)

    # Parameter aktualisieren
    w = w - lernrate * dw
    b = b - lernrate * db

    if epoch % 100 == 0:
        print(f"Epoch {epoch}: Loss = {loss:.4f}, w = {w:.4f}, b = {b:.4f}")

print(f"Finale Parameter: w = {w:.4f}, b = {b:.4f}")

In diesem Beispiel werden die Parameter w und b schrittweise angepasst, um den quadratischen Fehler zwischen Vorhersage und tatsächlichen Werten zu minimieren.

Gradient Descent beim Training neuronaler Netze

Beim Training von neuronalen Netzen und Deep-Learning-Modellen ist Gradient Descent unverzichtbar. Der Prozess läuft typischerweise so ab:

Forward Pass: Eingabedaten werden durch das Netzwerk geleitet, um eine Vorhersage zu erzeugen
Loss-Berechnung: Der Fehler zwischen Vorhersage und Zielwert wird berechnet
Backward Pass (Backpropagation): Die Gradienten werden für alle Parameter im Netzwerk berechnet
Parameter-Update: Alle Gewichte werden mit Gradient Descent aktualisiert
Wiederholung: Schritte 1-4 werden für viele Batches und Epochen wiederholt

Die Backpropagation (Rückwärtspropagierung) ist dabei das Verfahren, mit dem die Gradienten effizient durch alle Schichten des Netzwerks berechnet werden können. Sie nutzt die Kettenregel der Differentialrechnung.

Gradient Descent in der Praxis

In modernen Deep-Learning-Frameworks wie PyTorch oder TensorFlow musst du Gradient Descent nicht selbst implementieren. Die Frameworks berechnen Gradienten automatisch (Automatic Differentiation) und stellen verschiedene Optimierer bereit:

# Beispiel mit PyTorch
import torch
import torch.nn as nn
import torch.optim as optim

# Modell definieren
model = nn.Linear(10, 1)

# Optimierer wählen (Adam mit Lernrate 0.001)
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Trainingsschritt
for batch in dataloader:
    optimizer.zero_grad()      # Gradienten zurücksetzen
    output = model(batch)      # Forward Pass
    loss = criterion(output)   # Loss berechnen
    loss.backward()            # Backpropagation
    optimizer.step()           # Parameter-Update mit Gradient Descent

Relevanz für die IT-Ausbildung

Das Verständnis von Gradient Descent ist für Fachinformatiker für Daten- und Prozessanalyse besonders wichtig, da Machine Learning zu ihren Kernkompetenzen gehört. Aber auch Fachinformatiker für Anwendungsentwicklung profitieren vom Grundverständnis, wenn sie ML-Modelle in Anwendungen integrieren oder APIs von KI-Diensten nutzen.

Wichtige Zusammenhänge im Machine-Learning-Kontext:

Supervised Learning nutzt Gradient Descent zum Training
Large Language Models werden mit Varianten von Gradient Descent trainiert
GPUs beschleunigen die Gradientenberechnung erheblich
TPUs sind speziell für Matrix-Operationen beim Training optimiert

Quellen und weiterführende Links

Mini-Batch Gradient Descent

Mini-Batch Gradient Descent ist ein Kompromiss zwischen beiden Ansätzen. Der Datensatz wird in kleine Gruppen (Mini-Batches) aufgeteilt, typischerweise 32 bis 256 Datenpunkte. Diese Variante kombiniert die Stabilität von Batch GD mit der Effizienz von SGD und ist in der Praxis am weitesten verbreitet.

# Mini-Batch Gradient Descent (vereinfacht)
for epoch in range(num_epochs):
    for mini_batch in erstelle_batches(trainingsdaten, batch_size=32):
        gradient = berechne_gradient(mini_batch)
        parameter = parameter - lernrate * gradient

Erweiterte Optimierungsalgorithmen

Auf Basis von Gradient Descent wurden zahlreiche verbesserte Algorithmen entwickelt, die in der Praxis oft bessere Ergebnisse liefern.

Momentum

Momentum fügt dem Gradient Descent einen "Schwung" hinzu. Der Algorithmus berücksichtigt nicht nur den aktuellen Gradienten, sondern auch die Richtung der vorherigen Updates. Dies beschleunigt die Konvergenz und hilft, flache Bereiche der Verlustfunktion schneller zu überwinden.

Adam

Adam (Adaptive Moment Estimation) kombiniert Momentum mit adaptiven Lernraten für jeden Parameter. Adam passt die Schrittgröße automatisch an und ist robust gegenüber verschiedenen Problemstellungen. Er ist einer der am häufigsten verwendeten Optimierer beim Training neuronaler Netze.

RMSprop

RMSprop (Root Mean Square Propagation) verwendet einen gleitenden Durchschnitt der quadrierten Gradienten, um die Lernrate anzupassen. Dies verhindert, dass die Lernrate zu früh zu klein wird, und funktioniert besonders gut bei nicht-stationären Problemen.

Herausforderungen beim Gradient Descent

Obwohl Gradient Descent sehr effektiv ist, gibt es einige typische Probleme, die du kennen solltest:

Lokale Minima: Der Algorithmus kann in einem lokalen Minimum stecken bleiben, das nicht das globale Minimum ist
Sattelpunkte: Punkte, an denen der Gradient null ist, aber kein Minimum vorliegt
Vanishing Gradients: Bei tiefen neuronalen Netzen können Gradienten sehr klein werden und das Lernen stoppen
Exploding Gradients: Gradienten können auch zu groß werden und numerische Instabilitäten verursachen
Langsame Konvergenz: Bei schlecht konditionierten Problemen kann die Konvergenz sehr langsam sein

Praxisbeispiel: Lineare Regression mit Gradient Descent

Ein einfaches Beispiel zeigt, wie Gradient Descent funktioniert. Wir trainieren eine lineare Regression, um eine Gerade an Datenpunkte anzupassen:

Zurück zum Lexikon