informatics4kids.de

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
====== 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 =====
 
          * **Eingangsneurone** $x_1$,  $x_2$ und $x_3$
                * Das Neuron $x_3$  hat __immer__ den Wert <color #22b14c>1</color>.
          * **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 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_{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 das //Perzeptron// lautet:


\begin{equation}
     f(x)=\left\{\begin{array}{ll}0 : & x < 0  \\
         1 : & x\geq 0 \end{array}\right.
 \end{equation}

{{ :inf:ki:schwellenwertfunktion.png? |}}
===== 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 Trainingsmuster:**


^Input^Output t^
|$(0,0)$| 0| 
|$(0,1)$| 0| 
|$(1,0)$| 0| 
|$(1,1)$| 1| 
 
===== Perzeptron lernen =====


==== 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.


==== Algorithmus ====
<WRAP center round box 100%>
//Perzeptron Lernalgorithmus//


  - **forward pass:** Wähle (zufällig) ein Trainingsmuster und berechne die Ausgabe $o$
  - **error:** Berechne den Fehler  zwischen der gewünschten Ausgabe (**t** //für Target//) und der tatsächlichen **o** mit: $t-o$.
  - **hebb rule:** Berechne die Gewichtsänderung $\Delta w_{ij} = \eta\cdot (t-o)\cdot x_i$ 
  - **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.**🕱 🕱 🕱**

<WRAP center round tip 90%>
Passen Sie gegebenenfalls die Lernrate oder die Anzahl der Iterationen an, damit das Problem erfolgreich gelernt werden kann.
</WRAP>