PCA

La PCA est une méthode d’apprentissage non supervisé utilisée pour réduire la dimensionnalité des données tout en conservant l’essentiel de leur variance. L’objectif est de transformer les variables initiales en un nouvel ensemble de variables non corrélées, appelées composantes principales.

Chaque composante principale est une combinaison linéaire des variables originales et représente une direction de variance maximale dans les données. La PCA permet ainsi de simplifier les données, faciliter la visualisation et réduire le bruit tout en conservant l’information la plus importante.

La PCA est utilisée en science des données, bioinformatique, finance et traitement d’images pour explorer, visualiser et préparer des données avant l’application de méthodes d’apprentissage supervisé ou non supervisé.

La qualité de la réduction peut être évaluée par la proportion de variance expliquée par les composantes principales.

En résumé, la PCA permet de résumer et visualiser des données complexes tout en conservant l’information essentielle.

Fonctions :

PCA()

La fonction PCA() (Analyse en Composantes Principales) permet de réduire la dimensionnalité d’un jeu de données tout en conservant l’essentiel de sa variance. Elle transforme les variables initiales en un nouvel ensemble de variables orthogonales (composantes principales) classées par ordre d’importance, facilitant ainsi la visualisation, l’analyse et le traitement des données.

Importation :

from sklearn.decomposition import PCA

Attributs :

Paramètre	Type	Description	Valeur par défaut
`n_components`	int, float, str ou None	Nombre de composantes principales à garder. Peut être un entier, une fraction (pour garder une variance expliquée), ou "mle" pour estimation automatique.	`None`
`copy`	bool	Si True, les données sont copiées avant transformation, sinon transformées en place.	`True`
`whiten`	bool	Si True, les composantes principales sont mises à l'échelle pour avoir une variance unitaire.	`False`
`svd_solver`	str	Méthode de décomposition : "auto", "full", "arpack", "randomized".	`"auto"`
`tol`	float	Seuil de tolérance pour le solveur "arpack".	`0.0`
`iterated_power`	int ou "auto"	Nombre d'itérations pour le solveur "randomized".	`"auto"`
`random_state`	int, RandomState instance ou None	Graine aléatoire pour la reproductibilité du solveur "randomized".	`None`

Exemple de code :

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

# Générer des données 2D (3 clusters)
X, y = make_blobs(n_samples=300, centers=3, cluster_std=1.0, random_state=42)

# Appliquer PCA pour réduire de 2D à 1D
pca = PCA(n_components=1)
X_pca = pca.fit_transform(X)

print("Variance expliquée par la composante principale :", pca.explained_variance_ratio_)

# Visualiser les données originales et leur projection PCA
plt.figure(figsize=(12,5))

plt.subplot(1, 2, 1)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis')
plt.title("Données originales (2D)")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")

plt.subplot(1, 2, 2)
plt.scatter(X_pca, np.zeros_like(X_pca), c=y, cmap='viridis')
plt.title("Données projetées sur 1D (PCA)")
plt.xlabel("Composante principale 1")
plt.yticks([])

plt.show()

Explication du code :

import numpy as np importe la bibliothèque NumPy, utilisée pour la manipulation de tableaux numériques.

import matplotlib.pyplot as plt importe matplotlib, qui sert à créer des graphiques.

from sklearn.decomposition import PCA importe la classe PCA du module de décomposition de scikit-learn, qui permet de réduire la dimensionnalité des données.

from sklearn.datasets import make_blobs importe la fonction make_blobs, utilisée pour générer des données synthétiques en clusters.

Génération de données en 2D

X, y = make_blobs(n_samples=300, centers=3, cluster_std=1.0, random_state=42) crée un jeu de données contenant 300 points répartis en 3 clusters distincts, avec un écart-type de 1.0.

La variable X contient les coordonnées des points (features), et y leurs étiquettes de cluster (labels).

Application de la PCA

pca = PCA(n_components=1) initialise un objet PCA qui va réduire les données à 1 dimension (composante principale).

X_pca = pca.fit_transform(X) ajuste la PCA sur les données X et projette ces données originales dans un espace à 1 dimension.
Le résultat est stocké dans X_pca.

Variance expliquée

print("Variance expliquée par la composante principale :", pca.explained_variance_ratio_) affiche la proportion de la variance totale des données expliquée par la première composante principale.
Cela indique à quel point la réduction à 1 dimension conserve l'information originale.

Visualisation des données

plt.figure(figsize=(12,5)) crée une figure large pour afficher deux graphiques côte à côte.

plt.subplot(1, 2, 1) prépare le premier sous-graphique pour afficher les données originales en 2D.

plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis') trace un nuage de points coloré par cluster dans l’espace 2D.

plt.title("Données originales (2D)") et les commandes plt.xlabel /

plt.ylabel ajoutent un titre et des étiquettes aux axes.

plt.subplot(1, 2, 2) prépare le deuxième sous-graphique pour afficher les données projetées en 1D.

plt.scatter(X_pca, np.zeros_like(X_pca), c=y, cmap='viridis') trace les données projetées sur une ligne horizontale (axe y = 0) colorées par cluster, pour visualiser la réduction dimensionnelle.

plt.title("Données projetées sur 1D (PCA)"), plt.xlabel définissent le titre et l’étiquette de l’axe x.

plt.yticks([]) masque les graduations sur l’axe y car la dimension est réduite à une ligne.

Cette visualisation montre comment la PCA réduit la dimension tout en séparant autant que possible les clusters, et indique la qualité de cette réduction via la variance expliquée.

PCA