Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- lernalgorithmus [2025/01/22 14:38] – [Vorbereitung] torsten.roehl
+++ lernalgorithmus [2025/01/29 10:58] (aktuell) – [Netzeingabe $net$] torsten.roehl
@@ Zeile 1: / Zeile 1: @@
 ====== Perzeptron Lernalgorithmus ======
+//Im Folgenden wird der Lernalgorithmus für das **einfache Perzeptron** beschrieben. Um das Prinzip zu verstehen, werden lediglich zwei Eingangsneuronen und ein Ausgangsneuron verwendet. Mithilfe des Lernalgorithmus kann dann (z. B. in Java) gezeigt werden, dass einfache Probleme wie das UND-Problem gelernt werden können.//
-==== Topologie ====
+===== Topologie =====
- * Gegeben:
-          * Eingangsneurone $x_1$ und $x_2$
-                  * $x_3$ dieses Neuron hat __immer__ den Wert 1.
-          * ein Ausgabeneuron $y_1$ oder $o$ für **O**utput.
-          * Drei Gewichte $w_{11}$ , $w_{21}$, $w_3$
-                  * Das Gewicht $w_{31}$ hat immer den Wert $w_{31}=-0.1$ .
-{{ :pnn.png?400 |}}
-===== Forward Pass =====
+          * **Eingangsneurone** $x_1$,  $x_2$ und $x_3$
-Unter dem „Forward Pass“ versteht man die Berechnung der Ausgabe eines neuronalen Netzes bei gegebener Eingabe und gegebenen Gewichten. Im ersten Schritt wird die Netzeingabe netnet berechnet. Anschließend wird darauf die Aktivierungsfunktion f(net)f(net) angewandt.
+                * Das Neuron $x_3$  hat __immer__ den Wert <color #22b14c>1</color>.
-<note>Der** Forward Pass** beschreibt die Berechnung der Netzausgabe bei gegebener Eingabe. Dabei wird f(net)f(net) berechnet.</note>
+          * **Ausgabeneuron** $y_1$ oder $o$ für **O**utput.
+          * **Gewichte** $w_{11}$ , $w_{21}$ und $w_{31}$
+                  * Das Gewicht $w_{31}$ hat (in unserem Beispiel) immer den Wert<color #22b14c> $w_{31}=-0.1$</color> .
+{{ :pnn.png?400 |}}
+<WRAP center round tip 90%>
+Die Schwelle θ wird durch ein konstantes Gewicht (in unserem Beispiel) $w_{31}=−0.1$ festgelegt. Nur  die Gewichte $w_{11}$ und $w_{21}$ werden gelernt, um alle Trainingsmuster wiedergeben zu können.
+Im **Perzeptron** kann anstelle der Schwelle ein Bias verwendet werden, da dieser als zusätzliches Gewicht modelliert wird, das mit einem konstanten Eingabewert von 1 multipliziert wird und dadurch die Schwelle direkt in die Gewichtsanpassung integriert.
+//Der Zusammenhang zwischen Schwelle und Bias kann mathematisch gezeigt werden, was an anderer Stelle erfolgt.//
+</WRAP>
+===== forward pass =====
+Unter dem „forward pass“ versteht man die Berechnung der Ausgabe eines neuronalen Netzes bei gegebener Eingabe und gegebenen Gewichten. Im ersten Schritt wird die Netzeingabe $net$ berechnet. Anschließend wird darauf die Aktivierungsfunktion $f(net)$ angewandt.
+<note>** forward pass** Berechnung der Netzausgabe $f(net)$ bei gegebener Eingabe.</note>
 ==== Netzeingabe $net$ ====
-Allgemein gilt für die Netzeingabe.
+Allgemein gilt für die Netzeingabe des Neuron $j$:
 \begin{equation} net_j = \sum w_{ij} \cdot x_i \end{equation}
 Da wir nur ein Ausgabeneuron haben ist $net_j=net_1=net$ also folgt für drei Eingabeneuronen:
-\begin{equation} net = \sum_1^3 w_{1j} \cdot x_i = w_{11}  \cdot x_1 +   w_{12}  \cdot x_1+ w_{13}  \cdot 1\end{equation}
+\begin{equation} net = \sum_{i=1}^3 w_{i1} \cdot x_i = w_{11}  \cdot x_1 +   w_{21}  \cdot x_2+ w_{31}  \cdot 1\end{equation}
+Dabei wird verwendet, dass $x_3=1$ gesetzt worden ist.
 ==== Aktivierungsfunktion ====
-Die Aktivierungsfunktion für //Perzeptron// lautet:
+Die Aktivierungsfunktion für das //Perzeptron// lautet:
@@ Zeile 29: / Zeile 39: @@
 {{ :inf:ki:schwellenwertfunktion.png? |}}
-=== Trainingsmuster ($x_1$,$x_2$) → $y$===
+===== Trainingsmuster ($x_1$,$x_2$) → $y$ =====
-Der Perzeptron-Lernalgorithmus wird auf Trainingsmuster angewendet. Ein Trainingsmuster (//engl. Training Pattern//) besteht aus der Eingabe zusammen mit der gewünschten Ausgabe, die es zu lernen gilt. Das neuronale Netz lernt die Gewichte so anzupassen, dass alle Trainingsmuster richtig wiedergegeben werden. Für das AND-Problem gibt es vier „Patterns“:
+Der Perzeptron-Lernalgorithmus wird auf Trainingsmuster angewendet. Ein Trainingsmuster (//engl. Training Pattern//) besteht aus der Eingabe zusammen mit der gewünschten Ausgabe, die es zu lernen gilt. Das neuronale Netz lernt die Gewichte so anzupassen, dass alle Trainingsmuster richtig wiedergegeben werden.
+**Für das AND-Problem gibt es vier Trainingsmuster:**
-  * (0,0) → 0
-  * (0,1) → 0
+^Input^Output t^
-  * (1,0) → 0
+|$(0,0)$| 0|
-  * (1,1) → 1
+|$(0,1)$| 0|
+|$(1,0)$| 0|
+|$(1,1)$| 1|
 ===== Perzeptron lernen =====
-m Folgenden wird ein Algorithmus vorgestellt, um beispielsweise das **AND-Problem** zu lernen und die Trainingsmuster repräsentieren zu können.
 ==== Vorbereitung ====
   * Wähle eine Lernrate $\eta$ zwischen 0 und 1, z.B. $\eta=0.1$.
   * Wähle zufällige Zahlen für die Gewichte $w_{ij}$ zwischen 0 und 1 für die Initialisierung.
-<WRAP center round tip 90%>
-Die Schwelle θ wird durch ein konstantes Gewicht $w_{31}=−0.1$ festgelegt. Die Gewichte $w_{11} und $w_21$ werden gelernt, um alle Trainingsmuster wiedergeben zu können.
-</WRAP>
 ==== Algorithmus ====
+<WRAP center round box 100%>
+//Perzeptron Lernalgorithmus//
-  - **forward pass** Wähle ein Trainingsmuster und berechne die Ausgabe $o$
+  - **forward pass:** Wähle (zufällig) ein Trainingsmuster und berechne die Ausgabe $o$
-  - Berechne den Fehler zwischen der gewünschten Ausgabe (**t** //für Target//) und der tatsächlicher **o**.
+  - **error:** Berechne den Fehler  zwischen der gewünschten Ausgabe (**t** //für Target//) und der tatsächlichen **o** mit: $t-o$.
-  - Berechne die Gewichtsänderung $\Delta w_{ij} = \eta\cdot (o-j)\cdot x_i$
+  - **hebb rule:** Berechne die Gewichtsänderung $\Delta w_{ij} = \eta\cdot (t-o)\cdot x_i$
-  - Berechne das neue Gewicht mit $w_{ij} = w_{ij}  +  \Delta w_{ij} $
+  - **update:** Ändere das Gewicht $w_{ij}$ mit: $w_{ij} = w_{ij}  +  \Delta w_{ij} $
   - Wiederhole ab Schritt 1. für eine Anzahl an Iterationen, bis das gewünschte Ergebnis erreicht ist.
+</WRAP>
+===== Test & Aufgaben =====
+  - Implementieren Sie den Perzeptron-Lernalgorithmus für das UND-Problem.
+          - Überprüfen Sie, ob das UND-Problem korrekt gelernt wurde, indem Sie für alle Inputvektoren $(x_1,x_2)$ die Ausgaben berechnen.
+  - Ändern Sie die Implementierung um auch das ODER-Problem zu lernen.
+          - Wiederholen Sie das Lernen mehrmals und untersuchen Sie die gelernten Gewichte $w_{11}$ und $w_{21}$.
+  - Untersuchen Sie die Abhängigkeit der Lernrate von der Anzahl der Iterationen, die benötigt werden, um das Problem zu lösen.
+          - Erstellen Sie hierfür einen aussagekräftigen Graphen.
+  -   Beschäftigen Sie sich nun mit dem <color #ed1c24> XOR-Problem</color>.
+          - Ändern Sie den Code um auch dieses Problem zu studieren.**🕱 🕱 🕱**
-===== Test =====
+<WRAP center round tip 90%>
+Passen Sie gegebenenfalls die Lernrate oder die Anzahl der Iterationen an, damit das Problem erfolgreich gelernt werden kann.
-Überprüfen Sie, ob das UND-Problem korrekt gelernt wurde, indem Sie für alle Inputvektoren $(x_1,x_2)$ die Ausgaben berechnen. Passen Sie gegebenenfalls die Lernrate oder die Anzahl der Iterationen an, damit das Problem erfolgreich gelernt werden kann.
+</WRAP>