Backpropagation: Wie KI die Schuldigen des Fehlers ermittelt (feat. Kettenregel)

1. Einführung: Der Schuldige steckt hier

Commandbox 광고

In unserem letzten Beitrag haben wir gelernt, dass die Ableitung ein "Kompass" ist, der uns sagt, in welche Richtung wir die Parameter drehen müssen, um den Fehler zu verringern.

Doch Deep Learning hat ein gravierendes Problem: Das Modell ist zu tief.

Von der Eingabeschicht bis zur Ausgabeschicht gibt es Hunderte, manchmal Tausende von Schichten.

Situation: Im Ausgabeschicht tritt ein Fehler (Loss) auf, weil das Ergebnis um etwa 10 von der Wahrheit abweicht.

Problem: Wer ist schuld?

Wir können nicht sagen, ob ein Parameter in der Nähe der Eingabeschicht die Kettenreaktion ausgelöst hat oder ob ein Parameter direkt vor der Ausgabeschicht das Problem verursacht hat.

Hier kommt Deep Learning zum Einsatz und findet den Schuldigen auf eine sehr geschickte Weise: "Denjenigen hinter mir beschuldigen (Kettenregel)".

2. Kettenregel: Die mathematische Definition von "Verantwortung"

In der Mathematik wird die Kettenregel so geschrieben:

$$\frac{dz}{dx} = \frac{dz}{dy} \cdot \frac{dy}{dx}$$

Für Entwickler sieht das wie eine Formel aus, aber aus Sicht des Managements ist es "Verantwortungsaufteilung".

Stellen Sie sich vor: A-Teamleiter (Input) -> B-Abteilungsleiter (Hidden) -> C-Vorstand (Output).

  1. C-Vorstand (Ausgabe) verursacht ein Problem (Error).
  2. C-Vorstand will nicht die volle Verantwortung übernehmen, also analysiert er: "Der Bericht von B war schlecht, deshalb war mein Ergebnis schlecht." ($\frac{dz}{dy}$: Wie stark hat B mein Ergebnis beeinflusst.)
  3. B-Abteilungsleiter ist verärgert: "A-Teamleiter hat mir falsche Daten gegeben, deshalb war mein Bericht schlecht!" ($\frac{dy}{dx}$: Wie stark hat A mein Ergebnis beeinflusst.)

Am Ende lässt sich die Gesamtwirkung von A auf das Projekt (z) berechnen als (C’s Schuld an B) × (B’s Schuld an A).

Das ist die Kettenregel der Ableitung – sie verbindet entfernte Ursachen (A) und Ergebnisse (z) durch Multiplikation der Zwischenschritte.

3. Backpropagation: Debugging, das rückwärts brennt

Commandbox 광고

Dieses "Verantwortungsaufteilung"-Verfahren wird auf das gesamte System ausgeweitet – das ist Backpropagation.

  1. Forward (Vorwärtsdurchlauf): Daten werden eingegeben und ein Ergebnis erzeugt. (Zuerst wird die Arbeit erledigt.)
  2. Loss Calculation: Der Fehler wird berechnet, indem das Ergebnis mit der Wahrheit verglichen wird. (Ein Unfall passiert.)
  3. Backward (Rückwärtsdurchlauf): Vom Ausgabeschicht zurück zur Eingabeschicht wird rückwärts gegangen und jeder Schicht gesagt: "Du bist verantwortlich für diesen Fehler."

Für Entwickler ist das wie das Lesen eines Stack Traces von unten nach oben, um die Wurzel des Fehlers zu finden.

Man schaut sich die Fehlermeldung (Loss) an, dann die Funktion, die sie aufgerufen hat, dann die Funktion, die diese aufgerufen hat… und so weiter, bis man die Ursache findet.

4. PyTorchs Autograd: Das automatisierte Audit-Team

Wenn wir Deep Learning mit numpy schreiben, ist das Herunterrechnen der Ableitungen die größte Belastung. (Man verliert sogar die Haare.)

PyTorch ist großartig, weil es diesen komplizierten "Verantwortungsaufteilung"-Prozess in einem Computational Graph abbildet und automatisch verarbeitet.

  • Sobald Sie loss.backward() aufrufen,
  • startet PyTorchs Autograd-Engine (Audit-Team).
  • Sie traversiert den Graphen von hinten nach vorne, wendet die Kettenregel (Multiplikation) an.
  • Und jedem Parameter (Gewicht) wird ein "Deine Verantwortungsquote (Gradient) ist 0,003" zugewiesen.

Wir müssen nur die Werte anpassen (optimizer.step()), die mit einem Stempel versehen wurden.

5. Fazit: Was passiert, wenn die Verantwortung verschwindet? (Vanishing Gradient)

Auch dieses scheinbar perfekte System hat eine Schwachstelle.

Wenn man Verantwortung weitergibt (multiplikativ), und die Schichten zu tief sind, kann die Verantwortung zu 0 werden.

"Ich bin nicht schuld" × 0,1 × 0,1 × 0,1 … führt dazu, dass die frühesten Schichten "es gibt nichts zu reparieren (Gradient = 0)" erhalten.

Das ist das berühmte Vanishing Gradient-Problem. Wie moderne KI dieses Problem löst? (Hinweis: ReLU und ResNet)

image of backpropagation