Regression der kleinsten Quadrate Schrittweise lineare Algebra-Berechnung

Als Vorbemerkung zu einer Frage zu linear gemischten Modellen in R und als Referenz für Kenner der Statistik für Anfänger und Fortgeschrittene entschied ich mich, die Schritte, die bei der "manuellen" Berechnung der R-Werte erforderlich sind, als unabhängigen "Q & A-Stil" zu veröffentlichen Koeffizienten und vorhergesagte Werte einer einfachen linearen Regression.

Das Beispiel bezieht sich auf den in R eingebauten Datensatz mtcarsund wird als Meilen pro Gallone festgelegt, die von einem Fahrzeug verbraucht werden, das als unabhängige Variable fungiert, die über das Gewicht des Fahrzeugs (kontinuierliche Variable) und die Anzahl der Zylinder als a zurückgegangen ist Faktor mit drei Ebenen (4, 6 oder 8) ohne Wechselwirkungen.

BEARBEITEN: Wenn Sie an dieser Frage interessiert sind, werden Sie in diesem Beitrag von Matthew Drury außerhalb des Lebenslaufs definitiv eine ausführliche und zufriedenstellende Antwort finden .

Hinweis : Ich habe eine erweiterte Version dieser Antwort auf meiner Website veröffentlicht .

Würden Sie freundlicherweise in Betracht ziehen, eine ähnliche Antwort mit dem tatsächlichen R-Motor zu veröffentlichen?

Sicher! Das Kaninchenloch runter gehen wir.

Die erste Schicht ist lmdie Schnittstelle, die dem R-Programmierer ausgesetzt ist. Sie können die Quelle dafür anzeigen, indem Sie einfach lman der R-Konsole tippen. Der größte Teil davon (wie der größte Teil des Codes auf Produktionsebene) ist damit beschäftigt, Eingaben zu überprüfen, Objektattribute festzulegen und Fehler zu werfen. aber diese Linie ragt heraus

lm.fit(x, y, offset = offset, singular.ok = singular.ok, 
                ...)

lm.fitist eine andere R-Funktion, die Sie selbst aufrufen können. Funktioniert zwar lmbequem mit Formeln und Datenrahmen, lm.fitmöchte aber Matrizen, so dass eine Abstraktionsebene entfernt wird. lm.fitSuchen Sie nach der Quelle , nach mehr Arbeit und nach der folgenden wirklich interessanten Zeile

z <- .Call(C_Cdqrls, x, y, tol, FALSE)

Jetzt kommen wir voran. .Callist Rs Art, C-Code aufzurufen. Es gibt eine C-Funktion, C_Cdqrls, irgendwo in der R-Quelle, und wir müssen sie finden. Hier ist es .

Wenn wir uns die C-Funktion noch einmal ansehen, finden wir meistens eine Überprüfung der Grenzen, eine Fehlerbereinigung und viel Arbeit. Aber diese Linie ist anders

F77_CALL(dqrls)(REAL(qr), &n, &p, REAL(y), &ny, &rtol,
        REAL(coefficients), REAL(residuals), REAL(effects),
        &rank, INTEGER(pivot), REAL(qraux), work);

Jetzt sind wir in unserer dritten Sprache, R hat C gerufen, was fortran anruft. Hier ist der Fortran-Code .

Der erste Kommentar sagt alles

c     dqrfit is a subroutine to compute least squares solutions
c     to the system
c
c     (1)               x * b = y

(Interessanterweise wurde der Name dieser Routine irgendwann geändert, aber jemand hat vergessen, den Kommentar zu aktualisieren). Damit sind wir endlich an dem Punkt angelangt, an dem wir eine lineare Algebra erstellen und das Gleichungssystem tatsächlich lösen können. Dies ist die Art von Dingen, in denen Fortran wirklich gut ist, was erklärt, warum wir so viele Schichten durchlaufen haben, um hierher zu gelangen.

Der Kommentar erklärt auch, was der Code tun wird

c     on return
c
c        x      contains the output array from dqrdc2.
c               namely the qr decomposition of x stored in
c               compact form.

Also wird fortran das System lösen, indem es die Zerlegung findet.$QR$

Das Erste, was passiert, und bei weitem das Wichtigste, ist

call dqrdc2(x,n,n,p,tol,k,qraux,jpvt,work)

Dies ruft die fortran -Funktion dqrdc2in unserer Eingabematrix auf x. Was ist das?

 c     dqrfit uses the linpack routines dqrdc and dqrsl.

Also haben wir es endlich geschafft, Linpack zu machen . Linpack ist eine Fortran-Bibliothek für lineare Algebra, die es seit den 70er Jahren gibt. Die schwerste lineare Algebra findet schließlich ihren Weg zum Linpack. In unserem Fall verwenden wir die Funktion dqrdc2

c     dqrdc2 uses householder transformations to compute the qr
c     factorization of an n by p matrix x.

Hier wird die eigentliche Arbeit erledigt. Es würde einen guten ganzen Tag dauern, bis ich herausgefunden hätte, was dieser Code tut. Er ist so niedrig wie er kommt. Aber im Allgemeinen haben wir eine Matrix und wollen sie in ein Produkt zerlegen, wobei eine orthogonale Matrix und eine obere Dreiecksmatrix ist. Dies ist eine kluge Sache, denn sobald Sie und , können Sie die linearen Gleichungen für die Regression lösenX = Q R Q R Q $X$$X = QR$$Q$$R$$Q$$R$

sehr leicht. Tatsächlich

so wird das ganze system

aber ist das obere Dreieck und hat den gleichen Rang wie , solange unser Problem gut gestellt ist, ist es der volle Rang, und wir können das reduzierte System genauso gut lösenX t$R$$X^t X$

Aber hier ist die tolle Sache. ist das obere Dreieck, also ist die letzte lineare Gleichung gerade , also ist das Auflösen nach trivial. Sie können dann die Zeilen nacheinander durchlaufen und die bereits bekannten Werte ersetzen , wobei Sie jedes Mal eine einfache lineare Gleichung mit einer Variablen zur Lösung erhalten. Sobald Sie also und , kollabiert das Ganze zu einer so genannten Rückwärtssubstitution , was einfach ist. Sie können hier ausführlicher darüber lesen , wo ein explizites kleines Beispiel vollständig ausgearbeitet ist.β n β Q $R$constant * beta_n = constant$\beta_n$$\beta$$Q$$R$

Die tatsächlichen schrittweisen Berechnungen in R werden in der Antwort von Matthew Drury in diesem Thread sehr schön beschrieben. In dieser Antwort möchte ich durch den Prozess des Beweises gehen, dass die Ergebnisse in R mit einem einfachen Beispiel erreicht werden können, indem man der linearen Algebra von Projektionen auf den Spaltenraum und dem Konzept der senkrechten (Skalarprodukt-) Fehler folgt, die in verschiedenen Beiträgen dargestellt werden und erklärte schön Dr. Strang in Lineare Algebra und ihre Anwendungen und leicht zugänglich hier .

$\small \beta$

$\small D1$$\small D2$$\small X$

attach(mtcars)    
x1 <- wt

    x2 <- cyl; x2[x2==4] <- 1; x2[!x2==1] <-0

    x3 <- cyl; x3[x3==6] <- 1; x3[!x3==1] <-0

    x4 <- cyl; x4[x4==8] <- 1; x4[!x4==1] <-0

    X <- cbind(x1, x2, x3, x4)
    colnames(X) <-c('wt','4cyl', '6cyl', '8cyl')

head(X)
        wt 4cyl 6cyl 8cyl
[1,] 2.620    0    1    0
[2,] 2.875    0    1    0
[3,] 2.320    1    0    0
[4,] 3.215    0    1    0
[5,] 3.440    0    0    1
[6,] 3.460    0    1    0

$\small [*]$lm

$\small\beta$$\small ProjMatrix = \small (X^{T}X)^{-1}X^{T}$$\small [ProjMatrix] \,[y]\, =\, [RegrCoef's]$$\small (X^{T}X)^{-1}X^{T}\,y = \beta$

X_tr_X_inv <- solve(t(X) %*% X)    
Proj_M <- X_tr_X_inv %*% t(X)
Proj_M %*% mpg

          [,1]
wt   -3.205613
4cyl 33.990794
6cyl 29.735212
8cyl 27.919934

Identisch mit: coef(lm(mpg ~ wt + as.factor(cyl)-1)).

$\small Hat Matrix = \small X(X^{T}X)^{-1}X^{T}$

HAT <- X %*% X_tr_X_inv %*% t(X)

$\hat{y}$$\small X(X^{T}X)^{-1}X^{T}\,y$y_hat <- HAT %*% mpg

cyl <- as.factor(cyl); OLS <- lm(mpg ~ wt + cyl); predict(OLS):

y_hat <- as.numeric(y_hat)
predicted <- as.numeric(predict(OLS))
all.equal(y_hat,predicted)
[1] TRUE