ef:ki:nn

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen Revision Vorhergehende Überarbeitung
Nächste Überarbeitung		 Vorhergehende Überarbeitung
ef:ki:nn [2026/04/21 19:31] – andristnef:ki:nn [2026/04/23 14:17] (aktuell) – andristn
Zeile 88: Zeile 88:
 <code> <code>
                     ⎧ z    wenn z > 0                     ⎧ z    wenn z > 0
-f(z) = max(0, z) = ⎨+f(z) = max(0, z) =  ⎨
                     ⎩ 0    sonst                     ⎩ 0    sonst
 </code> </code>
Zeile 266: Zeile 266:
 **2. Ableitung der Softmax nach der gewichteten Summe** **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** **3. Ableitung der gewichteten Summe nach dem Gewicht**
Zeile 286: Zeile 280:
 **Alles einsetzen** **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> <code>
Zeile 345: Zeile 331:
  
 <code> <code>
-        ⎡ w₁₁  w₁₂ ⎤ +X = [ x₁  x₂  x₃ ] 
-X = [x₁ x₂ x₃]   W = ⎢ w₂₁  w₂₂ ⎥   b = [b₁ b₂] + 
-        ⎣ w₃₁  w₃₂ ⎦+ 
 +     ⎡ w₁₁  w₁₂ ⎤ 
 +W =  ⎢ w₂₁  w₂₂ ⎥ 
 +     ⎣ w₃₁  w₃₂ ⎦ 
 + 
 + 
 +b = [ b₁  b₂ ]
 </code> </code>
  
Zeile 392: Zeile 384:
 </code> </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> <code>
Zeile 398: Zeile 411:
 </code> </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> <code python>
Zeile 489: Zeile 504:
   * **Tiefe neuronale Netze (Deep Neural Networks)** – Netze mit vielen Hidden Layers   * **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   * **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
  • ef/ki/nn.1776792698.txt.gz
  • Zuletzt geändert: 2026/04/21 19:31
  • von andristn