CodeUtility
Mach dir das Coderleben leicht!
KI-Konzepte in Python

Gradientenabstieg und Backpropagation in Python

Trainieren heißt, die Gewichte so anzupassen, dass der Verlust sinkt. Der Gradient zeigt, in welche Richtung der Verlust wächst, also macht der Gradientenabstieg kleine Schritte in die Gegenrichtung. Backpropagation berechnet diesen Gradienten mit der Kettenregel für jedes Gewicht.

Das Konzept in einfachen Worten

Trainieren heißt, die Gewichte so anzupassen, dass der Verlust sinkt. Der Gradient zeigt, in welche Richtung der Verlust wächst, also macht der Gradientenabstieg kleine Schritte in die Gegenrichtung. Backpropagation berechnet diesen Gradienten mit der Kettenregel für jedes Gewicht.

Trainiere ein Neuron mit Gradientenabstieg: Finde mit der Kettenregel heraus, wie jedes Gewicht den Verlust beeinflusst, und gehe bergab.

Die wichtigsten Ideen

  • Der Gradient ist die Steigung des Verlusts bezüglich jedes Gewichts.
  • Die Lernrate bestimmt die Schrittweite: zu groß schießt über das Ziel hinaus, zu klein ist langsam.
  • Backpropagation wendet die Kettenregel von der Ausgabe zurück bis zur ersten Schicht an.
  • Eine Epoche ist ein Durchlauf durch alle Trainingsdaten.

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, um zu trainieren. Die Gerade nähert sich den Punkten, während der orange Pfad auf der Verlustlandschaft bergab zum tiefsten Punkt läuft.

Beispielcode

Code ausführen →
main.py
# Train one neuron y = w * x + b to fit points on the line y = 2x + 1.
data = [(0, 1), (1, 3), (2, 5), (3, 7)]
w, b = 0.0, 0.0
learning_rate = 0.05

for epoch in range(1, 201):
    grad_w = grad_b = 0.0
    for x, y in data:
        error = (w * x + b) - y          # prediction minus target
        # Chain rule: d(error²)/dw = 2 * error * x, d(error²)/db = 2 * error
        grad_w += 2 * error * x
        grad_b += 2 * error
    # Step against the gradient to make the loss smaller.
    w -= learning_rate * grad_w / len(data)
    b -= learning_rate * grad_b / len(data)
    if epoch in (1, 10, 50, 200):
        loss = sum(((w * x + b) - y) ** 2 for x, y in data) / len(data)
        print(f"epoch {epoch:>3}: w={w:.3f} b={b:.3f} loss={loss:.4f}")

Erwartete Ausgabe

epoch   1: w=0.850 b=0.400 loss=7.0587
epoch  10: w=2.009 b=0.958 loss=0.0009
epoch  50: w=2.005 b=0.989 loss=0.0000
epoch 200: w=2.000 b=1.000 loss=0.0000

So funktioniert es

Für jeden Punkt ist der Fehler die Vorhersage minus das Ziel. Die Kettenregel liefert den Gradienten des quadratischen Fehlers, 2·error·x für w und 2·error für b. Wird über die Daten gemittelt und gegen den Gradienten geschritten, nähern sich w und b den Werten 2 und 1, und der Verlust fällt fast auf 0.

Ä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.

  1. Ändere Eingaben oder Gewichte und sage die Ausgabe vor dem Ausführen voraus.
  2. Gib die Zwischenwerte aus, um jeden Rechenschritt zu verfolgen.
  3. 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