Mit Google fortfahren
Backpropagation: Fehler rückwärts berechnen
Backpropagation berechnet, wie stark jedes Gewicht und jeder Bias zum Verlust eines neuronalen Netzes beiträgt. Dazu verfolgt sie den Rechenweg vom Ausgang rückwärts und wendet die Kettenregel an. Ein Optimierer nutzt die berechneten Gradienten anschließend, um die Parameter zu verändern.
Hake ab, was du schon kannst — und komm am Ende hierher zurück!
Welche Aufgabe löst Backpropagation?
Ein neuronales Netz verarbeitet Eingaben schrittweise. Jede Verbindung besitzt ein Gewicht. Ein Bias wird zusätzlich zur gewichteten Eingangssumme addiert. Diese trainierbaren Parameter bestimmen die Vorhersage des Netzes.
Eine Verlustfunktion misst, wie stark die Vorhersage vom Zielwert abweicht. Ein kleinerer Verlust bedeutet für das gewählte Trainingsbeispiel eine bessere Übereinstimmung.
Backpropagation
Backpropagation, auf Deutsch Fehlerrückführung, berechnet den Gradienten der Verlustfunktion bezüglich der Gewichte und Biases. Der Gradient enthält die partiellen Ableitungen und beschreibt, wie sich der Verlust bei kleinen Parameteränderungen verändert.
Drei Vorgänge gehören zusammen, haben aber verschiedene Aufgaben:
- Der Vorwärtslauf berechnet aus der Eingabe eine Vorhersage.
- Backpropagation berechnet rückwärts die Gradienten.
- Ein Optimierer, zum Beispiel Gradientenabstieg, aktualisiert die Parameter.
Backpropagation berechnet die Änderungsrichtungen. Der Optimierer führt die Parameteränderungen aus.
Warum ist die Kettenregel entscheidend?
Ein Gewicht beeinflusst den Verlust meist nicht direkt. Es verändert zuerst die gewichtete Summe eines Neurons, diese verändert dessen Aktivierung und die Aktivierung beeinflusst schließlich den Verlust.
Für ein einfaches Neuron gilt:
$$z=wx+b$$
$$y=σ(z)$$
$$L=\frac{1}{2}(y-t)^2$$
Dabei sind $x$ die Eingabe, $w$ das Gewicht, $b$ der Bias, $z$ die Voraktivierung, $y$ die Ausgabe, $t$ der Zielwert und $L$ der Verlust.
Die Kettenregel zerlegt den Einfluss des Gewichts in drei lokale Einflüsse:
$$\frac{∂L}{∂w}=\frac{∂L}{∂y}\cdot\frac{∂y}{∂z}\cdot\frac{∂z}{∂w}$$
Für die Sigmoidfunktion $σ(z)=1/(1+e^{-z})$ gilt:
$$σ'(z)=σ(z)(1-σ(z))$$
Damit folgt:
$$\frac{∂L}{∂w}=(y-t)\cdot y(1-y)\cdot x$$
Beim Bias ist der letzte Faktor 1, weil $∂z/∂b=1$ gilt:
$$\frac{∂L}{∂b}=(y-t)\cdot y(1-y)$$
Betrachte die zusammengesetzte Funktion $f(x)=(3x+2)^2$.
Die innere Funktion ist $u=3x+2$ mit $u'=3$. Die äußere Funktion ist $u^2$ mit der Ableitung $2u$.
Deshalb gilt:
$$f'(x)=2(3x+2)\cdot3=6(3x+2)$$
Genau dieses Prinzip nutzt Backpropagation: Entlang des Rechenwegs werden lokale Ableitungen miteinander multipliziert.
Wie läuft ein Trainingsschritt ab?
Ein vollständiger Trainingsschritt folgt einer festen Reihenfolge:
- Vorwärts rechnen: Für jede Schicht werden Voraktivierung und Aktivierung berechnet und gespeichert.
- Verlust bestimmen: Die Vorhersage wird mit dem Zielwert verglichen.
- Ausgangsgradient berechnen: Der Rückwärtslauf beginnt bei der Verlustfunktion.
- Gradienten zurückführen: Die Kettenregel verbindet die lokalen Ableitungen bis zu früheren Schichten.
- Parameter aktualisieren: Ein Optimierer verwendet die Gradienten.
Beim einfachen Gradientenabstieg lautet das Update für einen Parameter $θ$:
$$θ_{neu}=θ_{alt}-η\frac{∂L}{∂θ}$$
Die Lernrate $η$ bestimmt die Schrittgröße. Das Minuszeichen ist wichtig: Der Gradient zeigt lokal in Richtung des stärksten Anstiegs, daher bewegt sich das Update in die Gegenrichtung.
Gewichte sollten während eines Trainingsschritts nicht nacheinander mit bereits veränderten Zwischenwerten zurückgerechnet werden. Zuerst werden alle benötigten Gradienten aus demselben Vorwärtslauf bestimmt, danach erfolgt das Update.
Wähle in jeder Lücke die passende Form und prüfe anschließend deine Antworten.
Im entsteht die Vorhersage. Die misst deren Abweichung vom Ziel. Backpropagation liefert den . Der Optimierer verändert anschließend die .
Wie sieht eine vollständige Rechnung aus?
Wir verwenden ein Sigmoidneuron mit
- Eingabe $x=2$,
- Gewicht $w=0$,
- Bias $b=0$,
- Zielwert $t=1$,
- Lernrate $η=0{,}1$.
1. Vorwärtslauf
$$z=wx+b=0\cdot2+0=0$$
Für die Sigmoidfunktion gilt $σ(0)=0{,}5$. Daher ist $y=0{,}5$.
2. Verlust
$$L=\frac{1}{2}(y-t)^2=\frac{1}{2}(0{,}5-1)^2=0{,}125$$
3. Gewichtsgradient
$$\frac{∂L}{∂w}=(y-t)\cdot y(1-y)\cdot x$$
$$\frac{∂L}{∂w}=(-0{,}5)\cdot0{,}5\cdot0{,}5\cdot2=-0{,}25$$
4. Biasgradient
$$\frac{∂L}{∂b}=(-0{,}5)\cdot0{,}5\cdot0{,}5=-0{,}125$$
5. Update
$$w_{neu}=0-0{,}1\cdot(-0{,}25)=0{,}025$$
$$b_{neu}=0-0{,}1\cdot(-0{,}125)=0{,}0125$$
Der negative Gradient führt wegen des Minuszeichens im Update zu einer Erhöhung von Gewicht und Bias. Beim nächsten Vorwärtslauf wird $z$ positiv und die Ausgabe bewegt sich von $0{,}5$ in Richtung des Zielwerts 1.
Deine Rechnung
Verwende dieselben Startwerte, aber den Zielwert $t=0$. Bestimme $∂L/∂w$ und $w_{neu}$.
Wie wandert der Fehler durch mehrere Schichten?
In einem mehrschichtigen Netz beeinflusst ein verdecktes Neuron den Verlust über alle nachfolgenden Verbindungen. Dafür wird je Schicht ein Fehlersignal $δ$ berechnet.
Für die Ausgabeschicht gilt schematisch:
$$δ^L=\frac{∂L}{∂a^L}\circ f'(z^L)$$
Das Zeichen $\circ$ steht für elementweise Multiplikation. Für eine verdeckte Schicht $l$ wird das Signal der nächsten Schicht mit der transponierten Gewichtsmatrix zurückgeführt:
$$δ^l=((W^{l+1})^Tδ^{l+1})\circ f'(z^l)$$
Aus dem Fehlersignal entstehen die Parametergradienten:
$$\frac{∂L}{∂b^l}=δ^l$$
$$\frac{∂L}{∂W^l}=δ^l(a^{l-1})^T$$
Die Aktivierungen aus dem Vorwärtslauf werden also im Rückwärtslauf erneut benötigt. Das erklärt, warum sie üblicherweise zwischengespeichert werden.
Ein verdecktes Neuron erhält kein eigenes Ziel. Sein Fehlersignal ergibt sich aus den nachfolgenden Fehlersignalen, den verbindenden Gewichten und seiner lokalen Aktivierungsableitung.
Backpropagation nutzt gemeinsam benötigte Zwischenergebnisse. Bei $T$ Gewichten und Biases liegen Vorwärtslauf, Rückwärtslauf und Update jeweils in der Größenordnung $O(T)$. Eine naive finite Differenz würde jedes Gewicht einzeln verändern und dafür ungefähr $O(T^2)$ Arbeit verursachen.
Was kann beim Training schiefgehen?
Backpropagation berechnet Gradienten korrekt für den festgelegten Rechenweg. Sie garantiert jedoch weder gute Daten noch eine geeignete Architektur oder ein globales Minimum.
- Zu große Lernrate: Updates können über einen günstigen Bereich hinausschießen oder oszillieren.
- Zu kleine Lernrate: Das Training macht nur sehr langsame Fortschritte.
- Verschwindende Gradienten: Viele kleine lokale Ableitungen ergeben über zahlreiche Schichten ein sehr kleines Produkt. Frühe Schichten lernen dann kaum.
- Explodierende Gradienten: Große Faktoren können extrem große Gradienten und instabile Updates erzeugen.
- Unteranpassung: Ein zu kleines oder ungeeignetes Netz kann das notwendige Muster nicht darstellen.
- Überanpassung: Ein großes Netz kann Trainingsbeispiele gut wiedergeben, aber bei unbekannten Daten schlechter abschneiden.
Trainings- und Testdaten erfüllen deshalb verschiedene Aufgaben. Die Parameter werden mit Trainingsdaten gelernt. Getrennte Testdaten helfen anschließend einzuschätzen, ob das Netz auf unbekannte Fälle überträgt.
Ein verschwindender Gradient beweist nicht, dass ein globales Minimum erreicht wurde. Der Gradient kann auch an anderen stationären Punkten oder in sehr flachen Bereichen klein sein.
Karteikasten
Überlege zuerst selbst und drehe die Karte anschließend zum Prüfen um.
Alles auf einen Blick
- Backpropagation
- Vorwärtslauf: Aktivierungen und Vorhersage
- Verlust: Abweichung vom Ziel
- Kettenregel: lokale Ableitungen verbinden
- Rückwärtslauf: Fehlersignale und Gradienten
- Optimierer: Parameter mit Lernrate aktualisieren
- Prüfung: Trainings- und Testleistung vergleichen
Abschluss-Check
Du hast den Kern verstanden, wenn du zu jedem Parameter den Weg Parameter → Voraktivierung → Aktivierung → Verlust verfolgen, die lokalen Ableitungen verbinden und das Vorzeichen des anschließenden Updates begründen kannst.