Come interpretare i risultati della decomposizione dei valori singolari (Python 3)?

Question

Sto cercando di imparare come ridurre la dimensionalità nei set di dati. Mi sono imbattuto in alcuni tutorial su Principle Component Analysis e Singular Value Decomposition. Comprendo che prende la dimensione della massima varianza e collassa sequenzialmente le dimensioni della varianza immediatamente successiva (eccessivamente semplificata).

Sono confuso su come interpretare le matrici di output. Ho guardato la documentazione ma non è stato di grande aiuto. Ho seguito alcuni tutorial e non ero sicuro di quali fossero esattamente le matrici risultanti. Ho fornito un codice per avere un'idea della distribuzione di ciascuna variabile nel set di dati (sklearn.datasets).

mio array di input iniziale è un (n x m) matrice di n samples e m attributes. Potrei fare una trama PCA comune di PC1 contro PC2 ma come faccio a sapere quali dimensioni rappresenta ciascun PC?

Siamo spiacenti se questa è una domanda di base. Molte risorse sono molto complesse per la matematica e io sto bene, ma una risposta più intuitiva sarebbe utile. No, dove ho visto discorsi su come interpretare l'output in termini di dati etichettati originali.

Sono aperto ad usare sklearn s' decomposition.PCA

#Singular Value Decomposition 
U, s, V = np.linalg.svd(X, full_matrices=True) 
print(U.shape, s.shape, V.shape, sep="\n") 
(442, 442) 
(10,) 
(10, 10) 

Answer 1

Come detto sopra matrice M può decomposto come prodotto ot 3 matrici: U * S * V * . Il senso geometrico è il seguente: qualsiasi trasformazione può essere considerata come una sequenza di rotazione (V ^*), ridimensionamento (S) e rotazione di nuovo (U). Ecco il buono description and animation.

Cosa è importante per noi? Matrix S è diagonale - tutti i suoi valori situata al largo della diagonale principale sono 0.

come:

np.diag(s) 

array([[ 2.00604441, 0.  , 0.  , 0.  , 0.  ,   0.  , 0.  , 0.  , 0.  , 0.  ], 
     [ 0.  , 1.22160478, 0.  , 0.  , 0.  ,   0.  , 0.  , 0.  , 0.  , 0.  ], 
     [ 0.  , 0.  , 1.09816315, 0.  , 0.  ,   0.  , 0.  , 0.  , 0.  , 0.  ], 
     [ 0.  , 0.  , 0.  , 0.97748473, 0.  ,   0.  , 0.  , 0.  , 0.  , 0.  ], 
     [ 0.  , 0.  , 0.  , 0.  , 0.81374786,   0.  , 0.  , 0.  , 0.  , 0.  ], 
     [ 0.  , 0.  , 0.  , 0.  , 0.  ,   0.77634993, 0.  , 0.  , 0.  , 0.  ], 
     [ 0.  , 0.  , 0.  , 0.  , 0.  ,   0.  , 0.73250287, 0.  , 0.  , 0.  ], 
     [ 0.  , 0.  , 0.  , 0.  , 0.  ,   0.  , 0.  , 0.65854628, 0.  , 0.  ], 
     [ 0.  , 0.  , 0.  , 0.  , 0.  ,   0.  , 0.  , 0.  , 0.27985695, 0.  ], 
     [ 0.  , 0.  , 0.  , 0.  , 0.  ,   0.  , 0.  , 0.  , 0.  , 0.09252313]]) 

geometricamente - ogni valore è un fattore di scala lungo l'asse particolare. Per i nostri scopi (classificazione e regressione) questi valori mostrano l'impatto di un particolare asse sul risultato complessivo.

Come si può vedere questi valori sono in calo da 2,0 a 0,093. Una delle applicazioni più importanti - facile Low-rank matrix approximation con una precisione data. Se non hai bisogno di una decomposizione ultra-precisa (è vero per i problemi di ML) puoi buttare via i valori più bassi e mantenere solo l'importanza. In tal modo, è possibile affinare la soluzione passo dopo passo: stimare la qualità con il set di prova, eliminare i valori minimi e ripetere. Di conseguenza ottieni una soluzione facile e robusta.

Qui buoni candidati per essere a contrazione sono 8 e 9, poi 5-7, e come ultima opzione che si può approssimare il modello di un solo valore - in primo luogo.