Merge branch 'master' of raven.am28.uni-tuebingen.de:scientificComputing

Conflicts:
	programming/lecture/programming.tex

Makefile

@@ -1,7 +1,6 @@
 BASENAME=scientificcomputing-script
 
-SUBDIRS=plotting designpattern statistics bootstrap regression likelihood pointprocesses 
-# programming
+SUBDIRS=programming plotting statistics bootstrap regression likelihood pointprocesses designpattern
 SUBTEXS=$(foreach subd, $(SUBDIRS), $(subd)/lecture/$(subd).tex)
 
 pdf : chapters $(BASENAME).pdf

plotting/lecture/plotting.tex

@@ -1,6 +1,6 @@
 \chapter{\tr{Data plotting}{Graphische Darstellung von Daten}}
 
-\section{Graphische Darstellung von Daten}
+\section{Does and Don'ts bei der Graphische Darstellung von Daten}
 
 Die ad\"aquate Darstellung wissenschaftlicher Daten darf man durchaus
 zu den notwendigen Kernkompetenzen z\"ahlen. Wir brauchen sie um
@@ -57,7 +57,7 @@ Beispiele (\url{https://en.wikipedia.org/wiki/Misleading_graph}).
 Man kann durch graphische Tricks wie Perspektive (Abbildung
 \ref{misleadingpiefig}) oder auch gezielte Achsenskalierungen
 (Abbildung \ref{misleadingscalingfig}) den Eindruck des Betrachters
-steuern. Insbesondere wenn die Gr ß''o{\ss}e von Symbolen zur
+steuern. Insbesondere wenn die Gr\"o{\ss}e von Symbolen zur
 Darstellung einer Quantit\"at eingesetzt werden, muss man mit Vorsicht
 vorgehen um Unterschiede nicht zu \"uberproportional zu verzerren
 (Abbildung \ref{misleadingsymbolsfig}).
@@ -119,4 +119,134 @@ vorgehen um Unterschiede nicht zu \"uberproportional zu verzerren
 
 \newpage
 
-\subsection{Plottingsystem in \matlab{}}
+\section{Plottingsystem in \matlab{}}
+
+Plotten in \matlab{} ist zun\"achst einmal einfach. Durch den Aufruf
+von \code{plot(x, y)} wird ein einfacher, schlichter Linienplot
+erstellt. Zun\"achst fehlem diesem Plot jegliche Annotationen wie
+Achsbeschriftungen Legenden, etc. Um diese hizuzuf\"ugen kann man zwei
+Wege gehen: Das Graphische User Interface oder die
+Kommandozheile. Beide haben ihre Berechtigung und Vor- und
+Nachteile. W\"ahrend es bequem ist die Abbildung mit der GUI
+(Abbildung \ref{ploteditorfig}) zu bearbeiten sind die erhaltenen
+Ergebnisse nicht unbedingt reproduzierbar. Auch wenn eine Abbildung
+korrigiert werden mus{\ss}, wird es schwierig und zeitaufwendig. Die
+Nachtr\"agliche Bearbeitung der Abbildungen mit dem Graphikprogramm
+seiner Wahl birgt seine eigenen Risiken. Das Bestreben sollte sein,
+aus \matlab{} heraus publikationsreife Abbildungen zu erzeugen.
+
+\begin{figure}
+  \begin{minipage}[t]{0.45\columnwidth}
+    \includegraphics[width=0.9\textwidth]{plot_editor}
+  \end{minipage}
+  \begin{minipage}[t]{0.225\columnwidth}
+    \includegraphics[width=0.9\textwidth]{property_editor}
+  \end{minipage}
+  \caption{\textbf{Grahischer Plot Editor.} Editor f\"ur plots. Je
+    nachdem welches Element des Plots ausgew\"ahlt wurde ver\"andern
+    sich Einstellungsm\"oglichkeiten. Weitere Eigenschaften k\"onnen
+    \"uber den ``Property Editor'', rechts, eingestellt werden. Der
+    Property Editor ist \"uber die Schaltfl\"ache ``More Properties''
+    erreichbar.}\label{ploteditorfig}
+\end{figure}
+
+Alle Einstellungen, die man \"uber das graphische Interface machen
+kann sind auch \"uber Befehle auf der Kommandozeile m\"oglich. Das
+heisst, dass die Einstellungen problemlos in eine Skript, eine
+Funktion eingebaut werden k\"onnen. Dieser Ansatz hat den Vorteil,
+dass man sich die M\"uhe nur ein mal machen muss.  Unter den
+h\"aufigsten Einstellungen sind:
+\begin{enumerate}
+\item Einstellungen der Linienplots:
+  \begin{itemize}
+  \item St\"arke und Farbe.
+  \item Linienstil, Marker.
+  \end{itemize}
+\item Achsbeschriftung:
+  \begin{itemize}
+  \item \code{xlabel}, \code{ylabel}.
+  \item Schriftart und Gr\"o{\ss}e.
+  \end{itemize}
+\item Achsenskalierung und Ticks:
+  \begin{itemize}
+  \item Skalierung der Achsen (Minumum und Maxmimum, logarithmisch oder linear).
+  \item Manuelles Setzen der Ticks, ihrer Richtung und Beschriftung.
+  \item Grid or no Grid?
+  \end{itemize}
+\item Setzen von globalen Parametern:
+  \begin{itemize}
+  \item Einstellung der Papiergr\"o{\ss}e und plzieren der
+    Zeichenfl\"ache.
+  \item Soll die Zeichenfl\"ache auf allen vier Seiten von einer Box eingeschlossen sein oder nicht?
+  \item Speichern der Abbildung als pdf.      
+  \end{itemize}
+\end{enumerate}
+
+Das folgende Listing \ref{niceplotlisting} zeigt das Skript, das die
+Abbildung \ref{spikedetectionfig} erstellt und speichert. Abh\"angig
+davon, ob man Eigenschaften der Abbildung oder der Achsen setzen will
+benutzt man die \code{set} Funktion und \"ubergibt ihr ein sogenanntes
+Handle der Achse oder der Abbildung und sowohl den Namen als auch den
+gew\"unschten Wert der der Eigenschaft: \code{set(gcf, 'PaperUnits',
+  'centimeters')} setzt die Eigenschaft ``PaperUnits'' der Abbildung
+auf ``centimeters'', Standard ist, nat\"urlich, ``inches''.
+\code{gcf} steht f\"ur ``get current figure'' und stellt ein Handle
+der aktuellen Abbildung zur Verf\"ugung. Um Eigenschaften der Achse zu
+setzten benutzt man: \code{set(gca, 'linewidth', 1.5)} wobei
+\code{gca} f\"ur ``get current axis'' steht. Wenn man den Namen einer
+Eigenschaft nicht kennt, kann man entweder in der Hilfe nachschlagen
+oder sie im ``Property Editor'' finden.
+
+\begin{lstlisting}[caption={Skript zur Erstellung des Plots in Abbildung \ref{spikedetectionfig}.}, label=niceplotlisting]
+fig = figure();
+set(gcf, 'PaperUnits', 'centimeters', 'PaperSize', [11.7 9.0]);
+set(gcf, 'PaperPosition',[0.0 0.0 11.7 9.0], 'Color', 'white')
+hold on
+plot(time, neuronal_data, 'color', [ 0.2 0.5 0.7], 'linewidth', 1.)
+plot(spike_times, ones(size(spike_times))*threshold, 'ro', 'markersize', 4)
+line([time(1) time(end)], [threshold threshold], 'linestyle', '--',
+    'linewidth', 0.75, 'color', [0.9 0.9 0.9])
+ylim([0 35])
+xlim([0 2.25])
+box('off')
+xlabel('time [s]', 'fontname', 'MyriadPro-Regular', 'fontsize', 10)
+ylabel('potential [mV]', 'fontname', 'MyriadPro-Regular', 'fontsize', 10)
+title('pyramidal cell', 'fontname', 'MyriadPro-Regular', 'fontsize', 12)
+set(gca, 'TickDir','out', 'linewidth', 1.5, 'fontname', 'MyriadPro-Regular')
+saveas(fig, 'spike_detection.pdf', 'pdf')
+\end{lstlisting}
+
+\begin{figure}
+  \includegraphics[width=0.5\columnwidth]{./images/spike_detection}
+  \caption{\textbf{Annehmbarer Plot.} Dieser Plot wurde vollst\"andig
+    mit dem Skript in Listing \ref{niceplotlisting} erstellt und
+    gespeichert.}\label{spikedetectionfig}
+\end{figure}
+
+
+Neben den Standard Linienplots gibt es eine ganze Reihe weiterer
+M\"oglichkeiten Daten zu Visualisieren. Mathworks zeigt unter
+\url{http://www.mathworks.de/discovery/gallery.html} viele Beispiele
+mit zugeh\"origem Code. 
+
+\subsection{Fazit}
+
+Ein guter Datenplot stellt die Daten m\"oglichst vollst\"andig und
+n\"uchtern dar. Verzerrungen durch perspektivische Darstellungen,
+Achs- oder Symbolskalierungen sollten vermieden werden. Wenn man
+verschiedene Linienplots in einen Graphen plottet, sollte man neben
+der Farbe auch den Linienstil (durchgezogen, gepunktet, gestrichelt,
+etc.) variieren um auch im Schwarzweissdruck eine Unterscheidung zu
+erm\"oglichen. Bei der Farbwahl sollte man auf Kombinationen aus Rot
+und Gr\"un verzichten, da sie f\"ur einen nicht unwesentlichen Teil
+der m\"annlichen Bev\"olkerung nicht unterscheidbar sind. Man achte
+insbesondere auf:
+\begin{enumerate}
+\item Klarheit.
+\item Vollstaendige Beschriftung.
+\item Deutliche Unterscheidbarkeit von Kurven.
+\item Keine suggestive Darstellung. 
+\item Ausgewogenheit von Linienst\"arken Schrift- und Plotgr\"o{\ss}e.
+\item Fehlerbalken, wenn sie angebracht sind.
+\end{enumerate}
+

pointprocesses/lecture/pointprocesses.tex

@@ -17,11 +17,11 @@ Nervensystemen.  Dabei ist in erster Linie nur der Zeitpunkt des
 Auftretens eines Aktionspotentials von Bedeutung. Die genaue Form
 spielt keine oder nur eine untergeordnete Rolle.
 
-Nach etwas Vorverarbeitung haben elektrophysiologischer Messungen
+Nach etwas Vorverarbeitung haben elektrophysiologische Messungen
 deshalb Listen von Spikezeitpunkten als Ergebniss - sogenannte
 ``Spiketrains''. Diese Messungen k\"onnen wiederholt werden und es
 ergeben sich mehrere ``trials'' von Spiketrains
-(\figref{rasterexamples}).
+(\figref{rasterexamplesfig}).
 
 Spiketrains sind Zeitpunkte von Ereignissen --- den Aktionspotentialen
 --- und deren Analyse f\"allt daher in das Gebiet der Statistik von

programming/lecture/programming.tex

@@ -128,7 +128,6 @@ interpretiert werden. Die wichtigsten Datentpyen sind folgende:
   (\code{true}) oder falsch (\code{false}) interpretiert werden.
 \item \textit{char} - ASCII Zeichen
 \end{itemize}
-
 Unter den numerischen Datentypen gibt es verschiedene Arten mit
 unterschiedlichem Speicherbedarf und Wertebreich.
 
@@ -144,8 +143,6 @@ unterschiedlichem Speicherbedarf und Wertebreich.
     uint8 & 8 bit & $0$ bis $255$ & Digitalisierte Imaging Daten. \\ \hline  
   \end{tabular}
 \end{table}
-
-
 \matlab{} arbeitet meist mit dem ``double'' Datentyp wenn numerische
 Daten gespeichert werden. Dennoch lohnt es sich, sich ein wenig mit
 den Datentypen auseinanderzusetzen. Ein Szenario, dass in der
@@ -164,18 +161,15 @@ ben\"otigen.
 
 \section{Vektoren und Matrizen}
 
-% \begin{definition}[Vektoren und Matrizen]
 Vektoren und Matrizen sind die wichtigsten Datenstrukturen in
-\matlab. In anderen Programmiersprachen heissen sie ein-
+\matlab{}. In anderen Programmiersprachen heissen sie ein-
 bzw. mehrdimensionalen Felder. Felder sind Datenstrukturen, die
 mehrere Werte des geleichen Datentyps in einer Variablen vereinen. Da
-Matalb seinen Ursprung in der Verarbeitung von mathematischen Vektoren
-und Matrizen hat, werden sie hier auch so genannt.
-
-\matlab{} macht keinen Unterschied zwischen Vektoren und Matrizen.
-Vektoren sind 2-dimensionale Matrizen bei denen eine Dimension die
-Gr\"o{\ss}e 1 hat.
-% \end{definition}
+\matlab{} seinen Ursprung in der Verarbeitung von mathematischen
+Vektoren und Matrizen hat, werden sie hier auch so genannt. \matlab{}
+macht keinen Unterschied zwischen Vektoren und Matrizen.  Vektoren
+sind 2--dimensionale Matrizen bei denen eine Dimension die Gr\"o{\ss}e
+1 hat.
 
 
 \subsection{Vektoren}
@@ -210,7 +204,6 @@ k\"onnen.
   c = 
   0  2  4  6  8  10
 \end{lstlisting}
-
 Die L\"ange eines Vektors, d.h. die Anzahl der Elemente des Vektors,
 kann mithilfe der Funktion \code{length()} bestimmt werden. \"Ahnliche
 Information kann \"uber die Funktion \code{size()} erhalten werden. Im
@@ -307,9 +300,9 @@ Element gleichzeitig zuzugreifen.
 \subsubsection{Operationen auf Vektoren}
 
 Mit Vektoren kann sehr einfach gerechnet werden. Listing
-\ref{arrayListing5} zeigt Rechnungen mit Vektoren.
+\ref{arrayListing6} zeigt Rechnungen mit Vektoren.
 
-\begin{lstlisting}[caption={Rechnen mit Vektoren.},label=arrayListing5]
+\begin{lstlisting}[caption={Rechnen mit Vektoren.},label=arrayListing6]
   >> a = (0:2:8);
   >> a + 5 % addiere einen Skalar
   ans =
@@ -347,7 +340,7 @@ entsprechenden Matrixoperationen aus der linearen Algebrar belegt
 (s.u.).
 
 Zu Beachten ist des Weiteren noch die Fehlermeldung am Schluss von
-Listing \ref{arrayListing5}. Wenn zwei Vektoren (elementweise)
+Listing \ref{arrayListing6}. Wenn zwei Vektoren (elementweise)
 miteinander verrechnet werden sollen, muss nicht nur die Anzahl der Elemente
 übereinstimmen, sondern es muss auch das Layout (Zeilen- oder
 Spaltenvektoren) \"ubereinstimmen.
@@ -356,7 +349,7 @@ Spaltenvektoren) \"ubereinstimmen.
 Will man Elemente aus einem Vektor entfernen, dann weist man den
 entsprechenden Zellen einen leeren Wert (\code{[]}) zu.
 
-\begin{lstlisting}[label=arrayListing6, caption={L\"oschen von Elementen aus einem Vektor.}]
+\begin{lstlisting}[label=arrayListing7, caption={L\"oschen von Elementen aus einem Vektor.}]
   >> a = (0:2:8);
   >> length(a) 
   ans =
@@ -375,13 +368,13 @@ entsprechenden Zellen einen leeren Wert (\code{[]}) zu.
 
 Neben dem L\"oschen von Vektorinhalten k\"onnen Vektoren auch
 erweitert oder zusammengesetzt werden. Auch hier muss das Layout der Vektoren
-\"ubereinstimmen (Listing \ref{arrayListing7}, Zeile 12). Will man
+\"ubereinstimmen (Listing \ref{arrayListing8}, Zeile 12). Will man
 einen Vektor erweitern, kann man \"uber das Ende hinaus
 zuweisen. \matlab{} erweitert dann die Variable. Auch hierbei muss auf
 das Layout geachtet werden. Zudem ist dieser Vorgang
 ``rechenintensiv'' und sollte soweit m\"oglich vermieden werden.
 
-\begin{lstlisting}[caption={Zusammenf\"ugen und Erweitern von Vektoren.}, label=arrayListing7]
+\begin{lstlisting}[caption={Zusammenf\"ugen und Erweitern von Vektoren.}, label=arrayListing8]
   >> a = (0:2:8);
   >> b = (10:2:19);
   >> c = [a b] % erstelle einen Vektor aus einer Liste von Vektoren
@@ -577,7 +570,7 @@ Beziehung zwischen Entit\"aten zu testen. Hierzu werden die
 \emph{relationalen Operatoren} (\code{>}, \code{<}, \code{==},
 \code{!}, gr\"o{\ss}er als, kleiner als, gleich und nicht)
 eingesetzt. Mehrere Ausdr\"ucke werden mittels der \textit{logischen
-  Operatoren} (\code{\&}, \code{|}}, UND, ODER ) verkn\"upft. Sie sind f\"ur
+  Operatoren} (\code{\&}, \code{|}, UND, ODER ) verkn\"upft. Sie sind f\"ur
 uns nicht nur wichtig um Codeabschnitte bedingt auszuf\"uhren
 (Verzweigungen, \ref{controlstructsec}) sondern auch um aus Vektoren
 und Matrizen bequem Elemente auszuw\"ahlen (logisches Indizieren,
@@ -933,18 +926,18 @@ bestimmten Bedingungen ausgef\"uhrt wird.
 Am h\"aufigsten genutzter Vertreter ist die \code{if} -
 Anweisung. Sie Wird genutzt um Programmcode nur unter bestimmten
 Bedingungen auszuf\"uhren. 
-\begin{definition}
-  Der Kopf der if - Anweisung beginnt mit dem Schl\"usselwort
-  \code{if} welches von einem \underline{Booleschen Ausdruck}
-  gefolgt wird. Wenn dieser zu \code{true} ausgewertet werden kann,
-  wird der Code im K\"orper der Anweisung ausgef\"uhrt.  Optional
-  k\"onnen weitere Bedingungen mit dem Schl\"usselwort \code{elseif}
-  folgen.  Ebenfalls optional ist die Verwendung eines finalen
-  \code{else} Falls. Dieser wird immer dann ausgef\"uhrt wenn alle
-  vorherigen Bedingungen nicht erf\"ullt werden.  Die \code{if}
-  Anweisung wird mit \code{end} beendet. Listing \ref{ifelselisting}
-  zeigt den Aufbau einer if-Anweisung.
-\end{definition}
+
+Der Kopf der if - Anweisung beginnt mit dem Schl\"usselwort \code{if}
+welches von einem \underline{Booleschen Ausdruck} gefolgt wird. Wenn
+dieser zu \code{true} ausgewertet werden kann, wird der Code im
+K\"orper der Anweisung ausgef\"uhrt.  Optional k\"onnen weitere
+Bedingungen mit dem Schl\"usselwort \code{elseif} folgen.  Ebenfalls
+optional ist die Verwendung eines finalen \code{else} Falls. Dieser
+wird immer dann ausgef\"uhrt wenn alle vorherigen Bedingungen nicht
+erf\"ullt werden.  Die \code{if} Anweisung wird mit \code{end}
+beendet. Listing \ref{ifelselisting} zeigt den Aufbau einer
+if-Anweisung.
+  
 
 \begin{lstlisting}[label=ifelselisting, caption={Grundger\"ust einer \code{if} Anweisung.}]
   if x < y
@@ -971,19 +964,16 @@ end
 Die \code{switch} Verzweigung Wird eingesetzt wenn mehrere F\"alle
 auftreten k\"onnen, die einer unterschiedlichen Behandlung bed\"urfen.
 
-\begin{definition}
-  Wird mit dem Schl\"usselwort \code{switch} begonnen, gefolgt von
-  der \textit{switch Anweisung} (Zahl oder String). Jeder Fall auf den
-  die Anweisung \"uberpr\"ft werden soll wird mit dem Schl\"usselwort
-  \code{case} eingeleitet. Diese wird gefolgt von der \textit{case
-    Anweisung} welche definiert gegen welchen Fall auf
-  \underline{Gleichheit} getestet wird. F\"ur jeden Fall wird der
-  Programmcode angegeben, der ausgef\"uhrt werden soll Optional
-  k\"onnen mit dem Schl\"usselwort \code{otherwise} alle nicht
-  explizit genannten F\"alle behandelt werden.  Die \code{switch}
-  Anweisung wird mit \code{end} beendet (z.B. in Listing
-  \ref{switchlisting}).
-\end{definition}
+Wird mit dem Schl\"usselwort \code{switch} begonnen, gefolgt von der
+\textit{switch Anweisung} (Zahl oder String). Jeder Fall auf den die
+Anweisung \"uberpr\"ft werden soll wird mit dem Schl\"usselwort
+\code{case} eingeleitet. Diese wird gefolgt von der \textit{case
+  Anweisung} welche definiert gegen welchen Fall auf
+\underline{Gleichheit} getestet wird. F\"ur jeden Fall wird der
+Programmcode angegeben, der ausgef\"uhrt werden soll Optional k\"onnen
+mit dem Schl\"usselwort \code{otherwise} alle nicht explizit genannten
+F\"alle behandelt werden.  Die \code{switch} Anweisung wird mit
+\code{end} beendet (z.B. in Listing \ref{switchlisting}).
 
 
 \begin{lstlisting}[label=switchlisting, caption={Grundger\"ust einer \code{switch} Anweisung.}]
@@ -1022,7 +1012,7 @@ werden, werden die Schl\"usselworte \code{break} und
 \code{continue} eingesetzt (Listing \ref{breakcontinuelisting}
 zeigt, wie sie eingesetzt werden k\"onnen).
 
-\begin{lstlisting}[caption={Ensatz der \code{continue} und \code{break} Schl\"usselworte um die Ausf\"uhrung von Abschnitte in Schleife zu \"uberspringen oder abzubrechen.}, label=breakcontinuelisting]
+\begin{lstlisting}[caption={Ensatz der \code{continue} und \code{break} Schl\"usselworte um die Ausf\"uhrung von Code-Abschnitten in Schleifen zu \"uberspringen oder abzubrechen.}, label=breakcontinuelisting]
 for x = 1:10 
   if(x > 2 & x < 5)
     continue;
@@ -1051,7 +1041,7 @@ end
   die zwischen \code{tic} und \code{toc} vergangene Zeit.
 
   \begin{enumerate}
-  \item Benutze eine \code{for} Schleife um die Element auszuw\"ahlen.
+  \item Benutze eine \code{for} Schleife um die Elemente auszuw\"ahlen.
   \item Benutze logisches Indizieren.
   \end{enumerate}
 \end{exercise}
@@ -1076,7 +1066,7 @@ end
 
 Ein Programm ist eine Sammlung von Anweisungen, die in einer Datei auf
 dem Rechner abgelegt sind. Wenn es durch den Aufruf zum Leben erweckt
-wird, dann wird es Zeile f\"r Zeile von oben nach unten ausgef\"uhrt.
+wird, dann wird es Zeile f\"Ur Zeile von oben nach unten ausgef\"uhrt.
 
 \matlab{} kennt drei Arten von Programmen:
 \begin{enumerate}

programming/lectures/control_structures.tex

@@ -1,14 +0,0 @@
-\section{Kontrollstrukturen}
-
-\begin{definition}[Kontrollstrukturen]
-  In der Regel wird ein Programm Zeile f\"ur Zeile von oben nach unten
-  ausgef\"uhrt. Manchmal muss der Kontrollfluss aber so gesteuert
-  werden, dass bestimmte Teile des Programmcodes wiederholt oder nur
-  unter bestimmten Bedingungen ausgef\"uhrt werden. Von grosser
-  Bedeutung sind hier zwei Strukturen:
-  \begin{enumerate}
-    
-  \item Schleigen.
-  \item Bedingte Anweisungen und Verzweigungen.
-  \end{enumerate}
-\end{definition}

programming/lectures/variables_datatypes.tex

@@ -1,164 +0,0 @@
-\section{Variablen und Datentypen}
-
-\subsection{Variablen}
-
-Eine Variable ist ein Zeiger auf eine Stelle im Speicher (RAM). Dieser
-Zeiger hat einen Namen, den Variablennamen, und einen Datentyp
-(Abbildung \ref{variablefig}). Im Speicher wird der Wert der Variablen
-bin\"ar gespeichert. Wird auf den Wert der Variable zugegriffen, wird
-dieses Bitmuster je nach Datentyp interpretiert. Das Beispiel in
-Abbildung \ref{variablefig} zeigt, dass das gleiche Bitmuster im einen
-Fall als 8-Bit Integer Datentyp zur Zahl 38 interpretiert wird und im
-anderen Fall als Character zum kaufm\"annischen ``und'' ausgewertet
-wird. In Matlab sind Datentypen nicht von sehr zentraler
-Bedeutung. Wir werden uns dennoch sp\"ater etwas genauer mit ihnen
-befassen.
-
-\begin{figure}
-\centering
-\begin{subfigure}{.5\textwidth}
-  \includegraphics[width=0.8\textwidth]{images/variable}
-  \label{variable:a}
-\end{subfigure}%
-\begin{subfigure}{.5\textwidth}
-  \includegraphics[width=.8\textwidth]{images/variableB}
-  \label{variable:b}
-\end{subfigure}
-\caption{\textbf{Variablen.}  Variablen sind Zeiger auf eine Adresse
-  im Speicher, die einen Namen und einen Datentypen beinhalten. Im
-  Speicher ist der Wert der Variable bin\"ar gespeichert. Abh\"angig
-  vom Datentyp wird dieses Bitmuster unterschiedlich
-  interpretiert.}\label{variablefig}
-\end{figure}
-
-
-\subsection{Erzeugen von Variablen}
-In Matlab kann eine Variable auf der Kommandozeile, in einem Skript
-oder einer Funktion an beliebiger Stelle erzeugen. Das folgende
-Listing zeigt zwei M\"oglichkeiten:
-\footnotesize
-\begin{lstlisting}[label=varListing1, caption=Erzeugen von Variablen]
->> y = []
-y = 
-   []
->>
->> x = 38
-x =
-   38
-\end{lstlisting}
-\normalsize 
-
-Die Zeile 1 kann etwa so gelesen werden:''Erzeuge eine Variable mit
-dem Namen y und weise ihr einen leeren Wert zu.''  Das
-Gleichheitszeichen ist der sogenannte
-\textit{Zuweisungsoperator}. Zeile 5 definiert eine Variable x, der
-nun der Zahlenwert 38 zugewiesen wird. Da Matlab, wenn nicht anders
-angegeben immer den ``double'' Datentypen benutzt, haben beide
-Variablen diesen Datentyp.
-
-\footnotesize
-\begin{lstlisting}[label=varListing2, caption={Erfragen des Datentyps einer Variable, Listen aller definierten Variablen.}]
->>disp(class(x))
-    double
->>
->> who % oder whos um mehr Information zu bekommen
-\end{lstlisting}
-\normalsize 
-
-Bei der Namensgebung ist zu beachten, dass Matlab auf Gro{\ss}- und
-Kleinschreibung achtet und ein Variablennane mit einem alphabethischen
-Zeichen beginnen muss. Des Weiteren sind Umlaute, Sonder- und
-Leerzeichen in Variablennamen nicht erlaubt.
-
-
-\subsection{Arbeiten mit Variablen}
-
-Nat\"urlich kann mit den Variablen auch gearbeitet, bzw
-gerechnet werden. Matlab kennt alle normalen arithmetischen Operatoren wie
-\code{+, -, *. /}. Die Potenz wird \"uber das Dach Symbol \verb+^+
-dargestellt. Das folgende Listing zeigt, wie sie benutzt werden.
-
-\footnotesize
-\begin{lstlisting}[label=varListing3, caption={Rechnen mit Variablen.}]
->> x = 1;
->> x + 10
-ans = 
-  11
->>
->> x % x wurde nicht veraendert
-ans =
-  1
->>
->> y = 2;
->>
->> x + y
-ans = 
-  3
->>
->> z = x + y
-z =
-  3
->>
->> z = z * 5;
->> z 
-z = 
-  15
->>
->> clear z
-\end{lstlisting}
-\normalsize
-
-Beachtenswert ist z.B. in Zeilen 3 und 6, dass wir mit dem Inhalt
-einer Variablen rechnen k\"onnen, ohne dass dadurch ihr Wert
-ver\"andert wird. Wenn der Wert einer Variablen ver\"andert werden
-soll, dann muss dieser der Variable explizit zugewiesen werden (mit
-dem \code{=} Zuweisungsoperator, z.B. Zeilen 16, 20). Zeile 25 zeigt
-wie eine einzelne Variable gel\"oscht wird.
-
-
-\subsection{Datentypen}
-
-Der Datentyp bestimmt, wie die im Speicher abgelegten Bitmuster
-interpretiert werden. Die Wichtigsten Datentpyen sind folgende:
-
-\begin{itemize}
-\item \textit{integer} - Ganze Zahlen. Hier gibt es mehrere
-  Unterarten, die wir in Matlab (meist) ignorieren k\"onnen.
-\item \textit{double} - Flie{\ss}kommazahlen.
-\item \textit{complex} - Komplexe Zahlen.
-\item \textit{logical} - Boolesche Werte, die als wahr
-  (\textit{true}) oder falsch (\textit{false}) interpretiert werden.
-\item \textit{char} - ASCII Zeichen
-\end{itemize}
-
-Unter den numerischen Datentypen gibt es verschiedene Arten mit
-unterschiedlichem Speicherbedarf und Wertebreich.
-
-\begin{table}[]
-\centering
-\caption{Gel\"aufige Datentypen und ihr Wertebereich.}
-\label{dtypestab}
-\begin{tabular}{l|l|c|cl}
-Datentyp & Speicherbedarf & Wertebereich & Beispiel \\ \cline{1-4}
-double & 64 bit & $-2^{15} bis 2^{15}-1$ &  Flie{\ss}kommazahlen.\\ \cline{1-4}
-int & 64 bit & $-2^{31} bis 2^{31}-1$ &  Ganzzahlige Werte  \\ \cline{1-4}
-int16 & 64 bit & $-2^{15} bis 2^{15}-1$ & Digitalisierte Spannungen. \\ \cline{1-4}
-uint8 & 64 bit & 0 bis 255 & Digitalisierte Imaging Daten. \cline{1-4}
-\end{tabular}
-\end{table}
-
-
-Matlab arbeitet meist mit dem ``double'' Datentyp wenn numerische
-Daten gespeichert werden. Dennoch lohnt es sich, sich ein wenig mit
-den DAtentypen auseinanderzusetzen. Ein Szenario, dass in der
-Neurobiologie nicht selten ist, ist, dass wir die elektrische
-Aktivit\"at einer Nervenzelle messen. Die gemessenen Spannungen werden
-mittels Messkarte digitalisiert und auf dem Rechner
-gespeichert. Typischerweise k\"onnen mit solchen Messkarten Spannungen
-im Bereich $\pm 10$\,V gemessen werden. Die Aufl\"osung der Wandler
-betr\"agt typischerweise 16 bit. Das heisst, dass der gesamte
-Spannungsbereich in $2^{16}$ Schritte aufgeteilt ist. Um Speicherplatz
-zu sparen ist es sinnvoll, die gemessenen Daten als ``int16'' Werte im
-Rechner abzulegen. Die Daten als ``echte'' Spannungen, also als
-Flie{\ss}kommawerte, abzulegen w\"urde den 4-fachen Speicherplatz
-ben\"otigen.

programming/lectures/vectors_matrices.tex

@@ -1,56 +0,0 @@
-\section{Vektoren und Matrizen}
-
-\begin{definition}[Vektoren und Matrizen]
-  Vektoren und Matrizen sind die wichtigsten Datenstrukturen in
-  Matlab. In andern Programmiersprachen spricht man von ein-
-  bzw. mehrdimensionalen Feldern. Felder sind Datenstrukturen, die
-  mehrere Werte des geleichen Datentyps in einer Variablen
-  vereinen. Da Matalb seinen Ursprung in der Verarbeitung von
-  mathematischen Vektoren und Matrizen hat werden sie hier auch so
-  genannt.\\
-
-  In Wahrheit existiert auch in Matlab kein Unterschied zwischen
-  beiden Datenstrukturen. Im Hintergrund sind auch Vektoren
-  2-diemsensionale Matrizen bei denen eine Dimension die Gr\"o{\ss}e 1
-  hat.
-\end{definition}
-
-
-\subsection{Vektoren}
-
-Im Gegensatz zu den Variablen, die einzelene Werte beinhalten,
-Skalare, kann ein Vektor mehrere Werte des gleichen Datentyps
-beinhalten (Abbildung \ref{vectorfig} B). Die Variable ``test''
-enth\"alt in diesem Beispiel vier ganzzahlige Werte. 
-
-
-\begin{figure}
-  \includegraphics[width=0.8\columnwidth]{programming/lectures/images/scalarArray}
-  \caption{\textbf{Skalare und Vektoren. A)} Eine skalare Variable kann
-      genau einen Wert tragen. \textbf{B)} Ein Vektor kann mehrer
-      Werte des gleichen Datentyps (z.B. ganzzahlige Integer Werte)
-      beinhalten. Matlab kennt den Zeilen- (row-) und Spaltenvektor
-      (columnvector).}\label{vectorfig}
-\end{figure}
-
-
-\footnotesize
-\begin{lstlisting}[label=arrayListing1]
->> a = [0 1 2 3 4 5 6 7 8 9] % Erstellen eines Zeilenvektors
-   a =
-    0  1   2   3   4   5   6   7   8   9
->>
->> b = (0:9) % etwas bequemer
-   b = 
-    0  1   2   3   4   5   6   7   8   9
->>
->> c = (0:2:10)                   
-   c = 
-    0  2  4  6  8  10
-\end{lstlisting}
-\normalsize
-
-\subsection{Unterscheidung Zeilen- und Spaltenvektoren}
-
-
-\subsection{Matrizen}

regression/code/errorGradient.m

@@ -0,0 +1,31 @@
+clear
+load('lin_regression.mat')
+
+ms = -1:0.5:5;
+ns = -10:1:10;
+
+error_surf = zeros(length(ms), length(ns));
+gradient_m = zeros(size(error_surf));
+gradient_n = zeros(size(error_surf));
+
+for i = 1:length(ms)
+    for j = 1:length(ns)
+        error_surf(i,j) = lsqError([ms(i), ns(j)], x, y);
+        grad = lsqGradient([ms(i), ns(j)], x, y);
+        gradient_m(i,j) = grad(1);
+        gradient_n(i,j) = grad(2);
+    end
+end
+
+figure()
+hold on
+[N, M] = meshgrid(ns, ms);
+%surface(M,N, error_surf, 'FaceAlpha', 0.5);
+contour(M,N, error_surf, 50);
+quiver(M,N, gradient_m, gradient_n)
+xlabel('slope')
+ylabel('intercept')
+zlabel('error')
+set(gcf, 'paperunits', 'centimeters', 'papersize', [15, 12.5], ... 
+    'paperposition', [0., 0., 15, 12.5])
+saveas(gcf, 'error_gradient', 'pdf')

regression/code/errorSurface.m

@@ -0,0 +1,31 @@
+clear
+close all
+
+load('lin_regression.mat');
+
+slopes = -5:0.25:5;
+intercepts = -30:1:30;
+
+error_surf = zeros(length(slopes), length(intercepts));
+
+for i = 1:length(slopes)
+    for j = 1:length(intercepts)
+        error_surf(i,j) = lsqError([slopes(i), intercepts(j)], x, y);
+    end
+end
+
+
+% plot the error surface
+figure()
+[N,M] = meshgrid(intercepts, slopes);
+s = surface(M,N,error_surf);
+xlabel('slope', 'rotation', 7.5)
+ylabel('intercept', 'rotation', -22.5)
+zlabel('error')
+set(gca,'xtick', (-5:2.5:5))
+grid on
+view(3)
+set(gcf, 'paperunits', 'centimeters', 'papersize', [15, 15], ... 
+    'paperposition', [0., 0., 15, 15])
+
+saveas(gcf, 'error_surface', 'pdf')

regression/code/gradientDescent.m

@@ -0,0 +1,31 @@
+clear 
+close all
+load('lin_regression.mat')
+
+position = [-2. 10.];
+gradient = [];
+errors = [];
+count = 1;
+eps = 0.01;
+
+while isempty(gradient) || norm(gradient) > 0.1
+    gradient = lsqGradient(position, x,y);
+    errors(count) = lsqError(position, x, y);
+    position = position - eps .* gradient; 
+    count = count + 1;
+end
+figure()
+subplot(2,1,1)
+hold on
+scatter(x,y, 'displayname', 'data')
+xaxis = min(x):0.01:max(x);
+f_x = position(1).*xaxis + position(2);
+plot(xaxis, f_x, 'displayname', 'fit')
+xlabel('Input')
+ylabel('Output')
+grid on
+legend show
+subplot(2,1,2)
+plot(errors)
+xlabel('optimization steps')
+ylabel('error')

regression/code/gradientDescentPlot.m

@@ -0,0 +1,43 @@
+clear 
+close all
+
+load('lin_regression.mat')
+
+ms = -1:0.5:5;
+ns = -10:1:10;
+
+position = [-2. 10.];
+gradient = [];
+error = [];
+eps = 0.01;
+
+% claculate error surface
+error_surf = zeros(length(ms), length(ns));
+for i = 1:length(ms)
+    for j = 1:length(ns)
+        error_surf(i,j) = lsqError([ms(i), ns(j)], x, y);
+    end
+end
+figure()
+hold on
+[N, M] = meshgrid(ns, ms);
+surface(M,N, error_surf, 'FaceAlpha', 0.5);
+view(3)
+xlabel('slope')
+ylabel('intersection')
+zlabel('error')
+
+% do the descent
+
+while isempty(gradient) || norm(gradient) > 0.1
+    gradient = lsqGradient(position, x,y);
+    error = lsqError(position, x, y);
+    plot3(position(1), position(2), error, '.', 'color', 'red', 'markersize', 20)
+    position = position - eps .* gradient; 
+    pause(0.05)
+end
+
+grid on
+set(gcf, 'paperunits', 'centimeters', 'papersize', [15, 15], ... 
+    'paperposition', [0., 0., 15, 15])
+saveas(gcf, 'gradient_descent', 'pdf')

regression/code/lsqError.m

@@ -0,0 +1,11 @@
+function error = lsqError(parameter, x, y)
+% Objective function for fitting a linear equation to data.
+%
+% Arguments: parameter, vector containing slope and intercept (1st and 2nd element) 
+%            x, the input values
+%            y, the measured system output
+%
+% Retruns: the estimation error in terms of the mean sqaure error
+
+y_est = x .* parameter(1) + parameter(2);
+error = meanSquareError(y, y_est);

regression/code/lsqGradient.m

@@ -0,0 +1,7 @@
+function gradient = lsqGradient(parameter, x, y)
+h = 1e-6;
+
+partial_m = (lsqError([parameter(1)+h, parameter(2)],x,y) - lsqError(parameter,x,y))/ h;
+partial_n = (lsqError([parameter(1), parameter(2)+h],x,y) - lsqError(parameter,x,y))/ h;
+
+gradient = [partial_m, partial_n];

regression/code/lsq_error.m

@@ -1,6 +0,0 @@
-function error = lsq_error(parameter, x, y)
-% parameter(1) is the slope
-% parameter(2) is the intercept
-
-f_x = x .* parameter(1) + parameter(2);
-error = mean((f_x - y).^2);

regression/code/lsq_gradient.m

@@ -1,7 +0,0 @@
-function gradient = lsq_gradient(parameter, x, y)
-h = 1e-6;
-
-partial_m = (lsq_error([parameter(1)+h, parameter(2)],x,y) - lsq_error(parameter,x,y))/ h;
-partial_n = (lsq_error([parameter(1), parameter(2)+h],x,y) - lsq_error(parameter,x,y))/ h;
-
-gradient = [partial_m, partial_n];

regression/code/meanSquareError.m

@@ -0,0 +1,9 @@
+function error = meanSquareError(y, y_est)
+% Function calculates the mean sqauare error between observed and predicted values.
+%
+% Agruments:    y, the observed values
+%               y_est, the predicted values.
+%
+% Returns:      the error in the mean-square-deviation sense.
+
+error = mean((y - y_est).^2);

regression/lecture/regression-slides.tex

@@ -222,7 +222,7 @@
     \end{column}
     \begin{column}{7cm}
       \begin{enumerate}
-      \item Die am h\"aufigstern Angewandte Methode ist die der
+      \item Die am h\"aufigsten angewandte Methode ist die der
         kleinsten quadratischen Abweichungen.
       \item Es wird versucht die Summe der quadratischen Abweichung zu
         minimieren.

regression/lecture/regression.tex

@@ -1,3 +1,256 @@
 \chapter{\tr{Optimization and Gradient Descent}{Optimierung und Gradientenabstiegsverfahren}}
 
+Ein sehr \"ubliches Problem ist, dass die Abh\"angigkeit von
+Messwerten von einem Input Parameter durch ein Modell erkl\"art werden
+soll. Die Frage ist, wie man die beste Parametrisierung des Modells
+findet. Den Prozess der Prarmeteranpassung nennt man auch Optimierung
+oder English Fitting. Betrachtet man zum Beispiel die Punktewolke in
+Abbildung \ref{linregressiondatafig} liegt es nahe einen
+(verrauschten) linearen Zusammenhang zwischen Einganggr\"{\ss}e
+(Input) und Systemantwort (output) zu postulieren.
 
+\begin{figure}
+  \includegraphics[width=0.45\columnwidth]{lin_regress.pdf}
+  \caption{\textbf{Blick auf die Rohdaten.} F\"ur eine Reihe von
+    Eingangswerten, z.B. Stimulusintensit\"aten wurden die Antworten
+    eines Systems gemessen.}\label{linregressiondatafig}
+\end{figure}
+
+Wir nehmen an, dass die lineare Geradengleichung ein guten Modell
+f\"ur das zugrundeliegende System ist.
+\[f_{m,n}(x) = m\cdot x + n \] 
+
+wobei $x$ die Eingangswerte, $f_{m,n}(x)$ die Systemantwort, $m$ die Steigung
+und $n$ der y-Achsenabschnitt darstellen (Abbildung
+\ref{linregressionslopeintersectfig}). In dieser Gleichung gibt es nur zwei Parameter
+und es wird die Kombination von Steigung ($m$) und y-Achsenabschnitt
+($n$) gesucht, die die Systemantwort am besten vorhersagen.
+
+\begin{figure}
+  \begin{minipage}[t]{0.45\columnwidth}
+    \includegraphics[width=\textwidth]{figures/lin_regress_slope.pdf}
+  \end{minipage}
+  \begin{minipage}[t]{0.45\columnwidth}
+    \includegraphics[width=\textwidth]{figures/lin_regress_abscissa.pdf}
+  \end{minipage}
+  \caption{\textbf{Ver\"anderungen der Parameter und ihre Folgen.} Die
+    linke Abbildung zeigt den Effekt einer Ver\"anderung der Steigung
+    w\"ahrend die reche Abbildung die Ver\"anderung des
+    y-Achsenabschnittes
+    illustriert. }\label{linregressionslopeintersectfig}
+\end{figure}
+
+Wie wird nun die optimale Kombination aus Steigung und y-Achsenabschnitt gefunden? 
+
+\section{Methode der kleinsten Quadratischen Abweichung}
+
+Um die optimale Parameterkombination zu finden muss zun\"achst ein
+Ma{\ss} f\"ur den Unterschied zwischen den tats\"achlich gemessenen
+und den unter Verwendung eines Parametersatzes vorhergesagten Werten
+definiert werden. Eine der am h\"aufigsten verwendeten
+Fehlersch\"atzungen ist der \emph{mittlere qaudratische Abstand} (im
+Englischen auch mean square error genannt, Abbildung \ref{leastsquareerrorfig}).
+
+\[ e = \frac{1}{N}\sum^{N}_{1=1} \left( y_i - y^{est}_i)\right )^2\]
+
+wobei $e$ der Fehler, $N$ die Anzahl gemessener Datenpunkte $y_i$ die
+Messwerte und $y^{est}_i$ die Vorhersagewerte an den enstprechenden
+Stellen sind.
+
+\begin{figure}
+  \includegraphics[width=0.5\columnwidth]{figures/linear_least_squares.pdf}
+  \caption{\textbf{Ermittlung des Mittleren quadratischen Abstands.}
+    Der Abstand zwischen der Vorhersage und dem Modell wird f\"ur
+    jeden gemessenen Datenpunkt ermittelt. Die Differenz zwischen
+    Messwert und Vorhersage wird quadriert, was zum einen das
+    Vorzeichen einer Abweichung entfernt und zum anderen gro{\ss}e
+    Abweichungen \"uberproportional st\"arker bestraft als
+    kleine. Quelle:
+    \url{http://en.wikipedia.org/wiki/Linear_least_squares_(mathematics)}} \label{leastsquareerrorfig}
+\end{figure}
+      
+\begin{exercise}{meanSquareError.m}{}\label{mseexercise}
+  Schreibt eine Funktion, die die mittlere quardatische Abweichung
+  zwischen den beobachteten Werten $y$ und der Vorhersage $y_{est}$
+  berechnet.
+\end{exercise}
+
+\section{Zielfunktion --- Objective function}
+
+Schliesst man in die Fehlerfunktion von oben (\"Ubung
+\ref{mseexercise}) die Vorhersage des Modells mit ein spricht man von
+der Zielfunktion oder Englisch ``objective function'':
+
+\[e(m,n) = \frac{1}{N}\sum^{N}_{1=1} \left( y_i - f_{m,
+    n}(x_i)\right )^2\] 
+
+Das Ziel der Parameteranpassung ist es, den Fehler zu minimieren, die
+Passung zu optimieren.
+
+\begin{exercise}{lsqError.m}{}
+  Implementiere die Zielfunktion (\code{lsqError}) f\"ur die
+  Optimierung mit der linearen Geradengleichung.
+  \begin{itemize}
+  \item Die Funktion \"ubernimmt drei Argumente: das erste ist ein
+    2-elementiger Vektor, der die Parameter \code{m} und \code{n}
+    enth\"alt. Der zweite sind die x-Werte, an denen gemessen wurde
+    und der dritte die zugeh\"origen y-Werte.
+  \item Die Funktion gibt den Fehler zur\"uck.
+  \end{itemize}
+\end{exercise}
+ 
+
+\section{Fehlerfl\"ache}
+
+Die beiden Parameter $m$ und $n$ spanngen eine F\"ache auf. F\"ur jede
+Kombination aus $m$ und $n$ erhalten wir Vorhersagewerte, die von den
+gemessenen Werten abweichen werden. Es gibt also f\"ur jeden Punkt in
+der sogenannten \emph{Fehlerfl\"ache} einen Fehler. In diesem Beispiel
+eines 2-dimensionalen Problems (zwei freie Parameter) kann man die
+Fehlerfl\"ache graphisch durch einen 3-d ``surface-plot''
+darstellen. Wobei auf der x- und y-Achse die beiden Parameter und auf
+der z-Achse der Fehlerwert aufgetragen wird (Abbildung
+\ref{errorsurfacefig}).
+
+\clearpage
+\begin{figure}
+  \includegraphics[width=0.75\columnwidth]{figures/error_surface.pdf}
+  \caption{\textbf{Fehlerfl\"ache.} Die beiden freien Parameter
+    unseres Modells spannen die Grundfl\"ache des Plots auf. F\"ur
+    jede Kombination von Steigung und y-Achsenabschnitt wird die
+    errechnete Vorhersage des Modells mit den Messwerten verglichen
+    und der Fehlerwert geplottet.}\label{errorsurfacefig}
+\end{figure}
+
+Die Fehlerfl\"ache zeigt uns nun an bei welcher Parameterkombination
+der Fehler minimal, beziehungsweise die Parametertrisierung optimal an
+die Daten angepasst ist. Wie kann die Fehlerfunktion und die durch sie
+definierte Fehlerfl\"ache nun benutzt werden um den
+Optimierungsprozess zu leiten? 
+
+
+\begin{exercise}{errorSurface.m}{}\label{errorsurfaceexercise}
+  Ladet den Datensatz \textit{lin\_regression.mat} in den
+  Workspace. und schreibt ein Skript \code{errorSurface.m} dass den
+  Fehler in Abh\"angigkeit von \code{m} und \code{n} als surface plot
+  darstellt (siehe Hilfe f\"ur die \code{surf} Funktion).
+\end{exercise}
+
+
+\section{Gradient}
+
+Man kann sich den Optimierungsprozess veranschaulichen wenn man sich
+vorstellt, dass eine Parameterkombination einen Punkt auf der
+Fehlerfl\"ache definiert. Wenn von diesem Punkt aus eine Kugel
+losgelassen w\"urde, dann w\"urde sie, dem steilsten Gef\"alle
+folgend, zum Minimum der Fehlerfl\"ache rollen und dort zum Stehen
+kommen. Um dem Computer zu sagen, in welche Richtung die Position
+ver\"andert werden soll muss also die Steigung an der aktellen
+Position berechnet werden.
+
+Die Steigung einer Funktion an einer Stelle ist die Ableitung der
+Funktion an dieser Stelle, die durch den Differenzquotienten f\"ur
+unendlich kleine Schritte bestimmt wird.
+
+\[f'(x) = \lim\limits_{h \rightarrow 0} \frac{f(x + h) - f(x)}{h} \]
+Bei unserem Fittingproblem h\"angt die Fehlerfunktion von zwei
+Parametern ab und wir bestimmen die Steigung partiell f\"ur jeden
+Parameter einzeln. Die Partielle Ableitung nach \code{m} sieht so aus:
+\[\frac{\partial g(m,n)}{\partial m} = \lim\limits_{h \rightarrow 0} \frac{g(m + h, n) - g(m,n)}{h}\]
+Da wir die Ver\"anderung des Fehlers in Abh\"angigkeit der beiden
+Parameter bewerten ist der Gradient an der Stelle $(m,n)$ ein
+zweielementigen Vektor der aus den partiellen Ableitungen nach $m$ und
+nach $n$ besteht. Die Richtung des Gradienten zeigt die Richtung der
+gr\"o{\ss}ten Steigung an, seine L\"ange repr\"asentiert die St\"arke
+des Gef\"alles.
+
+\[\bigtriangledown g(m,n) = \left( \frac{\partial g(m,n)}{\partial m}, \frac{\partial g(m,n)}{\partial n}\right)\]
+Die partiellen Ableitungen m\"ussen nicht analytisch berechnet werden
+sondern wir n\"ahern sie numerisch durch einen sehr kleinen Schritt
+an.
+\[\frac{\partial g(m,n)}{\partial m} = \lim\limits_{h \rightarrow
+  0} \frac{g(m + h, n) - g(m,n)}{h} \approx \frac{g(m + h, n) -
+  g(m,n)}{h}\]
+
+Die graphische Dargestellung der Gradienten (Abbildung
+\ref{gradientquiverfig}) zeigt, dass diese in die Richtung der
+gr\"o{\ss}ten Steigung zeigen. Um zum Minimum der Fehlerfunktion zu
+gelangen sollte man also die entgegengesetzte Richtung einschlagen.
+
+\begin{figure}
+  \includegraphics[width=0.75\columnwidth]{figures/error_gradient}
+  \caption{\textbf{Darstellung der Gradienten f\"ur jede
+      Parameterkombination.} Jeder Pfeil zeigt die Richtung und die
+    Steigung f\"ur verschiedene Parameterkombination aus Steigung und
+    y-Achsenabschnitt an. Die Kontourlinien im Hintergrund
+    illustrieren die Fehlerfl\"ache. Warme Farben stehen f\"ur
+    gro{\ss}e Fehlerwerte, kalte Farben f\"ur kleine. Jede
+    Kontourlinie steht f\"ur eine Linie gleichen
+    Fehlers.}\label{gradientquiverfig}
+\end{figure}
+
+\begin{exercise}{lsqGradient.m}{}\label{gradientexercise}
+  Implementiert eine Funktion \code{lsqGradient}, die den aktuellen
+  Parametersatz als 2-elementigen Vektor, die x-Werte und die y-Werte
+  als Argumente entgegennimmt und den Gradienten zur\"uckgibt.
+\end{exercise}
+
+\begin{exercise}{errorGradient.m}{}
+  Benutzt die Funktion aus verheriger \"Ubung (\ref{gradientexercise})
+  um f\"ur die jede Parameterkombination aus der Fehlerfl\"ache
+  (\"Ubung \ref{errorsurfaceexercise}) auch den Gradienten zu
+  berechnen und darzustellen. Vektoren im Raum kann man mithilfe der
+  Funktion \code{quiver} geplottet werden.
+\end{exercise}
+
+\section{Der Gradientenabstieg}
+
+Zu guter Letzt muss ``nur'' noch der Gradientenabstieg implementiert
+werden. Die daf\"ur ben\"otigten Zutaten sollten wir aus den
+vorangegangenen \"Ubungen haben. Wir brauchen: 1. Die Fehlerfunktion
+(\code{meanSquareError.m}), 2. die Zielfunktion (\code{lsqError.m})
+und 3. den Gradienten (\code{lsqGradient.m}).  Der Algorithmus
+f\"ur den Abstieg lautet:
+\begin{enumerate}
+\item Starte mit einer beliebigen Parameterkombination $p_0 = (m_0,
+  n_0)$.
+\item Wiederhole die folgenden Schritte solange, wie die der Gradient \"uber einer bestimmten
+  Schwelle ist (Es kann z.B. die L\"ange des Gradienten \code{norm(gradient) > 0.1}
+  benutzt werden):
+  \begin{itemize}
+  \item Berechne den Gradienten an der akutellen Position $p_t$.
+  \item Gehe einen kleinen Schritt ($\epsilon = 0.01$) in die entgegensetzte Richtung des
+    Gradienten:
+    \[p_{t+1} = p_t - \epsilon \cdot \bigtriangledown g(m_t, n_t)\]
+  \end{itemize}
+\end{enumerate}
+
+
+Abbildung \ref{gradientdescentfig} zeigt den Verlauf des
+Gradientenabstiegs. Von einer Startposition aus wird die Position
+solange ver\"andert, wie der Gradint eine bestimmte Gr\"o{\ss}e
+\"uberschreitet. An den Stellen, an denen der Gradient sehr stark ist
+ist auch die Ver\"anderung der Position gro{\ss} und der Abstand der
+Punkte in Abbildung \ref{gradientdescentfig} gro{\ss}.
+
+\begin{figure}[hb]
+  \includegraphics[width=0.6\columnwidth]{figures/gradient_descent}
+  \caption{\textbf{Gradientenabstieg.} Es wird von einer beliebigen
+    Position aus gestartet und der Gradient berechnet und die Position
+    ver\"andert. Jeder Punkt zeigt die Position nach jedem
+    Optimierungsschritt an.} \label{gradientdescentfig}
+\end{figure}
+
+\clearpage
+\begin{exercise}{gradientDescent.m}{}
+  Implementiere den Gradientenabstieg f\"ur das Problem der
+  Parameteranpassung der linearen Geradengleichung an die Messdaten in
+  der Datei \code{lin\_regression.mat}.
+  \begin{enumerate}
+  \item Merke Dir f\"ur jeden Schritt den Fehler zwischen
+    Modellvorhersage und Daten.
+  \item Erstelle eine Plot, der die Entwicklung des Fehlers als
+    Funktion der Optimierungsschritte zeigt.
+  \item Erstelle einen Plot, der den besten Fit in die Daten plottet.
+  \end{enumerate}
+\end{exercise}

scientificcomputing-script.tex

@@ -18,22 +18,15 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \part{Grundlagen des Programmierens}
 
-\graphicspath{{programming/lectures/}{programming/lectures/images/}}
+\graphicspath{{programming/lecture/}{programming/lecture/images/}}
 \lstset{inputpath=programming/code}
-\include{programming/lectures/programming}
+\include{programming/lecture/programming}
 
 
 \graphicspath{{plotting/lecture/}{plotting/lecture/images/}}
 \lstset{inputpath=plotting/code/}
 \include{plotting/lecture/plotting}
 
-\graphicspath{{designpattern/lecture/}{designpattern/lecture/figures/}}
-\lstset{inputpath=designpattern/code}
-\include{designpattern/lecture/designpattern}
-
-\chapter{Cheat-Sheet}
-
-
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \part{Grundlagen der Datenanalyse}
 
@@ -58,4 +51,13 @@
 \renewcommand{\texinputpath}{pointprocesses/lecture/}
 \include{pointprocesses/lecture/pointprocesses}
 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\part{Appendix: }
+
+\graphicspath{{designpattern/lecture/}{designpattern/lecture/figures/}}
+\lstset{inputpath=designpattern/code}
+\include{designpattern/lecture/designpattern}
+
+\chapter{Cheat-Sheet}
+
 \end{document}