Accueil › Glossaire › Réduction de Dimensionnalité

Réduction de Dimensionnalité (Dimensionality Reduction)

La réduction de dimensionnalité est un ensemble de techniques qui transforment des données de haute dimension en une représentation de dimension inférieure, tout en préservant au maximum l’information essentielle (structure, relations, variance).

Quand un dataset contient des centaines ou des milliers de features, les algorithmes de machine learning souffrent du « fléau de la dimensionnalité » : les données deviennent éparses, les distances perdent leur pouvoir discriminant, les modèles sont plus lents et plus sujets à l’overfitting. La réduction de dimensionnalité résout ces problèmes en compressant l’information dans un nombre réduit de dimensions tout en conservant les patterns importants.

Pourquoi réduire la dimensionnalité ?

Le fléau de la dimensionnalité

En haute dimension, des phénomènes contre-intuitifs apparaissent. Les distances euclidiennes convergent vers une même valeur : tous les points semblent « également éloignés » les uns des autres. Le volume de l’espace explose exponentiellement, rendant les données extrêmement éparses. Un modèle de classification ou de clustering a besoin exponentiellement plus de données pour couvrir un espace de haute dimension avec la même densité.

Concrètement, si vous avez 1 000 features mais que seulement 20 portent l’information utile, les 980 features restantes ne sont que du bruit qui dilue les signaux et ralentit l’entraînement.

Les bénéfices concrets

Visualisation : impossible de visualiser des données à 100 dimensions. La réduction à 2D ou 3D permet d’explorer visuellement la structure des données, d’identifier des clusters et de détecter des anomalies.

Performance des modèles : moins de features = moins de bruit = meilleure généralisation. En supprimant les dimensions non informatives, vous réduisez l’overfitting et améliorez souvent les scores sur le jeu de test.

Vitesse d’entraînement : moins de features = calculs plus rapides. Sur un dataset avec 10 000 features, réduire à 50 composantes principales peut accélérer l’entraînement de plusieurs ordres de grandeur.

Débruitage : les premières composantes d’une PCA capturent le signal, les dernières capturent le bruit. En ne gardant que les premières, vous effectuez un débruitage naturel.

Deux approches : sélection vs extraction

Il faut distinguer deux familles de méthodes :

Sélection de features : on conserve un sous-ensemble des features originales. Les features non retenues sont supprimées. L’avantage : les dimensions restantes sont interprétables (ce sont les variables d’origine). Méthodes : corrélation avec la cible, élimination récursive (RFE), importance des features via Random Forest ou XGBoost.

Extraction de features : on crée de nouvelles dimensions comme combinaisons des features originales. Les nouvelles dimensions ne correspondent plus aux variables d’origine. L’avantage : on capture plus d’information en moins de dimensions. C’est cette famille que l’on désigne habituellement par « réduction de dimensionnalité ». Méthodes : PCA, t-SNE, UMAP, autoencodeurs.

Méthodes linéaires

PCA (Principal Component Analysis)

La méthode la plus fondamentale et la plus utilisée. La PCA identifie les directions (composantes principales) qui capturent le maximum de variance dans les données. Chaque composante est une combinaison linéaire des features originales, orthogonale aux précédentes.

Forces : rapide (O(n·d²)), interprétable (chaque composante a des contributions mesurables), transformation inverse possible, déterministe (pas de composante aléatoire). Limites : ne capture que les relations linéaires, sensible à l’échelle des variables (toujours standardiser avant).

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# Standardiser les données
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# PCA avec 95% de variance expliquée
pca = PCA(n_components=0.95)
X_reduced = pca.fit_transform(X_scaled)

print(f"Dimensions originales : {X.shape[1]}")
print(f"Dimensions réduites : {X_reduced.shape[1]}")
print(f"Variance expliquée totale : {pca.explained_variance_ratio_.sum():.2%}")

SVD tronquée (Truncated SVD)

Similaire à la PCA mais travaille directement sur la matrice de données sans centrer. Utile pour les matrices creuses (sparse), typiquement en NLP avec les matrices TF-IDF. C’est la méthode derrière le LSA (Latent Semantic Analysis).

LDA (Linear Discriminant Analysis)

Contrairement à la PCA (non supervisée), la LDA est supervisée : elle cherche les projections qui maximisent la séparation entre classes connues. Utile comme prétraitement avant une classification quand on dispose de labels.

Méthodes non linéaires

t-SNE (t-distributed Stochastic Neighbor Embedding)

t-SNE est la référence pour la visualisation de données de haute dimension en 2D. L’algorithme modélise la similarité entre points proches dans l’espace original, puis optimise un embedding 2D qui préserve ces similarités locales.

Forces : produit des visualisations spectaculaires, révèle les clusters et la structure locale. Limites : lent sur de grands datasets (O(n²)), non déterministe (résultats différents à chaque exécution), ne préserve pas bien la structure globale (les distances entre clusters ne sont pas fiables), sensible au paramètre perplexity, pas de transformation inverse.

from sklearn.manifold import TSNE

# t-SNE en 2D
tsne = TSNE(n_components=2, perplexity=30,
            n_iter=1000, random_state=42)
X_tsne = tsne.fit_transform(X_scaled)

# Visualisation
import matplotlib.pyplot as plt
plt.scatter(X_tsne[:, 0], X_tsne[:, 1],
            c=labels, cmap='viridis', s=5, alpha=0.7)
plt.title('t-SNE')
plt.show()

UMAP (Uniform Manifold Approximation and Projection)

UMAP est le successeur moderne de t-SNE. Basé sur la théorie des variétés (manifolds) et la topologie algébrique, il construit un graphe pondéré des voisinages dans l’espace original, puis optimise un embedding qui préserve cette topologie.

Forces : beaucoup plus rapide que t-SNE, préserve mieux la structure globale (distances entre clusters plus fiables), scalable aux grands datasets, peut servir de prétraitement pour le ML (pas seulement la visualisation). Limites : sensible aux hyperparamètres (n_neighbors, min_dist), non déterministe, pas de transformation inverse native.

import umap

# UMAP en 2D
reducer = umap.UMAP(n_neighbors=15, min_dist=0.1,
                     n_components=2, random_state=42)
X_umap = reducer.fit_transform(X_scaled)

plt.scatter(X_umap[:, 0], X_umap[:, 1],
            c=labels, cmap='viridis', s=5, alpha=0.7)
plt.title('UMAP')
plt.show()

Autoencodeurs

Les autoencodeurs sont des réseaux de neurones qui apprennent à compresser les données dans un espace latent de faible dimension (encodeur), puis à les reconstruire (décodeur). Le goulot d’étranglement central force le réseau à apprendre une représentation compacte. Les VAE (Variational Autoencoders) ajoutent une contrainte probabiliste sur l’espace latent, permettant la génération de nouvelles données.

Comparaison des principales méthodes

Le pipeline hybride PCA + UMAP

Une pratique très courante et efficace consiste à combiner PCA et UMAP. La PCA réduit d’abord la dimensionnalité de manière rapide (par exemple de 10 000 features à 50 composantes), ce qui élimine le bruit et accélère le calcul. Puis UMAP affine la réduction à 2D en capturant les structures non linéaires.

# Pipeline hybride PCA + UMAP
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
import umap

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('pca', PCA(n_components=50)),
    ('umap', umap.UMAP(n_neighbors=15, min_dist=0.1,
                        n_components=2, random_state=42))
])

X_2d = pipeline.fit_transform(X)

Ce pipeline est le standard de facto en bioinformatique (analyse single-cell RNA-seq), en NLP (visualisation d’embeddings), et en vision par ordinateur.

Applications par domaine

Visualisation et exploration

L’usage le plus visible : projeter des données de haute dimension en 2D pour identifier visuellement des clusters, des outliers et des tendances. Indispensable pour l’analyse exploratoire de données (EDA), surtout avec des embeddings de LLM ou des features extraites de réseaux de neurones.

Prétraitement pour le ML supervisé

Réduire la dimensionnalité avant d’entraîner un classifieur ou un régresseur peut améliorer les performances en éliminant le bruit et en réduisant l’overfitting. La PCA est la méthode standard pour cet usage car elle est déterministe et offre une transformation inverse.

Compression de données

La PCA sert de technique de compression avec perte : en gardant les K premières composantes (qui capturent la majorité de la variance), on réduit drastiquement la taille des données. Utilisé en compression d’images, de signaux audio et de données scientifiques volumineuses.

Bioinformatique

L’analyse transcriptomique single-cell produit des matrices de 20 000+ gènes × millions de cellules. Le pipeline PCA (50 composantes) + UMAP (2D) est le standard pour visualiser les types cellulaires et identifier les sous-populations. C’est l’un des cas d’usage les plus importants de la réduction de dimensionnalité.

NLP et embeddings

Les embeddings de mots (Word2Vec, GloVe) et de phrases (Sentence Transformers) vivent dans des espaces à 768 ou 1 536 dimensions. La réduction en 2D via UMAP permet de visualiser les relations sémantiques, d’identifier des clusters thématiques et de vérifier la qualité des embeddings.

Pièges courants

Ne pas standardiser avant la PCA

La PCA maximise la variance. Si une feature a une échelle 1 000 fois plus grande qu’une autre, la première composante principale sera dominée par cette feature, indépendamment de son utilité. Standardisez toujours (moyenne 0, écart-type 1) avant d’appliquer la PCA.

Surinterprétation de t-SNE/UMAP

Les tailles des clusters et les distances entre clusters dans une projection t-SNE ou UMAP ne sont pas fiables. Un cluster qui apparaît gros en 2D n’est pas nécessairement plus dispersé en haute dimension. Deux clusters éloignés en 2D ne sont pas nécessairement éloignés dans l’espace original. Utilisez ces visualisations pour identifier l’existence de clusters, pas pour mesurer leurs propriétés.

Ignorer les hyperparamètres

En t-SNE, la perplexité contrôle le compromis entre structure locale et globale (typiquement 5-50). En UMAP, n_neighbors joue un rôle similaire. Des valeurs mal choisies produisent des visualisations trompeuses. Testez toujours plusieurs valeurs et vérifiez la stabilité des résultats.

Utiliser t-SNE comme prétraitement ML

t-SNE est conçu pour la visualisation, pas pour le prétraitement. Il ne préserve pas les distances globales, ne supporte pas la transformation de nouvelles données (pas de .transform()), et produit des résultats différents à chaque exécution. Pour le prétraitement, utilisez PCA ou UMAP.

Verdict

La réduction de dimensionnalité est indispensable dès que vos données dépassent quelques dizaines de features. Le trio PCA / t-SNE / UMAP couvre l’immense majorité des cas d’usage.

En pratique : utilisez la PCA pour tout ce qui est prétraitement, compression et débruitage. Utilisez UMAP pour la visualisation exploratoire (il a largement remplacé t-SNE grâce à sa vitesse et sa meilleure préservation de la structure globale). Et combinez les deux (PCA → UMAP) pour les datasets à très haute dimension.

La clé est de comprendre ce que chaque méthode préserve et ce qu’elle sacrifie. La PCA préserve la variance globale mais manque les structures non linéaires. UMAP préserve la topologie locale et partiellement globale mais n’est pas interprétable. Le choix dépend de votre objectif : comprendre les features (PCA), explorer la structure (UMAP), ou alimenter un modèle (PCA ou autoencodeur).