Ich studiere PCA von Andrew Ngs Coursera-Kurs und anderen Materialien. In der ersten Aufgabe des Stanford NLP-Kurses cs224n und im Vorlesungsvideo von Andrew Ng wird anstelle der Eigenvektorzerlegung der Kovarianzmatrix eine Singulärwertzerlegung durchgeführt, und Ng sagt sogar, dass SVD numerisch stabiler ist als eigendecomposition.

Nach meinem Verständnis sollten wir für PCA eine SVD der Datenmatrix der (m,n)Größe durchführen, nicht der Kovarianzmatrix der (n,n)Größe. Und Eigenvektorzerlegung der Kovarianzmatrix.

Warum machen sie SVD der Kovarianzmatrix, nicht der Datenmatrix?

Amöbe gab bereits eine gute Antwort in den Kommentaren, aber wenn Sie ein formelles Argument wollen, hier geht es.

Die Singularwertzerlegung einer Matrix ist , wobei die Spalten von Eigenvektoren von und die diagonalen Einträge von die Quadratwurzeln ihrer Eigenwerte sind, dh .A = U ≤ V T V A T A ≤ σ i i = $A$$A=U\Sigma V^T$$V$$A^TA$$\Sigma$$\sigma_{ii}=\sqrt{\lambda_i(A^TA)}$

Wie Sie wissen, sind die Hauptkomponenten die orthogonalen Projektionen Ihrer Variablen auf den Raum der Eigenvektoren der empirischen Kovarianzmatrix . Die Varianz der Komponenten ergibt sich aus ihren Eigenwerten .λi($\frac{1}{n-1}A^TA$$\lambda_i(\frac{1}{n-1}A^TA)$

Betrachte eine beliebige quadratische Matrix , und einen Vektor so dass . Dannα ∈ R v B v = λ $B$$\alpha \in \mathbb R$$v$$Bv=\lambda v$

1. $B^kv=\lambda^kv$
2. $\lambda(\alpha B) = \alpha\lambda( B)$

Definieren wir . Die SVD von berechnet die eigendezusammensetzung von zu ergebenSSTS=$S=\frac{1}{n-1}A^TA$$S$$S^TS=\frac{1}{(n-1)^2}A^TAA^TA$

1. die Eigenvektoren von , die nach Eigenschaft 1 diejenigen vonA T$(A^TA)^TA^TA=A^TAA^TA$$A^TA$
2. die Quadratwurzeln der Eigenwerte von , die nach Eigenschaft 2, dann 1, dann wieder 2 .$\frac{1}{(n-1)^2}A^TAA^TA$$\sqrt{\frac{1}{(n-1)^2} \lambda_i(A^TAA^TA)} = \sqrt{\frac{1}{(n-1)^2} \lambda_i^2(A^TA)} = \frac{1}{n-1}\lambda_i(A^TA) = \lambda_i(\frac{1}{n-1}A^TA)$

Voilà!

In Bezug auf die numerische Stabilität müsste man herausfinden, welche Algorithmen verwendet werden. Wenn Sie dazu bereit sind, glaube ich, dass dies die von numpy verwendeten LAPACK-Routinen sind:

• numpy.linalg.eig
• numpy.linalg.svd

Update: In Bezug auf die Stabilität scheint die SVD-Implementierung einen Divide-and-Conquer-Ansatz zu verwenden, während die eigendecomposition einen einfachen QR-Algorithmus verwendet. Ich kann nicht auf einige relevante SIAM-Papiere meiner Institution zugreifen (Kürzungen bei der Schuldforschung), aber ich habe etwas gefunden, das die Einschätzung unterstützen könnte, dass die SVD-Routine stabiler ist.

Im

Nakatsukasa, Yuji und Nicholas J. Higham. "Stabile und effiziente Spektralteilungs- und Eroberungsalgorithmen für die symmetrische Eigenwertzerlegung und die SVD." SIAM Journal on Scientific Computing 35.3 (2013): A1325-A1349.

Sie vergleichen die Stabilität verschiedener Eigenwertalgorithmen, und es scheint, dass der Divide-and-Conquer-Ansatz (sie verwenden denselben Ansatz wie Numpy in einem der Experimente!) stabiler ist als der QR-Algorithmus. Dies, zusammen mit den Behauptungen an anderer Stelle, dass D & C-Methoden tatsächlich stabiler sind, stützt Ngs Wahl.

@amoeba hatte ausgezeichnete Antworten auf PCA Fragen, darunter diese auf Bezug von SVD zu PCA. Bei der Beantwortung Ihrer genauen Frage werde ich drei Punkte ansprechen:

• Mathematisch gibt es keinen Unterschied, ob Sie PCA direkt in der Datenmatrix oder in ihrer Kovarianzmatrix berechnen
• Der Unterschied liegt lediglich in der numerischen Präzision und Komplexität. Das Anwenden von SVD direkt auf die Datenmatrix ist numerisch stabiler als auf die Kovarianzmatrix
• SVD kann auf die Kovarianzmatrix angewendet werden, um PCA durchzuführen oder Eigenwerte zu erhalten. Tatsächlich ist es meine bevorzugte Methode zur Lösung von Eigenproblemen

Es stellt sich heraus, dass SVD insbesondere für maschinelles Lernen stabiler ist als typische Verfahren zur Zerlegung von Eigenwerten. Beim maschinellen Lernen kommt es leicht zu hochkollinearen Regressoren. SVD funktioniert in diesen Fällen besser.

Hier ist Python-Code, um den Punkt zu demonstrieren. Ich habe eine hochkollineare Datenmatrix erstellt, ihre Kovarianzmatrix erhalten und versucht, deren Eigenwerte zu ermitteln. SVD funktioniert immer noch, während die gewöhnliche Eigenzerlegung in diesem Fall fehlschlägt.

import numpy as np
import math
from numpy import linalg as LA

np.random.seed(1)

# create the highly collinear series
T = 1000
X = np.random.rand(T,2)
eps = 1e-11
X[:,1] = X[:,0] + eps*X[:,1]

C = np.cov(np.transpose(X))
print('Cov: ',C)

U, s, V = LA.svd(C)
print('SVDs: ',s)

w, v = LA.eig(C)
print('eigen vals: ',w)

Ausgabe:

Cov:  [[ 0.08311516  0.08311516]
 [ 0.08311516  0.08311516]]
SVDs:  [  1.66230312e-01   5.66687522e-18]
eigen vals:  [ 0.          0.16623031]

Aktualisieren

Als Antwort auf Federico Polonis Kommentar hier der Code mit Stabilitätsprüfungen von SVD gegen Eig an 1000 Zufallsstichproben derselben Matrix oben. In vielen Fällen zeigt Eig einen kleinen Eigenwert von 0 an, was zur Singularität der Matrix führen würde, und SVD tut dies hier nicht. SVD ist bei einer kleinen Eigenwertbestimmung etwa doppelt so genau, was je nach Problem möglicherweise wichtig ist oder nicht.

import numpy as np
import math
from scipy.linalg import toeplitz
from numpy import linalg as LA

np.random.seed(1)

# create the highly collinear series
T = 100
p = 2
eps = 1e-8

m = 1000 # simulations
err = np.ones((m,2)) # accuracy of small eig value
for j in range(m):
    u = np.random.rand(T,p)
    X = np.ones(u.shape)
    X[:,0] = u[:,0]
    for i in range(1,p):
        X[:,i] = eps*u[:,i]+u[:,0]

    C = np.cov(np.transpose(X))

    U, s, V = LA.svd(C)

    w, v = LA.eig(C)

    # true eigen values
    te = eps**2/2 * np.var(u[:,1])*(1-np.corrcoef(u,rowvar=False)[0,1]**2)
    err[j,0] = s[p-1] - te
    err[j,1] = np.amin(w) - te


print('Cov: ',C)
print('SVDs: ',s)
print('eigen vals: ',w)
print('true small eigenvals: ',te)

acc = np.mean(np.abs(err),axis=0)    
print("small eigenval, accuracy SVD, Eig: ",acc[0]/te,acc[1]/te)

Ausgabe:

Cov:  [[ 0.09189421  0.09189421]
 [ 0.09189421  0.09189421]]
SVDs:  [ 0.18378843  0.        ]
eigen vals:  [  1.38777878e-17   1.83788428e-01]
true small eigenvals:  4.02633695086e-18
small eigenval, accuracy SVD, Eig:  2.43114702041 3.31970128319

Hier Code funktioniert der Code. Anstatt die zufällige Kovarianzmatrix zum Testen der Routinen zu generieren, generiere ich die zufällige Datenmatrix mit zwei Variablen: wobei - unabhängige einheitliche Zufallsvariablen. Die Kovarianzmatrix lautet also wobei - Varianzen der Uniformen und der Korrelationskoeffizienten zwischen Sie.u , v ( σ 2 1 σ 2 1 + ε & rgr; σ 1 σ 2 σ 2 1 + ε & rgr; σ 1 σ 2 σ 2 1 + 2 ε & rgr; σ

$$x_1=u\\ x_2=u+\varepsilon v$$ $u,v$ $$\begin{pmatrix} \sigma_1^2 & \sigma_1^2 + \varepsilon \rho \sigma_1 \sigma_2\\ \sigma_1^2 + \varepsilon \rho \sigma_1 \sigma_2 & \sigma_1^2 + 2 \varepsilon \rho \sigma_1 \sigma_2 + \varepsilon^2 \sigma_2^2\sigma^2\end{pmatrix}$$ $\sigma_1^2,\sigma_2^2,\rho$

Sein kleinster Eigenwert: Der kleine Eigenwert kann nicht durch einfaches Einstecken des in die Formel berechnet werden, da die Genauigkeit begrenzt ist. Sie müssen ihn also erweitern:

$$\lambda= \frac 1 2 \left(\sigma_2^2 \varepsilon^2 - \sqrt{\sigma_2^4 \varepsilon^4 + 4 \sigma_2^3 \rho \sigma_1 \varepsilon^3 + 8 \sigma_2^2 \rho^2 \sigma_1^2 \varepsilon^2 + 8 \sigma_2 \rho \sigma_1^3 \varepsilon + 4 \sigma_1^4} + 2 \sigma_2 \rho \sigma_1 \varepsilon + 2 \sigma_1^2\right)$$ $\varepsilon$ $$\lambda\approx \sigma_2^2 \varepsilon^2 (1-\rho^2)/2$$

Ich führe Simulationen der Realisierungen der Datenmatrix aus, berechne die Eigenwerte der simulierten Kovarianzmatrix und die Fehler .λ j e j = λ - λ$j=1,\dots,m$$\hat\lambda_j$$e_j=\lambda-\hat\lambda_j$

Für Python-Benutzer möchte ich darauf hinweisen, dass es für symmetrische Matrizen (wie die Kovarianzmatrix) besser ist, numpy.linalg.eighFunktion anstelle einer allgemeinen numpy.linalg.eigFunktion zu verwenden.

eighist 9-10 mal schneller als eigauf meinem Computer (unabhängig von der Matrixgröße) und hat eine bessere Genauigkeit (basierend auf dem Genauigkeitstest von @ Aksakal).

Ich bin nicht überzeugt von der Demonstration des Genauigkeitsvorteils der SVD mit kleinen Eigenwerten. @ Aksakals Test ist 1-2 Größenordnungen empfindlicher für den Zufallszustand als für den Algorithmus (versuchen Sie, alle Fehler aufzuzeichnen, anstatt sie auf ein absolutes Maximum zu reduzieren). Dies bedeutet, dass kleine Fehler in der Kovarianzmatrix eine größere Auswirkung auf die Genauigkeit haben als die Wahl eines Algorithmus für die Neuzusammenstellung. Dies hat auch nichts mit der Hauptfrage zu tun, bei der es um PCA geht. Die kleinsten Komponenten werden in PCA ignoriert.

Ein ähnliches Argument kann zur numerischen Stabilität angeführt werden. Wenn ich die Kovarianzmatrixmethode für PCA verwenden muss, würde ich sie mit eighanstelle von zerlegen svd. Wenn dies fehlschlägt (was hier noch nicht demonstriert wurde), lohnt es sich wahrscheinlich, das zu lösende Problem zu überdenken, bevor Sie nach einem besseren Algorithmus suchen.

Um den letzten Teil Ihrer Frage zu beantworten: "Warum machen sie SVD der Kovarianzmatrix, nicht der Datenmatrix?" Ich glaube, es ist aus Performance- und Speichergründen. Typischerweise ist eine sehr große Zahl, und selbst wenn groß ist, würden wir erwarten .n m ≫ $m$$n$$m \gg n$

Das Berechnen der Kovarianzmatrix und das anschließende Durchführen einer SVD ist unter diesen Bedingungen erheblich schneller als das Berechnen der SVD für die vollständige Datenmatrix, um dasselbe Ergebnis zu erzielen.

Selbst bei relativ kleinen Werten beträgt der Leistungszuwachs mehrere tausend Faktoren (Millisekunden gegenüber Sekunden). Ich habe ein paar Tests auf meinem Computer durchgeführt, um Matlab zu vergleichen:

Das ist nur CPU-Zeit, aber der Speicherbedarf ist genauso wichtig, wenn nicht noch wichtiger. Wenn Sie in Matlab SVD auf einer Million mal Tausend-Matrix versuchen, tritt standardmäßig ein Fehler auf, da eine funktionierende Array-Größe von 7,4 TB erforderlich ist.