\chapter{Fehlerbasiertes Lernen}
\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.