Mehrdimensionale lineare Regression/iterative Umsetzung in R

Einleitung

Diese Seite zum Thema Kurs:Mehrdimensionale lineare Regression/Umsetzung in R 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) Laden der Daten
(2) Iterationen zur Fehlerminimierung mit Gradientenabstiegsverfahren
(3) Ausgabe der Matrix und des quadratischen Fehlers pro Einzeldatum

Zielsetzung

Diese Lernressource hat das Ziel, die interative Umsetzung der mehrdimensionale linearen Regression in R zu behandeln und die wesentlichen Schritte in Analogie zum Gradientenabstiegsverfahren und dessen mathematischen Herleitung zu implementieren. Dies geschieht zusätzlich zu den mit lm()^[1] für die lineare Regression bereits implementierten Verfahren in R.

Lernvoraussetzungen

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

(Mathematische Grundlagen) Die mathematischen Grundlagen sind wesentlich, um die Einsatzmöglichkeiten der Verfahren abschätzen zu kennen.
(Grundlagen in GNU R) Die Grundlagen der Implementierung und GNU R sind hilfreich, um die Implementationsschritte zu verstehen und den Code auf anderen Datenquellen ggf. anpassen zu können.

Aufgaben Studierende KnitR

Bitten erzeugen Sie ein R-Markdown-Dokument für KnitR, indem Sie die Teilschritte als Codefragemente / Codechunks einbauen und testen. Gehen Sie schrittweise vor bis Sie mit den angegeben Codezeilen ein vollständiges Verfahren zur mehrdimensionalen lineare Regression in R umgesetzt haben. Demodatei in KnitR finden Sie für diese Lerneinheit in knitr4education^[2]

Minimierung der Fehlerfunktion

Das in dieser Lerneinheit behandelte iterative Verfahren der mehrdimensionalen linearen Regression hat das Ziel, die Optimierung in einzelnen Berechnungsschritten sichtbar zu machen.

Schritte der Optimierung

Die einzelnen Schritte der Optimierung sind u.a.:

Definition der Fehlerfunktion in R sowohl für die Komponentenfunktionen $E_{LR}$ als auch für die Matrix $E_{MLR}$ .
Berechnung des Gradienten der Fehlerfunktion
Normierung des Gradienten auf $Grad(A_{t})$ die Länge 1
Berechnung der Schrittweite in Abhängigkeit von der Lernrate $\alpha >0$ , mit der man die aktuelle Matrix $A_{t}$ zu $A_{t+1}$ so modifiziert, dass der Fehler kleiner wird (also $E_{MLR}(A_{t})>E_{MLR}(A_{t+1})$

Bezug zur Umsetzung mit lm-Funktion in R

Die Darstellung in dieser Lerneinheit zur iterativen Umsetzung mit Gradientenabstiegsverfahren sollte ebenfalls mit der in R bereits implementierten Funktion lm() zur Berechnung der linearen Regression in Verbindung gebracht werden, die in der Regel für großen Datenmengen zur Berechnung der linearen Regression verwendet werden.

Laden der Daten

Als einführenden Schritt eines überwachten Lernverfahrens muss man aus den gegebenen Daten festlegen, welche Datenspalten die Eingabespalten und welche Datenspalten die Ausgabespalten der Traininfsdaten darstellen. Kurs:Mehrdimensionale lineare Regression/Umsetzung in R dient dabei Speichen Sie zunächst die obige Beispieldatei multlinreg.csv^[3] in Ihr Verzeichnis mit dem KnitR-Dokument. Das Laden von Dateien in R und KnitR kann bzgl. der obigen Beispieldatei^[3] wie folgt geschehen:

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

CSV-Datei

"x1","x2","x3","y1","y2"
1,2,3,16.05071,1.92142 
2,3,1,22.06779,0.08923 
7,0,4,24.96846,10.98239
7,6,5,56.06086,6.02315

Tabelle für die Daten

In der folgenden Tabelle sind x1,x2,x3 die Komponenten der Eingabevektoren und y1,y2 die Komponenten der Ausgabevektoren.

Tabellarische Darstellung
x1	x2	x3	y1	y2
1	2	3	16.05071	1.92142
2	3	1	22.06779	0.08923
7	0	4	24.96846	10.98239
7	6	5	56.06086	6.02315

Bemerkung - Matrixdimension

Die gesuchte lineare Abbildung $A$ für die mehrdimensionale lineare Regression ist also eine $2\times 3$ -Matrix.

A:={\begin{pmatrix}a_{1,1}&a_{1,2}&a_{1,3}\\a_{2,1}&a_{2,2}&a_{2,3}\\\end{pmatrix}}

Dataframes für die Ein-/Ausgabe

Oft enthalten die Rohdaten auch weitere Spalten, die für die mehrdimensionale lineare Regression keine Rolle spielen. Daher muss man die Ein- und Ausgabevektor aus den Rohdaten auswählen und in ein Eingabe-Dataframe und ein Ausgabe-Dataframe zusammenfassen.

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

Die obige verwendete Tabelle multlinreg.csv^[3]. enthält in diesem Fall nur Spalten, die für die mehrdimensionale lineare Regression notwendig sind. Die Zuordnung der relevanten Datenspalten für die x- und y-Werte der linearen Regression wird nun gezeigt.

  data <- read.csv("data/multlinreg.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] 
  y2 <- data[,5] 
  ## Dataframes für die Fehlerfunktion
  x_D <- data.frame(x1,x2,x3)
  y_D <- data.frame(y1,y2)

Bemerkung - Pfad zu Daten

In dem Verzeichnis, in dem die R-Markdown-Dateien (Endung .Rmd) liegen, ist empfehlenswert, Unterverzeichnisse zu erzeugen:

data/ - Verzeichnis in dem alle CSV-Dateien bzw. Tabellenkalkulationsdateien liegen oder in das erzeugt Tabellen abgespeichert werden.
lib/ - Verzeichnis im dem R-Skripte und R-Bibliotheken liegen, die Sie für mehr als eine R-Markdown-Datei benötigen (z.B. knitr4education.R)

Ladefunktion definieren

Für die mehrdimensionale lineare Regression muss man die relevanten Eingabespalten für die Eingabevektoren pInCols und relevanten Ausgabespalten für die Ausgabevektoren pInCols benennen. Diese werden als Vektoren der Spaltenbezeichnungen definiert:

 ## Ladefunktion für
 load_inout_csv <- function(pFilename,pInCols,pOutCols) {
    data <- read.csv(pFilename, header=TRUE, stringsAsFactors=FALSE)
    ### Spalten mit den Bezeichnung pColNames extrahieren
    data4cols <-  list(
       xin  = data[pInCols],
       yout = data[pOutCols]
    )
    
    ### Rueckgabe der extrahierten Spalten
    return(data4cols)
 }

Mit der obigen Ladefunktion kann man die relevanten Datenspalten aus der CSV-Datei auch wie folgt in die Eingabedaten x_ID bzw. in die Ausgabedaten y_ID laden.

 ## Spaltenbezeichnungen: Eingabevektoren IR^3
 incolnames  <- c("x1","x2","x3")
 ## Spaltenbezeichnungen: Ausgabevektoren IR^2 
 outcolnames <- c("y1","y2")
 
 ### Input- und Outputdaten aus Datei laden
 df <- load_inout_csv("data/multlinreg.csv",incolnames,outcolnames)
 
 x_ID <- df$xin
 y_ID <- df$yout

MLR-Fehlerfunktion

Die LR-Fehlerfunktion $E_{LR}(a,x_{_{D}},y)$ habe den Fehler für die Komponentenfunktionen berechnet, die nur einen eindimensionalen Werterbereich besitzen.

Zerlegung in Fehler der Komponentenfunktionen

Die MLR-Fehlerfunktion $E_{MLR}(A,x_{_{D}},y_{_{D}})$ zerlegt die Matrix $A$ in Zeilenvektoren $a_{i}$ und ruft die Fehlerfunktion $E_{LR}(a_{i},,x_{_{D}},y^{(i)})$ für die $i$ -te Spalte $y^{(i)}$ des Ausgabevektors in $y_{\mathbb {D} }$ auf.

Aggregation der Fehler aus Komponentenfunktionen

MLR-Fehlerfunktion $E_{MLR}(A,x_{_{D}},y_{_{D}})$ aggregiert dann die Fehler der Komponentenfunktionen (siehe Zerlegung in Komponentenfunktionen für die Berechnung des Gesamtfehlers).

LR-Fehlerfunktion für Komponentenfunktionen

Die Bezeichnung LR-Fehlerfunktion wird verwendet, wenn man den Fehler für eine Komponentenfunktion berechnet, dessen Wertebereich $\mathbb {R}$ .

E_LR <- function (pa,px_D,py_D) {
    ## px_D : Dataframe - Liste von x-Vektoren   
    ## py_D : Dataframe - Spaltenvektor 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
  }

Gradient der LR-Fehlerfunktion für Komponenten

Von der obigen Fehlerfunktion für einzelne Komponentenfunktionen muss man nun noch den Gradienten implementieren, um die Fehler zu minimieren.

  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)
    return <- rep(0,length(pa)) 
    ## Fehler für alle Datenpunkte berechnen 
    for (i in 1:datenanzahl) {
      ## Gradient der Summanden der Fehlerfunktion E_LR addieren
      ret <- ret + (sum(pa*px_D[i, ]) - py_D[i, ]) * px_D[i, ]
    } 
    ## Rückgabewert: ret Gradient des quadratischen  Gesamtfehler
    ret
  }

MLR-Gesamtfehlerfunktion

Die Gesamtfehlerfunktion $E_{MLR}$ aggregiert alle $m$ Fehler $E_{LR}$ für die Komponentenfunktionen mit eindimensionalem Wertebereich $\mathbb {R}$ . Der Fehler wird in $E_{MLR}$ für einen Matrix $A\in Mat(m\times n,\mathbb {R} )$ berechnet, während $E_{LR}$ den Fehler jeweils für einen Zeilenvektor aus der Matrix $A$ berechnet. Für die Abbildung $f(x)=A\cdot x\in \mathbb {R} ^{m}$ und Daten $\mathbb {D} :=\{(x^{(1)},y^{(1)},\ldots ,(x^{(d)},y^{(d)})\}$ sucht man eine geeignete Matrix $A\in Mat(m\times n,\mathbb {R} )$ , sodass der aggregierte quadratische Fehler $E_{MLR}(A,x_{\mathbb {D} },y_{\mathbb {D} })$ über alle Daten aus $\mathbb {D}$ möglichst klein wird.

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

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
    
    ## Fehler pro Datenpunkt 
    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 
    return(fehler)
 }

Gradient der MLR-Gesamtfehlerfunktion

Auch für die Gesamtfehlerfunktion $E_{MLR}$ benötigt man den Gradienten. Da sich der Gesamtfehler $E_{MLR}$ aus den Komponentenfunktionsfehlern $E_{LR}$ additiv zusammensetzt, kann man mit Ableitungsregeln den Gradienten über die Gradienten von $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
    
    ## Rückgabewert retA ist eine m x n-Matrix analog zu pA
    ## Initialisierung mit Nullmatrix 
    retGrad <- 0 * pA
    ### retGrad hat die gleiche Zeilen- und Spaltenzahl wie pA
    ## Dimension des Gradienten
    cols4x <- ncols(px_D) 
    grad <- rep(0,cols4x) 
    ## cols4y Anzahl der Komponentenfunktionen 
    ##        enspricht der Spaltenanzahl von py_D
    cols4y <- ncols(py_D) 
    ## 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]
      ### i-te Zeile der Gradientenmatrix retA definieren
      retGrad[i, ] <- GradE_LR(a,px_D,y1_D) 
     } 
    ## Rückgabewert: grad Gradient von E_MLR
    return(retGrad)
 }

Normierter MLR-Gradient

Um mit der Lernrate $\alpha >0$ die Schrittweite im Parameter $a\in \mathbb {R} ^{n}$ kontrollieren zu können, verwendet man ein normierten Gradienten, der die Vektorlänge $\|{\mathtt {normgrad}}\|=1$ , wenn der Gradient nicht der Nullvektor ist (siehe auch normiert LR-Gradient).

normGradE_MLR <- function (pa,px_D,py_D) {
 g_LR <- GradE_MLR(pa,px_D,py_D)
 ## Länge des Gradientenvektors bestimmen als euklidische 2-Norm
 norm4g <- norm(g_LR,"2")
 normgrad <- g_LR
 if (norm4g > 0) {
    ### Normierung des Gradienten
    normgrad <- g_LR / norm4g   
 } else {
   print("MLR-Gradient ist Nullvektor")
 }
 ## Rückgabewert: normierter Gradient, wenn kein Nullvektor 
 ##               Sonst Nullvektor als Rückgabewert
 return(normgrad)
}

Definition der mehrdimensionalen lineare Regression

mdimLR <- function (pA, px_D, py_D, alpha=1, max_iteration=10, evalcount=100)  {
  ## max_iteration  maximale Anzahl der  Iterationszyklen
  ## max_iteration <- 25
  alterfehler <- E_MLR(pA,px_D,py_D)
  minwert <- c(0,alterfehler)
  print(paste("Error 0: ",alterfehler,sep=""))
  for (i in 1:max_iteration) {
    ### minimalen Fehler in Gradientenrichtung suchen 
    minwert <- find_min4error(E_MLR, normGradE_MLR, pa, px_D, py_D, alpha, evalcount)
    print(paste("Iteration ",i," (",paste(minwert[1]*alpha,minwert[2],sep=","),")",sep=""))
    #print(minwert) 
    ### normierten Gradienten berechnen
    normgrad <- normGradE_MLR(pA, px_D, py_D)
    pA + minwert[1]* normgrad
    
    if (alterfehler > minwert[2]) {
      pA <- pA + minwert[1]*normgrad
      print(paste("Gradient",i," alpha=",alpha,sep=""))
      print(paste("Error ",i,": ",minwert[2],sep=""))
      alterfehler > minwert[2]
    } else {
      print("Fehler wird größer")
    }
  }
  ### Rückgabewert ist die Matrix mit kleinerem MLR-Fehler
  return(pA)
}

Interative Berechnung der mehrdimesionalen linearen Regression

## Spaltenbezeichnungen: Eingabevektoren IR^3
 incolnames  <- c("x1","x2","x3")
 ## Spaltenbezeichnungen: Ausgabevektoren IR^2 
 outcolnames <- c("y1","y2")
 
 ### Input- und Outputdaten aus Datei "multlinreg.csv" laden
 ### Datei befindet sich im Unterverzeichnis "data/"
 df <- load_inout_csv("data/multlinreg.csv",incolnames,outcolnames)
 
 x_ID <- df$xin
 y_ID <- df$yout
 
 ## Startmatrix für die mehrdim. lin Regression setzen
 A <- matrix(c(1,2,3,4,5,6), ncol=3)
 ## mehrdim lin. Regression starten
mdimLReg(A,x_D,y_D)

Literatur/Quellennachweise

↑ Wikibook contributors. (2025, June 21). GNU R: lm(). In Wikibook, . Retrieved 05:01, June 22, 2025, from https://de.wikibooks.org/w/index.php?title=GNU_R:_lm&oldid=1067930
↑ Bert Niehaus (2025) knitr4education - Demodateien für KnitR für Wikiversity - u.a. lineare Regression - URL: https://github.com/niebert/knitr4education/tree/main/de
↑ ^a ^b ^c Bert Niehaus (2024) GitHub-Repository KnitR for Education https://github.com/niebert/knitr4education für eine Wikiversity-Lernressource - Datei: multilinreg.csv

Siehe auch

Seiteninformation

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

Wiki2Reveal

Dieser Wiki2Reveal Foliensatz wurde für den Lerneinheit Kurs: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/Umsetzung%20in%20R
siehe auch weitere Informationen zu Wiki2Reveal und unter Wiki2Reveal-Linkgenerator.

[1] Wikibook contributors. (2025, June 21). GNU R: lm(). In Wikibook, . Retrieved 05:01, June 22, 2025, from https://de.wikibooks.org/w/index.php?title=GNU_R:_lm&oldid=1067930

[2] Bert Niehaus (2025) knitr4education - Demodateien für KnitR für Wikiversity - u.a. lineare Regression - URL: https://github.com/niebert/knitr4education/tree/main/de

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

[1]

[2]

[3]