Mehrdimensionale lineare Regression/Komponentenfunktionen

Einleitung

Diese Seite zum Thema Mehrdimensionale lineare Regression/Komponentenfunktionen kann als Wiki2Reveal Folien angezeigt werden. Einzelne Abschnitte werden als Folien betrachtet und Änderungen an den Folien wirken sich sofort auf den Inhalt der Folien aus. Dabei werden die folgenden Teilaspekte im Detail behandelt:

(1 Zerlegung einer linearen Funktion $f(x)=A\cdot x$ in lineare Komponentenfunktionen $f_{a}(x)=\langle a,x\rangle$
(2) Durchführung der linearen Regression für die Komponentenfunktion.
(3) Nutzung der Regression bzgl. der Komponentenfunktion $f_{a}(x)=\langle a,x\rangle$ für die Funktion $f(x)=A\cdot x$ mit darstellender $m\times n$ -Matrix $A$ .

Zielsetzung

Diese Lernressource zu den Komponentenfunktionen eine mehrdimensionalen lineare Abbildung hat das Ziel, die lineare Regression einer mehrdimensionalen Funktion $f(x)=A\cdot x$ auf eine einfachere lineare Regression der Komponentenfunktionen $f_{(}x)=\langle a,x\rangle$ als Skalarprodukt zu vereinfachen und dann diese lineare Regression mit einem eindimensionalen Wertebereich durchzuführen.

Lernvoraussetzungen

Die Lernressource zum Thema Mehrdimensionale lineare Regression/Komponentenfunktionen hat die folgenden Lernvoraussetzungen, die zum Verständnis der nachfolgenden Ausführungen hilfreich bzw. notwendig sind.

Grundkenntnisse über lineare Abbildungen und Gradient des Fehlers eines linearen Funktionals
Grundkenntnisse über die Implementation von Funktionen in GNU R.

Ziel der linearen Regression - Dimension 1

Ist der Wertebereich der linearen Abbildung eindimensional ist $f_{a}(x)=\langle a,x\rangle \in \mathbb {R}$ und Daten $\mathbb {D} :=\{(x^{(1)},y^{(1)}),\ldots ,(x^{(m)},y^{(m)})\}$ sucht man einen geeigneten Vektor $a\in \mathbb {R} ^{n}$ , sodass der absolute aggregierte quadratische Fehler $E_{_{LR}}(a,x_{\mathbb {D} },y_{\mathbb {D} })$ über alle Daten aus $\mathbb {D}$ möglichst klein wird.

E_{_{LR}}(a,x_{\mathbb {D} },y_{\mathbb {D} }):=\sum _{k=1}^{d}\|f_{a}(x^{(k)})-y^{(k)}\|^{2}{\mbox{ minimal}}

Fehler für Datenpunkte

Für einen 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$ jeweils den Fehler wie folgt angeben:

f_{a}(x)-y=\langle a,x\rangle -y

Definition der Fehlerfunktion

Nun kann man die Fehlerfunktion $e_{_{LR}}$ der linearen Regression mit eindimensionalen Wertebereich definieren:

{\begin{array}{rrcl}e_{_{LR}}:&\mathbb {R} ^{n}\times \mathbb {R} ^{n}\times \mathbb {R} &\rightarrow &\mathbb {R} \\&\left(a,x,y\right)&\mapsto &e_{_{LR}}\left(a,x,y\right)=\langle a,x\rangle -y\end{array}}

Implemenation der Fehlerfunktion in R

In der folgenden Implementation bezeichnet p immer Variablen, die als Parameter der Funktion übergeben.

   e_LR <- function (px,pa,py) {
    ## pa : Vektor - n-dimensional a
    ## px : Vektor - n-dimensional x
    ## py : Zahl - Messwert y
    return <-  sum(pa * px) - py 
    ## Rückgabewert: Fehler für (pa,px,py) 
    return
  }

Aufruf der Fehlerfunktion in R

Mit der obigen Definition steht nun die Funktion zur Verfügung und man kann den Fehler für gegebene Vektoren $a,x\in \mathbb {R} ^{n}$ und dem Messwert $y\in \mathbb {R}$ berechnen.

  ## Aufruf der Funktion für den Vektor x
  a <- c(1,3,4)
  x <- c(4,2,1)
  sum(a*x) ## Ergebnis <a,x> = 14
  y <- 14.4
  e_LR(a,x,y) ## Ergebnis -0,4

Quadratische Fehler für Datenpunkte

Der quadratische Fehler ergibt aus dem Quadrat der euklidischen Länge (Norm) des Fehlervektors $e$ mit

\|e\|^{2}:=\|f(x)-y\|^{2}=\left\|{\begin{pmatrix}-1\\1\end{pmatrix}}\right\|^{2}=(-1)^{2}+1^{2}=2

Dabei ist die euklidische Norm wie folgt definiert:

\|y\|:=\left\|{\begin{pmatrix}y_{1}\\\vdots \\y_{m}\end{pmatrix}}\right\|={\sqrt {\sum _{k=0}^{m}y_{k}^{2}}}

Implementation - Quadratischer Fehler in R

Die Norm ist in R bereits definiert und kann wie folgt berechnet werden.

e <- c(3, 4) ## Fehlervektor mit zwei Komponenten
norm(e,"2")  ## liefert als Länge von e den Wert 5=sqrt(3^2+4^4)=sqrt(25)

Normquadrat - Summe der Komponentenquadrate

Da die Norm im obigen Beispiel quadriert wird, ist der absolute (quadratische) Fehler allgemein die Summe der Quadrate, d.h

\|y\|^{2}:=\left\|{\begin{pmatrix}y_{1}\\\vdots \\y_{m}\end{pmatrix}}\right\|^{2}=\sum _{k=0}^{m}y_{k}^{2}

Implementation des quadratischen Fehlers in R

Damit lässt der quadratische Fehler wie folgt berechnen:

error2 <- function (px) {
   return <- sum(px^2)
   ## Rückgabewert: quaderror - quadratischer Fehler
   return
}

## quadratischen Fehler berechnen von v 
v <- c(3,4)
error2(v)   ## liefert den Wert 25 als quadratischen Fehler

## quadratischen Fehler der affinen Abbildung f
e <- f(x) - y
error2(e)

Bemerkung - Dimension des Vektors als Parameter px

Die Funktion error2(px) erlaubt das einsetzen von Spaltenvektoren error2(v) mit beliebiger Anzahl von numerischen Komponenten.

Fehlerfunktion der Linearen Regression in R

 E_LR <- function (pa,px_D,py_D) {
    ## pa : darstellender Vektor von f_a
    ## px_D : Dataframe - Liste von x-Vektoren   
    ## py_D : Dataframe - Liste von y-Werten
    
    ## Fehler pro Datenpunkt berechnen
    datenanzahl <- nrow(px_D) ## Anzahl Reihen 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: aufsummierte Einzelfehler aus e_D
    return <-  sum(e_D) 
    ## Rückgabewert: return  Gesamtfehler quadratisch
    return
 }

Daten für Fehlerfunktion in R definieren

## Datenspalten festlegen
x1 <- c(1,2,7,7) # Datenspalte für x1
x2 <- c(2,3,0,6) # Datenspalte für x2
x3 <- c(3,1,4,5) # Datenspalte für x3
y1 <- c(16.1,22.1,25.9,56.6) # Datenspalte für y1
## Daten für x aus IR^3
x_D <- data.frame(x1,x2,x3)
## Daten für y aus IR^3
y_D <- data.frame(y1)

Fehlerfunktion in R aufrufen

## a für f_a(x)=<a,x> definieren
a <- c(2,3,2)
## Fehler für a berechnen
E_LR(a,x_D,y_D) 
 
## a verändern für f_a(x)=<a,x> 
a <- c(3,5,2)
## Fehler für a erneut berechnen
E_LR(a,x_D,y_D)

Gradient der Fehlerfunktion in R

 GradE_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)
    grad <- rep(0,length(pa)) 
    e_D <- rep(0,datenanzahl)
    ## Fehler für alle Datenpunkte berechnen 
    for (i in 1:datenanzahl) {
      ## quadratische Einfehler mit Funktion e 
      grad <- grad + (sum(pa*px_D[i, ]) - py_D[i, ]) * px_D[i, ]
    } 
    ## grad (dataframe) als Vektor umwandeln
    return <- as.vector(unlist(grad))
    ## Rückgabewert: Gradient der Fehlerfunktion in pa
    return
  }

Gradient für Vektor berechnen

Für die oben angegebenen und in R definierten Daten $x_{\mathbb {D} }$ und $x_{\mathbb {D} }$ wird nun der Gradient der Fehlerfunktion

Grad_{a}(E_{_{LR}})(a)=Grad_{a}(E_{_{LR}})(5,2,19)

für den Vektor $a:=(5,2,19)\in \mathbb {R} ^{3}$ berechnet.

 a <- c(5,2,19)
 g <- GradE_LR(a,x_D,y_D)
 g ## Gradient ausgeben

Siehe auch

Seiteninformation

Diese Lernresource können Sie als Wiki2Reveal-Foliensatz darstellen.

Wiki2Reveal

Dieser Wiki2Reveal Foliensatz wurde für den Lerneinheit Mehrdimensionale lineare Regression' erstellt der Link für die Wiki2Reveal-Folien wurde mit dem Wiki2Reveal-Linkgenerator erstellt.

Die Seite wurde als Dokumententyp PanDocElectron-SLIDE erstellt.
Link zur Quelle in Wikiversity: https://de.wikiversity.org/wiki/Mehrdimensionale%20lineare%20Regression/Komponentenfunktionen
siehe auch weitere Informationen zu Wiki2Reveal und unter Wiki2Reveal-Linkgenerator.