Regressão dos mínimos quadrados passo a passo computação em álgebra linear

Como prequel para uma pergunta sobre modelos lineares mistos em R, e para compartilhar como referência para os aficionados por estatísticas iniciantes / intermediárias, decidi publicar como um "estilo de perguntas e respostas" independente as etapas envolvidas no cálculo "manual" do coeficientes e valores previstos de uma regressão linear simples.

O exemplo é com o conjunto de dados R embutido mtcars, e seria configurado como milhas por galão consumido por um veículo atuando como variável independente, regredido sobre o peso do carro (variável contínua) e o número de cilindros como um fator com três níveis (4, 6 ou 8) sem interações.

EDIT: Se você está interessado nesta pergunta, você definitivamente encontrará uma resposta detalhada e satisfatória neste post por Matthew Drury fora da CV .

Nota : Publiquei uma versão expandida desta resposta no meu site .

Você consideraria postar uma resposta semelhante com o mecanismo R real exposto?

Certo! Abaixo a toca do coelho nós vamos.

A primeira camada é lma interface exposta ao programador R. Você pode procurar a fonte disso apenas digitando lmno console R. A maior parte (como a maioria da maioria dos códigos de nível de produção) é ocupada na verificação de entradas, na configuração de atributos de objetos e no lançamento de erros; mas essa linha se destaca

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

lm.fité outra função R, você pode chamá-lo você mesmo. Embora lmtrabalhe convenientemente com fórmulas e quadro de dados, lm.fitdeseja matrizes, então esse é um nível de abstração removido. Verificando a fonte lm.fit, mais trabalho ocupado e a seguinte linha realmente interessante

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

Agora estamos chegando a algum lugar. .Callé a maneira de R chamar o código C. Existe uma função C, C_Cdqrls na fonte R em algum lugar, e precisamos encontrá-la. Aqui está .

Olhando para a função C, novamente, encontramos principalmente verificação de limites, limpeza de erros e trabalho ocupado. Mas essa linha é diferente

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

Então agora estamos no nosso terceiro idioma, R chamou C, que está chamando para o fortran. Aqui está o código fortran .

O primeiro comentário diz tudo

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

(curiosamente, parece que o nome dessa rotina foi alterado em algum momento, mas alguém se esqueceu de atualizar o comentário). Então, finalmente chegamos ao ponto em que podemos fazer álgebra linear e resolver o sistema de equações. É nesse tipo de coisa que o fortran é realmente bom, o que explica por que passamos por tantas camadas para chegar até aqui.

O comentário também explica o que o código fará

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

$QR$

A primeira coisa que acontece, e de longe a mais importante, é

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

Isso chama a função fortran dqrdc2em nossa matriz de entrada x. O que é isso?

 c     dqrfit uses the linpack routines dqrdc and dqrsl.

Finalmente chegamos ao linpack . O Linpack é uma biblioteca de álgebra linear fortran que existe desde os anos 70. A álgebra linear mais séria acaba chegando ao linpack. No nosso caso, estamos usando a função dqrdc2

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

$X$$X = QR$$Q$$R$$Q$$R$

muito facilmente. De fato

então todo o sistema se torna

$R$$X^t X$

$R$constant * beta_n = constant$\beta_n$$\beta$$Q$$R$

Os cálculos passo a passo reais em R são belamente descritos na resposta de Matthew Drury neste mesmo tópico. Nesta resposta, quero percorrer o processo de provar a si mesmo que os resultados em R com um exemplo simples podem ser alcançados seguindo a álgebra linear de projeções no espaço da coluna e o conceito de erros perpendiculares (produtos pontuais), ilustrados em postagens diferentes , e bem explicado pelo Dr. Strang em Álgebra linear e suas aplicações , e facilmente acessível aqui .

$\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

A idêntico: 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