fehlerbasiertes lernen hinzugefügt

Acronyms.tex

@@ -27,4 +27,6 @@
     \acro{MFPC}{Modified-Fuzzy-Pattern-Classifier}
     \acro{FPGA}{Field Programmable Gate Array}
     \acro{ID3}{Iterative Dichotomizer 3}
+    \acro{KNN}{Künstliches Neuronales Netz}
+    \acrodefplural{KNN}{Künstliche Neuronale Netze}
 \end{acronym}

chapters/Maschinelles Lernen/Fehlerbasiertes Lernen.tex

@@ -1,2 +1,155 @@
 \chapter{Fehlerbasiertes Lernen}
-\label{error-based learning}
+\label{error-based learning}
+    Beim \say{fehlerbasiertem Lernen} wird ein bereits parametrisiertes Prädiktionsmodell zufällig initialisiert.
+    Anschließend wird das Modell iterativ auf Basis einer Kostenfunktion (Fehlerfunktion) so angepasst,
+    dass die Kosten/ der Fehler minimiert wird.
+    Diese Art des Lernens setzt 2 Dinge voraus:
+    \begin{enumerate}
+        \item Fehlerfunktion für Modelle
+        \item Optimierungsalgorithmus zur Anpassung der Parameter
+    \end{enumerate}
+    Dieser Ansatz des Lernens wird vorallem bei \acsp{KNN}(\ref{knn}) benutzt.
+
+    \section{\acfp{KNN}}
+    \label{knn}
+        Wie man schon am Namen erkennen kann sind \aclp{KNN} Modelle,
+        deren Informationsverarbeitung, der eines menschlichen Gehirns nachempfungen sind.
+        Sie setzen sich auch vernetzten einfachen, parallel arbeitenden Einheiten zusammen.
+        Den \textbf{Neuronen}.
+        Durch die Anpassung und Gewichtung der Verbindungen zwischen den Neuronen kann ein \ac{KNN} angelernt werden.
+
+        \subsection{formales Neuron}
+        \label{knn: neuron}
+            Formal ist ein Neuron eines \ac{KNN} beschrieben als:
+            \begin{center}
+                \includegraphics[width = .5\textwidth]{knn_neuron.png}
+            \end{center}
+            Es setzt sich zusammen aus:
+            \begin{itemize}
+                \item Eingangsvektor $e$:
+                    \large
+                    $$e=(e_1,\dots,e_N,1)^T$$
+                    \normalsize
+                \item Gewichtsvektor $g$:
+                    \large    
+                    $$g=(g_1,\dots,g_N,-B)^T$$
+                    \normalsize
+                \item Aktivitätszustand $z$:
+                    \large
+                    $$z=\sum^{N+1}_{i=1}g_i\cdot e_i = g^T e$$
+                    \normalsize
+                \item Ausgabefunktion $f$:
+                    \large
+                    $$a = f(z)$$
+                    \normalsize
+                    Für die Ausgabefunktion werden unterschiedliche Funktionen verwendet.\\
+                    \includegraphics[width = \textwidth]{knn_ausgabefunktionen.png}
+            \end{itemize}
+
+        \subsection{Netzwerkarchitektur}
+        \label{knn: architecture}
+            Theoretisch lässt sich jedes Problem, dass von einem \ac{KNN} gelöst werden kann mit nur einem 
+            dense Layer (\ref{knn: dense layer}) und einer Ausgabeschicht lösen.
+            Allerdings steigt bei diesem Ansatz die Anzahl der benötigten Neuronen häufig mit exponentiell mit dem Anstieg der Dimensionen.
+            Daher werden meist \acp{KNN} mit mehreren verborgenen Schichten (hidden layers) verwendet.
+            \begin{center}
+                \includegraphics[width = .8\textwidth]{knn_netzwerkarchitektur.png}
+            \end{center}
+
+            \subsubsection{Dense Layer}
+            \label{knn: dense layer}
+                Unter einem \say{Dense Layer} versteht man bei eim \ac{KNN} eine vollvernetzte Schicht.
+                Das bedeutet, dass jedes Neuron in dieser Schicht mit jedem Neuron der vorhergegangenen Schicht verknüpft ist.
+                \begin{center}
+                    \includegraphics[width = .6\textwidth]{knn_dense_layer.png}
+                \end{center}
+
+        \subsection{Fehlerfunktion}
+        \label{knn: error function}
+            Zwei der am häufigst verwendeten Fehlerfunktionen sind:\\
+            ($t_i\in\{0,1\}:$vorgegebenes Ausgangssignal; $a_i\in]0,1[:$ Ausgangssignal des Netzes)
+            \paragraph{Quadratische Abweichung}
+                \large
+                $$f(a,t)=\sum_i \frac{1}{2}(a_i-t_i)^2$$
+                \normalsize
+
+            \paragraph{Kategorische Kreuzentropie}
+                \large
+                $$f(a,t)=-\sum_i t_i\ln(a_i)$$
+                \normalsize
+
+        \subsection{Parameteroptimierung}
+        \label{knn: parameteroptimierung}
+            Die Parameter werden iterativ so verändert/ optimiert, dass die Fehlerfunktion (\ref{knn: error function}) minimal wird.
+
+            \subsubsection{Gradientenabstieg}
+            \label{knn: gradientenabstieg}
+                Das Gradientenverfahren ist ein Verfahren zur Parameteroptimierung.
+                Die Idee für das Verfahren leitet sich vom Hill-Climbing Algorithmus (\ref{hill climbing}) ableitet.
+                Der größte Unterschied liegt darin, dass der Parameterraum nicht diskret sondern kontinuierlich ist.
+                Das bedeutet, das jeder Punkt unendlich viele Nachbarn hat.
+                Durch die Bestimmung des \textbf{Gradienten} kann die Richtung des steilsten Abstiegs angegeben werden:
+                \large
+                $$\Delta g= \begin{bmatrix}
+                    \frac{\delta g}{\delta w_1}\\
+                    \frac{\delta g}{\delta w_2}\\
+                    \vdots\\
+                    \frac{\delta g}{\delta w_n}
+                \end{bmatrix}
+                $$
+                \normalsize
+                Zu beginn werden die Gewichte $w$ des Neuronen definiert (zufällig oder anders).
+                Anschließend werden sie bei jeder Iteration über 
+                \large
+                $$w\gets w+\alpha\cdot \Delta g(w)$$
+                \normalsize
+                umdefiniert.
+                Hierbei ist $\alpha$ ein Hyperparamter, der die \textbf{Lernrate} definiert.\\
+                Zu erwähnen ist noch, dass auch hier wie beim Hill-Climbing (\ref{hill climbing}) die Gefahr besteht,
+                dass lediglich ein lokales anstatt dem globalen Minimum gefunden wird.
+
+            \subsubsection{Backpropagation}
+            \label{knn: backpropagation}
+                Da der Fehler, den die Fehlerfunktion angibt auf alle Schichten des \ac{KNN} zurückzuführen ist,
+                muss auch die Optimierung Rückwärtsgerichtet in allen Schichten stattfinden.
+                Man spricht hierbei von einer \say{Backpropagation}.\\
+                Um ein Ausgangsneuron zu updaten muss die Fehlerfunktion
+                $$f(a,t) = \sum_i \frac{1}{2}(a_i-t_i)^2$$
+                erstmal auf den Ausgabewert des jeweiligen Neurons abgeleitet werden:
+                $$\frac{\delta f}{\delta a_i}=a_i-t$$
+                Wenn man dies nun auf die Zustandsfunktion des Neurons ableitet erhält man:
+                $$\frac{\delta f}{\delta z_i} = \frac{\delta f}{\delta a_i}\cdot\frac{\delta a_i}{\delta z_i}$$
+                Um die Änderung für eine Gewichtung $g_{ij}$ zu bestimmen muss die Fehlerfunktion nun zunächst auf dieses $g_{ij}$ abgeleitet werden:
+                $$\frac{\delta f}{\delta g_{ij}} = \frac{\delta f}{\delta z_i} \cdot\frac{\delta z_i}{\delta g_{ij}} = \frac{\delta f}{\delta a_i}\cdot\frac{\delta a_i}{\delta z_i}\cdot\frac{\delta z_i}{\delta g_{ij}}$$
+                Nun kann man durch Einsetzen der verwendeten $f$, $a_i$ und $z_i$ die Formel für die Änderung von $g_{ij}$ aufstellen.\\
+                \textbf{Beispiel:}
+                \Large
+                \begin{tabbing}
+                    $f(a,t)=\sum_i\frac{1}{2}(a_i-t_i)^2$\hspace{5mm}\=und\hspace{5mm}\=$\frac{\delta f}{\delta a_i}=a_i-t_i$\\\\
+                    $a_i =\frac{1}{a+e^{z_i}}$ \>und \>$\frac{\delta a_i}{\delta z_i}=a_i(1-a_i)$\\\\
+                    $z_i=\sum^{N+1}_{j=1}g_{ij}\cdot a_i$ \>und \>$\frac{\delta z_i}{\delta g_{ij}}=a_j$
+                \end{tabbing}
+                \normalsize
+                Hieraus ergibt sich:
+                $$\frac{\delta f}{\delta g_{ij}} = \frac{\delta f}{\delta z_i} \cdot\frac{\delta z_i}{\delta g_{ij}} = \frac{\delta f}{\delta a_i}\cdot\frac{\delta a_i}{\delta z_i}\cdot\frac{\delta z_i}{\delta g_{ij}}=(a_i-t_i)\cdot a_i(1-a_i)\cdot a_j$$
+                Da uns alle diese Werte bekannt sind können wir $g_{ij}$ updaten:
+                \large
+                $$g_{ij}\gets g_{ij} + \alpha\cdot\left((a_i-t_i)\cdot a_i(1-a_i)\cdot a_j\right)$$
+                \normalsize
+                Um die Backpropagation nun bei den anderen Neuronen auf tieferen Schichten anzuwenden muss auf diese abgeleitet werden:
+                \begin{align*}
+                    \frac{\delta f}{\delta a_i}&=(a_i-t_i)\\
+                    \frac{\delta f}{\delta z_i}&=\frac{\delta f}{\delta a_i}\cdot\frac{\delta a_i}{\delta z_i}=a_i(1-a_i)\frac{\delta f}{\delta a_i}\\
+                    \frac{\delta f}{\delta g_{ij}}&=\frac{\delta f}{\delta z_i}\cdot\frac{\delta z_i}{\delta g_{ij}} = a_j\frac{\delta f}{\delta z_i}\\
+                    \frac{\delta f}{\delta a_j}&=\sum_i\frac{\delta f}{\delta z_i}\cdot\frac{\delta z_i}{\delta a_j}=\sum_i g_{ij}\frac{\delta f}{\delta z_i}
+                \end{align*}
+                Die Summe wird durch die Mehrzahl der Nachfolgenden Neuronen von $B_j$ berursacht.
+                \begin{center}
+                    \includegraphics[width = .4\textwidth]{backpropagation_inner_layer.png}
+                \end{center}
+
+        \subsection{Normalisierung}
+        \label{knn: normalisierung}
+            Auch bei \acp{KNN} ist es sinnvoll die Eingangs-Features zu normalisieren (\ref{k-nearest-neighbour: normalisierung}).
+            Hierdurch wird verhindert,
+            dass die Features alleine durch ihren Wertebereich einen ungleichmäßigen Einfluss auf die Ausgabe der Neuronen haben.

chapters/Maschinelles Lernen/Ähnlichkeitsbasiertes Lernen.tex

@@ -35,7 +35,7 @@
             \end{cases}$$
 
         \subsection{Normalisierung}
-        \label{k-nearest-neighbour}
+        \label{k-nearest-neighbour: normalisierung}
             Da unterschiedliche Wertebereiche der verschiedenen Features einen großen Einfluss auf den K-Nächsten Nachbarn haben müssen sie normalisiert werden.
             Hierbei ist es üblich alle Merkmale auf das Intervall $[0,1]$ zu normalisieren.
             z.B. durch

parts/Maschinelles Lernen.tex

@@ -5,4 +5,5 @@
 \input{chapters/Maschinelles Lernen/Informationsbasiertes Lernen.tex}
 \input{chapters/Maschinelles Lernen/Lernbarkeit.tex}
 \input{chapters/Maschinelles Lernen/Ähnlichkeitsbasiertes Lernen.tex}
+\input{chapters/Maschinelles Lernen/Fehlerbasiertes Lernen.tex}
 \input{chapters/Maschinelles Lernen/Reinforcement Learning.tex}