Kurs:Mehrdimensionale lineare Regression

Im Unterschied zu dem eindimensionalen Fall für ${\displaystyle x\in \mathbb {R} }$ und ${\displaystyle y\in \mathbb {R} }$ bei der unten veranschaulichten lineare Regression beschreibt eine mehrdimensionalen lineare Regressionsanalyse einen linearen Zusammenhang ${\displaystyle f:\mathbb {R} ^{n}\to \mathbb {R} ^{m}}$ zwischen einem unabhängigen Vektor ${\displaystyle x\in \mathbb {R} ^{n}}$ und einem davon abhängigen Vektor ${\displaystyle y\in \mathbb {R} ^{m}}$.

Das Vorgehen in dieser Lernressource umfasst folgende Schritte:

• Daten und Abbildungen - Gegeben sind Daten für einen unbekannten funktionalen Zusammenhang f
• Transformation - affin zu linear
• Zerlegung einer linearen Abbildung in Komponentenfunktionen
• Regression für Komponentenfunktion - exakte Lösung und Approximation
• Gradient - lineares Funktional - (Foliensatz)
• Gesamtfehler aller Fehlerfunktionen - (Foliensatz)
• iterative Umsetzung in R

Regressionsebene, die sich an eine „Punktwolke“ im dreidimensionalen Raum anpasst (Fall Dimension Graph ${\displaystyle \mathbb {R} ^{3}}$)

Für die Abbildung ${\displaystyle f(x)=A\cdot x+b\in \mathbb {R} ^{m}}$ und Daten ${\displaystyle \mathbb {D} :=\{(x^{(1)},y^{(1)}),\ldots ,(x^{(m)},y^{(m)})\}}$ sucht man eine geeignete Matrix ${\displaystyle A\in Mat(m\times n,\mathbb {R} )}$ und einem Vektor ${\displaystyle b\in \mathbb {R} ^{m}}$, sodass der aggregierte quadratische Fehler ${\displaystyle E(A,x_{\mathbb {D} },y_{\mathbb {D} })}$ über alle Daten aus ${\displaystyle \mathbb {D} }$ möglichst klein wird.

${\displaystyle E(A,x_{\mathbb {D} },y_{\mathbb {D} }):=\sum _{k=1}^{d}\left\|f(x^{(k)})-y^{(k)}\right\|^{2}{\mbox{ minimal}}}$

Die Fehlerfunktion für die aggregierten quadratischen Fehler in normierten Räumen wird wie folgt definiert:

${\displaystyle E(A,x_{\mathbb {D} },y_{\mathbb {D} }):=\sum _{k=1}^{m}\|f(x^{(k)})-y^{(k)}\|^{2}.}$

Dabei beschreibt ${\displaystyle \|f(x^{(k)})-y^{(k)}\|}$ die Länge des Fehlervektors.

Der Einzelfehler von einem Datum hängt von den Vektoren ${\displaystyle x^{(k)}\in \mathbb {R} ^{n}}$ und ${\displaystyle y^{(k)}\in \mathbb {R} ^{m}}$ ab mit:

${\displaystyle x_{\mathbb {D} }:=\left(x^{(1)},\ldots ,x^{(d)}\right)\quad y_{\mathbb {D} }:=\left(y^{(1)},\ldots ,y^{(d)}\right)}$

Mit ${\displaystyle \|f(x^{(k)})-y^{(k)}\|}$ kann man den euklischen Abstand zwischen einem Sollvektor ${\displaystyle y^{(k)}\in \mathbb {R} ^{m}}$ aus den Daten ${\displaystyle \mathbb {D} }$ und einem durch ${\displaystyle f}$ approximierten Vektor ${\displaystyle f(x^{(k)})\in \mathbb {R} ^{m}}$ messen.

Dabei ist ${\displaystyle \|\cdot \|:\mathbb {R} ^{m}\to \mathbb {R} _{o}^{+}}$ eine Norm auf dem Wertebereich ${\displaystyle \mathbb {R} ^{m}}$ der Funktion ${\displaystyle f:\mathbb {R} ^{n}\to \mathbb {R} ^{m}}$.

Wählt man Datenpunkte ${\displaystyle (x,y)}$ mit ${\displaystyle x=(x_{1},x_{2})\in \mathbb {R} ^{2}}$ als unabhängige Variablen und einer eindimensionalen abhängigen Variablen ${\displaystyle y_{1}\in \mathbb {R} }$, so ist der Graph der affinen Abbildung ${\displaystyle f:\mathbb {R} ^{2}\to \mathbb {R} }$ eine Ebenen im dreidimensionalen Raum ${\displaystyle \mathbb {R} ^{3}=\mathbb {R} ^{2}\times \mathbb {R} }$, in der man die Datenpunkten die Form ${\displaystyle (x_{1},x_{2},y_{1})\in \mathbb {R} ^{3}}$ den den Graphen der affinen Abbildung noch darstellen kann.

Betrachten Sie nun einen eindimensionalen Definitionsbereich und einen zweidimensionalen Werterbereich mit Datenpunkte ${\displaystyle (x,y_{1},y_{2})}$, die entlang einer Gerade im dreidimensionalen Raum angeordnet sind. Wie kann man die lineare Abbildung durch zwei standardmäßige lineare Regressionen berechnen?

Ist der Wertebereich der linearen Abbildung ${\displaystyle f_{a}:\mathbb {R} ^{n}\times \mathbb {R} }$ mit ${\displaystyle f_{a}(x)=\langle a,x\rangle \in \mathbb {R} }$ eindimensional, sucht man zu den Datenpunkten ${\displaystyle (x^{(k)},y^{(k)})\in \mathbb {R} ^{n}\times \mathbb {R} }$ mit

${\displaystyle \mathbb {D} :=\{(x^{(1)},y^{(1)},\ldots ,(x^{(m)},y^{(m)})\}}$

einen geeigneten Vektor ${\displaystyle a\in \mathbb {R} ^{n}}$, sodass der aggregierte quadratische Fehler ${\displaystyle E(A,x_{\mathbb {D} },y_{\mathbb {D} })}$ über alle Daten aus ${\displaystyle \mathbb {D} }$ möglichst klein wird.

${\displaystyle E(a,x_{\mathbb {D} },y_{\mathbb {D} }):=\sum _{k=1}^{m}|f(x^{(k)})-y^{(k)}|^{2}{\mbox{ minimal}}}$

Für einen einzelnen Datenpunkt ${\displaystyle (x,y)=(x_{1},\ldots ,x_{n},y)\in \mathbb {R} ^{n+1}}$ kann man mit ${\displaystyle f_{a}(x)=\langle a,x\rangle }$ jeweils den Fehler wie folgt angeben:

${\displaystyle e(a,x,y):=f_{a}(x)-y=\langle a,x\rangle -y}$

Nun kann man die Fehlerfunktion ${\displaystyle e}$ definieren:

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

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

   e_LR <- function (pa,px,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
  }

Das folgende Codefragement berechnet das Skalarprodukt ${\displaystyle \langle a,v\rangle }$ von zwei Vektor ${\displaystyle a,v\in \mathbb {R} ^{n}}$

sum(pa * px)

Mit der obigen Definition steht nun die Funktion zur Verfügung und man kann den Fehler für gegebene Vektoren ${\displaystyle a,x\in \mathbb {R} ^{n}}$ und dem Messwert ${\displaystyle 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

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

${\displaystyle \|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:

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

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)

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

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

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)

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

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

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.

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

${\displaystyle e(a,x,y)^{2}=(f_{a}(x)-y)^{2}=(\langle a,x\rangle -y)^{2}}$

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

${\displaystyle {\frac {\partial e^{2}}{\partial a_{k}}}(a,x,y)=2\cdot (f_{a}(x)-y)\cdot x_{k}}$

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

Der Gradient ${\displaystyle \operatorname {Grad} _{a}(e^{2})}$ des quadratischen Fehlers ergibt sich aus den partiellen Ableitungen bzgl. der Argumente ${\displaystyle a=(a_{1},\ldots ,a_{n})}$. Die weiteren Argumente ${\displaystyle x}$ und ${\displaystyle y}$ des quadratischen Fehlers ${\displaystyle 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 ${\displaystyle \operatorname {Grad} _{a}(e^{2})}$ statt ${\displaystyle \operatorname {Grad} (e^{2})}$ verwendet.

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

${\displaystyle {\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}}}$

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

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

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

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

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

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

${\displaystyle {\begin{array}{rcl}E(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}}}$

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

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

Mit der obigen Dimension von Definitionsbereich und Wertebereich der lineare Abbildung ${\displaystyle 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

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)

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)

Für die Implementation des Gesamtfehlers ${\displaystyle E_{LR}(a,x_{\mathbb {D} },y_{\mathbb {D} })}$ in R verwendet man die geladenen Daten in data. Die Datenpunkte ${\displaystyle (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)
    fehler <- 0
    ## Fehler für alle Datenpunkte berechnen 
    for (i in 1:datenanzahl) {
      ## quadratische Einfehler mit Funktion e 
      fehler <- fehler + (sum(pa*px_D[i, ]) - py_D[i, ])^2
    } 
    ## Rückgabewert als aufsummierte Einzelfehler setzen
    ## Rückgabewert: fehler  Gesamtfehler quadratisch
    return(fehler)
  }

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

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

Bezogen auf die Beispieldaten^[1] in ${\displaystyle \mathbb {D} }$ kann nun den Fehler für unterschiedliche darstellende Vektoren ${\displaystyle 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 darstellende Vektors ${\displaystyle a}$ für die Funktion ${\displaystyle f_{a}(x)=\langle a,x\rangle }$ eine kleineren Fehler.

Beim Gradientenabstieg wird bei der aktuellen Position der Gradient der Fehlerfunktion berechnet und der aktuelle Vektor ${\displaystyle a^{(t)}\in \mathbb {R} ^{3}}$ in Richtung des negativen Gradient zu ${\displaystyle a^{(t+1)}\in \mathbb {R} ^{3}}$ verändert, um den Gesamtfehler zu verkleinern.

Mit der Anwendung der Summenregel für den Gradienten einer Summe man den Gradienten des Gesamtfehlers wie folgt berechnen.

${\displaystyle {\begin{array}{rcl}\operatorname {Grad} _{a}(E_{LR})(a,x_{\mathbb {D} },y_{\mathbb {D} })&=&\displaystyle \sum _{k=1}^{d}\operatorname {Grad} _{a}(e_{LR}^{2})\left(a,x^{(i)},y^{(i)}\right)\\&=&\displaystyle \sum _{k=1}^{d}\underbrace {2\cdot (f_{a}(x^{(i)})-y^{(i)})\cdot x^{(i)}} _{=\operatorname {Grad} _{a}(e^{2})\left(a,x^{(i)},y^{(i)}\right)}\\&=&\displaystyle 2\cdot \sum _{k=1}^{d}(f_{a}(x^{(i)})-y^{(i)})\cdot x^{(i)}\\\end{array}}}$

Für die Implementation des Gesamtfehlers ${\displaystyle E_{LR}(a,x_{\mathbb {D} },y_{\mathbb {D} })}$ in R für eine Komponentenfunktion verwendet man die geladenen Daten in x_D und y_D. Die Datenpunkte ${\displaystyle (x^{(i)},y^{(i)})\in \mathbb {D} }$ liegen als Zeilen in der CSV-Datei vor.

  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)) 
    ## 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, ]
    } 
    ## Rückgabewert: grad - Gradient des Gesamtfehler E_MLR
    return(grad)
  }

Die Gesamtfehlerfunktion ${\displaystyle E_{MLR}}$ aggregiert alle Fehler ${\displaystyle E_{LR}}$ für die Komponentenfunktionen mit eindimensionalem Wertebereich ${\displaystyle \mathbb {R} }$. Der Fehler wird in ${\displaystyle E_{MLR}}$ für einen Matrix ${\displaystyle A}$ berechnet, während ${\displaystyle E_{LR}}$ den Fehler jeweils für einen Zeilenvektor aus der Matrix ${\displaystyle A}$ berechnet.

E_MLR <- function (pA,px_D,py_D) {
    ## pA : Matrix A, für die der Fehler berechnet wurde
    ## px_D : Dataframe - Liste von x-Vektoren   
    ## py_D : Dataframe - Liste von y-Werten
    
    ## cols4y: Spalten y = Anzahl der Komponentenfunktionen
    cols4y <- ncols(py_D) ## Anzahl der Spalten von y_D
    fehler <- 0 
    ## Fehler für alle y-Spalten 
    for (i in 1:cols4y) {
      ## Fehler für Komponentenfunktion f_a berechnen
      a <- pA[i, ] 
      y1_D <- py_D[ ,i]
      fehler <- fehler + E_LR(a,px_D,y1_D) 
     } 
    ## Rückgabewert: fehler  quadratisch
    return(fehler)
 }

Auch für die Gesamtfehlerfunktion ${\displaystyle E_{MLR}}$ benötigt man den Gradienten. Da sich der Gesamtfehler ${\displaystyle E_{MLR}}$ aus den Komponentenfunktionsfehlern ${\displaystyle E_{LR}}$ additiv zusammensetzt, kann man mit Ableitungsregeln den Gradienten über die Gradienten von ${\displaystyle E_{LR}}$ berechnen.

GradE_MLR <- function (pA,px_D,py_D) {
    ## pA : Matrix A, für die der Fehler berechnet wurde
    ## px_D : Dataframe - Liste von x-Vektoren   
    ## py_D : Dataframe - Liste von y-Werten
    
    ## cols4y Anzahl der Komponentenfunktionen 
    ##        enspricht der Spaltenanzahl von py_D
    cols4y <- ncols(py_D) 
    grad <- rep(0,cols4y) 
    ## Fehler für alle y-Spalten 
    for (i in 1:cols4y) {
      ## Gradient für alle Komponentenfunktion von E_LR addieren
      a <- pA[i, ] 
      y1_D <- py_D[ ,i]
      grad <- grad + GradE_LR(a,px_D,y1_D) 
     } 
    ## Rückgabewert: grad Gradient von E_MLR
    return(grad)
 }

Siehe auch iterative Umsetzung in der mehrdimensionalen linearen Regression in R^[2].

1. ↑ ^{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
2. ↑ Bert Niehaus (2025) GitHub-Repository KnitR for Education https://github.com/niebert/knitr4education für eine Wikiversity-Lernressource - Datei: demo_10_mehrdim_lineare_regression_gradientenabstieg.Rmd

• Implementation in R
• lineare Regression in R
• Kurs:Numerik I
• Gradient (Mathematik)
• Gradientenabstiegsverfahren
• Laden und Speichern von CSV-Dateien in R
• Open Source Software
• Open Community Approach
• Wikibuch R

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

Dieser Wiki2Reveal Foliensatz wurde für den Lerneinheit Kurs:Maschinelles Lernen' 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/Kurs:Maschinelles%20Lernen/Mehrdimensionale%20lineare%20Regression
• siehe auch weitere Informationen zu Wiki2Reveal und unter Wiki2Reveal-Linkgenerator.