Backpropagation

Aus Zweites Gehirn, dem persönlichen Wiki
Backpropagation
TypKonzept
QuellenQuelle - Neuronale Netze selbst programmieren
Quelle - Neuronale Netze programmieren mit Python
Quelle - Bildverarbeitung Zusammenfassung
Erstellt2026-09-26
Aktualisiert2026-09-27
Tagsneuronale-netze, maschinelles-lernen, algorithmus

Das Verfahren, mit dem ein mehrschichtiges neuronales Netz lernt: Der Fehler an der Ausgabe wird rückwärts durch das Netz verteilt, im Verhältnis zu den Gewichten. Mit der Kettenregel ergibt sich daraus für jedes Gewicht, wie es geändert werden muss, damit der Fehler kleiner wird.

Das Problem

Beim linearen Klassifikator gibt es nur einen Parameter, und der Fehler sagt direkt, wie er zu ändern ist. In einem Netz tragen aber mehrere Verbindungen zu jedem Ausgang bei, und die inneren Knoten haben gar keinen Sollwert, die Trainingsdaten geben nur die Ausgabe vor (Quelle - Neuronale Netze selbst programmieren, S. 73–79).

Fehler rückwärts verteilen

  1. Ausgabeschicht: Der Fehler ist einfach Soll minus Ist, eₖ = tₖ − oₖ.
  2. Aufteilen: Der Fehler eines Knotens wird auf die eingehenden Verbindungen verteilt, im Verhältnis zu ihren Gewichten. Bei Gewichten 3,0 und 1,0 gehen 3/4 an die erste und 1/4 an die zweite Verbindung (S. 74–76).
  3. Zusammenfassen: Der Fehler eines versteckten Knotens ist die Summe der Anteile auf allen Verbindungen, die von ihm ausgehen (S. 78–79).
  4. Das wiederholt sich Schicht für Schicht nach hinten. Daher der Name Fehler-Rückführung.

Beispiel (S. 80): Ausgabefehler 0,8 und 0,5 werden über die Gewichte 2,0 / 3,0 bzw. 1,0 / 4,0 verteilt. Die versteckten Knoten erhalten die Fehler 0,42 und 0,88, eine Schicht weiter vorne 0,362 und 0,938. Nachgerechnet, stimmt.

Matrixform

Lässt man die Normierung (die Division durch die Summe der Gewichte) weg, wird die Rückführung zu einer einfachen Matrizenmultiplikation mit der transponierten Gewichtsmatrix (S. 81–84):

e_hidden = Wᵀ_hidden_output · e_output

Der fehlende Normierungsfaktor verändert nur die Grösse der Fehler, nicht ihre Verteilung. Das Netz korrigiert das in den folgenden Lernschritten selbst.

Die Gewichtsänderung

Mit dem Gradientenverfahren und dem quadratischen Fehler ergibt die Kettenregel der Differentialrechnung für das Gewicht w_jk vom Knoten j zum Knoten k (S. 94–100):

∂E/∂w_jk = −eₖ · sigmoid(Σ w_jk·oⱼ) · (1 − sigmoid(Σ w_jk·oⱼ)) · oⱼ

Also: Fehler am Zielknoten × Steigung der Aktivierungsfunktion dort × Ausgang des Quellknotens. Für die vordere Schicht gilt dieselbe Form, nur mit dem rückgeführten Fehler eⱼ und den Eingängen oᵢ. Das neue Gewicht ist das alte minus Lernrate mal Steigung.

In Matrixform (S. 101, Code S. 145):

ΔW = α · (E ∗ O ∗ (1 − O)) · Oᵀ_vorher

(∗ = elementweise Multiplikation, · = Matrizenprodukt)

Beispiel (S. 103): e₁ = 0,8, gewichtete Summe 2,3 → sigmoid = 0,909, Steigung 0,909 · 0,091 = 0,083, Ausgang des Quellknotens 0,4. Die Steigung ist −0,0265. Mit Lernrate 0,1 wird das Gewicht von 2,0 zu 2,00265. Nachgerechnet, stimmt.

Dieselbe Rechnung mit Deltas

Quelle - Neuronale Netze programmieren mit Python (Kap. 6) schreibt den Algorithmus mit Deltas δ und programmiert ihn in NumPy für ein 2-2-1-Netz, das XOR lernt:

  1. Vorwärts rechnen und dabei für jedes Neuron gleich die Ableitung der Sigmoidfunktion o·(1 − o) speichern.
  2. Ausgabeschicht: δₖ = oₖ(1 − oₖ) · (yₖ − oₖ).
  3. Versteckte Schicht: δⱼ = oⱼ(1 − oⱼ) · (Wᵀ · δ)ⱼ, also wieder mit der transponierten Gewichtsmatrix. Die Multiplikation mit der Ableitung ist elementweise (Hadamard-Produkt, in NumPy einfach a * b).
  4. Gewichtsänderung: ΔW = η · δ · oᵀ der vorherigen Schicht, ein äusseres Produkt (np.outer), das aus zwei Vektoren eine Matrix macht.
  5. Die Gewichte werden erst angepasst, nachdem alle Deltas berechnet sind, sonst verfälscht man die Abstiegsrichtung (S. 174–188).

Mit Lernrate 0,03 und 40 000 Durchläufen lernt das Netz XOR: Ausgaben 0,04 / 0,96 / 0,96 / 0,04 (S. 186–188). Das Buch rechnet einen Lernschritt Zahl für Zahl vor (S. 189–198). Backpropagation ist eine Verallgemeinerung der Delta-Regel des Adaline (siehe Perzeptron).

Herkunft

Laut Quelle - Neuronale Netze programmieren mit Python beschrieb Paul Werbos die Anwendung auf neuronale Netze 1974 in seiner Dissertation und 1982 in der heute üblichen Form. Bekannt wurde das Verfahren 1986 durch David Rumelhart, Geoffrey Hinton und Ronald Williams (S. 289, 302). Zu den abweichenden Jahreszahlen siehe Geschichte der neuronalen Netze.

Einordnung (Claude)

Rashid erwähnt nur vage, dass das Verfahren „in den 1960er- bis 1970er-Jahren“ praktisch gelöst wurde und die Urheberschaft umstritten ist. Das zweite Buch belegt jetzt Werbos 1974 und Rumelhart, Hinton, Williams 1986. Die Zusammenfassung zur Mustererkennung von 2004 beschreibt denselben Algorithmus in drei Schritten (vorwärts, Fehler, rückwärts) (Quelle - Bildverarbeitung Zusammenfassung). Heute rechnen Frameworks wie PyTorch die Gradienten automatisch aus („automatisches Differenzieren“), mit loss.backward(). Auch grosse Sprachmodelle wie Claude werden mit diesem Verfahren trainiert.

Verwandt