155 lines
9.1 KiB
TeX
155 lines
9.1 KiB
TeX
\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. |