\chapter{Linear Machines}\label{linear machines}
    Mithilfe von linearen Maschinen lassen sich bestimmte Arten von Problemen klassifizieren.\\
    \includegraphics[width=\textwidth]{seperability.png}\\
    Hierfür wird auf viele Aspekte der Vektoralgebra zurückgegriffen (siehe \ref{Vektoralgebra}).

    \section{Aufstellung einer Diskriminanten}
        \includegraphics[width=.8\textwidth]{diskriminante.png}\\
        \paragraph{Verfahren}\mbox{}\\
        \begin{enumerate}
            \item durchschnittliches Element der Cluster errechnen:\\
                \vspace{0.1mm}\\
                Class C1: $\overline{m_{1C1}}=\frac{1}{M}\sum^{M-1}_{i=0}m_{1C1,i}\hspace{1mm}\overline{m_{2C1}}=\frac{1}{M}\sum^{M-1}_{i=0}m_{2C1,i}$\\
                \vspace{0.1mm}\\
                Class C2: $\overline{m_{1C2}}=\frac{1}{M}\sum^{M-1}_{i=0}m_{1C2,i}\hspace{1mm}\overline{m_{2C2}}=\frac{1}{M}\sum^{M-1}_{i=0}m_{2C2,i}$\\
            \item Diskriminanten Funktion errechnen:\\
                \includegraphics[width=.8\textwidth]{diskriminanten_berechnung.png}\\
                \includegraphics[width=.8\textwidth]{diskriminanten_berechnung2.png}\\
                \includegraphics[width=.8\textwidth]{diskriminanten_berechnung3.png}
            \item \begin{align*}
                m_2&=-\frac{1}{a}m_1+m_{h2}+\frac{a}{a}m_{h1}\\
                &\downarrow\\
                m_2 + \frac{1}{a}m_1 - \left(m_{h2}+\frac{a}{a}m_{h1}\right) &= 0\\
                &\downarrow
            \end{align*}
            \begin{align*}
                g(\bm{m}) &= \left(\frac{1}{a},1\right)\begin{pmatrix}m_1\\m_2\end{pmatrix}-\left(\frac{1}{a},1\right)\begin{pmatrix}m_{h1}\\m_{h2}\end{pmatrix} = 0\\
                g(\bm{m}) &= \left(\frac{1}{a},1\right)\cdot(\bm{m}-\bm{m}_{\bm{h}}) = 0 \hspace{1mm} \left(\frac{1}{a},1\right)=\bm{C}^T\\
                g(\bm{m}) &= \bm{C}^T\tilde{\bm{m}}=0
            \end{align*}
        \end{enumerate}

        \subsection{Beispiel: 3 Koeffizienten}
            $g(\bm{m}) = \bm{w}^T\bm{m}=0$ mit $\bm{w}^T = (w_2,w_1,w_0)$ und $\bm{m} = (m_2,m_1,1)^T$:
            $$g(\bm{m}) = w_2m_2 + w_1m_1 + w_0 = 0$$

            \paragraph{Vergleich der Koeffizienten}
            $$g(\bm{m}) = m_2 + \frac{1}{a}m_1-\left(m_{h2}+\frac{1}{a}m_{h1}\right) = 0  \rightarrow a\cdot m_2+m_1-(a\cdot m_{h2}+m_{h1})=0$$
            $$w_2m_2+w_1m_1+w_0=0\rightarrow w_2=a$$
            $$w_1=1$$
            $$w_0=-(a\cdot m_{h2}+m{h1})$$
            Daraus folgt:
            $$g(\bm{m}) > 0 \forall \bm{m}\in C_2$$
            $$g(\bm{m}) < 0 \forall \bm{m}\in C_1$$
            \pagebreak

    \section{Das technische Neuron}
        Ein technisches Neuron besteht aus den Gewichten für die Eingangswerte und der Aktivierungsfunktion:\\
        \includegraphics[width=.8\textwidth]{technisches_neuron.png}

    \section{Das Perzeptron}\label{perceptron}
        Ein Perzeptron beschreibt eine lineare Maschine, die eine Datenmenge durch eine Hyper-Ebene (die Diskriminante) in zwei Cluster unterteilt.
        Die Funktion für die Diskriminante ist hierbei $y(\bm{m})=\text{sng}(g(\bm{m})) = \text{sgn}(\bm{w}^T\bm{m}+w_0)$.
        Da sich $\bm{w}$ durch $\bm{w} = \sum^n_{i=1}\alpha_i\cdot y_i \cdot \bm{m}_i$ (mit $n = $Anzahl der Datenpunkte und $\alpha_i = $ Anzahl, wie oft $\bm{m}_i$ ausgewählt wurde) definiert ist die Dimension von $\bm{m}$ unwichtig.
        Das Gewicht $w_0$ wird auch als \say{Bias} bezeichnet wird.
        Dieses Gewicht ist wichtig, um die Geradengleichung der Diskriminanten aufstellen zu können ($w_0$ verschiebt die Gerade in y Richtung).
        Ohne das Bias könnte man die Gerade nur drehen und nicht verschieben.

        
        \subsection{Beispiel: nicht-symmetrischer Lernalgorithmus}
            \includegraphics[width=\textwidth]{Perzeptron_Lernalgorithmus.png}

        \subsection{Novikoff's Theorem}\label{novikoffs theorem}
            Novikoff's Theorem besagt, dass der Lernalgorithmus des Perzeptrons bei einem linear trennbaren Datensatz unweigerlich eine Diskriminante findet.
            Zudem besagt es, dass der Algorithmus bei einem nicht linear separierbaren Datensatz nicht konvergieren kann.
            Um die Konvergenz zu beschleunigen ist es sinnvoll die sigmoid-Funktion anstatt der signum-Funktion zu verwenden.
            $$ \text{sigm}(x)=\frac{2}{1+e^ {-x}}-1; -1\le\text{sigm}(x)\le 1$$

        \subsection{Beispiel: symmetrischer Lernalgorithmus}
            \includegraphics[width=.8\textwidth]{Perzeptron_Lernalgorithmus_symmetrisch.png}

    \section{\ac{VC-Dimension}}\label{vc-dimension}
        Die \ac{VC-Dimension} gibt ein Maß für die \say{learning power} einer Klassifizierung.

        \subsection{Shattering}
            \say{Here we will only consider functions that correspond to the two-class pattern recognition case, so that $g(\bm{m}, y) \in \{-1, 1\}\forall x, y$.
            Now if a given set of n points can be labeled in all possible $2^n$ ways,
            and for each labeling, a member of the set $\{g(y)\}$ can be found which correctly assigns those labels, we say that that set of points is shattered by that set of functions.}\\
            Hierbei zergliedert (shatters) eine Hyperebene in einem Feature Space $\mathbb{R}^d$ $h=d+1$ linear unabhängige Punkte.

            \subsubsection{Beispiel: Shattering im 2-dimensionalen Raum}
                \includegraphics[width = .5\textwidth]{vc-dimension_shattering.png}

            \subsection{Das XOR-Problem}
                Um das XOR-Problem zu zergliedern werden 2 Diskriminanten benötigt:\\
                \includegraphics[width=\textwidth]{XOR-Problem1.png}\\
                Um das XOR-Problem von einer linearen Maschine klassifizieren zu lassen muss diese aus mindestens 2 Schichten bestehen.
                \begin{center}
                    \includegraphics[width=.8\textwidth]{XOR-Problem2.png}
                \end{center}
                Allgemein werden mehr Neuronen in der verdeckten Schicht gebraucht, je komplexer die Klassifizierung ist.
                Hierbei kann sich an der \ac{VC-Dimension} orientiert werden.
                Dies gibt allerdings nur eine Angabe für die minimale Anzahl an benötigten Neuronen in der verdeckten Schicht.
                Die genaue Anzahl der verdeckten Schichten und der darin enthaltenen Neuronen müssen vom Entwickler gewählt werden.
                Hierbei ist die Erfahrung des Entwicklers entscheidend, um ein möglich gutes Modell zu erstellen.

    \section{Maximum Margin Approaches}
        Aus \ref{novikoffs theorem} ist bekannt, dass eine Diskriminate erstellt werden kann.
        Jedoch sind mehrere Diskriminanten möglich.
        Nun besteht die Aufgabe darin die Diskriminante zu wählen, die die Daten am besten teilt.

        \subsection{Cross-Validation}
            Das Verfahren der Cross-Validation trennt die Daten in Trainings- und Testdaten auf.
            Anhand des Fehlers eines Models auf den Testdaten wird versucht die Allgemeingültigkeit des Modells abzuschätzen.
            Das Modell mit dem geringsten Test-Fehler wird als bestes Modell ausgewählt.
            Dieser Ansatz beugt einem Over-Fitting des Modells auf die Trainingsdaten vor.\\
            \begin{center}
                \includegraphics[width=.8\textwidth]{cross-validation.png}
            \end{center}

        \subsection{Loss function}
            eine Verlustfunktion errechnet die Abweichung der vorhersage einer Klassifizierungsfunktion $f(\bm{m};\bm{w})$ von dem tatsächlichen Wert $y$.\\
            Beispiele hierfür sind der \say{Quadratic Loss}:
            $$L(y,f(\bm{m};\bm{w})) = f\left((y-f(\bm{m};\bm{w})^2)\right)$$
            oder der \say{Absolute Value Loss}:
            $$L(y,f(\bm{m};\bm{w})) = f\left(|y-f(\bm{m};\bm{w})|)\right)$$

        \subsection{Empirical Risk}\label{empirical risk}
            Das \say{Empirische Risiko} gibt auf Basis der Trainingsdaten eine Abschätzung dafür, wie hoch das Risiko ist, dass ein Datenpunkt von der Klassifizierungsfunktion falsch klassifiziert wird.
            Hierfür wird eine Loss function als Basis genommen.
            \begin{align*}
                R_{emp}(\bm{w}) = \frac{1}{N}\sum^N_{i=1}L\left(y_i,f(\bm{m}_i;\bm{w})\right)
            \end{align*}
            \begin{tabular}{|p{.475\textwidth}|p{.475\textwidth}|}
                \hline
                \textbf{Vorteile} & \textbf{Nachteile}\\
                \hline
                Alle benötigten Daten zur Berechnung vorhanden & keine direkte Angabe der \say{generalization ability}\\
                \hline
            \end{tabular}

        \subsection{True Risk}
            Das \say{echte Risiko} gibt das reale Risiko dafür an, dass eine Klassifizierungsfunktion einen Datenpunkt falsch klassifiziert.
            Hierfür wird die Dichtefunktion $p$ der Datenpunkte als Grundlage genommen.
            Da diese meist nicht bekannt ist, kann oft nur das Empirische Risiko angegeben werden.
            $$R(\bm{w}) = \iint L\left(y_i,f(\bm{m};\bm{w})\right) \cdot p(\bm{m},y) d\bm{m} dy$$
            \begin{tabular}{|p{.475\textwidth}|p{.475\textwidth}|}
                \hline
                \textbf{Vorteile} & \textbf{Nachteile}\\
                \hline
                Misst die \say{generalization ability} & Die Dichtefunktion $p$ muss bekannt sein\\
                \hline
            \end{tabular}

        \subsection{Risk Bound}\label{risk bound}
            Die Risikoschranke gibt an, wie weit das Empirische Risiko von dem tatsächlichen Risiko abweichen kann.
            $$R(\bm{w})\le R_{emp}(\bm{w})+\varepsilon(N,\kappa,h)$$
            \begin{itemize}
                \item $N$: Anzahl der Trainingsdatenpunkte
                \item $\kappa$: das \say{confidence level}, $0\le\kappa\le1$
                \item $h$: \ac{VC-Dimension} (\ref{vc-dimension})
            \end{itemize}
            \includegraphics[width=.8\textwidth]{risk-bound.png}

            \subsubsection{Capacity Term $\varepsilon$}\label{capacity term}
                Der Kapazitätsterm gibt eine Grenze dafür, wie gut das Risiko maximal werden kann.
                $$ \varepsilon(N,\kappa,h) = \sqrt{\frac{h \cdot \left(\lg\left(\frac{2N}{h}\right)+1\right)-\lg\left(\frac{\kappa}{4}\right)}{N}} $$
                \textbf{Beispiel:}\\
                \includegraphics[width=.5\textwidth]{capacity_term.png}

        \subsection{Structural Risk}\label{strucutral risk}
            Das Strukturelle Risiko wird durch das empirische Risiko $R_{emp}(\bm{w})$ (\ref{empirical risk}) und den Kapazitätsterm $\varepsilon(N,\kappa,h)$ (\ref{capacity term}) definiert.\\
            \includegraphics[width=.55\textwidth]{structural_risk.png}

            \subsubsection{\ac{SRM}}
                Eine Reduzierung kann entweder dadurch erreicht werden,
                dass das empirische Risiko (\ref{empirical risk}) bei gleichbleibenden $\varepsilon$ (\ref{capacity term}) reduziert wird,
                oder durch eine Reduzierung von $\varepsilon$ bei gleichbleibenden empirischen Risiko.
                Letzteres ist der Ansatz den die \ac{SVM}s (\ref{svm}) verfolgen.

    \section{Parameteroptimierung}
    \label{knn: parameteroptimierung}
        Die Parameter werden iterativ so verändert/ optimiert, dass die Fehlerfunktion (Zusammenfassung KI: Fehlerfunktionen) minimal wird.

        \subsection{Gradientenabstieg}
        \label{knn: gradientenabstieg}
            Das Gradientenverfahren ist ein Verfahren zur Parameteroptimierung.
            Die Idee für das Verfahren leitet sich vom Hill-Climbing Algorithmus (Zusammenfassung KI: 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 (Zusammenfassung KI: Hill Climbing) die Gefahr besteht,
            dass lediglich ein lokales anstatt dem globalen Minimum gefunden wird.

        \subsection{Backpropagation}
        \label{knn: backpropagation}
            Da der Fehler, den die Fehlerfunktion angibt auf alle Schichten 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{wrapfigure}{r}{.4\textwidth}
                \vspace{-10mm}
                \includegraphics[width = .4\textwidth]{backpropagation_inner_layer.png}
            \end{wrapfigure}

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