Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- ef:ki:nn [2026/04/21 19:39] – andristn
+++ ef:ki:nn [2026/04/23 14:17] (aktuell) – andristn
@@ Zeile 88: / Zeile 88: @@
 <code>
                     ⎧ z    wenn z > 0
-f(z) = max(0, z) = ⎨
+f(z) = max(0, z) =  ⎨
                     ⎩ 0    sonst
 </code>
@@ Zeile 266: / Zeile 266: @@
 **2. Ableitung der Softmax nach der gewichteten Summe**
-Wie Softmax intern abgeleitet wird, ist etwas komplizierter (weil jeder Output von allen z-Werten abhängt). Das Ergebnis nach der Ableitung sieht so aus:
+Hier wird es etwas komplizierter. Softmax ist nämlich eine Funktion, bei der jeder Output ŷᵢ von //allen// z-Werten gleichzeitig abhängt (wegen der Summe im Nenner). Die vollständige Ableitung ist deshalb eine sogenannte Jacobi-Matrix und würde den Rahmen hier sprengen. Wir sparen uns den detaillierten Zwischenschritt und halten einfach fest: es gibt eine wohldefinierte Ableitung.
-<code>
- ∂ŷ
-────  =  ŷ · (1 − ŷ)      (vereinfacht dargestellt)
- ∂z
-</code>
 **3. Ableitung der gewichteten Summe nach dem Gewicht**
@@ Zeile 286: / Zeile 280: @@
 **Alles einsetzen**
-Jetzt setzen wir die drei Teile in die Kettenregel ein:
+Wenn man nun alle drei Teile in die Kettenregel einsetzt und sauber ausrechnet (das ist der Punkt, an dem sich die komplizierte Softmax-Ableitung mit der −y/ŷ aus dem Cross Entropy Loss gegenseitig auffrisst), bleibt am Ende dieser wunderschön einfache Ausdruck übrig:
-<code>
- ∂L        y
-────  =  (−──) · (ŷ · (1 − ŷ)) · x
- ∂w        ŷ
-</code>
-Wenn man das ausrechnet und die Terme zusammenfasst (das y im Nenner kürzt sich teilweise weg), bleibt am Ende dieser wunderschön einfache Ausdruck übrig:
 <code>
@@ Zeile 398: / Zeile 384: @@
 </code>
-Jetzt muss dieser Fehler zurück durch die Gewichte W₂ in die Hidden Layer propagiert werden. Dazu wird δ₂ mit der transponierten Gewichtsmatrix multipliziert und mit der Ableitung von ReLU komponentenweise verrechnet:
+Jetzt muss dieser Fehler zurück durch die Gewichte W₂ in die Hidden Layer propagiert werden. Das klingt kompliziert, ist aber wieder nur eine Kettenregel. Schauen wir uns an, wie ein Hidden-Wert z₁ den Loss beeinflusst:
+<code>
+z₁  ──►  a₁  ──►  z₂  ──►  ŷ  ──►  L
+     (ReLU)    (W₂, b₂)  (Softmax)  (Cross Entropy)
+</code>
+z₁ wirkt also über mehrere Zwischenschritte auf den Loss. Die Kettenregel sagt uns:
+<code>
+ ∂L        ∂L      ∂z₂      ∂a₁
+────  =  ──── ·  ──── ·  ────
+ ∂z₁       ∂z₂     ∂a₁      ∂z₁
+</code>
+Schauen wir uns jeden Teil an:
+  * **∂L / ∂z₂**  –  das kennen wir schon, das ist der Output-Fehler δ₂ = ŷ − y
+  * **∂z₂ / ∂a₁**  –  die gewichtete Summe ist z₂ = a₁ · W₂ + b₂, abgeleitet nach a₁ bleibt W₂ übrig (in der Matrix-Version brauchen wir W₂ transponiert, damit die Dimensionen passen)
+  * **∂a₁ / ∂z₁**  –  das ist die Ableitung von ReLU, also ReLU'(z₁). Sie ist 1, wenn z₁ > 0, sonst 0
+Setzen wir alles zusammen:
 <code>
@@ Zeile 404: / Zeile 411: @@
 </code>
-Das ReLU' ist die Ableitung von ReLU, also ''reluDerivative''. Sie sorgt dafür, dass nur die Neuronen einen Fehleranteil zugewiesen bekommen, die vorhin auch wirklich gefeuert haben. Neuronen, die 0 ausgegeben haben, bekommen auch 0 Fehler zurück, denn sie haben nichts beigetragen:
+Das ⊙ steht dabei für "elementweise multiplizieren" (nicht Matrix-Multiplikation). Also: zuerst wird der Fehler δ₂ über die transponierten Gewichte W₂ᵀ zurück in die Hidden Layer gerechnet, und dann wird jedes Element mit der Ableitung von ReLU verrechnet.
+Das ReLU'(z₁) sorgt dafür, dass nur die Neuronen einen Fehleranteil zugewiesen bekommen, die vorhin auch wirklich gefeuert haben. Neuronen, die 0 ausgegeben haben, bekommen auch 0 Fehler zurück, denn sie haben nichts beigetragen:
 <code python>
@@ Zeile 495: / Zeile 504: @@
   * **Tiefe neuronale Netze (Deep Neural Networks)** – Netze mit vielen Hidden Layers
   * **flache vs. tiefe Netze** – eine vs. viele Hidden Layers, Komplexität und Rechenaufwand steigen
+===== Quellen =====
+==== Videos ====
+Die Videoserie von //3Blue1Brown// (Grant Sanderson) gilt als die beste visuelle Einführung in neuronale Netze und erklärt die Mathematik dahinter sehr anschaulich:
+  * [[https://www.youtube.com/watch?v=aircAruvnKk|But what is a Neural Network? – Deep learning, chapter 1]]
+  * [[https://www.youtube.com/watch?v=IHZwWFHWa-w|Gradient descent, how neural networks learn – Deep learning, chapter 2]]
+  * [[https://www.youtube.com/watch?v=Ilg3gGewQ5U|What is backpropagation really doing? – Deep learning, chapter 3]]
+  * [[https://www.youtube.com/watch?v=tIeHLnjs5U8|Backpropagation calculus – Deep learning, chapter 4]]
+  * [[https://www.youtube.com/playlist?list=PLZZWrBYkx7Otcjr3eCLZDCgfpqnxMY29s|Komplette Playlist: 3Blue1Brown Neural Networks]]
+==== Wikipedia ====
+  * [[https://de.wikipedia.org/wiki/K%C3%BCnstliches_neuronales_Netz|Künstliches neuronales Netz]]
+  * [[https://de.wikipedia.org/wiki/Perzeptron|Perzeptron]]
+  * [[https://de.wikipedia.org/wiki/Backpropagation|Backpropagation]]
+  * [[https://de.wikipedia.org/wiki/Aktivierungsfunktion|Aktivierungsfunktion]]
+  * [[https://en.wikipedia.org/wiki/Softmax_function|Softmax function (englisch)]]
+  * [[https://en.wikipedia.org/wiki/Cross-entropy|Cross-Entropy (englisch)]]
+  * [[https://en.wikipedia.org/wiki/Rectifier_(neural_networks)|ReLU / Rectifier (englisch)]]
+  * [[https://de.wikipedia.org/wiki/Gradientenverfahren|Gradientenverfahren]]
+==== Weiterführende Literatur ====
+  * Michael Nielsen: //Neural Networks and Deep Learning// – kostenloses Online-Buch unter [[http://neuralnetworksanddeeplearning.com/]]
+  * Ian Goodfellow, Yoshua Bengio, Aaron Courville: //Deep Learning// – frei verfügbar unter [[https://www.deeplearningbook.org/]]
+==== Bibliotheken und Tools ====
+  * [[https://numpy.org/|NumPy]] – die Bibliothek, die wir für alle Matrix-Operationen verwenden
+  * [[https://pillow.readthedocs.io/|Pillow (PIL)]] – für die Bildverarbeitung der Buchstabenbilder