Saya belajar PCA dari kursus Andrew Ng's Coursera dan materi lainnya. Dalam tugas pertama Stanford NLP kursus cs224n , dan dalam video ceramah dari Andrew Ng , mereka melakukan dekomposisi nilai singular bukan dekomposisi vektor eigen dari matriks kovarians, dan Ng bahkan mengatakan bahwa SVD secara numerik lebih stabil daripada komposisi eigend.

Dari pemahaman saya, untuk PCA kita harus melakukan SVD dari matriks (m,n)ukuran data , bukan dari matriks kovarians (n,n)ukuran. Dan dekomposisi vektor eigen dari matriks kovarians.

Mengapa mereka melakukan SVD matriks kovarians, bukan matriks data?

amuba sudah memberikan jawaban yang baik di komentar, tetapi jika Anda ingin argumen formal, ini dia.

Dekomposisi nilai singular dari matriks adalah , di mana kolom adalah vektor eigen dari dan entri diagonal adalah akar kuadrat dari nilai eigennya, yaitu .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)}$

Seperti yang Anda ketahui, komponen utama adalah proyeksi ortogonal variabel Anda ke ruang vektor eigen dari matriks kovarians empiris . komponen diberikan oleh nilai eigennya, .λi($\frac{1}{n-1}A^TA$$\lambda_i(\frac{1}{n-1}A^TA)$

Pertimbangkan matriks persegi , dan vektor sedemikian rupa sehingga . Kemudianα ∈ 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)$

Mari kita mendefinisikan . SVD akan menghitung komposisi eigend dari untuk menghasilkanSSTS=$S=\frac{1}{n-1}A^TA$$S$$S^TS=\frac{1}{(n-1)^2}A^TAA^TA$

1. vektor eigen dari , yang menurut properti 1 adalah milikA T$(A^TA)^TA^TA=A^TAA^TA$$A^TA$
2. yang akar kuadrat dari nilai eigen dari , yang oleh properti 2, kemudian 1, kemudian 2 lagi, adalah .$\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)$

Voa!

Mengenai stabilitas numerik, orang perlu mencari tahu apa alogritma yang digunakan. Jika Anda mau, saya percaya ini adalah rutinitas LAPACK yang digunakan oleh numpy:

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

Pembaruan: Pada stabilitas, implementasi SVD tampaknya menggunakan pendekatan divide-and-conquer, sedangkan komposisi eigend menggunakan algoritma QR polos. Saya tidak dapat mengakses beberapa makalah SIAM yang relevan dari institusi saya (menyalahkan pemotongan penelitian) tetapi saya menemukan sesuatu yang dapat mendukung penilaian bahwa rutin SVD lebih stabil.

Di

Nakatsukasa, Yuji, dan Nicholas J. Higham. "Algoritma spektral divide dan menaklukkan yang stabil dan efisien untuk dekomposisi nilai eigen simetris dan SVD." Jurnal SIAM tentang Scientific Computing 35.3 (2013): A1325-A1349.

mereka membandingkan stabilitas berbagai algoritma nilai eigen, dan tampaknya pendekatan divide-and-conquer (mereka menggunakan yang sama dengan numpy dalam salah satu eksperimen!) lebih stabil daripada algoritma QR. Ini, bersama dengan klaim di tempat lain bahwa metode D&C memang lebih stabil, mendukung pilihan Ng.

@amoeba memiliki jawaban yang sangat baik untuk pertanyaan PCA, termasuk yang ini tentang hubungan SVD ke PCA. Menjawab pertanyaan persis Anda, saya akan membuat tiga poin:

• Secara matematis tidak ada perbedaan apakah Anda menghitung PCA pada matriks data secara langsung atau pada matriks kovariannya
• perbedaannya murni karena presisi numerik dan kompleksitas. Menerapkan menerapkan SVD langsung ke matriks data secara numerik lebih stabil daripada ke matriks kovarians
• SVD dapat diterapkan ke matriks kovarians untuk melakukan PCA atau mendapatkan nilai eigen, pada kenyataannya, ini adalah metode favorit saya untuk memecahkan masalah eigen

Ternyata SVD lebih stabil daripada prosedur dekomoposisi nilai eigen tipikal, terutama, untuk pembelajaran mesin. Dalam pembelajaran mesin, mudah untuk berakhir dengan regresi yang sangat kolinear. SVD bekerja lebih baik dalam kasus ini.

Berikut kode Python untuk menunjukkan maksudnya. Saya membuat matriks data yang sangat collinear, mendapatkan matriks kovariannya dan mencoba untuk mendapatkan nilai eigen dari yang terakhir. SVD masih berfungsi, sementara dekomposisi eigen biasa gagal dalam kasus ini.

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)

Keluaran:

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

Memperbarui

Menjawab komentar Federico Poloni, inilah kode dengan pengujian stabilitas SVD vs Eig pada 1000 sampel acak dari matriks yang sama di atas. Dalam banyak kasus Eig menunjukkan 0 nilai eigen kecil, yang akan menyebabkan singularitas matriks, dan SVD tidak melakukannya di sini. SVD sekitar dua kali lebih tepat pada penentuan nilai eigen kecil, yang mungkin atau mungkin tidak penting tergantung pada masalah Anda.

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)

Keluaran:

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

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

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

$j=1,\dots,m$$\hat\lambda_j$$e_j=\lambda-\hat\lambda_j$

Untuk pengguna Python, saya ingin menunjukkan bahwa untuk matriks simetris (seperti matriks kovarians), lebih baik menggunakan numpy.linalg.eighfungsi daripada numpy.linalg.eigfungsi umum .

eigh9-10 kali lebih cepat daripada eigdi komputer saya (terlepas dari ukuran matriks) dan memiliki akurasi yang lebih baik (berdasarkan uji akurasi @ Aksakal).

Saya tidak yakin dengan demonstrasi manfaat akurasi SVD dengan nilai eigen kecil. Tes @ Aksakal adalah 1-2 urutan besarnya lebih sensitif terhadap keadaan acak daripada algoritma (cobalah merencanakan semua kesalahan alih-alih menguranginya menjadi satu maksimum absolut). Ini berarti bahwa kesalahan kecil dalam matriks kovarians akan memiliki efek yang lebih besar pada akurasi daripada pemilihan algoritma komposisi eigendec. Juga, ini tidak terkait dengan pertanyaan utama, yaitu tentang PCA. Komponen terkecil diabaikan dalam PCA.

Argumen serupa dapat dibuat tentang stabilitas numerik. Jika saya harus menggunakan metode matriks kovarians untuk PCA, saya akan menguraikannya dengan eighbukan svd. Jika gagal (yang belum didemonstrasikan di sini), maka mungkin Anda perlu memikirkan kembali masalah yang Anda coba selesaikan sebelum mulai mencari algoritma yang lebih baik.

$m$$n$$m \gg n$

Menghitung matriks kovarians dan kemudian melakukan SVD pada yang jauh lebih cepat daripada menghitung SVD pada matriks data lengkap dalam kondisi ini, untuk hasil yang sama.

Bahkan untuk nilai yang cukup kecil, peningkatan kinerja adalah faktor ribuan (milidetik vs detik). Saya menjalankan beberapa tes pada mesin saya untuk membandingkan menggunakan Matlab:

Itu hanya waktu CPU, tetapi kebutuhan penyimpanan sama pentingnya, jika tidak lebih penting. Jika Anda mencoba SVD pada sejuta demi seribu matriks di Matlab, ia akan melakukan kesalahan secara default, karena membutuhkan ukuran larik yang berfungsi yaitu 7.4TB.