ACP (Analyse en Composantes Principales) : Guide complet — Principes, Exemples et Implémentation Python

Résumé

L’Analyse en Composantes Principales (ACP), ou Principal Component Analysis (PCA) en anglais, est l’algorithme de réduction de dimensionalité non supervisé le plus fondamental et le plus largement utilisé en science des données. Elle transforme un ensemble de variables potentiellement corrélées en un nouvel ensemble de variables linéairement indépendantes, appelées composantes principales, ordonnées par la quantité de variance qu’elles capturent. Le résultat : moins de dimensions, moins de bruit, et des données toujours interprétables.

Dans ce guide complet, nous explorons les fondements mathématiques de l’ACP, son intuition géométrique, son implémentation pratique avec scikit-learn, ses hyperparamètres, ainsi que ses forces et limites.

Principe mathématique de l’ACP

L’ACP repose sur un enchaînement logique d’opérations algébriques. Comprendre chaque étape est essentiel pour l’appliquer correctement et interpréter ses résultats.

1. Centrage et réduction

Soit une matrice de données X de taille n × p, où n est le nombre d’observations et p le nombre de variables. La première étape consiste à centrer et réduire chaque variable :

Pour chaque variable j (colonne j de X) :

• Centrage : on soustrait la moyenne de la variable à chaque observation.
  x’_ij = x_ij − x̄_j
• Réduction : on divise par l’écart-type de la variable.
  x’‘_ij = (x_ij − x̄_j) / σ_j

La matrice résultante Z est centrée-réduite : chaque colonne a une moyenne nulle et un écart-type égal à 1. Cette étape est cruciale car les variables mesurées dans des unités différentes (par exemple, des kilogrammes et des centimètres) auraient sinon des échelles de variance incomparables, et l’ACP serait biaisée vers les variables à grande échelle.

2. Matrice de covariance

On calcule la matrice de covariance de la matrice centrée-réduite Z :

C = (1/n) × Zᵀ × Z

Cette matrice C est de taille p × p. Elle est :

• Symétrique : C_ij = C_ji
• Définie positive (ou semi-définie positive) : toutes ses valeurs propres sont positives ou nulles
• Ses termes diagonaux valent 1 (car les variables ont été réduites)
• Ses termes hors diagonale représentent les coefficients de corrélation entre variables

Lorsque les données ne sont pas réduites mais seulement centrées, les termes diagonaux représentent les variances de chaque variable, et les termes hors diagonale les covariances.

3. Décomposition en valeurs propres et vecteurs propres

Le cœur de l’ACP est la décomposition spectrale de la matrice de covariance C. On cherche les valeurs propres λ_i et les vecteurs propres v_i tels que :

C × v_i = λ_i × v_i

Pour une matrice p × p, on obtient p paires (λ_i, v_i) ordonnées par valeurs propres décroissantes :

λ₁ ≥ λ₂ ≥ … ≥ λ_p ≥ 0

Les propriétés clés sont :

• Chaque valeur propre λ_i représente la quantité de variance capturée par la i-ème composante principale.
• Chaque vecteur propre v_i définit la direction de cette composante principale dans l’espace original des p dimensions.
• Les vecteurs propres sont orthogonaux entre eux : ils forment une base orthonormée de l’espace.
• La somme des valeurs propres est égale à la trace de la matrice de covariance, c’est-à-dire la variance totale : Σλ_i = trace(C) = p (pour des données réduites).

4. Projection sur les k premières composantes

On choisit de garder seulement les k premières composantes principales (avec k < p). La matrice de projection V_k est formée des k premiers vecteurs propres (colonnes). La transformation s’écrit :

T = Z × V_k

où T est la matrice transformée de taille n × k. Chaque observation est maintenant représentée dans un espace de dimension k au lieu de p.

5. Variance expliquée

La proportion de variance expliquée par la i-ème composante principale se calcule comme :

Variance expliquée (composante i) = λ_i / Σλ_j

La variance expliquée cumulée des k premières composantes est :

Variance cumulée = (Σ_{i=1}^{k} λ_i) / Σλ_j

Un choix courant est de sélectionner k tel que la variance cumulée dépasse un seuil, typiquement 90 % ou 95 %. Cela garantit que l’essentiel de l’information est préservé malgré la réduction de dimension.

Intuition géométrique

Imaginez que vous observez un objet tridimensionnel — disons un ballon de rugby allongé. Si vous le regardez de face, vous ne voyez qu’un cercle plat. Si vous le regardez de côté, vous percevez sa vraie forme allongée. L’ACP fait exactement cela avec vos données : elle cherche automatiquement le « meilleur angle » pour les regarder.

Plus précisément :

1. Chercher la direction de plus grande dispersion : l’ACP identifie la droite le long de laquelle les points de données s’étalent le plus. C’est la première composante principale. Si vos données forment un nuage elliptique, c’est le grand axe de l’ellipse.
2. Trouver la direction orthogonale de deuxième plus grande dispersion : la deuxième composante principale est perpendiculaire à la première et capture le maximum de variance restante. C’est le petit axe de l’ellipse.
3. Projeter les données sur ces axes : au lieu de décrire chaque point par ses p coordonnées originales, on le décrit par ses coordonnées le long de ces nouvelles directions. On a perdu un peu d’information (la variance des dimensions rejetées), mais on a gardé l’essentiel.

Cette interprétation géométrique explique pourquoi l’ACP est si efficace : si vos données vivent naturellement dans un sous-espace de basse dimension (ce qui est fréquent), l’ACP le découvre automatiquement.

Implémentation Python avec scikit-learn

Voyons comment implémenter l’ACP en pratique avec la bibliothèque scikit-learn.

Exemple basique avec le jeu de données Iris

from sklearn.decomposition import PCA
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
import numpy as np

# Charger les données
iris = load_iris()
X, y = iris.data, iris.target

# Étape 1 : Centrage-réduction
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Étape 2 : ACP complète (4 composantes)
pca = PCA(n_components=4)
X_pca = pca.fit_transform(X_scaled)

# Analyser les résultats
print("Valeurs propres (variances) :", pca.explained_variance_)
print("Variances expliquées :", pca.explained_variance_ratio_)
print("Variance expliquée cumulée :", np.cumsum(pca.explained_variance_ratio_))
print("Composantes (vecteurs propres) :\n", pca.components_)

Le résultat typique montre que les deux premières composantes expliquent plus de 95 % de la variance totale :

Valeurs propres (variances) : [2.9108 0.9212 0.1474 0.0206]
Variances expliquées : [0.7296 0.2303 0.0368 0.0032]
Variance expliquée cumulée : [0.7296 0.9599 0.9967 1.0000]

Scree plot (éboulis des valeurs propres)

Le scree plot visualise la variance expliquée par chaque composante et aide à choisir k :

plt.figure(figsize=(8, 5))
components = range(1, len(pca.explained_variance_ratio_) + 1)

plt.bar(components, pca.explained_variance_ratio_,
        alpha=0.7, label='Variance expliquée', color='steelblue')
plt.plot(components, np.cumsum(pca.explained_variance_ratio_),
         'ro-', label='Variance cumulée', linewidth=2)

plt.axhline(y=0.95, color='green', linestyle='--', label='Seuil 95 %')
plt.xlabel('Numéro de la composante principale')
plt.ylabel('Proportion de variance expliquée')
plt.title('Éboulis des valeurs propres (Scree Plot)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.xticks(components)
plt.tight_layout()
plt.show()

Visualisation 2D après réduction

# Réduction à 2 dimensions
pca_2d = PCA(n_components=2)
X_2d = pca_2d.fit_transform(X_scaled)

plt.figure(figsize=(8, 6))
for target, color in zip([0, 1, 2], ['red', 'green', 'blue']):
    mask = y == target
    plt.scatter(X_2d[mask, 0], X_2d[mask, 1],
                c=color, label=iris.target_names[target],
                alpha=0.7, edgecolors='black', s=80)

plt.xlabel(f'Composante 1 ({pca_2d.explained_variance_ratio_[0]*100:.1f} % de variance)')
plt.ylabel(f'Composante 2 ({pca_2d.explained_variance_ratio_[1]*100:.1f} % de variance)')
plt.title('Projection ACP 2D — Jeu de données Iris')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Biplot (combinant observations et variables)

Le biplot superpose les observations projetées et les contributions des variables originales :

plt.figure(figsize=(10, 7))

# Points projetés
for target, color in zip([0, 1, 2], ['red', 'green', 'blue']):
    mask = y == target
    plt.scatter(X_2d[mask, 0], X_2d[mask, 1],
                c=color, label=iris.target_names[target], alpha=0.6, s=60)

# Flèches des variables originales
for i, feature in enumerate(iris.feature_names):
    # Coordonnées du vecteur propre mises à l'échelle
    x_arrow = pca_2d.components_[0, i] * np.sqrt(pca_2d.explained_variance_[0])
    y_arrow = pca_2d.components_[1, i] * np.sqrt(pca_2d.explained_variance_[1])
    plt.arrow(0, 0, x_arrow * 3, y_arrow * 3,
              color='black', head_width=0.15, head_length=0.1)
    plt.text(x_arrow * 3.2, y_arrow * 3.2, feature, fontsize=11, fontweight='bold')

plt.axhline(0, color='gray', linewidth=0.5)
plt.axvline(0, color='gray', linewidth=0.5)
plt.xlabel('Composante Principale 1')
plt.ylabel('Composante Principale 2')
plt.title('Biplot ACP — Iris')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

ACP automatique par seuil de variance

# Garder assez de composantes pour expliquer 95 % de la variance
pca_auto = PCA(n_components=0.95)
X_reduced = pca_auto.fit_transform(X_scaled)

print(f"Dimensions originales : {X.shape[1]}")
print(f"Dimensions après ACP  : {X_reduced.shape[1]}")
print(f"Variance conservée    : {sum(pca_auto.explained_variance_ratio_)*100:.1f} %")

Hyperparamètres de PCA dans scikit-learn

n_components

C’est le paramètre le plus important. Il contrôle le nombre de composantes à conserver :

• Entier (par exemple n_components=3) : garde exactement ce nombre de composantes.
• Flottant entre 0 et 1 (par exemple n_components=0.95) : garde automatiquement le nombre minimal de composantes nécessaire pour expliquer au moins cette proportion de variance.
• ‘mle’ : utilise l’estimation par maximum de vraisemblance de Minka pour déterminer automatiquement le nombre optimal de composantes.
• None (par défaut) : garde toutes les composantes.

svd_solver

Le solveur de décomposition en valeurs singulières :

• ‘full’ : SVD complet via LAPACK. Précis mais lent pour les très grandes matrices.
• ‘auto’ (par défaut) : choisit automatiquement selon la taille des données.
• ‘arpack’ : utilise ARPACK. Efficace quand k est petit par rapport à p.
• ‘randomized’ : SVD randomisé. Très rapide pour les grandes matrices quand on ne veut que quelques composantes.

whiten

Lorsque whiten=True, chaque composante est divisée par la racine carrée de sa valeur propre, ce qui normalise la variance de toutes les composantes à 1. Cela peut améliorer les performances de certains algorithmes en aval (comme les SVM), mais supprime l’information sur l’importance relative des composantes.

tol

Tolérance pour le solveur ‘arpack’. Par défaut 0.0. Contrôle la précision de la convergence.

iterated_power

Nombre d’itérations pour le solveur ‘randomized’. Par défaut ‘auto’ (généralement suffisant). Augmenter ce paramètre améliore la précision au prix du temps de calcul.

Avantages et limites de l’ACP

Avantages

• Extrêmement rapide : la décomposition en valeurs singulières est hautement optimisée et s’exécute en quelques millisecondes pour des données de taille raisonnable.
• Interprétable : les composantes sont des combinaisons linéaires des variables originales. On peut examiner les coefficients des vecteurs propres pour comprendre ce que chaque composante représente.
• Pas d’hyperparamètre sensible : le choix du nombre de composantes est guidé par la variance expliquée, un critère objectif.
• Universel : fonctionne avec n’importe quel type de données numériques ; aucune hypothèse sur la distribution n’est strictement requise pour l’application (bien que l’interprétation statistique soit optimale avec des données gaussiennes).
• Débruit les données : en rejetant les composantes de faible variance, on élimine souvent du bruit de mesure.

Limites

• Linéarité : l’ACP ne capture que les relations linéaires. Si la structure sous-jacente de vos données est non linéaire (les données varient le long d’une courbe ou d’une surface courbe), l’ACP donnera de mauvais résultats. C’est là que des méthodes comme t-SNE ou UMAP prennent le relais.
• Sensibilité aux outliers : les valeurs extrêmes gonflent artificiellement la variance et peuvent déformer les composantes principales. Un prétraitement robuste (médiane, IQR) est recommandé en présence d’outliers.
• Perte d’interprétabilité sémantique : chaque composante est un mélange de toutes les variables originales. Si les variables avaient un sens clair (prix, taille, poids), les composantes peuvent en perdre.
• Inadaptée aux données catégorielles : l’ACP exige des données numériques continues. Pour des données catégorielles, on préférera l’Analyse des Composantes Multiples (ACM).

4 cas d’usage concrets

1. Compression d’images

Les images peuvent être vues comme des matrices de pixels. L’ACP permet de compresser une image en ne gardant que les k premières composantes principales. Avec seulement 50 composantes sur une image de 1 000 pixels de large, on obtient souvent une reconstruction visuellement indiscernable de l’originale, tout en réduisant la taille des données de 95 %.

2. Prétraitement pour la classification

Avant d’entraîner un classifieur (régression logistique, forêt aléatoire, SVM) sur des données de grande dimension, l’ACP réduit le nombre de variables, ce qui accélère l’entraînement et réduit le risque de surapprentissage. C’est une étape classique dans les pipelines de machine learning pour les données génomiques (des milliers de gènes) ou textuelles (sacs de mots de grande dimension).

3. Visualisation de données de grande dimension

Projeter des données de 50, 100 ou 1 000 dimensions en 2D ou 3D pour les visualiser est l’un des usages les plus fréquents de l’ACP. Bien que t-SNE et UMAP donnent souvent des visualisations plus séparées pour les données complexes, l’ACP reste la référence pour sa rapidité et sa reproductibilité.

4. Détection d’anomalies

Les points anormaux ont typiquement des scores de reconstruction élevés : quand on les projette sur les composantes principales puis on les reconstruit dans l’espace original, l’erreur de reconstruction est grande. En calculant cette erreur pour chaque observation, on peut identifier les outliers — une technique utilisée en détection de fraude, surveillance industrielle et cybersécurité.

Conclusion

L’ACP est un outil fondamental dans la boîte à outils de tout praticien du machine learning. Sa simplicité mathématique, sa rapidité d’exécution et son interprétabilité en font souvent la première méthode à essayer pour toute tâche de réduction de dimensionalité. Même si des méthodes plus sophistiquées existent pour des cas spécifiques (t-SNE, UMAP, autoencodeurs), l’ACP reste incomparable comme point de départ — rapide, fiable, et toujours instructif.

Voir aussi

• Comprendre les Matrices Idempotentes en Python : Guide Complet pour Développeurs
• Maîtriser la Manipulation des Grilles Croisées avec Python : Guide Ultime pour Gérer les Rectangles