Optimierer für neuronale Netze: SGD, Momentum und Adam in Python

Das Konzept in einfachen Worten

Ein Optimierer ist die Regel, die Gradienten in Gewichtsänderungen übersetzt. Einfacher Gradientenabstieg nutzt nur den aktuellen Gradienten; Momentum merkt sich frühere Richtungen, und Adam passt zusätzlich die Schrittweite für jedes Gewicht an.

Vergleiche einfachen Gradientenabstieg, Momentum und Adam, indem alle drei Schritt für Schritt dieselbe Funktion minimieren.

Die wichtigsten Ideen

Momentum behält eine Geschwindigkeit und rollt so über flache Bereiche und kleine Unebenheiten.
Adam führt gleitende Mittelwerte des Gradienten und des quadrierten Gradienten.
Die Bias-Korrektur (Division durch 1 − βᵗ) korrigiert diese Mittelwerte in den ersten Schritten.
Gute Gewichtsinitialisierung und Mini-Batches machen das Training ebenfalls schneller und stabiler.

Wann wird dieser Ansatz verwendet?

Verstehen, was in neuronalen Netzen und KI-Bibliotheken passiert.
Die Idee lernen, bevor du sie in den passenden Challenges umsetzt.
Dich auf Kurse zu maschinellem Lernen, Vorstellungsgespräche und Projekte vorbereiten.

Selbst ausprobieren

Klicke auf Start, und drei Optimierer laufen um die Wette dasselbe holprige Tal hinunter. Mit einer größeren Lernrate siehst du, wie Momentum übers Ziel hinausschießt.

Beispielcode

Code ausführen →

main.py

import math

# Minimise f(x) = (x - 3)² with three optimizers. The gradient is 2(x - 3).
grad = lambda x: 2 * (x - 3)

def sgd(steps, lr=0.1):
    x = 0.0
    for _ in range(steps):
        x -= lr * grad(x)
    return x

def momentum(steps, lr=0.1, beta=0.9):
    x, v = 0.0, 0.0
    for _ in range(steps):
        v = beta * v + grad(x)        # remember the direction we were going
        x -= lr * v
    return x

def adam(steps, lr=0.3, b1=0.9, b2=0.999, eps=1e-8):
    x, m, v = 0.0, 0.0, 0.0
    for t in range(1, steps + 1):
        g = grad(x)
        m = b1 * m + (1 - b1) * g     # running mean of gradients
        v = b2 * v + (1 - b2) * g * g # running mean of squared gradients
        m_hat, v_hat = m / (1 - b1 ** t), v / (1 - b2 ** t)
        x -= lr * m_hat / (math.sqrt(v_hat) + eps)
    return x

for steps in (5, 20, 50):
    print(f"{steps:>2} steps  sgd={sgd(steps):.3f}  momentum={momentum(steps):.3f}  adam={adam(steps):.3f}")

Erwartete Ausgabe

5 steps  sgd=2.017  momentum=4.741  adam=1.476
20 steps  sgd=2.965  momentum=4.048  adam=3.813
50 steps  sgd=3.000  momentum=3.091  adam=3.014

So funktioniert es

Alle drei minimieren (x − 3)², dessen tiefster Punkt bei x = 3 liegt. SGD bewegt sich gleichmäßig, Momentum nimmt Fahrt auf und schießt über das Ziel hinaus, bevor es sich einpendelt, und Adam skaliert jeden Schritt mit gleitenden Mittelwerten des Gradienten und seines Quadrats. Nach 50 Schritten liegen alle drei nahe bei 3.

Ändere die Werte und führe das Programm im CodeUtility Python Online-Compiler aus, ohne Python lokal zu installieren.

Übungsaufgaben

Verändere Eingaben und Randfälle, bevor du die Lösung mit größeren Datenmengen testest.

Ändere Eingaben oder Gewichte und sage die Ausgabe vor dem Ausführen voraus.
Gib die Zwischenwerte aus, um jeden Rechenschritt zu verfolgen.
Löse die verlinkten Challenges unten, um die Idee selbst umzusetzen.

In der Python-IDE ausführen →

Mit einer Challenge üben

Nutze den Inhalt dieser Lektion, um ein echtes Problem zu lösen. Jede Challenge läuft im Browser, mit sofortigen Tests und einem KI-Review.

Alle Challenges