Pratique de l’ACP

1 Introduction

Après avoir introduit l’Analyse en Composantes Principales (Introduction à l’ACP), et avant d’en explorer les fondements théoriques (Approche Statistique), ce tutoriel se concentre sur sa mise en œuvre pratique. L’objectif est de vous guider à travers les étapes concrètes de la réalisation d’une ACP, de la préparation des données à l’interprétation des résultats, en utilisant les langages de programmation R et Python.

Nous aborderons :

Le principe de l’ACP dite normée: De la préparation et le prétraitement des données et son implémentation.
L’utilisation des bibliothèques et fonctions clés en R (comme FactoMineR, factoextra) et Python (avec scikit-learn) pour effectuer l’analyse.
La visualisation des résultats, notamment les éboulis des valeurs propres, les cercles de corrélation et les graphiques des individus.
L’interprétation des composantes principales et la manière de tirer des conclusions significatives de l’analyse.
Des exemples concrets et des exercices pour consolider votre compréhension et vos compétences pratiques.

Ce tutoriel est conçu pour vous rendre autonome dans l’application de l’ACP à vos propres jeux de données, vous permettant ainsi de découvrir des structures cachées et de simplifier des données complexes.

2 Principe de l’ACP

Dans la suite, les données qui nous intéressent seront notées: \[ X=\left(x_{i,j}\right)_{i=1,\cdots,n;j=1,\cdots,p}\in\mathbb{R}^{n\times p}, \] où $x_i=\left(x_{i,j}\right)\in\mathbb{R}^p$ est le vecteur des données de l’individu $i$.

On note $\omega_i\in ]0, 1[$ le poids de l’individu $i$. Ces poids vérifient $\sum_{i=1}^n\omega_i=1$. Dans la majorité des cas, on attribue le même poids $\omega_i=\dfrac{1}{n}$ à chacun des $n$ individus.

Matrice des poids

On appelle ainsi la matrice diagonale des poids: \[ D=diag\left(\omega_1,\cdots,\omega_n\right)\in ]0,1[^{n\times n}. \]

2.1 Quelques statistiques d’intérêt

Centre de gravité: $\bar{x}=\sum_{i=1}\omega_ix_i\in\mathbb{R}^p=X^TD^T1_n$, où $1_n\in\mathbb{n}$ est le vecteur de taille $n$ composé de $1$.
Données centées: $Y=(y_{i,j})_{i=1,,n;j=1,,p}$ où $y_{i,j}=x_{i,j}-\bar{x}_j$. On peut remarquer que $Y=X-1_n\bar{x}^T$
Matrice des variances-covariances: $S^2=Y^TDY$. Dans certains logiciel comme Python, en particulier dans la classe PCA de scikit-learn, $S^2=\dfrac{n}{n-1}Y^TDY$. Il s’agit d’une estimation sans-biais de la matrice des variances-covariances.
Données centrées et réduites: $Z=(z_{i,j})_{i=1,,n;j=1,,p}$ où $z_{i,j}=y_{i,j}/\sigma_j$, où $S_j=\sqrt{S_{j,j}^2}$
Matrice des corrélations: $R=Z^TDZ$. Comme pour la matrice $S^2$, certains logiciels adoptent plutôt $R=\dfrac{n}{n-1}Z^TDZ$.

2.2 Préparation des données

La préparation des données pour l’ACP consiste dans la pratique à centrer et réduire la matrice $X$. Ainsi, l’ACP est (en générale) faite sur la patrice $Z$ des données centrées réduites. On parle alors de l’ACP normée.

2.3 Inertie du nuage de points

On appelle ainsi la quantité: \[ I=\sum_{i=1}^n\omega_i\|z_i\|^2=\sum_{i=1}^n\omega_i\sum_{j=1}^pz_{i,j}^2 \]

Important

Dans le cas de l’ACP normée, on a: \[ I=\sum_{i=1}^n\omega_i\|z_i\|^2=\sum_{i=1}^n\omega_i\sum_{j=1}^pz_{i,j}^2=p. \]

2.4 Inertie expliquée par un sous-espace vectoriel $E$

L’inertie expliquée par un sous-espace vectoriel $E$ de $\mathbb{R}^p$ est: \[ I_E = \sum_{i=1}^n\omega_i\|P_Ez_i\|^2, \] où $P_Ez_i$ est la projection orthogonales de $z_i$ sur $E$.

Note

L’ACP (normée) consiste à cherche un sous-espace vectoriel $E_q$ de $\mathbb{R}^p$ de dimension $q\leq p$, qui maximise l’inertie expliquée parmi les sous-espaces vectoriels de $\mathbb{R}^p$ de dimension $q$. Autrement dit, on cherche la solution du problème d’optimisation: \[ max_{dim E=q}I_E \]

2.5 Solution de $max_{dim E=q}I_E$

Proposition 1 (Solution de $max_{dim E=q}I_E$$) On montre que la solution du problème d’optimisation est donnée par le sous-espace vectoriel $E_q=\langle v^1,v^2,\cdots,v^q\rangle$ engendré par les vecteurs propres normés $v^1,v^2,\cdots,v^q$ des $q$ valeurs premières plus grandes valeurs propres $\lambda_1>\lambda_2>\ldots>\lambda_q>0$ de la matrice des corrélations $R$.

Proposition 2 (Représentation des individus) Les coordonnées des individus dans $E_q$ sont données par les $q$ premières colonnes de la matrice \[ C = ZV\in\mathbb{R}^{n\times r} \] où la matrice \[ V=\left[v^1\quad v^2\quad\cdots\quad v^q \right]\in\mathbb{R}^{p\times r}. \]

Proposition 3 (Représentation des variables) Les coordonnées de représentation des variables dans l’espace principale des variables de dimension $q$ sont données par les $q$ premières colonnes de la matrice \[ \tilde{C} = Z^TDF=V\Lambda^{\frac{1}{2}} \]

où

$F=C\Lambda^{-\frac{1}{2}}$ est la matrice des facteurs principaux
$\Lambda=diag(\lambda_1,\lambda_2,\ldots,\lambda_q)$ est la matrice diagonale des valeurs propres de la matrice des corrélations $R$.

Definition 1 Voici quelques définitions:

Les vecteurs $v^k$ sont appelés vecteurs principaux.
Les espaces $E_q$ sont appelés espaces principaux. En particulier, $E_2$ est le plan principal.
La matrice $C$ est appelée matrice des composantes principales. Sa colonne $c^k$ est la composante principale $k$ \[ c^k=Zv^k. \]

Notes

Supposons que le rang de $X$ soit $rg(X)=r\leq\min\left\{n,p\right\}$. Alors $R$ admet $r$ valeurs propres distinctes et strictement positives \[ \lambda_1>\lambda_2>\ldots>\lambda_q>0. \]
L’ACP (normée) repose sur le calcul des éléments propres de la matrice $R$.
Il faut bien noter que les vecteurs principaux sont orthonormés.
$\left(v^1,\ldots, v^q\right)$ est une base orthonormée de $E_q$.
Les espaces principaux sont emboïtés: $E_1\subset E_2\subset\cdots\subset E_r$.
Les espaces principaux de représentation des variables sont engendrés par les colonnes de la matrice des facteurs principaux $F$.
Les colonnes de $F$ sont les vecteurs propres de la matrice $Z^TZD$ associés aux mêmes valeurs propres dans $\Lambda$: \[ Z^TZDF=F\Lambda. \]

Résumé de l’ACP

$\bar{x}=\sum_{i=1}\omega_ix_i\in\mathbb{R}^p=X^TD^T1_n$
$Y=\left(y_{i,j}\right)_{i=1,\ldots,n;j=1,\ldots,p}$ où $y_{i,j}=x_{i,j}-\bar{x}_j$
$S^2=\dfrac{n}{n-1}Y^TDY$ (ou $S^2=\dfrac{n}{n-1}Y^TDY$)
$Z=\left(z_{i,j}\right)_{i=1,\ldots,n;j=1,\ldots,p}$ où $z_{i,j}=\dfrac{y_{i,j}}{S_j}$, où $S_j=\sqrt{S_{j,j}^2}$
$R=Z^TDZ$$ (ou $R=\dfrac{n}{n-1}Z^TDZ$)
Calculer les éléments propres de la matrice $R$
1. Valeurs propres $\lambda_1>\lambda_2>\ldots>\lambda_r>0$
2. Vecteurs propres $v^1,v^2,\ldots, v^r$
Matrice des composantes principales: $C=ZV$
Matrice des facteurs principaux: $F=C\Lambda^{-\frac{1}{2}}$.
Matrice des composantes principales des variables: $\tilde{C}=V\Lambda^{\frac{1}{2}}$

3 Implémentation sous `Python` et première application

3.1 Notre Implémantation de l’ACP

Code

import numpy as np 
from numpy import linalg as LA
import matplotlib.pyplot as plt

class MyACP:
  def __init__(self):
    # Vecteurs propres
    self.V = None

    # Valeurs propres
    self.lambdas = None

    # Représentation des variables
    self.CTilde = None
    return

  def fit(self, Z, D=None):
    "Entrer les données centrées"
    # Numbre d'individu
    n = Z.shape[0]

    # Les poids
    D = np.ones(n)/n if D is None else D

    # Nombre de variables
    p = Z.shape[1]

    # Matrice des corrélation
    R = (Z.T @ Z) / n

    # Valeurs propres
    _, self.lambdas, VT = LA.svd(R)
    self.V = VT.T

    # Représentation des variables
    self.CTilde = self.V @ np.diag(np.sqrt(self.lambdas))
    return 

  def transform(self, Z):
    "Entrer les données centrées -> Composantes principales"
    return Z @ self.V

  def fit_transform(self, Z):
    "Entrer les données centrées -> Composantes principales"
    self.fit(Z)
    return self.transform(Z)

  def ebouli(self):
    "Ebouli des parts de l'inertie"
    plt.bar(range(1, len(self.lambdas)+1), self.lambdas/np.sum(self.lambdas))
    plt.xlabel('Composantes principales')
    plt.ylabel("Part de l'inertie")
    plt.title('Ebouli des valeurs propres')
    plt.show()
    return

  def scatter(self, Z, j1=0, j2=1, categories=None):
    "Entrer les données centrées -> Scatter"
    C = self.transform(Z)

    if categories is not None:
      levels = np.unique(categories)
      for level in levels:
        indices = categories==level
        plt.scatter(C[indices,j1], C[indices,j2], label=str(level))
      plt.legend()
    else:
      plt.scatter(C[:,j1], C[:,j2])
    
    plt.xlabel(f'PC{j1}')
    plt.ylabel(f'PC{j2}')
    plt.title('Scatter plot')
    plt.show()
    return

  def cercleCorrelation(self, feature_names, figsize=None):
    "Cercle des corrélations"
    figsize = (8,8) if figsize is None else figsize
    coord = self.CTilde[:,[0,1]]

    plt.figure(figsize=figsize)
    plt.axis('equal')
    plt.xlim(-1.1,1.1)
    plt.ylim(-1.1,1.1)
    plt.grid()
      
    # Ajouter le cercle
    circle = plt.Circle((0,0), 1, color='black', fill=False)
    plt.gcf().gca().add_artist(circle)

    # Ajouter les segments
    for i, txt in enumerate(iris.feature_names):
        plt.arrow(0, 0, coord[i,0], coord[i,1], head_width=0.05, head_length=0.01, fc='k', ec='k')
        plt.annotate(txt, (coord[i,0], coord[i,1]))
        
    plt.xlabel('PC1')
    plt.ylabel('PC2')
    plt.title('Cercle des corrélations')
    plt.show()
    return

3.2 Première application sur les données `iris`

Librairies

Code

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler

Les données

Code

iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['Species'] = iris.target_names[iris.target]

df.head()

Standardisation des données

Code

# Données pour l'ACP
X = iris.data

# Standardiser les données
scaler = StandardScaler(with_mean=True, with_std=True)
Z = scaler.fit_transform(X)

Application de l’ACP

Code

# Instanciation
acp = MyACP()

# Ajustement
acp.fit(Z)

Ebouli des valeurs propres

Code

acp.ebouli()

On remarque que les deux premiers axes expliquent plus de $90\%$ de la variabilité. Les conclusions que l’on peut tirer du premier plan sont tout à fait pertinentes.

Carte des individus

Code

acp.scatter(Z, j1=0, j2=1, categories=df['Species'])

Le premier axe permet de distinguer en particulier l’espèce setosa des autres, qui sont assez séparées.

Cercle des corrélations

Code

acp.cercleCorrelation(iris.feature_names)

Les dimensions des Pétals sont très positivement correlées
Les dimensions des Sepals sont presque décorrélées

4 Utilisation de l’ACP proposée par `scikit-learn`

4.1 Implémentation

Warning

Cette implémentation ne prend pas en compte les poids différents des $\omega_i=\dfrac{1}{n}$.
Dans les calculs des variances, la division est faite par $n-1$.

Exercise 1

Compléter cette implémentation

Code

from sklearn.decomposition import PCA

class MyACP(ACP):
  def __init__(self, n_components=None):
    super().__init__(n_components)
    return

  def fit(self, Z):
    pass

  def transform(self, Z):
    pass

  def fit_transform(self, Z):
    pass

  def ebouli(self):
    pass

  def scatter(self, Z, j1=0, j2=1, categories=None):
    pass

  def cercleCorrelation(self, feature_names, figsize=None):
    pass

Appliquer cette implémentation sur les données iris

5 Jeu de Données : Performances au Décathlon

Pour ce tutoriel pratique, nous allons utiliser un jeu de données classique souvent employé pour illustrer l’ACP : les résultats de plusieurs athlètes à différentes épreuves d’un décathlon. Un décathlon est une compétition d’athlétisme combinant dix épreuves. Les performances dans ces épreuves sont variées (courses, sauts, lancers) et sont susceptibles d’être corrélées.

Description des variables (hypothétiques pour l’instant, nous chargerons les vraies données ensuite) :

Le jeu de données pourrait contenir les variables suivantes pour chaque athlète :

100m (secondes)
Longueur (mètres) - Saut en longueur
Poids (mètres) - Lancer du poids
Hauteur (mètres) - Saut en hauteur
400m (secondes)
110m Haies (secondes)
Disque (mètres) - Lancer du disque
Perche (mètres) - Saut à la perche
Javelot (mètres) - Lancer du javelot
1500m (secondes)
Points (score total au décathlon)
Classement (rang final)

Pour l’ACP, nous nous concentrerons sur les variables de performance (les 10 premières).

5.1 Questions à Explorer avec l’ACP

En utilisant l’ACP sur ce jeu de données, nous chercherons à répondre aux questions suivantes :

Structure des corrélations : Quelles épreuves sont positivement ou négativement corrélées entre elles ? Par exemple, les athlètes performants sur 100m le sont-ils aussi en saut en longueur ?
Dimensions sous-jacentes : Peut-on identifier des “profils” ou des “dimensions latentes” de performance ? Par exemple, existe-t-il une dimension “vitesse/explosivité” et une dimension “force” ou “endurance” ?
Réduction de dimensionnalité : Combien de composantes principales sont nécessaires pour expliquer une part significative de la variabilité totale des performances ? Peut-on résumer la performance d’un athlète avec moins de 10 variables ?
Visualisation des athlètes : Comment se positionnent les athlètes les uns par rapport aux autres sur les premières composantes principales ? Peut-on identifier des groupes d’athlètes aux profils similaires ?
Interprétation des axes : Que représentent concrètement les premières composantes principales en termes d’épreuves du décathlon ?

Ces questions nous guideront dans l’application et l’interprétation de l’ACP.

5.2 Chargement et Exploration Initiale des Données

Commençons par charger les données en R et en Python et effectuons une première exploration.

6 R

Code

library(FactoMineR) # Pour le jeu de données decathlon2 et la fonction PCA
library(factoextra) # Pour des visualisations ggplot2-friendly de l'ACP
library(dplyr)      # Pour la manipulation de données
library(GGally)     # Pour ggpairs

# Chargement du jeu de données decathlon2 de FactoMineR
# Ce jeu de données contient les performances de 41 athlètes dans 10 épreuves du décathlon,
# plus leur classement et le total de points. Il y a aussi des variables qualitatives supplémentaires.
data(decathlon2)

# Afficher les premières lignes du jeu de données complet
cat("Premières lignes du jeu de données decathlon2:\n")
print(head(decathlon2))

# Afficher la structure du jeu de données
cat("\nStructure du jeu de données decathlon2:\n")
str(decathlon2)

# Sélectionner les variables actives pour l'ACP (les 10 épreuves de performance)
# Les colonnes 1 à 10 sont les performances numériques.
decathlon_actifs <- decathlon2[, 1:10]

cat("\nPremières lignes des variables actives pour l'ACP:\n")
print(head(decathlon_actifs))

cat("\nRésumé statistique des variables actives:\n")
summary(decathlon_actifs)

# Vérification des valeurs manquantes
cat("\nNombre de valeurs manquantes par colonne (variables actives):\n")
print(sapply(decathlon_actifs, function(x) sum(is.na(x))))

# Exploration visuelle des corrélations entre les épreuves
cat("\nMatrice de paires de graphiques (ggpairs) pour les variables actives (peut prendre un moment):\n")
# ggpairs(decathlon_actifs, title = "Corrélations entre les épreuves du décathlon")
# Note: ggpairs peut être long à générer pour 10 variables. Une matrice de corrélation est plus rapide.
correlation_matrix <- cor(decathlon_actifs)
cat("\nMatrice de corrélation des variables actives:\n")
print(round(correlation_matrix, 2))

# Nous pourrions aussi visualiser cette matrice avec corrplot ou heatmap
# library(corrplot)
# corrplot(correlation_matrix, method="circle")

7 Python

Code

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

decathlon_df = pd.read_csv("./data/decathlon.csv", index_col=0, sep=";")
decathlon_df.head()
decathlon_df.describe()

# Vérification des valeurs manquantes
decathlon_df.isnull().sum()

decathlon_actifs = decathlon_df.iloc[:, :10]
decathlon_actifs

# Matrice de corrélation
correlation_matrix = decathlon_actifs.corr()
correlation_matrix

# Heatmap de la matrice de corrélation
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap="coolwarm")
plt.title("Matrice de corrélation entre les épreuves du décathlon")
plt.show()

Code

# Standardisation des données
decathlon_std <- scale(decathlon_actifs)

# Vérification des moyennes
colMeans(decathlon_std)

# Vérification des écarts-types
apply(decathlon_std, 2, sd)

Code

# Standardisation des données
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
decathlon_std = scaler.fit_transform(decathlon_actifs)

# Vérification des moyennes
decathlon_std.mean(axis=0)

# Vérification des écarts-types
decathlon_std.std(axis=0)

9 Application de l’ACP

R
Python

Application de l’ACP

Code

# Librairie pour l'ACP
library(FactoMineR)

# Application de l'ACP
decathlon_pca <- PCA(decathlon_std, graph = FALSE)
print(summary(decathlon_pca))

# Pour afficher les valeurs propres et le pourcentage de variance expliquée :
print(get_eigenvalue(decathlon_pca))

Ébouli des valeurs propres

Carte des individus

Code

# Graphique des valeurs propres
plot(decathlon_pca)

10 Quiz

Copyright

2025 W. Toussile

1 Introduction

2 Principe de l’ACP

2.1 Quelques statistiques d’intérêt

2.2 Préparation des données

2.3 Inertie du nuage de points

2.4 Inertie expliquée par un sous-espace vectoriel \(E\)

2.5 Solution de \(max_{dim E=q}I_E\)

3 Implémentation sous `Python` et première application

3.1 Notre Implémantation de l’ACP

3.2 Première application sur les données `iris`

4 Utilisation de l’ACP proposée par `scikit-learn`

4.1 Implémentation

5 Jeu de Données : Performances au Décathlon

5.1 Questions à Explorer avec l’ACP

5.2 Chargement et Exploration Initiale des Données

6 R

7 Python

8 Préparation des Données

9 Application de l’ACP

10 Quiz

Copyright

1 Introduction

2 Principe de l’ACP

2.1 Quelques statistiques d’intérêt

2.2 Préparation des données

2.3 Inertie du nuage de points

2.4 Inertie expliquée par un sous-espace vectoriel \(E\)

2.5 Solution de \(max_{dim E=q}I_E\)

3 Implémentation sous Python et première application

3.1 Notre Implémantation de l’ACP

3.2 Première application sur les données iris

4 Utilisation de l’ACP proposée par scikit-learn

4.1 Implémentation

5 Jeu de Données : Performances au Décathlon

5.1 Questions à Explorer avec l’ACP

5.2 Chargement et Exploration Initiale des Données

6 R

7 Python

8 Préparation des Données

9 Application de l’ACP

10 Quiz

Copyright

3 Implémentation sous `Python` et première application

3.2 Première application sur les données `iris`

4 Utilisation de l’ACP proposée par `scikit-learn`