Fixed half of the regression chapter.

header.tex

@@ -171,7 +171,7 @@
 \newcommand{\enterm}[1]{``#1''}
 \newcommand{\determ}[1]{\textit{#1}}
 \newcommand{\codeterm}[1]{\textit{#1}}
-\newcommand{\filename}[1]{\texttt{#1}}
+\newcommand{\file}[1]{\texttt{#1}}
 
 %%%%% code/matlab commands: %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \usepackage{textcomp}

likelihood/lecture/likelihood.tex

@@ -2,6 +2,7 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{\tr{Maximum likelihood estimation}{Maximum-Likelihood-Sch\"atzer}}
+\label{maximumlikelihoodchapter}
 
 In vielen Situationen wollen wir einen oder mehrere Parameter $\theta$
 einer Wahrscheinlichkeitsverteilung sch\"atzen, so dass die Verteilung

regression/code/errorSurface.m

@@ -3,16 +3,17 @@ close all
 
 load('lin_regression.mat');
 
+% compute mean squared error for a range of sloopes and intercepts:
 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);
+        error_surf(i,j) = lsqError(x, y, [slopes(i), intercepts(j)]);
     end
 end
 
-% plot the error surface
+% plot the error surface:
 figure()
 [N,M] = meshgrid(intercepts, slopes);
 s = surface(M,N,error_surf);

regression/code/lsqError.m

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

regression/code/meanSquareError.m

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

regression/lecture/error_surface.py

@@ -0,0 +1,58 @@
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.pyplot as plt
+import matplotlib.cm as cm
+import numpy as np
+
+def create_data():
+    m = 0.75
+    n=  -40
+    x = np.arange(10.,110., 2.5)
+    y = m * x + n;
+    rng = np.random.RandomState(37281)
+    noise = rng.randn(len(x))*15
+    y += noise
+    return x, y, m, n
+    
+
+def plot_error_plane(ax, x, y, m, n):
+    ax.set_xlabel('Slope m')
+    ax.set_ylabel('Intercept b')
+    ax.set_zlabel('Mean squared error')
+    ax.set_xlim(-4.5, 5.0)
+    ax.set_ylim(-60.0, -20.0)
+    ax.set_zlim(0.0, 700.0)
+    ax.set_xticks(np.arange(-4, 5, 2))
+    ax.set_yticks(np.arange(-60, -19, 10))
+    ax.set_zticks(np.arange(0, 700, 200))
+    ax.grid(True)
+    ax.w_xaxis.set_pane_color((1.0, 1.0, 1.0, 1.0))
+    ax.w_yaxis.set_pane_color((1.0, 1.0, 1.0, 1.0))
+    ax.w_zaxis.set_pane_color((1.0, 1.0, 1.0, 1.0))
+    ax.invert_xaxis()
+    ax.view_init(25, 40)
+    slopes = np.linspace(-4.5, 5, 40)
+    intercepts = np.linspace(-60, -20, 40)
+    x, y = np.meshgrid(slopes, intercepts)
+    error_surf = np.zeros(x.shape)
+    for i, s in enumerate(slopes) :
+        for j, b in enumerate(intercepts) :
+                error_surf[j,i] = np.mean((y-s*x-b)**2.0)
+    ax.plot_surface(x, y, error_surf, rstride=1, cstride=1, cmap=cm.coolwarm,
+                    linewidth=0, shade=True)
+    # Minimum:
+    mini = np.unravel_index(np.argmin(error_surf), error_surf.shape)
+    #ax.scatter([m], [n], [0.0], color='#cc0000')
+    ax.scatter(slopes[mini[1]], intercepts[mini[0]], [0.0], color='#cc0000')
+
+
+if __name__ == "__main__":
+    x, y, m, n = create_data()
+    plt.xkcd()
+    fig = plt.figure()
+    ax = fig.add_subplot(1, 1, 1, projection='3d')
+    plot_error_plane(ax, x, y, m, n)
+    #fig.set_facecolor("white")
+    fig.set_size_inches(7., 5.)
+    fig.tight_layout()
+    fig.savefig("error_surface.pdf")
+    plt.close()

regression/lecture/lin_regress.py

@@ -1,6 +1,5 @@
 import matplotlib.pyplot as plt
 import numpy as np
-from matplotlib.transforms import Bbox
 
 def create_data():
     m = 0.75
@@ -33,7 +32,7 @@ def plot_data_slopes(ax, x, y, m, n):
     ax.scatter(x, y, marker='o', color='b', s=40)
     xx = np.asarray([2, 118])
     for i in np.linspace(0.3*m, 2.0*m, 5):
-        ax.plot(xx, i*xx+n, color="r", lw=2)
+        ax.plot(xx, i*xx+n, color='#CC0000', lw=2)
     ax.spines["right"].set_visible(False)
     ax.spines["top"].set_visible(False)
     ax.yaxis.set_ticks_position('left')
@@ -52,7 +51,7 @@ def plot_data_intercepts(ax, x, y, m, n):
     ax.scatter(x, y, marker='o', color='b', s=40)
     xx = np.asarray([2, 118])
     for i in np.linspace(n-1*n, n+1*n, 5):
-        ax.plot(xx, m*xx + i, color="r", lw=2)
+        ax.plot(xx, m*xx + i, color='#CC0000', lw=2)
     ax.spines["right"].set_visible(False)
     ax.spines["top"].set_visible(False)
     ax.yaxis.set_ticks_position('left')

regression/lecture/linear_least_squares.py

@@ -0,0 +1,81 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+def create_data():
+    m = 0.75
+    n=  -40
+    x = np.concatenate( (np.arange(10.,110., 2.5), np.arange(0.,120., 2.0)) )
+    y = m * x + n;
+    rng = np.random.RandomState(37281)
+    noise = rng.randn(len(x))*15
+    y += noise
+    return x, y, m, n
+
+    
+def plot_data(ax, x, y, m, n):
+    ax.spines["right"].set_visible(False)
+    ax.spines["top"].set_visible(False)
+    ax.yaxis.set_ticks_position('left')
+    ax.xaxis.set_ticks_position('bottom')
+    ax.tick_params(direction="out", width=1.25)
+    ax.tick_params(direction="out", width=1.25)
+    ax.set_xlabel('Input x')
+    ax.set_ylabel('Output y')
+    ax.set_xlim(0, 120)
+    ax.set_ylim(-80, 80)
+    ax.set_xticks(np.arange(0,121, 40))
+    ax.set_yticks(np.arange(-80,81, 40))
+    ax.annotate('Error',
+                xy=(x[34]+1, y[34]+15), xycoords='data',
+                xytext=(80, -50), textcoords='data', ha='left',
+                arrowprops=dict(arrowstyle="->", relpos=(0.9,1.0),
+                connectionstyle="angle3,angleA=50,angleB=-30") )
+    ax.scatter(x[:40], y[:40], color='b', s=10, zorder=0)
+    inxs = [3, 13, 16, 19, 25, 34, 36]
+    ax.scatter(x[inxs], y[inxs], color='b', s=40, zorder=10)
+    xx = np.asarray([2, 118])
+    ax.plot(xx, m*xx+n, color='#CC0000', lw=2)
+    for i in inxs :
+        xx = [x[i], x[i]]
+        yy = [m*x[i]+n, y[i]]
+        ax.plot(xx, yy, color='#FF9900', lw=2, zorder=5)
+    
+
+def plot_error_hist(ax, x, y, m, n):
+    ax.spines["right"].set_visible(False)
+    ax.spines["top"].set_visible(False)
+    ax.yaxis.set_ticks_position('left')
+    ax.xaxis.set_ticks_position('bottom')
+    ax.tick_params(direction="out", width=1.25)
+    ax.tick_params(direction="out", width=1.25)
+    ax.set_xlabel('Squared error')
+    ax.set_ylabel('Frequency')
+    bins = np.arange(0.0, 602.0, 50.0)
+    ax.set_xlim(bins[0], bins[-1])
+    ax.set_ylim(0, 35)
+    ax.set_xticks(np.arange(bins[0], bins[-1], 100))
+    ax.set_yticks(np.arange(0, 36, 10))
+    errors = (y-(m*x+n))**2.0
+    mls = np.mean(errors)
+    ax.annotate('Mean\nsquared\nerror',
+                xy=(mls, 0.5), xycoords='data',
+                xytext=(350, 20), textcoords='data', ha='left',
+                arrowprops=dict(arrowstyle="->", relpos=(0.0,0.2),
+                connectionstyle="angle3,angleA=10,angleB=90") )
+    ax.hist(errors, bins, color='#FF9900')
+
+
+
+if __name__ == "__main__":
+    x, y, m, n = create_data()
+    plt.xkcd()
+    fig = plt.figure()
+    ax = fig.add_subplot(1, 2, 1)
+    plot_data(ax, x, y, m, n)
+    ax = fig.add_subplot(1, 2, 2)
+    plot_error_hist(ax, x, y, m, n)
+    fig.set_facecolor("white")
+    fig.set_size_inches(7., 2.6)
+    fig.tight_layout()
+    fig.savefig("linear_least_squares.pdf")
+    plt.close()

regression/lecture/regression.tex

@@ -1,4 +1,4 @@
-\chapter{\tr{Optimization and Gradient Descent}{Optimierung und Gradientenabstiegsverfahren}}
+\chapter{\tr{Optimization and Gradient Descent}{Optimierung und Gradientenabstieg}}
 
 Ein sehr h\"aufiges Problem ist, dass die Abh\"angigkeit von
 Messwerten von einer Eingangsgr\"o{\ss}e durch ein Modell erkl\"art
@@ -6,10 +6,10 @@ werden soll. Das Modell enth\"alt \"ublicherweise einen oder mehrere
 Parameter, die den Zusammenhang modifizieren. Wie soll die beste
 Parameterisierung des Modells gefunden werden, so dass das Modell die
 Daten am besten beschreibt? Dieser Prozess der Parameteranpassung ist
-ein Optimierungsproblem, der besser als Kurvenfit bekannt ist
+ein Optimierungsproblem, der als Kurvenfit bekannt ist
 (\enterm{curve fitting}).
 
-\begin{figure}[tp]
+\begin{figure}[t]
   \includegraphics[width=1\textwidth]{lin_regress}\hfill
   \titlecaption{.}{F\"ur eine Reihe von Eingangswerten $x$,
     z.B. Stimulusintensit\"aten, wurden die Antworten $y$ eines
@@ -19,114 +19,188 @@ ein Optimierungsproblem, der besser als Kurvenfit bekannt ist
 \end{figure}
 
 Die Punktewolke in \figref{linregressiondatafig} legt
-zum Beispiel nahe einen (verrauschten) linearen Zusammenhang zwischen
+zum Beispiel nahe, einen (verrauschten) linearen Zusammenhang zwischen
 der Eingangsgr\"o{\ss}e $x$ (\enterm{input}) und der Systemantwort
 $y$ (\enterm{output}) zu postulieren.
 Wir nehmen also an, dass die Geradengleichung 
-\[y = f_{m,n}(x) = m\cdot x + n \] ein gutes Modell f\"ur das
+\[y = f(x; m, b) = m\cdot x + b \] 
-zugrundeliegende System sein k\"onnte (Abbildung
+ein gutes Modell f\"ur das zugrundeliegende System sein k\"onnte
-\ref{linregressiondatafig}).  Die Geradengleichung hat die
+(Abbildung \ref{linregressiondatafig}).  Die Geradengleichung hat die
-beiden Parameter Steigung $m$ und $y$-Achsenabschnitt $n$ und es wird
+beiden Parameter Steigung $m$ und $y$-Achsenabschnitt $b$ und es wird
-die Kombination von $m$ und $n$ gesucht, die die Systemantwort am
+die Kombination von $m$ und $b$ gesucht, die die Systemantwort am
 besten vorhersagt.
 
 In folgenden Kapitel werden wir anhand dieses Beispiels zeigen, welche
 Methoden hinter einem Kurvenfit stecken, wie also numerisch die
-optimale Kombination aus Steigung und $y$-Achsenabschnitt gefunden
+optimale Kombination aus Steigung und $y$-Achsen\-abschnitt gefunden
 werden kann.
 
 
-\section{Methode der kleinsten quadratischen Abweichung}
+\section{Mittlere quadratischen Abweichung}
-
+
-Um die optimale Parameterkombination zu finden, muss zun\"achst ein
+Zuerst m\"u{\ss}en wir pr\"azisieren, was wir unter optimalen
-Ma{\ss} f\"ur den Unterschied zwischen den tats\"achlich gemessenen
+Parametern verstehen. Es sollen die Werte der Parameter der
-und den unter Verwendung eines Parametersatzes vorhergesagten Werten
+Geradengleichung sein, so dass die entsprechende Gerade am besten die
-definiert werden. Eine der am h\"aufigsten verwendeten
+Daten beschreibt.  Was meinen wir damit? Jeder $y$-Wert der $N$
-Fehlersch\"atzungen ist der \emph{mittlere qaudratische Abstand}
+Datenpaare wird einen Abstand $y_i - y^{est}_i$ zu den durch das
-(``mean square error'', Abbildung \ref{leastsquareerrorfig})
+Modell vorhergesagten Werten $y^{est}_i$ (\enterm{estimate}) an den
-\[ e = \frac{1}{N}\sum^{N}_{1=1} \left( y_i - y^{est}_i\right)^2 \; ,\]
+entsprechenden $x$-Werten haben. In unserem Beispiel mit der
-wobei $e$ der Fehler, $N$ die Anzahl gemessener Datenpunkte $y_i$ die
+Geradengleichung ist die Modellvorhersage $y^{est}_i=f(x_i;m,b)$
-Messwerte und $y^{est}_i$ die Vorhersagewerte an den enstprechenden
+gegeben durch die Geradengleichung
-Stellen sind.
+(\figref{leastsquareerrorfig}). F\"ur den besten Fit sollten dieser
-
+Abst\"ande m\"oglichst klein sein.
-\begin{figure}[tp]
+
-  \includegraphics[width=0.5\columnwidth]{linear_least_squares}
+Wir k\"onnten z.B. fordern, die Summe $\sum_{i=1}^N y_i - y^{est}_i$
-  \caption{\textbf{Ermittlung des Mittleren quadratischen Abstands.}
+m\"oglichst klein zu machen. Das funktioniert aber nicht, da diese
-    Der Abstand zwischen der Vorhersage und dem Modell wird f\"ur
+Summe auch dann klein wird, wenn die H\"alfte der $y$-Daten weit
-    jeden gemessenen Datenpunkt ermittelt. Die Differenz zwischen
+oberhalb der Geraden und die andere H\"alfte weit darunter liegt, da
-    Messwert und Vorhersage wird quadriert, was zum einen das
+sich diese positiven und negativen Werte gegenseitig zu Zahlen nahe
-    Vorzeichen einer Abweichung entfernt und zum anderen gro{\ss}e
+Null aufsummieren. Besser w\"are es auf jeden Fall, die Summe des
-    Abweichungen \"uberproportional st\"arker bestraft als
+Betrags der Abst\"ande $\sum_{i=1}^N |y_i - y^{est}_i|$ zu betrachten. Ein
-    kleine. Quelle:
+kleiner Wert der Summe kann dann nur erreicht werden, wenn die
-    \url{http://en.wikipedia.org/wiki/Linear_least_squares_(mathematics)}} \label{leastsquareerrorfig}
+Abst\"ande der Datenpunkte von der Kurve tats\"achlich klein sind,
-\end{figure}
+unabh\"angig ob sie \"uber oder unter der Gerade liegen. Statt der
+Summe k\"onnen wir genauso gut fordern, dass der \emph{mittlere} Abstand
+\begin{equation}
+  \label{meanabserror}
+  e(\{(x_i, y_i)\}|\{y^{est}_i\}) = \frac{1}{N} \sum_{i=1}^N |y_i - y^{est}_i|
+\end{equation}
+der Menge der $N$ Datenpaare $(x_i, y_i)$ gegeben die Modellvorhersagen
+$y_i^{est}$ klein sein soll.
+
+Am h\"aufigsten wird jedoch bei einem Kurvenfit der \determ{mittlere
+  quadratische Abstand} (\enterm{mean squared distance} oder
+\enterm{mean squared error})
+\begin{equation}
+  \label{meansquarederror}
+  e(\{(x_i, y_i)\}|\{y^{est}_i\}) = \frac{1}{N} \sum_{i=1}^N (y_i - y^{est}_i)^2
+\end{equation}
+verwendet (\figref{leastsquareerrorfig}). Wie beim Betrag sind die
+quadratischen Abst\"ande immer positiv, unabh\"angig ob die Datenwerte
+\"uber oder unter der Kurve liegen. Durch das Quadrat werden
+zus\"atzlich gro{\ss}e Abst\"ande st\"arker gewichtet.
       
-\begin{exercise}{meanSquareError.m}{}\label{mseexercise}
+\begin{exercise}{meanSquareError.m}{}\label{mseexercise}%
-  Schreibt eine Funktion, die die mittlere quardatische Abweichung
+  Schreibe eine Funktion \code{meanSquareError}, die die mittlere
-  zwischen den beobachteten Werten $y$ und der Vorhersage $y_{est}$
+  quadratische Abweichung zwischen einem Vektor mit den beobachteten
-  berechnet.
+  Werten $y$ und einem Vektor mit den entsprechenden Vorhersagen
+  $y^{est}$ berechnet.\newpage
 \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,
+\section{Zielfunktion}
-    n}(x_i)\right )^2\] 
+
+$e(\{(x_i, y_i)\}|\{y^{est}_i\})$ ist eine sogenannte
+\determ{Zielfunktion}, oder \determ{Kostenfunktion} (\enterm{objective
+  function}, \enterm{cost function}), da wir die Modellvorhersage so
+anpassen wollen, dass der mittlere quadratische Abstand, also die
+Zielfunktion, minimiert wird. In
+Kapitel~\ref{maximumlikelihoodchapter} werden wir sehen, dass die
+Minimierung des mittleren quadratischen Abstands \"aquivalent zur
+Maximierung der Wahrscheinlichkeit ist, dass die Daten aus der
+Modellfunktion stammen, unter der Vorraussetzung, dass die Daten
+um die Modellfunktion normalverteilt streuen.
+
+\begin{figure}[t]
+  \includegraphics[width=1\textwidth]{linear_least_squares}
+  \titlecaption{Ermittlung des mittleren quadratischen Abstands.}
+  {Der Abstand (\enterm{error}, orange) zwischen der Vorhersage (rote
+    Gerade) und den Messdaten (blaue Punkte) wird f\"ur jeden
+    gemessenen Datenpunkt ermittelt (links). Anschlie{\ss}end werden
+    die Differenzen zwischen Messwerten und Vorhersage quadriert
+    (\enterm{squared error}) und der Mittelwert berechnet (rechts).}
+  \label{leastsquareerrorfig}
+\end{figure}
 
-Das Ziel der Parameteranpassung ist es, den Fehler zu minimieren, die
+Die Kostenfunktion mu{\ss} nicht immer der mittlere quadratische
-Passung zu optimieren.
+Abstand sein. Je nach Problemstellung kann die Kostenfunktion eine
+beliebige Funktion sein, die die Parameter eines Modells auf einen
+Wert abbildet, der in irgendeiner Weise die Qualit\"at des Modells
+quantifiziert. Ziel ist es dann, diejenigen Parameterwerte zu finden,
+bei der die Kostenfunktion --- oder eben ``Zielfunktion'' ---
+minimiert wird.
+%%% Einfaches verbales Beispiel?
+
+Wenn wir nun in unsere Gleichung \eqref{meansquarederror} f\"ur die
+Modellvorhersage $y^{est}$ die Geradengleichung einsetzen, erhalten wir
+f\"ur die Zielfunktion
+\begin{eqnarray}
+  e(\{(x_i, y_i)\}|m,b) & = & \frac{1}{N} \sum_{i=1}^N (y_i - f(x_i;m,b)^2 \label{msefunc} \\
+  & = & \frac{1}{N} \sum_{i=1}^N (y_i - m x_i - b)^2 \label{mseline}
+\end{eqnarray}
+den mittleren quadratischen Abstand der Datenpaare $(x_i, y_i)$
+gegeben die Parameterwerte $m$ und $b$ der Geradengleichung. Ziel des
+Kurvenfits ist es, die Werte f\"ur $m$ und $b$ so zu optimieren, dass
+der Fehler \eqnref{mseline} minimal wird.
 
 \begin{exercise}{lsqError.m}{}
-  Implementiere die Zielfunktion (\code{lsqError}) f\"ur die
+  Implementiere die Zielfunktion f\"ur die Optimierung mit der
-  Optimierung mit der linearen Geradengleichung.
+  linearen Geradengleichung als Funktion \code{lsqError}.
   \begin{itemize}
-  \item Die Funktion \"ubernimmt drei Argumente: das erste ist ein
+  \item Die Funktion \"ubernimmt drei Argumente: Das erste ist ein
-    2-elementiger Vektor, der die Parameter \code{m} und \code{n}
+    Vektor mit den $x$-Werten, an denen gemessen wurde, und das zweite
-    enth\"alt. Der zweite sind die x-Werte, an denen gemessen wurde
+    ein Vektor mit den zugeh\"origen $y$-Werten.  Das dritte Argument
-    und der dritte die zugeh\"origen y-Werte.
+    ist ein 2-elementiger Vektor, der die Parameter \code{m} und
-  \item Die Funktion gibt den Fehler zur\"uck.
+    \code{b} enth\"alt.
+  \item Die Funktion gibt als Ergebniss den Fehler als mittleren
+    quadratischen Abstand \eqnref{mseline} zur\"uck.
+  \item Die Funktion soll die Funktion \code{meanSquareError} der
+    vorherigen \"Ubung benutzen.
   \end{itemize}
 \end{exercise}
- 
+
 
 \section{Fehlerfl\"ache}
 
-Die beiden Parameter $m$ und $n$ spannen eine F\"ache auf. F\"ur jede
+Die beiden Parameter $m$ und $b$ der Geradengleichung spannen eine
-Kombination aus $m$ und $n$ erhalten wir Vorhersagewerte, die von den
+F\"ache auf. F\"ur jede Kombination aus $m$ und $b$ k\"onnen wir den
-gemessenen Werten abweichen werden. Es gibt also f\"ur jeden Punkt in
+Wert der Zielfunktion, hier der mittlere quadratische Abstand
-der sogenannten \emph{Fehlerfl\"ache} einen Fehler. In diesem Beispiel
+\eqnref{meansquarederror}, berechnen.  Es gibt also f\"ur jeden Punkt
-eines 2-dimensionalen Problems (zwei freie Parameter) kann die
+in der sogenannten \emph{Fehlerfl\"ache} einen Fehler. In diesem
-Fehlerfl\"ache graphisch durch einen 3-d ``surface-plot'' dargestellt
+Beispiel eines 2-dimensionalen Problems (zwei freie Parameter) kann
-werden. Dabei werden auf der $x$- und der $y$-Achse die beiden
+die Fehlerfl\"ache graphisch durch einen 3-d ``surface-plot''
-Parameter und auf der $z$-Achse der Fehlerwert aufgetragen
+dargestellt werden. Dabei werden auf der $x$- und der $y$-Achse die
+beiden Parameter und auf der $z$-Achse der Fehlerwert aufgetragen
 (\figref{errorsurfacefig}).
 
-\clearpage
+\begin{figure}[t]
-\begin{figure}
+  \includegraphics[width=0.75\columnwidth]{error_surface.pdf}
-  \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
+    unseres Modells $m$ und $b$ spannen die Grundfl\"ache des Plots
-    jede Kombination von Steigung und y-Achsenabschnitt wird die
+    auf. F\"ur jede Kombination von Steigung $m$ und
-    errechnete Vorhersage des Modells mit den Messwerten verglichen
+    $y$-Achsenabschnitt $b$ wird die errechnete Vorhersage des Modells
-    und der Fehlerwert geplottet.}\label{errorsurfacefig}
+    mit den Messwerten verglichen und der Fehlerwert geplottet. Die
+    sich ergebende Fehlerfl\"ache hat ein Minimum (roter Punkt) bei
+    den Werten von $m$ und $b$, f\"ur die die Gerade die Daten am
+    besten beschreibt.}\label{errorsurfacefig}
 \end{figure}
 
-Die Fehlerfl\"ache zeigt an, bei welcher Parameterkombination
+\begin{exercise}{errorSurface.m}{}\label{errorsurfaceexercise}%
-der Fehler minimal, beziehungsweise die Parameterisierung optimal an
+  Lade den Datensatz \textit{lin\_regression.mat} in den Workspace (20
-die Daten angepasst ist. Wie kann die Fehlerfunktion und die durch sie
+  Datenpaare in den Vektoren \code{x} und \code{y}). Schreibe ein Skript
-definierte Fehlerfl\"ache nun benutzt werden, um den
+  \file{errorSurface.m}, dass den Fehler, berechnet als mittleren
-Optimierungsprozess zu leiten? 
+  quadratischen Abstand zwischen den Daten und einer Geraden mit
-
+  Steigung $m$ und $y$-Achsenabschnitt $b$, in Abh\"angigkeit von $m$
-\begin{exercise}{errorSurface.m}{}\label{errorsurfaceexercise}
+  und $b$ als surface plot darstellt (siehe Hilfe f\"ur die
-  Ladet den Datensatz \textit{lin\_regression.mat} in den
+  \code{surf} Funktion).
-  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}
 
+An der Fehlerfl\"ache kann direkt erkannt werden, bei welcher
+Parameterkombination der Fehler minimal, beziehungsweise die
+Parameterisierung 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?
+
+Die naheliegenste Variante ist, von der Fehlerfl\"ache einfach den Ort
+des globalen Minimums zu bestimmen. Das ist im Allgemeinen jedoch zu
+rechenintensiv, da f\"ur jede m\"ogliche Kombination der Parameter der
+Fehler berechnet werden muss. Die Anzahl der n\"otigen Berechnungen
+steigt exponentiell mit der Anzahl der Parameter (``Fluch der
+Dimension''). Auch eine bessere Genauigkeit, mit der das Minimum
+bestimmt werden soll erh\"oht die Anzahl der n\"otigen
+Berechnungen. Wir suchen also ein Verfahren, dass das Minimum der
+Kostenfunktion mit m\"oglichst wenigen Berechnungen findet.
+
 
 \section{Gradient}
 
@@ -193,7 +267,7 @@ gelangen sollte man also die entgegengesetzte Richtung einschlagen.
   Funktion \code{quiver} geplottet werden.
 \end{exercise}
 
-\section{Der Gradientenabstieg}
+\section{Gradientenabstieg}
 
 Zu guter Letzt muss ``nur'' noch der Gradientenabstieg implementiert
 werden. Die daf\"ur ben\"otigten Zutaten sollten wir aus den
@@ -232,7 +306,6 @@ Punkte in Abbildung \ref{gradientdescentfig} gro{\ss}.
     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