Perché non usare le "equazioni normali" per trovare coefficienti di minimi quadrati semplici?

17

Ho visto questo elenco qui e non potevo credere che ci fossero così tanti modi per risolvere i minimi quadrati. I "equazioni normali" su Wikipedia sembrava essere un modo abbastanza

\begin{aligned} \hat{α} & = \bar{y} - \hat{β} \bar{x}, \\ \hat{β} & = \frac{\sum_{i = 1}^{n} (x_{i} - \bar{x}) (y_{i} - \bar{y})}{\sum_{i = 1}^{n} (x_{i} - \bar{x})^{2}} \end{aligned}

${\begin{aligned}{\hat {\alpha }}&={\bar {y}}-{\hat {\beta }}\,{\bar {x}},\\{\hat {\beta }}&={\frac {\sum _{i=1}^{n}(x_{i}-{\bar {x}})(y_{i}-{\bar {y}})}{\sum _{i=1}^{n}(x_{i}-{\bar {x}})^{2}}}\end{aligned}}$

Quindi perché non usarli? Ho ipotizzato che ci debba essere un problema computazionale o di precisione dato che nel primo link sopra Mark L. Stone menziona che SVD o QR sono metodi popolari nei software statistici e che le equazioni normali sono "TERRIBILI dal punto di vista dell'affidabilità e dell'accuratezza numerica". Tuttavia , nel codice seguente, le equazioni normali mi danno l'accuratezza di ~ 12 cifre decimali rispetto a tre funzioni pitone popolari: polyfit di numpy ; sciabolo di linea ; e LinearRegression di scikit-learn .

La cosa più interessante è che il normale metodo di equazione è il più veloce quando n = 100000000. I tempi di calcolo per me sono: 2,5 s per il ritorno di linea; 12,9s per polyfit; 4.2s per LinearRegression; e 1.8s per l'equazione normale.

Codice:

import numpy as np
from sklearn.linear_model import LinearRegression
from scipy.stats import linregress
import timeit

b0 = 0
b1 = 1
n = 100000000
x = np.linspace(-5, 5, n)
np.random.seed(42)
e = np.random.randn(n)
y = b0 + b1*x + e

# scipy                                                                                                                                     
start = timeit.default_timer()
print(str.format('{0:.30f}', linregress(x, y)[0]))
stop = timeit.default_timer()
print(stop - start)

# numpy                                                                                                                                      
start = timeit.default_timer()
print(str.format('{0:.30f}', np.polyfit(x, y, 1)[0]))
stop = timeit.default_timer()
print(stop - start)

# sklearn                                                                                                                                    
clf = LinearRegression()
start = timeit.default_timer()
clf.fit(x.reshape(-1, 1), y.reshape(-1, 1))
stop = timeit.default_timer()
print(str.format('{0:.30f}', clf.coef_[0, 0]))
print(stop - start)

# normal equation                                                                                                                            
start = timeit.default_timer()
slope = np.sum((x-x.mean())*(y-y.mean()))/np.sum((x-x.mean())**2)
stop = timeit.default_timer()
print(str.format('{0:.30f}', slope))
print(stop - start)

regression least-squares scikit-learn

— Oliver Angelil
fonte

Le risposte sono abbastanza esagerate. Non è così orribile se eviti di calcolare esplicitamente l'inverso.

— matematico

3

Alcune note sulla velocità: stai guardando solo una singola covariata, quindi il costo dell'inversione della matrice è essenzialmente 0. Se guardi qualche migliaio di covariate, questo cambierà. In secondo luogo, poiché hai una sola covariata, il munging dei dati è ciò che in realtà richiede molto tempo nei concorrenti confezionati (ma questo dovrebbe ridimensionarsi solo linearmente, quindi non è un grosso problema). La normale soluzione delle equazioni non esegue il munging dei dati, quindi è più veloce, ma non ha campane e fischietti associati ai suoi risultati.

— Cliff AB,

22

$Ax \approx b$ $A$ $A^TA$ $log_{10}(cond)$ $A^TA$ $A^TAx = A^Tb$ $log_{10}(cond(A^TA)) = 2*log_{10}(cond(A))$

$10^8$ $10^{16}$ e sostanzialmente non si ha precisione nella risposta.

A volte ti allontani dalle equazioni normali, altre volte no.

— Mark L. Stone
fonte

2

Un modo più semplice di vederlo (se non si conosce / si preoccupa dei numeri delle condizioni) è che si sta (essenzialmente) moltiplicando qualcosa da solo ("quadrandolo"), il che significa che ci si può aspettare di perdere circa la metà dei frammenti di precisione. (Questo dovrebbe essere più ovvio se A è uno scalare, e dovrebbe essere facile vedere che rendere A una matrice non cambia davvero il problema sottostante.)

— user541686

Oltre alle differenze di precisione, esiste anche una grande differenza di velocità tra QR e le equazioni normali? perché in quest'ultimo caso potresti risolvere (X'X) -1 * X'Y, che è lento a causa dell'inverso? Lo chiedo perché non sono sicuro di come funzioni QR, quindi forse c'è qualcosa che è lento quanto invertire una matrice. O è l'unico punto da considerare la perdita di precisione?

— Simon,

4

A^{T} A

$A^TA$

A^{T} b

$A^Tb$

8

Se devi solo risolvere questo problema con una variabile, vai avanti e usa la formula. Non c'è niente di sbagliato in questo. Potrei vederti scrivere alcune righe di codice in ASM per un dispositivo incorporato, per esempio. In effetti, ho usato questo tipo di soluzione in alcune situazioni. Non è necessario trascinare grandi librerie statistiche solo per risolvere questo piccolo problema, ovviamente.

L'instabilità numerica e le prestazioni sono problemi di maggiori problemi e impostazione generale. Se risolvete i minimi quadrati multivariati, ecc. Per un problema generale non lo userete, ovviamente.

— Aksakal
fonte

0

Nessun pacchetto statistico moderno risolverebbe una regressione lineare con le equazioni normali. Le equazioni normali esistono solo nei libri statistici.

Le equazioni normali non dovrebbero essere usate poiché calcolare l'inverso della matrice è molto problematico.

Perché usare la discesa gradiente per la regressione lineare, quando è disponibile una soluzione matematica a forma chiusa?

... sebbene sia disponibile l'equazione normale diretta. Si noti che nell'equazione normale si deve invertire una matrice. Ora invertire una matrice costa O (N3) per il calcolo in cui N è il numero di righe nella matrice X cioè le osservazioni. Inoltre, se la X è mal condizionata, creerà errori computazionali nella stima ...

— SmallChess
fonte