Fixed half of the regression chapter.
This commit is contained in:
parent
ed361930fa
commit
a0e4d306f1
@ -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}
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
58
regression/lecture/error_surface.py
Normal file
58
regression/lecture/error_surface.py
Normal file
@ -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()
|
||||
Binary file not shown.
@ -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')
|
||||
|
||||
81
regression/lecture/linear_least_squares.py
Normal file
81
regression/lecture/linear_least_squares.py
Normal file
@ -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()
|
||||
@ -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
|
||||
|
||||
Reference in New Issue
Block a user