Introduction
Ce laboratoire applique différentes méthodes de décomposition de matrice non supervisée (réduction de dimension) du module sklearn.decomposition au jeu de données Olivetti faces. Le jeu de données Olivetti faces est composé de 400 visages de taille 64x64 pixels provenant de 40 individus, chacun capturé avec différentes expressions faciales et conditions d'éclairage.
Conseils sur la VM
Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.
Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.
Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.
Préparation du jeu de données
Tout d'abord, nous chargeons et prétraitons le jeu de données Olivetti faces. Nous centrons les données pour avoir une moyenne nulle, à la fois globalement (en se concentrant sur une caractéristique et en centrant toutes les échantillons) et localement (en se concentrant sur un échantillon et en centrant toutes les caractéristiques). Nous définissons également une fonction de base pour tracer la galerie de visages.
## Chargement et prétraitement du jeu de données Olivetti faces.
import logging
from numpy.random import RandomState
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_olivetti_faces
from sklearn import cluster
from sklearn import decomposition
rng = RandomState(0)
## Afficher les journaux de progression sur la sortie standard
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
faces, _ = fetch_olivetti_faces(return_X_y=True, shuffle=True, random_state=rng)
n_samples, n_features = faces.shape
## Centrage global (en se concentrant sur une caractéristique, en centrant toutes les échantillons)
faces_centered = faces - faces.mean(axis=0)
## Centrage local (en se concentrant sur un échantillon, en centrant toutes les caractéristiques)
faces_centered -= faces_centered.mean(axis=1).reshape(n_samples, -1)
print("Le jeu de données contient %d visages" % n_samples)
## Définir une fonction de base pour tracer la galerie de visages.
n_row, n_col = 2, 3
n_components = n_row * n_col
image_shape = (64, 64)
def plot_gallery(title, images, n_col=n_col, n_row=n_row, cmap=plt.cm.gray):
fig, axs = plt.subplots(
nrows=n_row,
ncols=n_col,
figsize=(2.0 * n_col, 2.3 * n_row),
facecolor="white",
constrained_layout=True,
)
fig.set_constrained_layout_pads(w_pad=0.01, h_pad=0.02, hspace=0, wspace=0)
fig.set_edgecolor("black")
fig.suptitle(title, size=16)
for ax, vec in zip(axs.flat, images):
vmax = max(vec.max(), -vec.min())
im = ax.imshow(
vec.reshape(image_shape),
cmap=cmap,
interpolation="nearest",
vmin=-vmax,
vmax=vmax,
)
ax.axis("off")
fig.colorbar(im, ax=axs, orientation="horizontal", shrink=0.99, aspect=40, pad=0.01)
plt.show()
## Regardons notre données. La couleur grise indique des valeurs négatives,
## le blanc indique des valeurs positives.
plot_gallery("Visages du jeu de données", faces_centered[:n_components])
Eigenfaces - PCA utilisant la SVD aléatoire
La première méthode que nous appliquons est la PCA, qui est une technique de réduction de dimension linéaire qui utilise la Décoposition en Valeurs Singulières (SVD) des données pour les projeter dans un espace de dimension plus faible. Nous utilisons la SVD aléatoire, qui est une approximation plus rapide de l'algorithme de SVD standard. Nous traçons les six premiers composants principaux, qui sont appelés eigenfaces.
## Eigenfaces - PCA utilisant la SVD aléatoire
pca_estimator = decomposition.PCA(
n_components=n_components, svd_solver="randomized", whiten=True
)
pca_estimator.fit(faces_centered)
plot_gallery(
"Eigenfaces - PCA utilisant la SVD aléatoire", pca_estimator.components_[:n_components]
)
Composantes non négatives - NMF
Ensuite, nous appliquons la Factorisation de Matrice Non Négative (NMF), qui factorise la matrice de données en deux matrices non négatives, l'une contenant les vecteurs de base et l'autre contenant les coefficients. Cela résulte en une représentation des données basée sur des parties.
## Composantes non négatives - NMF
nmf_estimator = decomposition.NMF(n_components=n_components, tol=5e-3)
nmf_estimator.fit(faces) ## ensemble de données non négatif original
plot_gallery("Composantes non négatives - NMF", nmf_estimator.components_[:n_components])
Composantes indépendantes - FastICA
L'Analyse en Composantes Indépendantes (ICA) est une méthode pour séparer des signaux multivariés en sous-composantes additives qui sont maximale ment indépendantes. Nous appliquons FastICA, qui est un algorithme rapide et robuste pour l'ICA.
## Composantes indépendantes - FastICA
ica_estimator = decomposition.FastICA(
n_components=n_components, max_iter=400, whiten="arbitrary-variance", tol=15e-5
)
ica_estimator.fit(faces_centered)
plot_gallery(
"Composantes indépendantes - FastICA", ica_estimator.components_[:n_components]
)
Composantes sparses - MiniBatchSparsePCA
La PCA sparse est une variante de la PCA qui encourage la sparsité dans les vecteurs de chargement, ce qui conduit à une décomposition plus interprétable. Nous utilisons MiniBatchSparsePCA, qui est une version plus rapide de SparsePCA qui est mieux adaptée aux grands jeux de données.
## Composantes sparses - MiniBatchSparsePCA
batch_pca_estimator = decomposition.MiniBatchSparsePCA(
n_components=n_components, alpha=0.1, max_iter=100, batch_size=3, random_state=rng
)
batch_pca_estimator.fit(faces_centered)
plot_gallery(
"Composantes sparses - MiniBatchSparsePCA",
batch_pca_estimator.components_[:n_components],
)
Apprentissage de dictionnaire
L'apprentissage de dictionnaire est une méthode pour trouver une représentation sparse des données d'entrée sous forme d'une combinaison d'éléments simples, qui forment un dictionnaire. Nous appliquons MiniBatchDictionaryLearning, qui est une version plus rapide de DictionaryLearning qui est mieux adaptée aux grands jeux de données.
## Apprentissage de dictionnaire
batch_dict_estimator = decomposition.MiniBatchDictionaryLearning(
n_components=n_components, alpha=0.1, max_iter=50, batch_size=3, random_state=rng
)
batch_dict_estimator.fit(faces_centered)
plot_gallery("Apprentissage de dictionnaire", batch_dict_estimator.components_[:n_components])
Centres de grappe - MiniBatchKMeans
Le regroupement K-moyennes est une méthode pour partitionner un ensemble de données en grappes en minimisant la somme des distances carrées entre chaque point et le centroïde de la grappe à laquelle il est assigné. Nous appliquons MiniBatchKMeans, qui est une version plus rapide de KMeans qui est mieux adaptée aux grands jeux de données.
## Centres de grappe - MiniBatchKMeans
kmeans_estimator = cluster.MiniBatchKMeans(
n_clusters=n_components,
tol=1e-3,
batch_size=20,
max_iter=50,
random_state=rng,
n_init="auto",
)
kmeans_estimator.fit(faces_centered)
plot_gallery(
"Centres de grappe - MiniBatchKMeans",
kmeans_estimator.cluster_centers_[:n_components],
)
Composantes d'Analyse en Facteurs - FA
L'Analyse en Facteurs est une méthode pour modéliser la variance dans chaque direction de l'espace d'entrée indépendamment (bruit hétéroscédastique), similaire à la PCA mais avec cet avantage. Nous appliquons FactorAnalysis, qui est une implémentation de l'Analyse en Facteurs dans scikit-learn.
## Composantes d'Analyse en Facteurs - FA
fa_estimator = decomposition.FactorAnalysis(n_components=n_components, max_iter=20)
fa_estimator.fit(faces_centered)
plot_gallery("Analyse en Facteurs (FA)", fa_estimator.components_[:n_components])
## --- Variance pixel par pixel
plt.figure(figsize=(3.2, 3.6), facecolor="white", tight_layout=True)
vec = fa_estimator.noise_variance_
vmax = max(vec.max(), -vec.min())
plt.imshow(
vec.reshape(image_shape),
cmap=plt.cm.gray,
interpolation="nearest",
vmin=-vmax,
vmax=vmax,
)
plt.axis("off")
plt.title("Variance pixel par pixel à partir de \n l'Analyse en Facteurs (FA)", size=16, wrap=True)
plt.colorbar(orientation="horizontal", shrink=0.8, pad=0.03)
plt.show()
Décomposition : Apprentissage de dictionnaire
Nous appliquons à nouveau MiniBatchDictionaryLearning, mais cette fois-ci, nous imposons la positivité lors de la recherche du dictionnaire et/ou des coefficients de codage.
Apprentissage de dictionnaire - dictionnaire positif
dict_pos_dict_estimator = decomposition.MiniBatchDictionaryLearning(
n_components=n_components,
alpha=0.1,
max_iter=50,
batch_size=3,
random_state=rng,
positive_dict=True,
)
dict_pos_dict_estimator.fit(faces_centered)
plot_gallery(
"Apprentissage de dictionnaire - dictionnaire positif",
dict_pos_dict_estimator.components_[:n_components],
cmap=plt.cm.RdBu,
)
Apprentissage de dictionnaire - code positif
dict_pos_code_estimator = decomposition.MiniBatchDictionaryLearning(
n_components=n_components,
alpha=0.1,
max_iter=50,
batch_size=3,
fit_algorithm="cd",
random_state=rng,
positive_code=True,
)
dict_pos_code_estimator.fit(faces_centered)
plot_gallery(
"Apprentissage de dictionnaire - code positif",
dict_pos_code_estimator.components_[:n_components],
cmap=plt.cm.RdBu,
)
Apprentissage de dictionnaire - dictionnaire et code positifs
dict_pos_estimator = decomposition.MiniBatchDictionaryLearning(
n_components=n_components,
alpha=0.1,
max_iter=50,
batch_size=3,
fit_algorithm="cd",
random_state=rng,
positive_dict=True,
positive_code=True,
)
dict_pos_estimator.fit(faces_centered)
plot_gallery(
"Apprentissage de dictionnaire - dictionnaire et code positifs",
dict_pos_estimator.components_[:n_components],
cmap=plt.cm.RdBu,
)
Sommaire
Dans ce laboratoire, nous avons appliqué diverses méthodes de décomposition de matrices non supervisées à l'ensemble de données des visages Olivetti. Nous avons utilisé la PCA, la NMF, l'ICA, la PCA sparse, l'apprentissage de dictionnaire, le regroupement K-moyennes et l'analyse factorielle pour extraire différents types de caractéristiques à partir des données. Nous avons également imposé la positivité lors de la recherche du dictionnaire et/ou des coefficients de codage dans la méthode d'apprentissage de dictionnaire. Dans l'ensemble, ces méthodes peuvent être utiles pour réduire la dimensionalité d'ensembles de données à haute dimension et extraire des caractéristiques significatives pour les tâches de traitement ultérieur telles que la classification et le regroupement.