Mehrdimensionale lineare Regression/Gradientenabstieg und Fehlerfunktion

Einführung

In dieser Lerneinheit wird das gezeigt, wie man das Gradientenabstiegsverfahren auf die Fehlerfunktion von Daten anwenden kann. Daher benötigt man als Lernvoraussetzung allgemein eine affines Problem in ein lineares tranformieren kann und bei der Zerlegung in Komponentenfunktionen im Kern ein Optimierungsverfahren für Abbildungen $f_{a}:\mathbb {R} ^{n}\to \mathbb {R}$ mit einem gesuchten $a\in \mathbb {R} ^{n}$ verwandeln kann. An dieser geht es um die Anwendung des Gradientenabstiegs auf die Fehlerfunktion von $f_{a}$ .

Lernvoraussetzungen

Daten und Abbildungen - (Foliensatz)
- Affine Abbildung in R
- Rechenbeispiel
Transformation - affin zu linear
Zerlegung einer linearen Abbildung in Komponentenfunktionen
Regression für Komponentenfunktion - exakte Lösung und Approximation
Gradient - lineares Funktional - (Foliensatz)

Gradientenabstiegsverfahren und Fehlerfunktion

Ziel des Optimierungsproblems ist es, den Fehler bei mehrdimensionalen linearen Regression zu minimieren. In dem folgende Abschnitt wird das über das Gradientenabstiegsverfahren umgesetzt.

Bemerkung - Aggregation der absoluten Fehler über alle Daten

Bei der Berechnung des Gesamtfehlers über alle Daten macht es Sinn, dass man nicht die absoluten Fehler aufsummiert (da diese mit einem Vorzeichen) versehen sind, sondern Werte als Abweichung von den Daten aufsummiert, die nicht negativ sind. Der Betrag des absoluten Fehlers ist allerdings das Gradientenabstiegsverfahren ungeeignet, da die Betragsfunktion nicht differzierbar ist. Daher verwendet man für die Minimierung Fehlerquadrate.

Partielle Ableitungen des quadratischen Fehlers 1

Für ein lineares Funktional $f_{a}:\mathbb {R} ^{n}\to \mathbb {R}$ und einem einzelnen Datenpunkt $(x,y)=(x_{1},\ldots ,x_{n},y)\in \mathbb {R} ^{n+1}$ kann man mit $f_{a}(x)=\langle a,x\rangle$ ergibt sich der quadratische Fehler wie folgt:

e_{_{LR1}}(a,x,y)^{2}=(f_{a}(x)-y)^{2}=(\langle a,x\rangle -y)^{2}

Partielle Ableitungen des quadratischen Fehlers 2

Für den Gradienten $\operatorname {Grad} _{a}(e_{_{LR}}^{2})$ bzgl. der unbekannten Koeffizienten aus $a=(a_{1},\ldots ,a_{n})\in \mathbb {R} ^{n}$ benötigt man die partiellen Ableitungen ${\frac {\partial e_{_{LR1}}^{2}}{\partial a_{k}}}(a,x,y)$ der Fehlerquadrate. Mit der Kettenregel ergibt sich für diese partielle Ableitung mit $k\in \{1,\ldots ,n\}$ wie folgt:

{\frac {\partial e_{_{LR}}^{2}}{\partial a_{k}}}(a,x,y)=2\cdot (f_{a}(x)-y)\cdot x_{k}

wobei $x_{k}$ die innere Ableitung von $\langle a,x\rangle -y=\left(\sum _{i=1}^{n}a_{i}\cdot x_{i}\right)-y$ nach $a_{k}$ ist.

Gradient des quadratischen Fehlers 1

Der Gradient $\operatorname {Grad} _{a}(e^{2})$ des quadratischen Fehlers ergibt sich aus den partiellen Ableitungen bzgl. der Argumente $a=(a_{1},\ldots ,a_{n})$ . Die weiteren Argumente $x$ und $y$ des quadratischen Fehlers $e^{2}$ werden durch die Trainingsdaten belegt. Da die Definition des Gradienten i.d.R. auf alle Argumente der Funktion bezieht, wird hier in der Definition $\operatorname {Grad} _{a}(e^{2})$ statt $\operatorname {Grad} (e^{2})$ verwendet.

Gradient des quadratischen Fehlers 2

Der Gradient $\operatorname {Grad} _{a}(e^{2})$ des quadratischen Fehlers für einen einzelnen Datenpunkt $(x,y)=(x_{1},\ldots ,x_{n},y)\in \mathbb {R} ^{n+1}$ ergibt sich damit wie folgt.

{\begin{array}{rcl}\operatorname {Grad} _{a}(e^{2})(a,x,y)&=&\left({\frac {\partial e^{2}}{\partial a_{1}}}(a,x,y),\ldots ,{\frac {\partial e^{2}}{\partial a_{n}}}(a,x,y)\right)\\&=&\left(2\cdot (f_{a}(x)-y)\cdot x_{1},\ldots ,2\cdot (f_{a}(x)-y)\cdot x_{k}\right)\\&=&2\cdot (f_{a}(x)-y)\cdot \left(x_{1},\ldots ,x_{k}\right)\\&=&2\cdot (f_{a}(x)-y)\cdot x\\\end{array}}

CAS4Wiki - Partielle Ableitungen

Mit CAS4Wiki können Sie die obigen Ableitung berechnen, siehe z.B. partielle Ableitungen

Beispiel

Für folgenden Vektor $a\in \mathbb {R} ^{3}$ definiert man eine Abbildung $f_{a}:\mathbb {R} ^{3}\to \mathbb {R}$ :

a={\begin{pmatrix}1\\3\\7\end{pmatrix}},\quad x={\begin{pmatrix}x_{1}\\x_{2}\\x_{3}\\\end{pmatrix}}

Es ergibt sich daher die folgende lineare Funktion:

{\begin{array}{rcl}f_{a}(x)&=&\langle a,x\rangle =1\cdot x_{1}+3\cdot x_{2}+7\cdot x_{3}\end{array}}

Bemerkung - Komponentenfunktionen

Die hier betrachteten linearen Funktionen $f_{a}:\mathbb {R} ^{3}\to \mathbb {R}$ entstehen aus einer linearen Abbildung $f(x):=A\cdot x$ durch Zerlegung in Komponentenfunktionen.

Daten

Demo Daten
$x_{1}$	$x_{2}$	$x_{3}$	$y$
1	2	3	16.1
2	3	1	22.3
7	0	4	25.9
7	6	5	56.6

Vektoren in R

Die Vektoren werden in GNU R wie folgt definiert:

x1 <- c(1,2,7,7) 
x2 <- c(2,3,0,6)
x3 <- c(3,1,4,5)
y <- c(16.1,22.2,25.9,56.6)

Daten in Dataframe speichern

Aus den obigen Daten erzeugt man $x_{\mathbb {D} }$ und $y_{\mathbb {D} }$ als Dataframes und ein Dataframe $daten$ zum Speichern.

## x Vektoren aus dem IR^3
x_D  <- data.frame(x1,x2,x3)
## y Vektoren aus dem IR^1
y_D  <- data.frame(y)

## Dataframe (x1,x2,x3,y)
daten <- data.frame(x1,x2,x3,y)

## Daten in Datei schreiben
write.csv(daten, "daten3x1.csv", row.names = FALSE)

Gradient des Fehlers

Für $x:=(1,2,3)$ und $y=16.1$ ist der Gradient des quadratischen Fehlers mit $a:=(3,5,1)$

{\begin{array}{rcl}\operatorname {Grad} _{a}(e^{2})(a,x,y)&=&2\cdot (f_{a}(x)-y)\cdot x=2\cdot (\langle a,x\rangle -y)\cdot x\\&=&2\cdot \left(\left\langle {\begin{pmatrix}3\\5\\1\end{pmatrix}},{\begin{pmatrix}1\\2\\3\end{pmatrix}}\right\rangle -16.1\right)\cdot {\begin{pmatrix}1\\2\\3\end{pmatrix}}\\&=&2\cdot (16-16.1)\cdot x={\begin{pmatrix}-0.2\\-0.4\\-0.6\end{pmatrix}}\\\end{array}}

Berechnung des Gradienten in R

## x ist erste Zeile aus x_D im IR^3
a <- c(3,5,1)
x <- x_D[1, ] ## erste Zeile der x-Daten x=(1,2,3)
y <- y_D[1, ] ## erste Zeile der y-Daten y=16.1

### Gradient des Einzelfehlers berechnen
grad4fehler <- 2*(sum(a*x)-y) * x

Gesamtfehler des mehrdimensionalen Regression

Für die Berechnung des Gesamtfehlers der muss man die quadratischen Fehler über alle Datenpunkte aggregrien. Die Daten $\mathbb {D}$ für die mehrdimensionale lineare Regression bestehen aus Datenpunkten der Form $(x^{(i)},y^{(i)})\in \mathbb {R} ^{n}\times \mathbb {R} ^{m}$ :

\mathbb {D} :=\left\{(x^{(i)},y^{(i)})\in \mathbb {R} ^{n}\times \mathbb {R} ^{m}\ \colon \ i\in \{1,\ldots ,d\}\right\}

Wertebereich - eindimensional

Im Folgenden verwendet man Daten mit einen eindimensionalen Wertebereich und einer linearen Funktion $f_{a}:\mathbb {R} ^{n}\to \mathbb {R}$ . Daher liegen die Daten in folgender Form vor.

\mathbb {D} :=\left\{(x^{(i)},y^{(i)})\in \mathbb {R} ^{n}\times \mathbb {R} \ \colon \ i\in \{1,\ldots ,d\}\right\}

Berechnung des Gesamtfehlers

Für die Berechnung des Gesamtfehlers $E_{LR}(a,\mathbb {D} )$ werden die quadratischen Fehler für einzelne Datenpunkte $(x^{(i)},y^{(i)})\in \mathbb {D}$ aufsummiert mit $x_{\mathbb {D} }:=(x^{(1)},\ldots ,x^{(d)})$ und $y_{\mathbb {D} }:=(y^{(1)},\ldots ,y^{(d)})$ .

{\begin{array}{rcl}E_{LR}(a,x_{\mathbb {D} },y_{\mathbb {D} })&:=&\displaystyle \sum _{i=1}^{d}e(a,x^{(i)},y^{(i)})^{2}\\&=&\displaystyle \sum _{i=1}^{d}\left(\langle a,x^{(i)}\rangle -y^{(i)}\right)^{2}\\\end{array}}

Datenbeispiel

Mehrdimensionale lineare Regression soll als Optimierungsproblem für folgende lineare Abbildung $f_{a}$ mit $a=(a_{1},a_{2},a_{3})\in \mathbb {R} ^{3}$ und $x=(x_{1},x_{2},x_{3})\in \mathbb {R} ^{3}$ durchgeführt werden.

f_{a}(x)=\langle a,x\rangle =\sum _{k=1}^{3}a_{k}\cdot x_{k}

Daten in R in einer CSV-Tabelle

Mit der obigen Dimension von Definitionsbereich und Wertebereich der lineare Abbildung $f_{a}:\mathbb {R} ^{3}\to \mathbb {R}$ haben die tabellarischen Trainingdaten die folgenden Gestalt in einer Datei multilinreg1.csv^[1]

"x1" , "x2" , "x3" , "y"
1  , 2  , 3  , 16.05071 
2  , 3  , 1  , 22.06779 
7  , 0  , 4  , 24.96846
7  , 6  , 5  , 56.06086

Bemerkung - Fehler beim Laden der CSV

Achten Sie bei den Dateien darauf, dass die hinter der letzten Zeile der Daten noch ein "Return/Neue Zeile" steht, da sonst der letzte Datensatz in der CSV-Datei als unvollständig angesehen wird.

Laden der Daten in R aus einer CSV-Tabelle

Speichen Sie zunächst die obige Beispieldatei multlinreg1.csv^[1] in Ihr Verzeichnis mit dem KnitR-Dokument. Das Laden von Dateien in R und KnitR kann bzgl. der obigen Beispieldatei^[1] wie folgt geschehen:

  data <- read.csv("multlinreg1.csv", header=TRUE, stringsAsFactors=FALSE)

Selektieren der Daten für x- und y-Werte

Eine Tabelle enthält ggf. mehr Spalten als die elementare oben genannte Demodatei multlinreg1.csv^[1]. Daher muss man zunächst in R die relevanten Datenspalten für die x- und y-Werte der linearen Regression selektieren.

  data <- read.csv("multlinreg1.csv", header=TRUE, stringsAsFactors=FALSE)
  ## Spalten extrahieren für x_D
  x1 <- data[,1]
  x2 <- data[,2]
  x3 <- data[,3]
  ## Spalten extrahieren für y_D
  y1 <- data[,4] 
  ## Dataframes für die Fehlerfunktion
  x_D <- data.frame(x1,x2,x3)
  y_D <- data.frame(y1)

Implementation die quadratische Fehlerfunktion

Für die Implementation des Gesamtfehlers $E(a,x_{\mathbb {D} },y_{\mathbb {D} })$ in R verwendet man die geladenen Daten in data. Die Datenpunkte $(x^{(i)},y^{(i)})\in \mathbb {D}$ liegen als Zeilen in der CSV-Datei vor.

  E_LR <- function (pa,px_D,py_D) {
    ## px_D : Dataframe - Liste von x-Vektoren   
    ## py_D : Dataframe - Liste von y-Werten
    ## pa : darstellender Vektor von f_a
    
    ## Fehler pro Datenpunkt 
    datenanzahl <- nrow(px_D)
    e_D <- rep(0,datenanzahl)
    ## Fehler für alle Datenpunkte berechnen 
    for (i in 1:datenanzahl) {
      ## quadratische Einfehler mit Funktion e 
      e_D[i] <- (sum(pa*px_D[i, ]) - py_D[i, ])^2
    } 
    ## Rückgabewert als aufsummierte Einzelfehler setzen
    return <-  sum(e_D) ## datenanzahl
    ## Rückgabewert: return  Gesamtfehler quadratisch
    return
  }

Bemerkung - Implementation Fehlerfunktion

Die obige Funktion $E$ in R berechnet die nachstehende Summe mit einer for-Schleife über die quadratischen Einzelfehler.

{\begin{array}{rcl}E_{_{LR}}(a,x_{\mathbb {D} },y_{\mathbb {D} })&:=&\displaystyle \sum _{i=1}^{d}\underbrace {\left(\underbrace {\langle a,x^{(i)}\rangle } _{\mathtt {sum(a\ast x_{D}[i])}}-y^{(i)}\right)^{2}} _{\mathtt {=e_{_{D}}[i]}}\\\end{array}}

Auswertung der quadratischen Gesamtfehlers

Bezogen auf die Beispieldaten^[1] in $\mathbb {D}$ kann nun den Fehler für unterschiedliche darstellende Vektoren $a\in \mathbb {R} ^{3}$ berechnen.

  a <- c(2,3,2)
  E_LR(a,x_D,y_D) ## Ergebnis 260.6786

  a <- c(3,5,2)
  E_LR(a,x_D,y_D) ## Ergebnis 50.21575

Die zweite Setzung des darstellenden Vektors $a$ für die Funktion $f_{a}(x)=\langle a,x\rangle$ hat damit einen kleineren Fehler.

Nächste Lerneinheit

Fehlerminimierung und Lernrate

Quellennachweise

↑ ^a ^b ^c ^d ^e Bert Niehaus (2024) GitHub-Repository KnitR for Education https://github.com/niebert/knitr4education für eine Wikiversity-Lernressource - Datei: multilinreg1.csv

Siehe auch

[multlinreg1-1] Bert Niehaus (2024) GitHub-Repository KnitR for Education https://github.com/niebert/knitr4education für eine Wikiversity-Lernressource - Datei: multilinreg1.csv

[1]