diff --git a/header.tex b/header.tex
index b014897..6d15f95 100644
--- a/header.tex
+++ b/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}
diff --git a/likelihood/lecture/likelihood.tex b/likelihood/lecture/likelihood.tex
index d5a746c..4620e20 100644
--- a/likelihood/lecture/likelihood.tex
+++ b/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
diff --git a/regression/code/errorSurface.m b/regression/code/errorSurface.m
index 40d225f..636569f 100644
--- a/regression/code/errorSurface.m
+++ b/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);
diff --git a/regression/code/lsqError.m b/regression/code/lsqError.m
index b701b35..3ba0974 100644
--- a/regression/code/lsqError.m
+++ b/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) 
-%            x, the input values
-%            y, the measured system output
+% Arguments: x, the input values
+%            y, the corresponding measured output values
+%            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
diff --git a/regression/code/meanSquareError.m b/regression/code/meanSquareError.m
index ebb4bc0..253d31a 100644
--- a/regression/code/meanSquareError.m
+++ b/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
-%               y_est, the predicted values.
+% Arguments:    y, vector of observed 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
diff --git a/regression/lecture/error_surface.py b/regression/lecture/error_surface.py
new file mode 100644
index 0000000..124f13d
--- /dev/null
+++ b/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()
diff --git a/regression/lecture/figures/linear_least_squares.pdf b/regression/lecture/figures/linear_least_squares.pdf
deleted file mode 100644
index 11d1e64..0000000
Binary files a/regression/lecture/figures/linear_least_squares.pdf and /dev/null differ
diff --git a/regression/lecture/lin_regress.py b/regression/lecture/lin_regress.py
index 7a1adc1..c50a732 100644
--- a/regression/lecture/lin_regress.py
+++ b/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')
diff --git a/regression/lecture/linear_least_squares.py b/regression/lecture/linear_least_squares.py
new file mode 100644
index 0000000..1a73991
--- /dev/null
+++ b/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()
diff --git a/regression/lecture/regression.tex b/regression/lecture/regression.tex
index de73701..f0ac5d8 100644
--- a/regression/lecture/regression.tex
+++ b/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
-zugrundeliegende System sein k\"onnte (Abbildung
-\ref{linregressiondatafig}).  Die Geradengleichung hat die
-beiden Parameter Steigung $m$ und $y$-Achsenabschnitt $n$ und es wird
-die Kombination von $m$ und $n$ gesucht, die die Systemantwort am
+\[y = f(x; m, b) = m\cdot x + b \] 
+ein gutes Modell f\"ur das zugrundeliegende System sein k\"onnte
+(Abbildung \ref{linregressiondatafig}).  Die Geradengleichung hat die
+beiden Parameter Steigung $m$ und $y$-Achsenabschnitt $b$ und es wird
+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}
-
-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}
-(``mean square error'', 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}[tp]
-  \includegraphics[width=0.5\columnwidth]{linear_least_squares}
-  \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}
+\section{Mittlere quadratischen Abweichung}
+
+Zuerst m\"u{\ss}en wir pr\"azisieren, was wir unter optimalen
+Parametern verstehen. Es sollen die Werte der Parameter der
+Geradengleichung sein, so dass die entsprechende Gerade am besten die
+Daten beschreibt.  Was meinen wir damit? Jeder $y$-Wert der $N$
+Datenpaare wird einen Abstand $y_i - y^{est}_i$ zu den durch das
+Modell vorhergesagten Werten $y^{est}_i$ (\enterm{estimate}) an den
+entsprechenden $x$-Werten haben. In unserem Beispiel mit der
+Geradengleichung ist die Modellvorhersage $y^{est}_i=f(x_i;m,b)$
+gegeben durch die Geradengleichung
+(\figref{leastsquareerrorfig}). F\"ur den besten Fit sollten dieser
+Abst\"ande m\"oglichst klein sein.
+
+Wir k\"onnten z.B. fordern, die Summe $\sum_{i=1}^N y_i - y^{est}_i$
+m\"oglichst klein zu machen. Das funktioniert aber nicht, da diese
+Summe auch dann klein wird, wenn die H\"alfte der $y$-Daten weit
+oberhalb der Geraden und die andere H\"alfte weit darunter liegt, da
+sich diese positiven und negativen Werte gegenseitig zu Zahlen nahe
+Null aufsummieren. Besser w\"are es auf jeden Fall, die Summe des
+Betrags der Abst\"ande $\sum_{i=1}^N |y_i - y^{est}_i|$ zu betrachten. Ein
+kleiner Wert der Summe kann dann nur erreicht werden, wenn die
+Abst\"ande der Datenpunkte von der Kurve tats\"achlich klein sind,
+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}
-  Schreibt eine Funktion, die die mittlere quardatische Abweichung
-  zwischen den beobachteten Werten $y$ und der Vorhersage $y_{est}$
-  berechnet.
+\begin{exercise}{meanSquareError.m}{}\label{mseexercise}%
+  Schreibe eine Funktion \code{meanSquareError}, die die mittlere
+  quadratische Abweichung zwischen einem Vektor mit den beobachteten
+  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,
-    n}(x_i)\right )^2\] 
+\section{Zielfunktion}
+
+$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
-Passung zu optimieren.
+Die Kostenfunktion mu{\ss} nicht immer der mittlere quadratische
+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
-  Optimierung mit der linearen Geradengleichung.
+  Implementiere die Zielfunktion f\"ur die Optimierung mit der
+  linearen Geradengleichung als Funktion \code{lsqError}.
   \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.
+  \item Die Funktion \"ubernimmt drei Argumente: Das erste ist ein
+    Vektor mit den $x$-Werten, an denen gemessen wurde, und das zweite
+    ein Vektor mit den zugeh\"origen $y$-Werten.  Das dritte Argument
+    ist ein 2-elementiger Vektor, der die Parameter \code{m} und
+    \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
-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 die
-Fehlerfl\"ache graphisch durch einen 3-d ``surface-plot'' dargestellt
-werden. Dabei werden auf der $x$- und der $y$-Achse die beiden
-Parameter und auf der $z$-Achse der Fehlerwert aufgetragen
+Die beiden Parameter $m$ und $b$ der Geradengleichung spannen eine
+F\"ache auf. F\"ur jede Kombination aus $m$ und $b$ k\"onnen wir den
+Wert der Zielfunktion, hier der mittlere quadratische Abstand
+\eqnref{meansquarederror}, berechnen.  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
+die Fehlerfl\"ache graphisch durch einen 3-d ``surface-plot''
+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}
-  \includegraphics[width=0.75\columnwidth]{figures/error_surface.pdf}
+\begin{figure}[t]
+  \includegraphics[width=0.75\columnwidth]{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}
+    unseres Modells $m$ und $b$ spannen die Grundfl\"ache des Plots
+    auf. F\"ur jede Kombination von Steigung $m$ und
+    $y$-Achsenabschnitt $b$ wird die errechnete Vorhersage des Modells
+    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
-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? 
-
-\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).
+\begin{exercise}{errorSurface.m}{}\label{errorsurfaceexercise}%
+  Lade den Datensatz \textit{lin\_regression.mat} in den Workspace (20
+  Datenpaare in den Vektoren \code{x} und \code{y}). Schreibe ein Skript
+  \file{errorSurface.m}, dass den Fehler, berechnet als mittleren
+  quadratischen Abstand zwischen den Daten und einer Geraden mit
+  Steigung $m$ und $y$-Achsenabschnitt $b$, in Abh\"angigkeit von $m$
+  und $b$ 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