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:10] – 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 339: Zeile 325:
  
 Ist die Lernrate zu gross, springt das Netz über das Minimum hinweg. Ist sie zu klein, braucht das Training ewig. 0.01 ist ein guter Startwert für unser Netz. Ist die Lernrate zu gross, springt das Netz über das Minimum hinweg. Ist sie zu klein, braucht das Training ewig. 0.01 ist ein guter Startwert für unser Netz.
 +
 +**Das Ganze als Matrix**
 +
 +Bisher haben wir so getan, als hätten wir nur ein einziges Gewicht w und einen einzigen Input x. In Wirklichkeit ist w natürlich die ganze **Gewichtsmatrix W** und x der ganze **Input-Vektor**. Schauen wir uns ein Mini-Beispiel mit 3 Inputs und 2 Hidden-Neuronen an:
 +
 +<code>
 +X = [ x₁  x₂  x₃ ]
 +
 +
 +     ⎡ w₁₁  w₁₂ ⎤
 +W =  ⎢ w₂₁  w₂₂ ⎥
 +     ⎣ w₃₁  w₃₂ ⎦
 +
 +
 +b = [ b₁  b₂ ]
 +</code>
 +
 +Die gewichtete Summe ist dann eine Matrix-Multiplikation:
 +
 +<code>
 +z  =  X · W  +  b
 +
 +     = [x₁·w₁₁ + x₂·w₂₁ + x₃·w₃₁ + b₁ ,  x₁·w₁₂ + x₂·w₂₂ + x₃·w₃₂ + b₂]
 +</code>
 +
 +Für die Ableitung gilt genau dasselbe Prinzip wie vorher, nur eben für alle Gewichte auf einmal. Statt δ · x schreiben wir die Matrix-Version:
 +
 +<code>
 + ∂L
 +────  =  Xᵀ · δ
 + ∂W
 +</code>
 +
 +Das Xᵀ (X transponiert) sorgt dabei einfach dafür, dass die Dimensionen zusammenpassen. Im Code ist genau das diese Zeile, die du schon von oben kennst:
 +
 +<code python>
 +self.W1 -= self.lr * (X.T @ d1) / N
 +</code>
 +
 +Der Vorteil der Matrix-Schreibweise ist enorm: statt 100'000 mal einzeln Ableitungen auszurechnen, macht NumPy das in einer einzigen Zeile parallel für alle Gewichte gleichzeitig.
  
 ==== Schritt 3: Fehler zurück durch das Netz ==== ==== Schritt 3: Fehler zurück durch das Netz ====
Zeile 358: 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 364: 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 455: 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.1776791403.txt.gz
  • Zuletzt geändert: 2026/04/21 19:10
  • von andristn