Я вивчаю PCA з курсу Coursera Ендрю Нґ та інших матеріалів. У першому завданні курсу Stanford NLP cs224n , а в лекційному відео від Ендрю Нг вони роблять сингулярне розкладання значення замість власного вектора розкладання коваріаційної матриці, і Ng навіть говорить, що SVD чисельно стабільніше, ніж ейгендекомпозиція.

З мого розуміння, для PCA ми повинні робити SVD матриці даних (m,n)розміру, а не коваріаційної матриці (n,n)розміру. І власне векторне розкладання матриці коваріації.

Чому вони роблять SVD матриці коваріації, а не матрицю даних?

Амеба вже дав хорошу відповідь у коментарях, але якщо ви хочете формального аргументу, ось це йде.

Синулярне розкладання матриці дорівнює , де стовпці є власними векторами а діагональні записи - квадратні корені її власних значень, тобто .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)}$

Як відомо, основними компонентами є ортогональні проекції змінних на простір власних векторів емпіричної матриці коваріації . Варіантність компонентів задається його власними значеннями, .λi($\frac{1}{n-1}A^TA$$\lambda_i(\frac{1}{n-1}A^TA)$

Розглянемо будь-яку квадратну матрицю , та вектор такий, що . Потімα ∈ 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)$

Давайте визначимо . SVD of обчислить ейгендекомпозицію щоб отриматиSSTS=$S=\frac{1}{n-1}A^TA$$S$$S^TS=\frac{1}{(n-1)^2}A^TAA^TA$

1. власних векторів , які за властивістю 1 є тимиA T$(A^TA)^TA^TA=A^TAA^TA$$A^TA$
2. ці квадратні корені власних значень , який за властивістю 2, потім 1, потім 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)$

Вуаля!

Щодо чисельної стійкості, потрібно було б розібратися, що таке зайняті алоритми. Якщо ви вирішили це зробити, я вважаю, що це підпрограми LAPACK, якими користується numpy:

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

Оновлення: Щодо стабільності, реалізація SVD, як видається, використовує підхід «ділити і перемогти», тоді як для eigendecomposition використовується звичайний QR-алгоритм. Я не можу отримати доступ до якихось відповідних паперів SIAM від мого закладу (звинувачення у винах дослідження), але я знайшов щось, що могло б підтримати оцінку того, що звичайна програма SVD є більш стабільною.

В

Накацукаса, Юджі та Ніколас Дж. Хігхем. "Стабільний та ефективний спектральний алгоритм розділення та підкорення для симетричного розкладання власного значення та SVD." Журнал SIAM з наукових обчислень 35.3 (2013): A1325-A1349.

вони порівнюють стійкість різних алгоритмів власного значення, і здається, що підхід ділити і перемогти (вони використовують те саме, що і numpy в одному з експериментів!) є більш стійким, ніж алгоритм QR. Це разом із твердженнями в іншому місці про те, що методи науково-дослідної роботи дійсно більш стабільні, підтримує вибір Ng.

@amoeba отримав відмінні відповіді на питання PCA, включаючи цю щодо відношення SVD до PCA. Відповідаючи на ваше точне запитання, я зазначу три моменти:

• математично немає різниці, чи обчислюєте ви PCA на матриці даних безпосередньо чи на її коваріаційній матриці
• різниця обумовлена ​​чисельною точністю і складністю. Застосування застосування SVD безпосередньо до матриці даних чисельно стабільніше, ніж до матриці коваріації
• SVD можна застосувати до матриці коваріації для виконання PCA або отримання власних значень, насправді це мій улюблений метод вирішення власних задач

Виявляється, SVD більш стійкий, ніж типові процедури декомпозиції власного значення, особливо для машинного навчання. У машинному навчанні легко покінчити з висококолинеарними регресорами. SVD працює в цих випадках краще.

Ось код Python для демонстрації суті. Я створив високолінійну матрицю даних, отримав її коваріаційну матрицю і спробував отримати власні значення останньої. SVD все ще працює, в той час як звичайне розкладання власних властивостей не вдається.

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)

Вихід:

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

Оновлення

Відповідаючи на коментар Федеріко Полоні, ось код із тестуванням на стабільність SVD проти Eig на 1000 випадкових вибірках тієї ж матриці вище. У багатьох випадках Eig показує 0 малих власних значень, що призведе до сингулярності матриці, і SVD цього не робить. SVD приблизно вдвічі точніший при визначенні невеликого значення власного значення, що може бути або не бути важливим залежно від вашої проблеми.

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)

Вихід:

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$

Для користувачів Python я хотів би зазначити, що для симетричних матриць (як матриця коваріації) краще використовувати numpy.linalg.eighфункцію замість загальної numpy.linalg.eigфункції.

eighв 9-10 разів швидше, ніж eigна моєму комп’ютері (незалежно від розміру матриці) і має кращу точність (на основі тесту на @ Aksakal на точність).

Я не переконаний у демонстрації переваги точності SVD з малими власними значеннями. @ Тест Аксакала на 1-2 порядки більш чутливий до випадкового стану, ніж до алгоритму (спробуйте скласти всі помилки, а не зменшити їх до одного абсолютного максимуму). Це означає, що невеликі помилки в матриці коваріації матимуть більший вплив на точність, ніж вибір алгоритму ейгендекомпозиції. Також це не пов'язане з головним питанням, яке стосується PCA. Найменші компоненти ігноруються в PCA.

Аналогічний аргумент можна зробити щодо чисельної стійкості. Якщо мені доведеться використовувати метод коваріаційної матриці для PCA, я б розклав її eighзамість svd. Якщо це не вдалося (що ще тут не було продемонстровано), то, ймовірно, варто переосмислити проблему, яку ви намагаєтеся вирішити, перш ніж почати шукати кращий алгоритм.

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

Обчислення матриці коваріації, а потім виконання SVD на цьому значно швидше, ніж обчислення SVD на повній матриці даних за цих умов для того ж результату.

Навіть для досить малих значень підвищення продуктивності - це тисячі факторів (мілісекунд проти секунд). Я провів кілька тестів на своїй машині для порівняння за допомогою Matlab:

Це просто час процесора, але потреби в сховищі так само важливі, якщо не більше. Якщо ви спробуєте SVD на матриці на мільйон на тисячу в Matlab, він за замовчуванням помилиться, оскільки йому потрібен розмір робочого масиву 7,4 ТБ.