PCA

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.