PCA de la projection et de la reconstruction en scikit-learn

Je peux effectuer l'ACP, scikit par le code ci-dessous:
X_train a 279180 lignes et 104 colonnes.

from sklearn.decomposition import PCA
pca = PCA(n_components=30)
X_train_pca = pca.fit_transform(X_train)

Maintenant, quand je veux projeter les vecteurs propres sur la fonctionnalité de l'espace, je doit effectuer les opérations suivantes:

""" Projection """
comp = pca.components_ #30x104
com_tr = np.transpose(pca.components_) #104x30
proj = np.dot(X_train,com_tr) #279180x104 * 104x30 = 297180x30

Mais je suis hésitant à cette étape, parce que Scikit la documentation dit:

components_: array [n_components, n_features]

Axes principaux dans l'espace de la fonctionnalité, représentant les directions du maximum de la variance dans les données.

Il me semble que c'est déjà prévu, mais quand j'ai regardé le code source, il ne retourne que les vecteurs propres.

Quelle est la bonne façon de comment la projeter?

En fin de compte, je suis visant à calculer le MSE de la reconstruction.

""" Reconstruct """
recon = np.dot(proj,comp) #297180x30 * 30x104 = 279180x104

"""  MSE Error """
print "MSE = %.6G" %(np.mean((X_train - recon)**2))

InformationsquelleAutor HonzaB | 2016-04-12

22

Vous pouvez faire
```
proj = pca.inverse_transform(X_train_pca)
```
De cette façon, vous n'avez pas à vous soucier de la façon de faire les multiplications.

Ce que vous obtenez après pca.fit_transform ou pca.transform sont ce qu'on appelle habituellement les "charges" pour chaque échantillon, signifiant la quantité de chaque composant dont vous avez besoin pour le mieux pour le décrire à l'aide d'une combinaison linéaire de la components_ (les axes principaux en fonction de l'espace).

La projection que vous visez est de retour dans le signal d'origine de l'espace. Cela signifie que vous devez aller dans le signal de l'espace en utilisant les composants et les chargements.

Donc, il y a trois étapes pour lever l'ambiguïté ici. Vous avez ici, étape par étape, ce que vous pouvez faire à l'aide de l'APC objet et comment il est effectivement calculé:
1. pca.fit estimations les composants (à l'aide d'un SVD sur l'centrée Xtrain):
```
from sklearn.decomposition import PCA
import numpy as np
from numpy.testing import assert_array_almost_equal

#Should this variable be X_train instead of Xtrain?
X_train = np.random.randn(100, 50)

pca = PCA(n_components=30)
pca.fit(X_train)

U, S, VT = np.linalg.svd(X_train - X_train.mean(0))

assert_array_almost_equal(VT[:30], pca.components_)
```
2. pca.transform calcule les charges que vous la décrivez
```
X_train_pca = pca.transform(X_train)

X_train_pca2 = (X_train - pca.mean_).dot(pca.components_.T)

assert_array_almost_equal(X_train_pca, X_train_pca2)
```
3. pca.inverse_transform obtient la projection sur les composantes du signal de l'espace qui vous intéresse
```
X_projected = pca.inverse_transform(X_train_pca)
X_projected2 = X_train_pca.dot(pca.components_) + pca.mean_

assert_array_almost_equal(X_projected, X_projected2)
```
Vous pouvez maintenant évaluer la projection perte
```
loss = ((X_train - X_projected) ** 2).mean()
```
- Ok, donc, je peux appeler pca.fit pour calculer les composants, puis la projection peut être calculée par pca.fit_transform (c'est aussi quand je veux continuer à travailler avec les données récupérer leur de certains, car la dimension est réduite). Et pour la reconstruction, j'appelle pca.invert_transform pour calculer MSE. Est-ce exact?
- Cela dépend de ce que tu veux dire par projection. Tout d'abord, notez que pca.fit_transform(X) donne le même résultat que pca.fit(X).transform(X) (c'est une optimisation du raccourci). Deuxièmement, une projection est généralement quelque chose qui va d'un espace dans le même espace, alors voici ce que donnerait le signal de l'espace de signal de l'espace, avec la propriété que de l'appliquer deux fois, c'est comme de l'appliquer une fois. Ici, il serait f= lambda X: pca.inverse_transform(pca.transform(X)). Vous pouvez le vérifier f(f(X)) == f(X). Donc, je dirais que la projection. pca.transform est l'obtention de l'chargements. En fin de compte c'est juste terminolgy
- Par projection, je veux dire de transformer les vecteurs sur l'espace de la fonctionnalité. C'est ce que j'ai fait dans ma question (deuxième étape) et c'est la même chose que pca.transform(X) n'est la matrice de Mxk, où M est le nombre de lignes et de k nombre de composants sélectionnés. Je vais l'utiliser comme entrée pour les modèles (et je devrais attendre de meilleurs résultats que l'utilisation d'ensembles de données d'origine)
- Ensuite, l'utilisation de la canalisation. from sklearn.pipeline import make_pipeline puis pipeline = make_pipeline(PCA(n_components=30), your_classifier) et vous pouvez l'utiliser comme votre propre classificateur. Toutefois, notez qu'une projection est une opération définie mathématiquement et il peut être préférable de l'utiliser de cette façon pour éviter tout malentendu: en.wikipedia.org/wiki/Projection_%28linear_algebra%29
- Vous avez raison, je reçois ma terminologie de concert pour la prochaine fois. Et l'utilisation de la canalisation. Merci pour l'aide.
- Oubliez ce que j'ai dit à propos de la projection à la fois 2 et 3 sont des projections, simplement représenté de différentes manières.
- super génial explicatives répondre
- Je voulais juste dire que assert_array_almost_equal(VT[:30], pca.components_) n'est pas toujours vrai. Dans la mise en œuvre de l'APC, les signes sont bousculés entre U et V. Pour imiter ce brassage remplacer U, S, VT = np.linalg.svd(Xtrain - Xtrain.mean(0)) par U, S, VT = np.linalg.svd(Xtrain - Xtrain.mean(0), full_matrices=False) et insérez from sklearn.utils.extmath import svd_flip suivie par U, VT = svd_flip(U, VT).
- oui, bonne remarque, merci!
- Ne X_train dans loss = ((X_train - X_projected) ** 2).mean() remplacer Xtrain variable définie plus haut dans le code?
- Ouais c'était une faute de frappe. N'hésitez pas à modifier (probablement Xtrain -> X_train serait le mieux)
- Merci pour l'edit
- Grâce eickenberg. Grande explication ainsi, m'a aidée à sortir massivement!
InformationsquelleAutor eickenberg

Ajout sur @eickenberg post, voici comment faire de l'apc de reconstruction des chiffres' images:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn import decomposition

n_components = 10
image_shape = (8, 8)

digits = load_digits()
digits = digits.data

n_samples, n_features = digits.shape
estimator = decomposition.PCA(n_components=n_components, svd_solver='randomized', whiten=True)
digits_recons = estimator.inverse_transform(estimator.fit_transform(digits))

# show 5 randomly chosen digits and their PCA reconstructions with 10 dominant eigenvectors
indices = np.random.choice(n_samples, 5, replace=False)
plt.figure(figsize=(5,2))
for i in range(len(indices)):
    plt.subplot(1,5,i+1), plt.imshow(np.reshape(digits[indices[i],:], image_shape)), plt.axis('off')
plt.suptitle('Original', size=25)
plt.show()
plt.figure(figsize=(5,2))
for i in range(len(indices)):
    plt.subplot(1,5,i+1), plt.imshow(np.reshape(digits_recons[indices[i],:], image_shape)), plt.axis('off')
plt.suptitle('PCA reconstructed'.format(n_components), size=25)
plt.show()

PCA de la projection et de la reconstruction en scikit-learn

InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.