\documentclass[bibliography=totoc]{scrartcl} 
\usepackage[utf8]{inputenc} % Kodierung
\usepackage[ngerman]{babel} % Sprache 
\usepackage{scrpage}
\usepackage{amsmath}
\usepackage[final]{graphicx}
\usepackage{times}
\usepackage{textcomp}
\usepackage{multicol}
\usepackage{placeins}
\usepackage{braket}
\usepackage{calc}
\usepackage{amssymb}
\usepackage{subfig}
\usepackage{pdfcolparcolumns}
\usepackage{listings}

\usepackage{auto-pst-pdf}
\usepackage{pst-all}
\usepackage{pst-bspline}
\usepackage{pst-plot}
\usepackage{pst-3dplot}
\usepackage{pstricks-add}


% Eigene Kopf- und Fußzeilen definieren
\usepackage{fancyhdr}
% Eigener Stil:
\pagestyle{fancy} %eigener Seitenstil
\fancyhf{} % Alle Kopf- und Fußzeilenfelder bereinigen
\fancyhead[C]{Klassifizierungsverfahren und neuronale Netze -- Thomas Keck} %zentrierte Kopfzeile
\renewcommand{\headrulewidth}{0.4pt} %obere Trennlinie
\fancyfoot[C]{\thepage} %Seitennummer
\renewcommand{\footrulewidth}{0.4pt} %untere Trennlinie

\newtheorem{example}{Beispiel}
\newtheorem{definition}{Definition}

\begin{document} 

\subject{Hauptseminar WS 2011/2012}

\title{Klassifizierungsverfahren\\ und neuronale Netze}
\subtitle{Hauptseminar - Methoden der experimentellen Teilchenphysik}

\author{Thomas Keck\\ 
t.keck@online.de\\
Karlsruher Institut für Technologie,} 

\date{09.12.2011}

\maketitle 

\newpage

\tableofcontents

\newpage

\section{Klassifizierung}
\subsection{Das Klassifizierungsproblem}
Viele Probleme in Naturwissenschaft, Technik und Wirtschaft lassen sich auf ein Klassifizierungsproblem
zurückführen. Das zu klassifizierende Objekt $X$ ist dabei durch einen Merkmalvektor $\vec{x}$ aus dem
betrachteten Merkmalraum $M$ mit der Dimension $n$ charakterisiert. 
Das Problem besteht nun darin zu entscheiden, ob das Objekt $X$
in der betrachteten Klasse $K$ liegt oder nicht. Je nach Klassenzugehörigkeit sind die Mermalvektoren
unterschiedlich im $M$ Raum verteilt. Man sagt sie besitzen eine gemeinsame Verteilung \textit{probability density function} (PDF) $f(\vec{x}) \hspace{0.5em} \forall \vec{x} \in K$ oder $g(\vec{x}) \hspace{0.5em} \forall \vec{x} \notin K$. \\[0.5em]
\noindent
\textit{Das Klassifizierungsproblem}
\begin{align*}
X \in K \quad &\textrm{oder} \quad X \notin K
\end{align*}

\begin{example}{.\\}
\fbox{\parbox{\linewidth-10\fboxsep-2\fboxrule}{
Die Ärztin Alice untersucht einen Patienten $X$. Sie misst Blutdruck $B$, Temperatur $T$ und Herzschlag $H$.
Der Zustand des Patienten wird daher beschrieben durch $\vec{x} = \left( B, T, H \right)^T$. Sie
möchte nun entscheiden, ob der Patient krank ist. Also in der Menge (Klasse) der Kranken $K$ liegt.
Ein möglicher Wert der PDFs ist z.B. $g(180,44,130)=0$ und $f(180,44,130)=0.1$ $\rightarrow$ der Patient ist also keinesfalls gesund!
}
}
\end{example}

\begin{example}{.\\}
\fbox{\parbox{\linewidth-10\fboxsep-2\fboxrule}{
Der Physiker Bob ist auf der Suche nach neuen Elementarteilchen. Er misst Energie $E$, Impuls $P$ und
Halbwertszeit $\tau$ eines Teilchens im Detektor. Das Ereignis ist daher beschrieben durch
$\vec{x} = \left( E, P, \tau \right)^T$. Er möchte nun wissen, ob das Teilchen in der Klasse $K$ der
unbekannten Elementarteilchen liegt.
}
}
\end{example}
\FloatBarrier
\begin{figure}
\psset{unit=2.0cm,Alpha=45, Beta=10,linewidth=1.5pt}
\begin{pspicture}(-3,-3)(3,3)
\parametricplotThreeD[algebraic=true,xPlotpoints=500, yPlotpoints=20,linecolor=blue!60](-2,2)(-3,0){%
    t | u | 2.718^(-(u-1)^2-t^2)
  }
\parametricplotThreeD[algebraic=true,xPlotpoints=500, yPlotpoints=20,linecolor=blue!60](-3,0)(-2,2){%
    u | t | 2.718^(-u^2-(t-1)^2)
  }
  \parametricplotThreeD[algebraic=true,xPlotpoints=500, yPlotpoints=20,linecolor=red!60](-2,2)(-3,0){%
    t | u | 2.718^(-(u+1)^2-t^2)
  }
\parametricplotThreeD[algebraic=true,xPlotpoints=500, yPlotpoints=20,linecolor=red!60](-3,0)(-2,2){%
    u | t | 2.718^(-u^2-(t+1)^2)
  }
  \parametricplotThreeD[algebraic=true,xPlotpoints=500, yPlotpoints=20,linecolor=red!60](-2,2)(0,3){%
    t | u | 2.718^(-(u+1)^2-t^2)
  }
\parametricplotThreeD[algebraic=true,xPlotpoints=500, yPlotpoints=20,linecolor=red!60](0,3)(-2,2){%
    u | t | 2.718^(-u^2-(t+1)^2)
  }  
  \parametricplotThreeD[algebraic=true,xPlotpoints=500, yPlotpoints=20,linecolor=blue!60](-2,2)(0,3){%
    t | u | 2.718^(-(u-1)^2-t^2)
  }
\parametricplotThreeD[algebraic=true,xPlotpoints=500, yPlotpoints=20,linecolor=blue!60](0,3)(-2,2){%
    u | t | 2.718^(-u^2-(t-1)^2)
  }

\pstThreeDCoor[xMin=-3, xMax=3.0, yMin=-4, yMax=4.0, zMin=0,zMax=1.5,linecolor=black,linewidth=0.6pt]
\end{pspicture}
\caption{Beispiel für PDFs in einem zweidimensionalen Merkmalraum}
\end{figure}
\FloatBarrier
%%TODO PDF 2D Bild

\subsection{Der Klassifikator}
\noindent
Ein Klassifikator $K_F$ ist eine Funktion, die den $n$-dimensionalen Merkmalraum
auf $\mathbb{R}$ abbildet. Dann ist die Zugehörigkeit des Objektes $X$ 
mit $\vec{x} \in M$ zu $K$ leicht bestimmbar.\\[0.5em]
\noindent \textit{Der Klassifikator}
\begin{align}
K_F: M &\rightarrow \mathbb{R},\quad \vec{x} \mapsto y
\end{align}
Wird ein Merkmalvektor $\vec{x}$ in ein bestimmtes Intervall $I_K$ abgebildet,
so legt man fest $X \in K$.
Über dieses Intervall kann man bei einem gegebenen Klassifikator bestimmte Eigenschaften festlegen,
die sich komplementär zueinander verhalten:
\begin{description}
\item \textbf{Effizienz} \textit{efficency} -- Anteil der $X \in K$, die $K$ zugeordnet werden.
\item \textbf{Reinheit} \textit{purity} -- Anteil der $X$ die $K$ zugeordnet wurden, die richtig zugeordnet sind.
\end{description}

\subsection{Begriffe der Statistik}
Zur Begriffsbildung erfolgen an dieser Stelle einige Anleihen aus der Statistik.
Die Nullhypothese $H_0$ bezeichnet die Annahme
$X \in K$.
Die Alternativhypothese bezeichnet die Annahme $X \notin K$.
Unser Klassifizierungsproblem entspricht in der Statistik einem
Hypothesentest.
Mit diesen Begriffen können wir die
möglichen Fehler des Klassifikators beschreiben.\\[0.5em]
\noindent \textit{Fehler 1. Art}
Die Nullhypothese wird angenommen, obwohl sie falsch ist. Je mehr Fehler 1. Art
gemacht werden, desto geringer ist normalerweise die Reinheit. $\alpha$ bezeichnet
die Wahrscheinlichkeit für einen Fehler 1. Art. Man spricht auch von Signifikanz.\\[0.5em]
\noindent \textit{Fehler 2. Art}
Die Alternativhypothese wird angenommen, obwohl sie falsch ist. Je mehr Fehler 2. Art
gemacht werden, desto geringer ist die Effizienz. $\beta$ bezeichnet die Wahrscheinlichkeit
für einen Fehler 2. Art.\\[0.5em]
Das Histogramm aller zu klassifizierenden Merkmalvektoren $T\left( K_F(\vec{x}) \right)$ wird
Teststatistik genannt. Sie ist die Abbildung der PDFs nach $\mathbb{R}$.

\begin{figure}[htp!]
\centering
\psset{xunit=1cm,yunit=0.4cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(-1,0)(11,10)
\psclip{
\pscustom[linestyle=none]{
\psplot[plotpoints=200,algebraic=true]{-5}{5}{10*2.718^(-0.5*(x-1)^2)}
}
\pscustom[linestyle=none]{
\psplot[plotpoints=200,algebraic=true]{-5}{5}{8*2.718^(-0.3*(x+1)^2)}
}
\psframe*[linecolor=brown](0,0)(10,10)
}
\endpsclip
\psclip{
\pscustom[linestyle=none]{
\psplot[plotpoints=200,algebraic=true]{-5}{5}{10*2.718^(-0.5*(x-1)^2)}
}
\pscustom[linestyle=none]{
\psplot[plotpoints=200,algebraic=true]{-5}{5}{8*2.718^(-0.3*(x+1)^2)}
}
\psframe*[linecolor=blue](0,0)(-10,10)
}
\endpsclip

\psplot[plotpoints=200,algebraic=true]{-5}{5}{10*2.718^(-0.5*(x-1)^2)}
\psplot[plotpoints=200,algebraic=true]{-5}{5}{8*2.718^(-0.3*(x+1)^2)}
\rput(0,-1){c}
\psaxes[labels=none]{->}(5,11)
\psaxes[labels=none]{->}(-5,0)
\end{pspicture}
%\includegraphics[width=0.7\textwidth]{images/teststatistik.png}
\caption{Teststatistik für $\forall \vec{x} \in K$ rechts und $\forall \vec{x} \notin K$ links. Der Cut an
der Stelle $c$ separiert die Daten. Die farbigen Flächen entsprechen den Fehlern 1. Art (braun) und 2. Art (blau). Normiert man diese Flächen mit der Gesamtfläche unter den jeweiligen Kurven, so erhält man die entsprechenden Wahrscheinlichkeiten.}
\end{figure}

\begin{example}{.\\}
\fbox{\parbox{\linewidth-10\fboxsep-2\fboxrule}{
Alice ist selbst ein Klassifikator für die Klasse $K$ der kranken Menschen.
Die Nullhypothese von Alice ist: ,,Der Patient ist krank''.
Alice möchte wenig Fehler 2. Art machen, um möglichst viele Patienten die krank sind auch als
solche zu erkennen. Für sie ist Effizienz sehr wichtig, dabei klassifiziert sie natürlich
häufig Patienten als krank die es garnicht sind.
}
}
\end{example}
\begin{example}{.\\}
\fbox{\parbox{\linewidth-10\fboxsep-2\fboxrule}{
Bob verwendet ein Klassifikationsverfahren als Klassifikator.
Seine Nullhypothese ist ,,bei dem detektierten
Teilchen handelt es sich um ein neues Elementarteilchen''.
Bob setzt seine Reputation aufs Spiel, falls er fäschlicherweise ein neues
Elementarteilchen entdeckt. Er möchte möglichst wenig Fehler 1. Art machen,
da er eine sehr hohe Reinheit anstrebt. 
}
}
\end{example}

\newpage

\section{Klassifizierungsverfahren}
Ein Klassifizierungsverfahren ist ein Klassifikator. Oft ist der Merkmalraum $M$ sehr groß und
besitzt eine hohe Dimensionalität. Ganz allgemein gilt es die Dimension des Merkmalraumes so klein
wie möglich zu halten:
\begin{enumerate}
\item So wenig Merkmale wie möglich, so viele wie nötig.
\item Verwendung von Merkmalen mit \textbf{hoher Korrelation} zu $K$.
\item Sehr ähnliche Merkmale vermeiden.
\item \textbf{Preprocessing} der Merkmale (z.B. Normierung)
\item Ausgabe von bereits \textbf{vorhandenen Verfahren} als Merkmal nutzen
\end{enumerate}
\subsection{Neyman-Pearson-Lemma}
Möchte man eine Nullhypothese $g(\vec{x}) \hspace{0.5em} \forall \vec{x} \notin K$ gegenüber einer Alternativhypothese
$f(\vec{x}) \hspace{0.5em} \forall \vec{x} \in K$ testen, und kennt die zugehörigen Verteilungsfunktionen $g$ und $f$
im Merkmalraum, so ist der ideale Klassifikator durch
\begin{align}
K_{NPL} &= \frac{f\left(\vec{x}\right)}{g\left(\vec{x}\right)}
\end{align}
gegeben. Besitzt man ausreichend Informationen über das betrachtete System, so kann man die Verteilungsfunktionen
theoretisch oder über Simulation bestimmen. Oft besitzt man nur bereits klassifizierte Datensätze im Folgenden als Trainingsdatensatz bezeichnet. In der Praxis ist das Neyman-Pearson-Lemma nicht anwendbar, da es nur für 1 oder
 manchmal auch 2-dimensionale Probleme möglich ist genug Daten zu besitzen, um die Verteilungsfunktionen
 zu bestimmen. Für höhere Dimensionen ist dies hoffnungslos.
 
\begin{example}{.\\}
\fbox{\parbox{\linewidth-10\fboxsep-2\fboxrule}{
Bob besitzt eine sehr genaue physikalische Vorstellung von seinem System und hat die 3D-Verteilungsfunktionen
für alle Elementarteilchen, sowie den von ihm neu postulierten, mithilfe einer jahrelangen Monte-Carlo-Simulation
berechnet. Das Neyman-Pearson-Lemma erlaubt ihm eine optimale Klassifikation und der Nobelpreis sollte
nicht mehr lange auf sich warten lassen.
}
}
\end{example}

\subsection{Fisher-Diskriminante}
Ein weiteres Klassifizierungsverfahren ist die ,,Fisher-Diskriminante''. Sie eignet sich
zur Trennung eines Signals von Untergrundereignissen.
Man macht einen linearen Ansatz für den Klassifikator:
\begin{align}
K_{Fisher} \left(\vec{x}\right) &= \sum^n_{i=1} a_i x_i = \vec{a} \cdot \vec{x}
\end{align}
Die Koeffizienten $a_i$ werden nun so bestimmt, dass die Mittelwerte $\mu$ von Signal und Untergrund
in der Teststatistik möglichst weit auseinanderliegen,
und die Varianzen $\sigma^2$ möglichst klein sind.
Dafür muss jedoch der Mittelwert $\vec{\mu}$ und die
Kovarianzmatrix $V$ der PDFs bekannt sein, diese approximiert man mithilfe der Trainingsdaten.
\begin{align}
\mu &= \vec{a} \cdot \vec{\mu}\\
\sigma^2 &= \vec{a}^T V \vec{a}
\end{align}
Hieraus ergibt sich die sogenannte Fisher-Diskriminante
\begin{align}
J\left(\vec{a}\right) &= \frac{\left( \mu_s - \mu_b \right)^2}{\sigma^2_s + \sigma^2_b}\\
\frac{\partial J}{\partial a_i} &= 0
\end{align}
Die Fisher-Diskriminante wird nun maximiert, dies ist analytisch möglich und leicht in einer
beliebigen Programmiersprache zu implementieren.
%%TODO Referenzimplementierung
%%TODO Bild von Fisher Statistik
\subsection{Support Vector Machines}
Eine Support Vector Machine (SVM) trennt die Daten durch eine (n-1)-dimensionale Hyperfläche
im Merkmalraum. Die Fläche wird so angelegt, dass der freie Abstand zu den nächsten Merkmalvektoren,
die sogennanten Stützvektoren, der jeweiligen Klasse maximiert wird. Zur Berechnung der Trennfläche
gehen aber alle Datenpunkte mit ein. Dieses Verfahren ist prinzipiell in der Lage, die
bestmöglichste Trennung zu finden, skaliert in der Praxis jedoch sehr schlecht ($O\left( N^2 \right)$
wobei $N$ die Anzahl der Datenpunkte ist). Sinnvoll ist dieses Verfahren wenn man nur sehr wenige
Beispieldatensätze besitzt. Mathematisch kann man zeigen, dass jedes neuronale Netz auch als
SVM darstellbar ist. Durch sogenannte Kernelfunktionen können auch nichtlineare
Klassifikationsprobleme behandelt werden. Die SVM sollen an dieser
Stelle nur kurz erwähnt bleiben. Besitzt man sehr wenige Trainingsdatensätze, so sind diese
neuronalen Netzen überlegen.

\subsection{Neuronale Netze}
Ist der Merkmalraum sehr groß und analytische Methoden versagen, so kann man ein neuronales
Netz als Klassifikator einsetzen. Ein neuronales Netz muss für diesen Zweck zuerst
mithilfe eines Trainingsdatensatzes trainiert werden. Die Güte der Klassifikation hängt dabei
sehr stark von der Qualität des Trainingsdatensatzes ab. Im Gegensatz zur SVM skaliert das
neuronale Netz linear mit der Anzahl der Trainingsdatensätze ($O\left( N^2 \right)$
wobei $N$ die Anzahl der Datenpunkte ist). Neuronale Netze eignen sich weiterhin
sehr gut um die Ausgabe von bereits vorhandenen Klassifikatoren nochmals zu verarbeiten und so
ein noch besseres Ergebnis zu erzielen.

\begin{example}{.\\}
\fbox{\parbox{\linewidth-10\fboxsep-2\fboxrule}{
Alice ist ein neuronales Netz. Durch ihre 10-jährigen Berufserfahrung kennt sie
mögliche Krankheiten und Symptome. Daher kann sie sehr schnell und sicher feststellen ob
ein Patient krank ist.
}
}
\end{example}
Künstliche neuronale Netze sind biologisch motiviert. Im menschlichen Gehirn (und dem von Tieren) sind
bis zu einer Billion Nervenzellen, sogenannte Neuronen, vernetzt. Jedes Neuron besitzt dabei tausende
gewichtete Verbindungen, sogenannte Synapsen, zu benachbarten Neuronen. Über chemische Signale
aktivieren die Neuronen sich gegenseitig und verarbeiten so Informationen. Dieses Prinzip
wird in Software adaptiert. Das Hauptproblem war bis zur Entdeckung des Backpropagation Algorithmus 1986, das
Training der Netze, also die Einstellung der Gewichte zwischen den Neuronen. 
Das Anwendungsgebiet geht weit über das der Klassifizierung hinaus.

\newpage
\section{Strukturen von künstlichen neuronalen Netzen}
Im Allgemeinen besteht ein neuronales Netz aus sogenannten Neuronen die einen Eingabevektor $\vec{x}$
auf eine Ausgabe $y$ abbilden. Zur Beschreibung der Struktur dieses Netzes bedient man sich eines
Schichtenmodells.
Ein- und Ausgänge des Netzes werden durch Neuronen
symbolisiert, im Folgenden als \textbf{Eingabeschicht} \textit{input layer} und \textbf{Ausgabeschicht}
\textit{output layer} bezeichnet.
Die Neuronen der Eingabeschicht sind dabei wiederum mit anderen Neuronen über gewichtete
Verbindungen $W$ verknüpft, diese Neuronen bilden die sogenannte \textbf{Versteckte Schicht} \textit{hidden layer}. Von diesen versteckten Schichten kann es beliebig viele geben. Grundsätzlich sind dabei die Ausgänge der $n$-ten Schicht mit den Eingängen der $n+1$-ten Schicht verbunden. 

\FloatBarrier
\begin{figure}[htp!]
\centering
\psset{xunit=1cm,yunit=1cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(10,10)
%Beschriftung
\rput(0.5,8){\psframebox{Eingabeschicht}}
\rput(5,8){\psframebox{Versteckte Schicht}}
\rput(9,8){\psframebox{Ausgabe Schicht}}
%Input Neurons
\rput(0.5,6){\rnode{1}{\pscirclebox{1}}}
\rput(0.5,4){\rnode{2}{\pscirclebox{2}}}
%Hidden Neurons
\rput(5.0,7){\rnode{3}{\pscirclebox{3}}}
\rput(5.0,5){\rnode{4}{\pscirclebox{4}}}
\rput(5.0,3){\rnode{5}{\pscirclebox{5}}}
%Output Neurons
\rput(9.0,5){\rnode{6}{\pscirclebox{6}}}
%Verbindungslinien
\ncarc[arcangle=0]{->}{1}{3}\ncput*[npos=0.15]{$w_{13}$}
\ncarc[arcangle=0]{->}{2}{3}\ncput*[npos=0.15]{$w_{23}$}
\ncarc[arcangle=0]{->}{1}{4}\ncput*[npos=0.15]{$w_{14}$}
\ncarc[arcangle=0]{->}{2}{4}\ncput*[npos=0.15]{$w_{24}$}
\ncarc[arcangle=0]{->}{1}{5}\ncput*[npos=0.15]{$w_{15}$}
\ncarc[arcangle=0]{->}{2}{5}\ncput*[npos=0.15]{$w_{25}$}
\ncarc[arcangle=0]{->}{3}{6}\ncput*[npos=0.15]{$w_{36}$}
\ncarc[arcangle=0]{->}{4}{6}\ncput*[npos=0.15]{$w_{46}$}
\ncarc[arcangle=0]{->}{5}{6}\ncput*[npos=0.15]{$w_{56}$}
\end{pspicture}
\caption{Schichtenmodell eines neuronalen Netzes, am Beispiel eines MLP mit einer versteckten Schicht}
\end{figure}
\FloatBarrier

\subsection{Rekurrente Netze}
In diesen Netzen können Neuronen beliebig untereinander verknüpft sein. In unserem Schichtenmodell
bedeutet dies, dass ein einzelnes Neuron sich in mehreren Schichten befinden kann.
Es kommt in diesem Fall zu sogenannten Rückkopplungen \textit{feedback} im System. Diese Art von Netz besitzt
daher ein kontextabhängiges Gedächtnis. Das neuronale Netz kann dann auch als assoziativer Speicher dienen.
Diese Form ist den natürlichen neuronalen Netzen am nächsten.
Bekannte Vertreter sind das Hopfield und das Jordan Netz. 
\FloatBarrier
\begin{figure}[htp!]
\centering
\subfloat[Symmetrisches Hopfield-Netz]{\centering
\psset{xunit=0.7cm,yunit=0.7cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(10,10)
%Neurons
\rput(1,1){\rnode{4}{\pscirclebox{4}}}
\rput(1,6){\rnode{3}{\pscirclebox{3}}}
\rput(6,1){\rnode{1}{\pscirclebox{1}}}
\rput(6,6){\rnode{2}{\pscirclebox{2}}}
%Verbindungslinien
\ncarc[arcangle=0]{<->}{1}{2}
\ncarc[arcangle=0]{<->}{1}{3}
\ncarc[arcangle=0]{<->}{1}{4}
\ncarc[arcangle=0]{<->}{2}{3}
\ncarc[arcangle=0]{<->}{2}{4}
\ncarc[arcangle=0]{<->}{3}{4}
\end{pspicture}
}\hfill
\subfloat[Jordan-Netz mit Kontextneuron]{
\centering
\psset{xunit=0.7cm,yunit=0.7cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(10,10)
%Input Neurons
\rput(0.5,6){\rnode{1}{\pscirclebox{1}}}
\rput(0.5,4){\rnode{2}{\pscirclebox{2}}}
\rput(0.5,2){\rnode{7}{\pscirclebox{7}}}
%Hidden Neurons
\rput(5.0,7){\rnode{3}{\pscirclebox{3}}}
\rput(5.0,5){\rnode{4}{\pscirclebox{4}}}
\rput(5.0,3){\rnode{5}{\pscirclebox{5}}}
%Output Neurons
\rput(9.0,5){\rnode{6}{\pscirclebox{6}}}
%Verbindungslinien
\ncarc[arcangle=0]{->}{1}{3}
\ncarc[arcangle=0]{->}{2}{3}
\ncarc[arcangle=0]{->}{1}{4}
\ncarc[arcangle=0]{->}{2}{4}
\ncarc[arcangle=0]{->}{1}{5}
\ncarc[arcangle=0]{->}{2}{5}
\ncarc[arcangle=0]{->}{3}{6}
\ncarc[arcangle=0]{->}{4}{6}
\ncarc[arcangle=0]{->}{5}{6}
\ncarc[arcangle=0]{->}{7}{3}
\ncarc[arcangle=0]{->}{7}{4}
\ncarc[arcangle=0]{->}{7}{5}
\ncangle[angleA=-90,armA=3cm, linearc=0.2]{->}{6}{7}

\end{pspicture}
}
\caption{Rekurrente Netze}
\end{figure}
\FloatBarrier
\begin{parcolumns}{2}
\colchunk{
\textbf{Hopfield}
\begin{itemize}
\item Jedes Neuron ist mit jedem anderen verbunden. Vollverknüpft.
\item Alle Neuronen sind sowohl Eingabe als auch Ausgabeneuronen.
\item Speziell zugeschnittener Lernalgorithmus.
\item Sehr großer Speicher und Rechenzeitbedarf.
\item Ursprünglich entwickelt als Modell für Spineis $H = -\frac{1}{2} \sum_{i,j} w_{ij} s_i s_j$
\end{itemize}
}
\colchunk{
\textbf{Jordan}
\begin{itemize}
\item Ausgabeschicht ist über Kontextneuronen auf die versteckte Schicht zurückgekoppelt.
\item Training erfolgt mit ,,Backpropagation of Error'' für den Feed-Forward Teil
\item Keine Anpassung der rückgekoppelten Verbindungen, diese sind konstant 1.
\end{itemize}
}
\colplacechunks
\end{parcolumns}
%%TODO Pro Kontra
%%Schwieriger Lernvorgang
%%Gedächtnis
\subsection{Feed Forward Netze}
In Feed Forward Netzen ist die Zuordnung der Neuronen zu den Schichten eindeutig. Es gibt keine
Rückkopplungen. Feed Forward Netze sind die bevorzugten
Netze in der Klassifizierung, da die zu klassifizierenden Datensätze als unabhängig betrachtet werden
und keine Rückkopplungen benötigen.
Der Lernvorgang gestaltet sich bei diesen Netzen besonders einfach (siehe ,,Backpropagation of Error'').
Bekannte Vertreter sind das ,,radial base function'' Netz (kurz RBF) und das Multi-Layer Perceptron (kurz MLP).

\FloatBarrier
\begin{figure}[htp!]
\centering
\subfloat[RBF]{
\psset{xunit=0.7cm,yunit=0.7cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(10,10)
%Input Neurons
\rput(0.5,6){\rnode{1}{\pscirclebox{1}}}
\rput(0.5,4){\rnode{2}{\pscirclebox{2}}}
%Hidden Neurons
\rput(4.0,6){\rnode{3}{\pscirclebox{$\curlywedge$}}}
\rput(4.0,4){\rnode{4}{\pscirclebox{$\curlywedge$}}}
%Output Neurons
\rput(7.0,5){\rnode{5}{\pscirclebox{$\sum$}}}
%Verbindungslinien
\ncarc[arcangle=0]{->}{1}{3}
\ncarc[arcangle=0]{->}{2}{3}
\ncarc[arcangle=0]{->}{1}{4}
\ncarc[arcangle=0]{->}{2}{4}
\ncarc[arcangle=0]{->}{3}{5}
\ncarc[arcangle=0]{->}{4}{5}
\end{pspicture}
}\hfill
\subfloat[MLP]{
\psset{xunit=0.7cm,yunit=0.7cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(10,10)
%Input Neurons
\rput(0.5,6){\rnode{1}{\pscirclebox{1}}}
\rput(0.5,4){\rnode{2}{\pscirclebox{2}}}
%Hidden Neurons
\rput(4.0,6){\rnode{3}{\pscirclebox{3}}}
\rput(4.0,4){\rnode{4}{\pscirclebox{4}}}
\rput(7.0,6){\rnode{5}{\pscirclebox{5}}}
\rput(7.0,4){\rnode{6}{\pscirclebox{6}}}
%Output Neurons
\rput(9.0,5){\rnode{7}{\pscirclebox{7}}}
%Verbindungslinien
\ncarc[arcangle=0]{->}{1}{3}
\ncarc[arcangle=0]{->}{2}{3}
\ncarc[arcangle=0]{->}{1}{4}
\ncarc[arcangle=0]{->}{2}{4}
\ncarc[arcangle=0]{->}{3}{5}
\ncarc[arcangle=0]{->}{3}{6}
\ncarc[arcangle=0]{->}{4}{5}
\ncarc[arcangle=0]{->}{4}{6}
\ncarc[arcangle=0]{->}{5}{7}
\ncarc[arcangle=0]{->}{6}{7}
\end{pspicture}

}
\caption{Feed Forward Netze}
\end{figure}
\FloatBarrier

\newpage


\begin{parcolumns}{2}
\colchunk{
\textbf{RBF}
\begin{itemize}
\item Eingabevektor wird nach radialen Basisfunktionen entwickelt.
\item Besteht aus genau 3 Schichten.
\item Nur die Verbindungen zur Ausgabeschicht sind gewichtet.
\item Versteckte Schicht implementiert radiale Basisfunktionen. 
\item Ausgabeschicht berechnet gewichtete Summe.
\item Training der Parameter der Basisfunktionen und der Gewichte der Ausgabeschicht per Backpropagation.
\end{itemize}
}
\colchunk{
\textbf{MLP}
\begin{itemize}
\item Eingabevektor wird in vielen Schichten verarbeitet.
\item Besteht aus beliebig vielen Schichten.
\item Alle Verbindungen sind gewichtet.
\item Training je nach Schichtanzahl langsam und instabil.
\item Versteckte Schichten besitzen beliebige Verarbeitungsfunktionen.
\item Ausgabeschicht besitzt beliebige Verarbeitungsfunktionen.
\item Training aller Gewichte per Backpropagation.
\end{itemize}
}
\colplacechunks
\end{parcolumns}


\newpage
\section{Propagation in neuronalen Netzen}
Ein beliebiges neuronales Netz sei gegeben. Die Eingänge werden mit dem Merkmalvektor $\vec{x}$ initalisiert.
Über die gewichteten Verbindungen propagiert dieser Vektor nun durch das Netz und wird durch die Neuronen
verarbeitet. Am Ende erhält man ein Ausgabesignal am Ausgang. Im Folgenden wird diese Propagation der Eingabe
durch das Netz mathematisch erfasst. Ein einzelnes Neuron $j$ mit den Eingängen $x_i$ ist dabei durch zwei Funktionen $net_j$ und $f_j$ charakterisiert. Das Netz insgesamt besitzt eine Fehlerfunktion $E$, welche die
Abweichung der Ausgabe vom gewünschten Wert berechnet.
\FloatBarrier
\begin{figure}[htp!]
\centering
\psset{xunit=1cm,yunit=1cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(13,10)
\pnode(0.5,1){1}
\pnode(0.5,3){2}
\pnode(0.5,5){3}
\pnode(12,3){4}
\rput(6,3){\rnode{jp}{\psframebox{$t=net_j\left(x_i,w_{ij},\theta_j\right)$}}}
\rput(9,3){\rnode{jt}{\psframebox{$x_j=f_j\left(t\right)$}}}
%Verbindungslinien
\ncarc[arcangle=0]{->}{1}{jp}\ncput*[npos=0.5]{$x_1 \quad w_{1j}$}
\ncarc[arcangle=0]{->}{2}{jp}\ncput*[npos=0.5]{$x_2 \quad w_{2j}$}
\ncarc[arcangle=0]{->}{3}{jp}\ncput*[npos=0.5]{$x_3 \quad w_{3j}$}
\ncarc[arcangle=0]{->}{jt}{4}\ncput*[npos=0.5]{$x_j$}
\ncarc[arcangle=45]{->}{jp}{jt}\naput*[npos=0.5]{$t$}
\end{pspicture}
\caption{Innere Struktur eines einzelnen Neurons}
\end{figure}
\FloatBarrier
\subsection{Notation}
Aufgrund der netzartigen Struktur und der sehr allgemein gehaltenen Betrachtung sind die Argumente
der einzelnen Funktionen schwierig zu erfassen. Folgende Notation wird verwendet:
\begin{description}
\item $x_i$ Steht für alle Eingänge des jeweiligen Neurons, summen über $x_i$ laufen über alle Eingänge.
\item $x_j$ Steht für den Ausgang des Neurons.
\item $\theta_j$ Sind die Parameter des Neurons $j$. Es kann sich um einen Skalar, ein Vektor, ... handeln.
\item $w_{ij}$ Steht für die Gewichtsmatrix selbst, bzw. für das Gewicht zwischen Neuron $i$ und $j$. 
\end{description}
Kurz gefasst: Der Index $i$ steht immer für eine beliebige Menge von Eingabeneuronen, der Index $j$
für das jeweils betrachtete Neuron.
Diese Notation ermöglicht es bei einer konkreten Implementierung die Neuronen einfach durchzunummerieren
und die jeweiligen Formeln fast direkt in eine Programmiersprache zu übertragen. 

\subsection{Übertragungsfunktion - \textit{propagation function}}
Die Übertragungsfunktion bildet die Eingänge $x_i$ mit den jeweiligen Gewichten $w_{ij}$ auf ein Aktivierungssignal $t$ ab. Dabei kann die Übertragungsfunktion von beliebigen weiteren Variablen
$\theta_j$ abhängen, die für jedes Neuron verschieden sein können. Die Funktion muss differenzierbar nach allen Parametern sein. 
\\[0.5em]
\noindent
\textit{Übertragungsfunktion}
\begin{align*}
t &= net_j \left( w_{ij}, x_i, \theta_j  \right)
\end{align*}
Für ein MLP werden die gewichteten Eingänge aufsummiert und $\theta_j$ realisiert einen
konstanten Schwellwert.
\begin{align*}
net_j &= \sum w_{ij} x_i + \theta_j
\end{align*}
Für ein RBF-Netz liefert die Übertragungsfunktion den radialen Abstand der Eingabe zum
Zentrum des Neurons. Für ein RBF-Netz aus Gaußglocken ist die Übertragungsfunktion
daher der Exponent einer mehrdimensionalen Gaußglocke.
Die $\theta_j$ realisieren Breite und Verschiebung der Gaußglocke. Die Gewichte werden in
dieser Funktion nicht verwendet und in einer realen Implementierung daher auch nicht benötigt.
\begin{align*}
net_j &= \frac{\sum \left( x_i - \theta_{j_i} \right)^2}{2 \cdot  \theta_s^2}
\end{align*}
Eine andere Möglichkeit, welche näher am biologischen Vorbild ist, wäre die SoftMax Funktion, welche
eine differenzierbare Annäherung der Maximumsfunktion ist.
\begin{align*}
net_j &= \frac{\sum \left( w_{ij} x_i \right)^{q+1}}{k + \sum \left( w_{ij} x_i \right)^{q}}
\end{align*}

\subsection{Aktivierungsfunktion - \textit{transfer function}}
Die Aktivierungsfunktion bildet dass von der Übertragungsfunktion berechnete Aktivierungssignal $t$
auf das Ausgangssignal $x_j$ des Neurons ab. Die Funktion muss differenzierbar nach allen Parametern sein.
\\[0.5em]
\noindent
\textit{Aktivierungsfunktion}
\begin{align*}
x_j &= f_j \left( t \right)
\end{align*}
\FloatBarrier
\begin{figure}[htp!]
\subfloat{
\begin{minipage}[b]{0.55\textwidth}
Sehr häufig verwendet man für ein MLP die sogenannte Sigmoid Funktion. Sie verhält sich für $t \approx 0$ linear,
für $t \gg 0$ logarithmisch und für  $t \ll 0$ exponentiell. Ihre Ableitung ist direkt aus dem Funktionswert
berechenbar und beschleunigt damit das Lernverfahren (siehe ,,Backpropagation of Error'').
\begin{align*}
f_j &=  \frac{1}{1+e^{-at}}
\end{align*}
\end{minipage}
}
\hfill
\subfloat{
\psset{xunit=0.5cm,yunit=0.4cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(-1,0)(11,10)
\psplot[plotpoints=200,algebraic=true]{0}{10}{9/(1+2.718^(-1*(x-5)))}
\rput(5,-1){0}
\psaxes[labels=none]{->}(10,10)
\end{pspicture}
}
\end{figure}
\FloatBarrier
\FloatBarrier
\begin{figure}[htp!]
\subfloat{
\begin{minipage}[b]{0.55\textwidth}
Für ein Gaußglocken-RBF-Netz ist die Aktivierungsfunktion einfach die Exponentialfunktion. Zusammen mit der Übertragungsfunktion
ergibt sich so die mehrdimensionale Gaußglocke.
\begin{align*}
f_j &=  \frac{1}{\sqrt{2\pi}} e^{-t}
\end{align*}
\end{minipage}
}
\hfill
\subfloat{
\begin{minipage}[b]{0.45\textwidth}
\psset{unit=1.0cm,Alpha=45, Beta=15,linecolor=blue!60,linewidth=1.5pt}
\begin{pspicture}(-2,-2)(2,2)
\parametricplotThreeD[algebraic=true,xPlotpoints=500, yPlotpoints=10](-2,2)(-2,2){%
    t | u | 2.718^(-u^2-t^2)
  }
\parametricplotThreeD[algebraic=true,xPlotpoints=500, yPlotpoints=10](-2,2)(-2,2){%
    u | t | 2.718^(-u^2-t^2)
  }
\pstThreeDCoor[xMin=-3, xMax=3, yMin=-3, yMax=3.0, zMin=0,zMax=1.5,linecolor=black,linewidth=0.6pt]
\end{pspicture}
Zweidimensionales Beispiel eines RBF-Neurons mit Gaußglockenform
\end{minipage}
}
\end{figure}
\FloatBarrier
Im Prinzip ist jede differenzierbare Funktion geeignet, in der Ein- und Ausgabeschicht kann man z.B.
die Eingabe $t \in \left[e_0,e_1\right]$ durch eine Skalierungsfunktion auf einen beliebigen Ausgabebereich normieren $x_j \in \left[a_0,a_1\right]$:
\begin{align*}
f_j &=   \left(t-e_0\right) \cdot \frac{a_1 - a_0}{e_1 - e_0} + a_0
\end{align*}
Eine Ausnahme bildet die Aktivierungsfunktion des Hopfield Netzes. Sie ist nicht differenzierbar,
da ein anderes Lernverfahren (nicht ,,Backpropagation of Error'') zum Einsatz kommt. Die Aktivierungsfunktion
entspricht (in Analogie zu Spins) der Sprungfunktion.
\begin{align*}
f_j &= \Theta\left(t\right)
\end{align*}
\subsection{Fehlerfunktion - \textit{error function}}
Um die Qualität des Netzes zu bestimmen benötigt man eine Fehlerfunktion. Diese bestimmt, aus
den Ausgaben der Ausgangsneuronen und den Gewichten, den Fehler des Netzes. Die Funktion muss
differenzierbar nach allen Parametern sein.
\\[0.5em]
\noindent
\textit{Fehlerfunktion}
\begin{align*}
E &= E \left( x_j, w_{ij} \right)
\end{align*}
In der Praxis verwendet man die quadratische Abweichung von der gewünschten Ausgabe $t_j$ des Netzes
zum jeweiligen Trainingsdatensatz. 
\begin{align*}
E &= \frac{1}{2}\sum \left( x_j - t_j \right)^2
\end{align*}
Um die Gewichte möglichst klein zu halten, kann man einen sogenannten ,,Weight-Decay'' Term
verwenden, um die Gewichte gegen 0 zu drücken. Unwichtige Details die die Generalisierungsfähigkeit des
Netzes verschlechtern werden so vergessen. Man spricht auch von Optimal Brain Damage.
\begin{align*}
E &= E_0 + \frac{1}{2} \beta \sum w_{ij}^2
\end{align*}

\newpage
\section{Backpropagation of Error}
\subsection{Prinzip}
Der ,,Backpropagation of Error''-Algorithmus wurde im Jahr 1986 entdeckt und führte
zur Renaissance der neuronalen Netze, da er das Training eines mehrschichtigen 
Netzes ermöglichte. Vorherige Lernalgorithmen, wie die ,,Delta-Regel'', waren hierzu nicht in der Lage.
Beim ,,Backpropagation of Error'' handelt es sich um ein \textbf{Gradientenabstiegsverfahren}.
Dabei wird im Raum der Gewichte $G$ die Fehlerfunktion des Netzes minimalisiert.
Die Gewichte des Netzes $w_{ij}$ werden dabei schrittweise, entsprechend des Gradienten
 $\frac{\mathrm{d}E}{\mathrm{d}w_{ij}}$ auf der Fehleroberfläche, angepasst. Zur Anpassung der Parameter
 $\theta_j$ der Übertragungsfunktion kann man analog verfahren:

{
\noindent
\Large
\textit{Änderung}
\begin{align*}
\Delta w_{ij} &= - \eta \frac{\mathrm{d}E}{\mathrm{d}w_{ij}}\\
\Delta \theta_j &= - \eta \frac{\mathrm{d}E}{\mathrm{d}\theta_j}
\end{align*}
}
\subsection{Lernrate $\eta$}
\FloatBarrier
\begin{figure}[htp!]
\centering
\psset{xunit=1cm,yunit=0.5cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(10,10)
\rput(0.5,3){\rnode{jt}{\textbf{Konvergenz}}}
\rput(0.5,5){\rnode{jt}{\textbf{Lernrate}}}
\rput(0.5,7){\rnode{jt}{\textbf{Gebiet}}}

\rput(3,3){\rnode{jt}{Langsam}}
\rput(3,7){\rnode{jt}{Klein}}
\rput(5,3){\rnode{jt}{Schnell}}
\rput(5,7){\rnode{jt}{Groß}}
\rput(7,3){\rnode{jt}{Keine}}
\rput(7,7){\rnode{jt}{Riesig}}
\psline(2,6)(8,6)
\psline(2,4)(8,4)
\rput(2.5,5){\tiny $\eta$}
\rput(3.5,5){\scriptsize $\eta$}
\rput(4.5,5){\normalsize $\eta$}
\rput(5.5,5){\Large $\eta$}
\rput(6.5,5){\LARGE $\eta$}
\rput(7.5,5){\Huge $\eta$}
\end{pspicture}
\caption{Einfluss der Lernrate $\eta$ auf das untersuchte Gebiet im Gewichtsraum und die Konvergenz
des Gradientenabstiegverfahrens}
\label{eta}
\end{figure}
\FloatBarrier
Die Lernrate $\eta$ ist bei diesem Gradientenverfahren entscheidend. Schaubild \ref{eta} veranschaulicht dies.
Das auf ein Minimum untersuchte Gebiet im Gewichtsraum wird mit wachsendem $\eta$ größer, da die Gewichte sich
stärker ändern. Die Konvergenz ist für kleine $\eta$ sehr langsam und für sehr große $\eta$ konvergiert
das Verfahren überhaupt nicht, da große Sprünge immer wieder aus einem bereits
gefundenen Minimum herausführen.

\subsection{Backpropagation-Formel}
Die konkrete Formel erhält man durch partielle Differentation.
\\[0.5em]
\noindent
{\Large
\textit{Backpropagation-Formel}
\begin{align*}
\frac{\mathrm{d}E}{\mathrm{d}w_{ij}} &=  \underbrace{{\frac{\partial E}{\partial x_{j}}} \cdot \frac{\partial f_j}{\partial t}}_{\delta_j} \cdot \frac{\partial net_j}{\partial w_{ij}} + \frac{\partial E}{\partial w_{ij}}\\
\frac{\mathrm{d}E}{\mathrm{d}\theta_j} &=  \underbrace{{\frac{\partial E}{\partial x_{j}}} \cdot \frac{\partial f_j}{\partial t}}_{\delta_j} \cdot \frac{\partial net_j}{\partial \theta_j}
\end{align*}
}
$\delta_j$ ist dabei das sogenannte Fehlersignal des $j$-ten Neurons. Die Berechnung der einzelnen
Gewichtsänderungen erfolgt nun iterativ. Zuerst werden die Gewichtsänderungen und Fehlersignale der
Ausgabeschicht berechnet, da für sie $\frac{\partial E}{\partial x_{j}}$ bekannt ist, z.B:
\begin{align*}
E \left( x_j \right) &= \frac{1}{2} \left( x_j - t_j \right)^2\\
\frac{\partial E}{\partial x_{j}} &= -\left( x_j - t_j \right)
\end{align*}
Die beiden anderen partiellen Ableitungen sind ebenfalls bekannt, und hängen von der konkreten Wahl
der Übertragungs- und Aktivierungsfunktionen ab.
Die Fehlersignale dieser Schicht definieren nun die Fehleroberfläche für die Schicht von Neuronen,
die eine direkte Verbindung zur Ausgabeschicht besitzen:
\begin{align*}
E \left( x_j \right) &= \sum_k E \left( x_k \right)\\
\frac{\partial E}{\partial x_{j}} &= \sum_k \frac{\partial E}{\partial x_k} \cdot \frac{\partial f_k}{\partial t} \cdot \frac{\partial net_k}{\partial x_j} = \sum_k \delta_k w_{jk}
\end{align*}
Nun sind die Gewichtsänderungen und Fehlersignale für diese Schicht bekannt. Der Fehler kann nach diesem Prinzip
daher durch das gesamte Netz, Schicht für Schicht, zurückgepflanzt (,,backpropagation'') werden. Am einfachsten
ist dies in Feed-Forward-Netzen. Für rekurrente Netze benötigt man weitere Annahmen oder Näherungen.

\newpage
\section{Häufige Probleme beim Training und ihre Lösung}
\FloatBarrier
\begin{figure}[htp!]
\centering
\psset{xunit=0.5cm,yunit=0.5cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(13,10)
\psaxes[labels=none]{->}(12,9.5)
\rput(0,10){$E$}
\rput(13,0){$w_{ij}$}
\psbspline{B}(0,5)(1,4.3)(2,4.2)(3,4.1)(3.5,3)(4,1)(4.5,4)(5,7)(6,3)(7,9)(7.5,6)(8,4)(9,4)(10,4.5)(11,2)(11.5,6)(12,9)
\end{pspicture}
\caption{Projektion der Fehleroberfläche auf ein Gewicht $w_{ij}$}
\end{figure}
\FloatBarrier
Im Folgenden betrachten wir die Projektion der Fehleroberfläche auf ein beliebiges aber festes Gewicht $w_{ij}$.
Der Backpropagation Algorithmus erlaubt uns die sukzessive Suche nach einem Minimum in dem hochdimensionalen
Raum der Gewichte. Bei dieser Suche kommt es häufig zu einer Reihe von Problemen.

\vspace*{2em}

\begin{minipage}{0.45\textwidth}
\psset{xunit=0.5cm,yunit=0.5cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(13,10)
\psaxes[labels=none]{->}(12,9.5)
\rput(0,10){$E$}
\rput(13,0){$w_{ij}$}
\psbspline(0,5)(1,4.3)(2,4.2)(3,4.1)(3.5,3)(4,1)(4.5,4)(5,7)(6,3)(7,9)(7.5,6)(8,4)(9,4)(10,4.5)(11,2)(11.5,6)(12,9)
\pnode(5.05,6){A}
\pnode(6.8,6){B}
\ncarc[arcangle=0]{<->}{A}{B}
\end{pspicture}
\end{minipage}
\hfill
\begin{minipage}{0.45\textwidth}
\textbf{Oszillation in einer schmalen Schlucht}\\
Die Gewichtsänderung überspringt in einer schmalen Schlucht das Minimum, und erfährt auf der
anderen Seite die entgegengesetzte Änderung. Es kommt zur Oszillation. Die Einführung
eines \textbf{Momentum-Terms} verhindert dieses Problem.
\begin{align*}
\Delta w_{ij}\left(n\right) &= - \eta \frac{\mathrm{d}E}{\mathrm{d}w_{ij}} + \alpha \Delta w_{ij}\left(n-1\right)
\end{align*}
Der Term fügt der Gewichtsänderung eine gewisse Trägheit hinzu und verhindert somit Oszillationen.
\end{minipage}

\vspace{2em}

\begin{minipage}{0.45\textwidth}
\textbf{Langsame Konvergenz auf einem Plateau}\\
Der Gradient kann verschwinden, falls eine der partiellen Ableitungen
in der Backpropagation-Formel verschwindet. Für die Übertragungsfunktion und die
Fehlerfunktion ist dies selten der Fall. Die Transferfunktion dagegen besitzt oft
Sättigungsbereiche (z.B. die Sigmoid-Funktion für sehr kleine und große Werte) für
die die Ableitung gegen 0 strebt. Um aus diesen Sättigungsbereichen wieder herauszukommen
empfiehlt sich die \textbf{FlatSpotEliminiation}
\begin{align*}
\frac{\partial f_j}{\partial t} &\stackrel{!}{\neq} 0 & \frac{\partial f_j}{\partial t}^* &= \frac{\partial f_j}{\partial t} + c
\end{align*}
\end{minipage}
\hfill
\begin{minipage}{0.45\textwidth}
\psset{xunit=0.5cm,yunit=0.5cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(13,10)
\psaxes[labels=none]{->}(12,9.5)
\rput(0,10){$E$}
\rput(13,0){$w_{ij}$}
\psbspline(0,5)(1,4.3)(2,4.2)(3,4.1)(3.5,3)(4,1)(4.5,4)(5,7)(6,3)(7,9)(7.5,6)(8,4)(9,4)(10,4.5)(11,2)(11.5,6)(12,9)
\pnode(1,4.5){A}
\pnode(3,4.5){B}
\ncarc[arcangle=0]{->}{A}{B}
\end{pspicture}
\end{minipage}

\vspace*{2em}

\begin{minipage}{0.45\textwidth}
\psset{xunit=0.5cm,yunit=0.5cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(13,10)
\psaxes[labels=none]{->}(12,9.5)
\rput(0,10){$E$}
\rput(13,0){$w_{ij}$}
\psbspline(0,5)(1,4.3)(2,4.2)(3,4.1)(3.5,3)(4,1)(4.5,4)(5,7)(6,3)(7,9)(7.5,6)(8,4)(9,4)(10,4.5)(11,2)(11.5,6)(12,9)
\pnode(11.5,6){A}
\pnode(9,5){B}
\ncarc[arcangle=0]{->}{A}{B}
\end{pspicture}
\end{minipage}
\hfill
\begin{minipage}{0.45\textwidth}
\textbf{Verlassen oder Überspringen eines scharfen Minimums}\\
Ist der Gradient sehr steil, so kann ein scharfes Minimum leicht übersprungen werden.
Die Lösung ist eine variable Lernrate $\eta$. Diese kann abhängig sein von der
Anzahl der Lerniterationen. Ein anderer Ansatz ist die Verwendung von 
$signum\left(\frac{\mathrm{d}E}{\mathrm{d}w_{ij}}\right)$ anstatt $\frac{\mathrm{d}E}{\mathrm{d}w_{ij}}$
bei der Gewichtsanpassung, man spricht dann vom RPROP (Resilient Propagation) Verfahren.
Die Lernrate wird hier in Abhängigkeit von der letzten Änderung erhöht (gleiches Vorzeichen)
oder verringert (wechselndes Vorzeichen).
\end{minipage}

\vspace{2em}

\begin{minipage}{0.45\textwidth}
\textbf{Konvergenz zu einem schlechten Minimum}\\
Die Konvergenz gegen ein schlechtes Minimum lässt sich im exakten Sinn nicht verhindern,
da das globale Minimum in einem hochdimensionalen Raum nicht bestimmbar ist. Mit zufälligen
Anfangsgewichten und mehreren Durchläufen erhöht man jedoch die Chance ein gutes
Minimum zu finden.
\begin{align*}
w_{ij} &= \mathrm{random}\left(-1,1\right) \neq 0
\end{align*}
Im Bezug auf die Anfangsgewichte sind zufällige Werte wichtig, damit diese sich nicht
komplett synchron ändern. Man spricht auch von ,,Symmetry Breaking''.
\end{minipage}
\hfill
\begin{minipage}{0.45\textwidth}
\psset{xunit=0.5cm,yunit=0.5cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(13,10)
\psaxes[labels=none]{->}(12,9.5)
\rput(0,10){$E$}
\rput(13,0){$w_{ij}$}
\psbspline(0,5)(1,4.3)(2,4.2)(3,4.1)(3.5,3)(4,1)(4.5,4)(5,7)(6,3)(7,9)(7.5,6)(8,4)(9,4)(10,4.5)(11,2)(11.5,6)(12,9)
\pnode(10,5){A}
\pnode(8.2,4.2){B}
\ncarc[arcangle=0]{->}{A}{B}
\end{pspicture}
\end{minipage}

\vspace{2em}

\begin{minipage}{0.45\textwidth}
\psset{xunit=0.6cm,yunit=0.6cm,runit=1cm,nodesep=3pt,linewidth=1pt}
\begin{pspicture}(0,0)(12,10)
\psaxes[labels=none]{->}(11,9.5)
\rput(0,10){$E$}
\rput(11.5,0){$n$}
\psplot[plotpoints=200,algebraic=true,linecolor=blue]{0}{10}{9*2.718^(-1.5*x/3)}
\psplot[plotpoints=200,algebraic=true]{0}{6}{9*2.718^(-1.0*x/3)}
\psplot[plotpoints=200,algebraic=true]{6}{10}{(x-6)*0.5+1.218}
\end{pspicture}
\end{minipage}
\hfill
\begin{minipage}{0.45\textwidth}
\textbf{Early Stopping}\\
Der Fehler des Netzes im Bezug auf die Trainingsdaten sinkt exponentiell ab. Bis zu einem
gewissen Punkt trifft dies auch auf den Fehler des Netzes im Bezug auf unabhängige Testdaten
zu. Wird dieser Punkt überschritten, lernt das Netz die Trainingsdaten auswendig und verliert
die Abstraktionsfähigkeit. Man unterteilt daher die vorhandenen Daten in einen Trainingsteil
zum Trainieren und einen Testdatenteil, der nur zur Fehlerbestimmung herangezogen wird. Sobald
der Fehler der Testdaten wieder steigt wird das Training abgebrochen. Man spricht von
,,Early Stopping''. Um keine wertvollen Trainingsbeispiele zu verschenken, kann man das Netz mehrmals
Trainieren und dabei jeweils einen anderen Teil der Daten zum Test verwenden.
 Man spricht von ,,Cross Validation''.
 Eine andere Möglichkeit die Generalisierungsfähigkeit des Netzes zu erhöhen
ist das bereits erwähnte ,,Optimal Brain Damage''.
\end{minipage}

\newpage
\section{Werkzeuge}
\subsection{ROOT}
ROOT ist ein Datenanalyse-Framework von CERN in C++. Neben zahlreichen Klassen zum Speichern,
Plotten und Analysieren von großen Datenmengen findet sich auch die Klasse ,,TMultiLayerPerceptron''
welche, ein MLP mit 6 verschiedenen Lernalgorithmen implementiert. Die Handhabung
ist kompliziert und setzt die Kenntnisse des restlichen Frameworks voraus.

\subsection{Eigenentwicklungen}
Die Implementierung eines neuronalen Netzes ist recht simpel und kann innerhalb weniger
Stunden in gängigen Programmiersprachen erfolgen. Für spezielle Anwendungszwecke
kann eine Eigenentwicklung daher durchaus in Betracht gezogen werden.

\begin{thebibliography}{999}
\bibitem[Kriesel]{Kriesel} Ein kleiner Überblick über Neuronale Netze von David Kriesel
\bibitem[MMDD]{MMDD} Vorlesung ,,Moderne Methoden der Datenanalyse'' SS11 Uni Karlsruhe
\bibitem[Adamy]{Adamy} Fuzzy-Logik, neuronale Netze und evolutionäre Algorithmen von Jürgen Adamy
\end{thebibliography}


\end{document}
%%% Local Variables: 
%%% mode: latex
%%% TeX-master: t
%%% End: