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 11:11] – 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 204: Zeile 204:
 ==== Schritt 1: Fehler messen ==== ==== Schritt 1: Fehler messen ====
  
-Der erste Schritt ist, den Fehler zu messen. Das macht die **Loss Function**, in unserem Fall //Cross Entropy Loss//:+Der erste Schritt ist, den Fehler zu messen. Das macht die **Loss Function**. Davon gibt es natürlich mehrere Varianten, die zwei wichtigsten sind //Mean Squared Error// und //Cross Entropy Loss//. 
 + 
 +Der **Mean Squared Error** (MSE) ist der Klassiker und wird zum Beispiel auch von 3Blue1Brown in seiner bekannten YouTube-Serie über neuronale Netzwerke verwendet. Er misst den Fehler, indem er für jedes Output-Neuron die Differenz zwischen Vorhersage und richtigem Wert quadriert und dann den Durchschnitt bildet: 
 + 
 +<code> 
 +          1      
 +MSE  =  ───  Σ (ŷᵢ − yᵢ)² 
 +         N   i 
 +</code> 
 + 
 +Wir haben uns aber für **Cross Entropy Loss** entschieden, weil er für Klassifikationsaufgaben wie unsere Buchstabenerkennung besser geeignet ist. Im Code sieht das so aus:
  
 <code python> <code python>
Zeile 211: Zeile 221:
 </code> </code>
  
-Mathematisch gesehen berechnet sie, wie weit die vorhergesagte Wahrscheinlichkeit vom richtigen Wert entfernt ist:+Mathematisch gesehen berechnet er, wie weit die vorhergesagte Wahrscheinlichkeit vom richtigen Wert entfernt ist:
  
 <code> <code>
Zeile 217: Zeile 227:
          i          i
 </code> </code>
 +
 +Der grosse Vorteil von Cross Entropy gegenüber MSE ist, dass er starke Fehler viel härter bestraft. Sagt das Netz mit 99% Sicherheit "b", obwohl die richtige Antwort "a" wäre, geht der Loss dank des Logarithmus praktisch gegen unendlich. Bei MSE wäre der Fehler in so einem Fall höchstens 1. Dadurch bekommt das Netz bei Fehlklassifikationen einen viel stärkeren Gradienten und **konvergiert deutlich schneller**. Ausserdem passt Cross Entropy perfekt zu Softmax, weil beide mit Wahrscheinlichkeiten arbeiten.
  
 War die Vorhersage für "a" zum Beispiel nur 0.02, obwohl sie 1.0 sein sollte, ist der Loss gross. War sie 0.95, ist der Loss klein. Jetzt wissen wir, wie gross der Fehler ist, aber noch nicht, woher er kommt. War die Vorhersage für "a" zum Beispiel nur 0.02, obwohl sie 1.0 sein sollte, ist der Loss gross. War sie 0.95, ist der Loss klein. Jetzt wissen wir, wie gross der Fehler ist, aber noch nicht, woher er kommt.
Zeile 224: Zeile 236:
 Hier kommt der **Gradient** ins Spiel. Ein Gradient sagt uns für jedes einzelne Gewicht, in welche Richtung und wie stark es den Loss beeinflusst. Man kann sich das wie einen Hügel vorstellen. Der Loss ist die Höhe, und wir wollen den tiefsten Punkt finden. Der Gradient zeigt uns die steilste Richtung bergauf, also gehen wir genau die entgegengesetzte Richtung bergab. Das nennt sich **Gradientenabstieg**. Hier kommt der **Gradient** ins Spiel. Ein Gradient sagt uns für jedes einzelne Gewicht, in welche Richtung und wie stark es den Loss beeinflusst. Man kann sich das wie einen Hügel vorstellen. Der Loss ist die Höhe, und wir wollen den tiefsten Punkt finden. Der Gradient zeigt uns die steilste Richtung bergauf, also gehen wir genau die entgegengesetzte Richtung bergab. Das nennt sich **Gradientenabstieg**.
  
-Bei einem einzelnen Neuron ist das noch überschaubar. Angenommen, wir haben einen Output-Neuron mit nur einem Gewicht w. Der Fehler am Ausgang ist einfach die Differenz zwischen Vorhersage und richtigem Wert:+Um den Gradienten zu berechnen, müssen wir verstehen, wie ein Gewicht überhaupt den Loss beeinflusst. Das Gewicht w ist ja nicht direkt im Loss drin, sondern es gibt eine ganze Kette von Zwischenschritten:
  
 <code> <code>
-δ  =  ŷ − y+w  ──►  z  ──►  ŷ  ──►  L 
 +     (gewichtete    (Softmax)   (Cross Entropy 
 +       Summe)                    Loss)
 </code> </code>
  
-Das Gewicht w hat diesen Fehler verursacht, proportional dazu, wie gross der Input x war. Also ist der Gradient:+Das Gewicht beeinflusst zuerst die gewichtete Summe z, diese wird dann durch Softmax zur Vorhersage ŷ, und ŷ fliesst in den Loss L. Um zu wissen, wie stark w den Loss verändert, müssen wir diese Kette komplett durchrechnen. Genau dafür gibt es die **Kettenregel** aus der Differentialrechnung:
  
 <code> <code>
-∂L / ∂w  =  δ · x+ ∂L        ∂L      ∂ŷ      ∂z 
 +────  =   ──── ·  ──── ·  ──── 
 + ∂w        ∂ŷ      ∂z      ∂w
 </code> </code>
  
-Und das Gewicht wird dann in die entgegengesetzte Richtung angepasst:+Wir leiten also drei Mal einzeln ab und multiplizieren das Ergebnis. Schauen wir uns jeden Teil einzeln an. 
 + 
 +**1. Ableitung des Loss nach der Vorhersage** 
 + 
 +Cross Entropy Loss ist L = −Σ yᵢ · log(ŷᵢ). Leiten wir ihn nach ŷ ab:
  
 <code> <code>
-w_neu  =  w_alt  −  η · (∂L / ∂w)+ ∂L         y 
 +────  =  − ─── 
 + ∂ŷ         ŷ 
 +</code> 
 + 
 +**2. Ableitung der Softmax nach der gewichteten Summe** 
 + 
 +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. 
 + 
 +**3. Ableitung der gewichteten Summe nach dem Gewicht** 
 + 
 +Die gewichtete Summe ist z = w·x + b. Leiten wir nach w ab, bleibt einfach x übrig: 
 + 
 +<code> 
 + ∂z 
 +────  =  x 
 + ∂w 
 +</code> 
 + 
 +**Alles einsetzen** 
 + 
 +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) · x   =   δ · x 
 + ∂w 
 +</code> 
 + 
 +Das ist genau das, was wir vorhin als "Fehler mal Input" beschrieben haben. Der Term δ = ŷ − y ist der Fehler am Output. Genau deshalb ist die Kombination aus Softmax und Cross Entropy so elegant: nach der ganzen Ableiterei bleibt einfach die Differenz zwischen Vorhersage und Zielwert übrig. 
 + 
 +**Gradient für den Bias** 
 + 
 +Für den Bias b läuft dieselbe Kettenregel, nur der letzte Teil ist anders. Die gewichtete Summe ist z = w·x + b. Leiten wir nach b ab: 
 + 
 +<code> 
 + ∂z 
 +────  =  1 
 + ∂b 
 +</code> 
 + 
 +Also ist der Gradient für den Bias einfach der Fehler selbst, ohne Multiplikation mit dem Input: 
 + 
 +<code> 
 + ∂L 
 +────  =  (ŷ − y) · 1   =   δ 
 + ∂b 
 +</code> 
 + 
 +**Update-Regel** 
 + 
 +Jetzt wo wir beide Gradienten kennen, können wir Gewicht und Bias in die entgegengesetzte Richtung anpassen: 
 + 
 +<code> 
 +w_neu  =  w_alt  −  η · (∂L / ∂w)  =  w_alt  −  η · δ · x 
 + 
 +b_neu  =  b_alt  −  η · (∂L / ∂b)  =  b_alt  −  η · δ
 </code> </code>
  
Zeile 249: 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 268: 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 274: 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 365: 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.1776762690.txt.gz
  • Zuletzt geändert: 2026/04/21 11:11
  • von andristn