Analyse en composantes principales

Introduction

L'Analyse en Composantes Principales (PCA en anglais) est une technique statistique utilisée pour simplifier les données. Il s'agit d'une technique de transformation linéaire qui trouve les caractéristiques ou les modèles les plus importants dans les données. La PCA est largement utilisée dans l'analyse de données et l'apprentissage automatique pour la réduction de la dimensionalité, la compression de données et l'extraction de caractéristiques. Dans ce laboratoire, nous allons utiliser la bibliothèque scikit-learn de Python pour effectuer une PCA sur un ensemble de données et visualiser les résultats.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle 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églerons rapidement le problème pour vous.

Importation des bibliothèques

Nous commençons par importer les bibliothèques nécessaires pour ce laboratoire. Nous utiliserons numpy pour les opérations numériques, matplotlib pour la visualisation et scikit-learn pour la PCA.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA

Création des données

Nous allons générer un ensemble de données aléatoires pour ce laboratoire. L'ensemble de données aura trois variables x, y et z. Nous définirons x et y comme des variables aléatoires distribuées normalement avec une moyenne de 0 et un écart-type de 0,5. z est également distribuée normalement avec une moyenne de 0 et un écart-type de 0,1.

e = np.exp(1)
np.random.seed(4)

y = np.random.normal(scale=0.5, size=(30000))
x = np.random.normal(scale=0.5, size=(30000))
z = np.random.normal(scale=0.1, size=len(x))

Effectuer une PCA

Ensuite, nous allons effectuer une PCA sur notre ensemble de données. Nous concaténons d'abord x, y et z pour former un tableau 3D Y. Nous créons ensuite une instance de la classe PCA et l'ajustons à nos données. Nous pouvons ensuite accéder aux composantes principales en utilisant l'attribut components_ de l'objet PCA.

Y = np.c_[x, y, z]
pca = PCA(n_components=3)
pca.fit(Y)
components = pca.components_

Visualiser les résultats de la PCA

Nous pouvons visualiser les résultats de notre PCA en traçant les composantes principales. Nous créons un nuage de points 3D de nos données et colorons chaque point en fonction de sa densité. Nous traçons ensuite les deux premières composantes principales sous forme de plan. Nous répétons ce processus pour deux vues différentes des données.

fig = plt.figure(figsize=(10, 5))

## Première vue
ax = fig.add_subplot(121, projection="3d", elev=-40, azim=-80)
ax.set_title("Vue 1")

## Tracer les données
density = np.exp(-(x ** 2 + y ** 2))
ax.scatter(x, y, z, c=density, cmap="plasma", marker="+", alpha=0.4)

## Tracer les composantes principales
v1 = components[:, 0]
v2 = components[:, 1]
x_pca_plane = np.array([v1[0], -v1[0], -v1[0], v1[0]])
y_pca_plane = np.array([v1[1], -v1[1], -v1[1], v1[1]])
z_pca_plane = np.array([v1[2], -v1[2], v1[2], v1[2]])
ax.plot_surface(x_pca_plane, y_pca_plane, z_pca_plane, alpha=0.2)

## Deuxième vue
ax = fig.add_subplot(122, projection="3d", elev=30, azim=20)
ax.set_title("Vue 2")

## Tracer les données
density = np.exp(-(x ** 2 + y ** 2))
ax.scatter(x, y, z, c=density, cmap="plasma", marker="+", alpha=0.4)

## Tracer les composantes principales
v1 = components[:, 0]
v2 = components[:, 1]
x_pca_plane = np.array([v1[0], -v1[0], -v1[0], v1[0]])
y_pca_plane = np.array([v1[1], -v1[1], -v1[1], v1[1]])
z_pca_plane = np.array([v1[2], -v1[2], v1[2], v1[2]])
ax.plot_surface(x_pca_plane, y_pca_plane, z_pca_plane, alpha=0.2)

plt.show()

Résumé

Dans ce laboratoire, nous avons appris à effectuer une PCA sur un ensemble de données à l'aide de la bibliothèque scikit-learn de Python. Nous avons généré un ensemble de données aléatoires avec trois variables, effectué une PCA et visualisé les résultats. Nous avons tracé les données dans un nuage de points 3D et ajouté un plan pour les deux premières composantes principales. La PCA est une technique puissante pour réduire la dimensionalité des données et trouver les motifs ou les caractéristiques les plus importants.