Accueil › Glossaire › UMAP

UMAP (Uniform Manifold Approximation and Projection)

UMAP est un algorithme de réduction de dimensionnalité non linéaire qui projette des données de haute dimension dans un espace de faible dimension en préservant à la fois la structure locale (voisinages) et, dans une certaine mesure, la structure globale (relations entre clusters).

Publié en 2018 par Leland McInnes, John Healy et James Melville, UMAP s’est rapidement imposé comme le successeur de t-SNE pour la visualisation de données de haute dimension. Il est nettement plus rapide, produit des embeddings plus stables, préserve mieux la structure globale, et peut servir à la fois de visualisation et de prétraitement pour le machine learning. UMAP est devenu le standard de facto dans de nombreux domaines, de la bioinformatique single-cell au NLP.

Comment fonctionne UMAP

UMAP repose sur trois hypothèses fondamentales : les données sont distribuées uniformément sur une variété (manifold) riemannienne, la métrique riemannienne est localement constante, et la variété est localement connexe. À partir de ces hypothèses, l’algorithme procède en deux grandes étapes.

Étape 1 : Construction du graphe de voisinage

UMAP construit un graphe pondéré reliant chaque point à ses k plus proches voisins (contrôlé par n_neighbors). Les poids des arêtes reflètent la similarité entre les points, avec une adaptation locale qui tient compte de la densité : dans les zones denses, seuls les voisins très proches ont un poids significatif ; dans les zones éparses, des voisins plus éloignés reçoivent un poids non négligeable. Ce graphe est ensuite symétrisé par une union floue (fuzzy union).

Cette construction mathématique, basée sur les ensembles simpliciaux flous (fuzzy simplicial sets) de la topologie algébrique, est l’innovation théorique principale de UMAP. En pratique, elle permet à l’algorithme de s’adapter automatiquement aux variations locales de densité.

Étape 2 : Optimisation de l’embedding

UMAP optimise la position des points dans l’espace de faible dimension (2D, 3D, ou plus) pour que le graphe de voisinage en basse dimension ressemble le plus possible au graphe en haute dimension. L’optimisation minimise la cross-entropy entre les deux graphes via une descente de gradient stochastique.

Les forces attractives rapprochent les points qui sont voisins en haute dimension, tandis que les forces répulsives éloignent les points qui ne sont pas voisins. Le paramètre min_dist contrôle la distance minimale entre les points dans l’embedding, déterminant la compacité des clusters.

Les paramètres clés de UMAP

n_neighbors : le compromis local/global

C’est le paramètre le plus important. Il contrôle la taille du voisinage local considéré pour chaque point, similaire au rôle de la perplexité dans t-SNE.

Valeurs basses (2-5) : UMAP se concentre sur des voisinages très locaux. Produit des chaînes et des fragments déconnectés. Utile pour révéler la microstructure mais perd la vue d’ensemble.

Valeurs moyennes (10-20) : bon compromis local/global. La plage recommandée par défaut. 15 est le défaut de la librairie.

Valeurs élevées (50-200) : UMAP capture la structure globale au détriment des détails locaux. Les clusters se fondent progressivement. Utile pour comprendre les relations entre groupes.

min_dist : la compacité des clusters

Contrôle l’espacement minimum entre les points dans l’embedding.

min_dist = 0.0 : les points peuvent être empilés les uns sur les autres. Produit des clusters très denses et compacts avec des séparations nettes. Idéal comme prétraitement avant le clustering (HDBSCAN notamment).

min_dist = 0.1 (défaut) : bon compromis entre compacité et lisibilité. Standard pour la visualisation.

min_dist = 0.5-1.0 : les points sont plus étalés. Donne une vue plus « aérée » et uniforme, mais les clusters sont moins distincts.

metric : la mesure de distance

UMAP supporte un large éventail de métriques de distance, y compris des métriques personnalisées compilées avec Numba. Les plus courantes :

n_components : la dimension cible

2 par défaut (visualisation). Contrairement à t-SNE qui fonctionne mal au-delà de 3D, UMAP gère bien des dimensions cibles plus élevées (10, 50, 100). C’est ce qui le rend utilisable comme prétraitement ML : réduire de 10 000 features à 50 dimensions UMAP avant un classifieur.

UMAP en Python

Installation

pip install umap-learn

Usage de base

import umap
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
import matplotlib.pyplot as plt

# Charger et standardiser
X, y = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)

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

# Visualisation
plt.figure(figsize=(10, 8))
scatter = plt.scatter(X_2d[:, 0], X_2d[:, 1],
                      c=y, cmap='tab10', s=5, alpha=0.7)
plt.colorbar(scatter, label='Chiffre')
plt.title('UMAP des chiffres manuscrits')
plt.xlabel('UMAP 1')
plt.ylabel('UMAP 2')
plt.tight_layout()
plt.show()

Pipeline PCA + UMAP (recommandé pour la haute dimension)

from sklearn.decomposition import PCA
from sklearn.pipeline import Pipeline

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)

Transformer de nouvelles données

Contrairement à t-SNE, UMAP supporte .transform() pour projeter de nouvelles observations sur un embedding existant :

# Entraîner sur le jeu d'entraînement
reducer = umap.UMAP(random_state=42)
reducer.fit(X_train_scaled)

# Projeter le jeu de test
X_test_2d = reducer.transform(X_test_scaled)

Cette capacité est ce qui rend UMAP utilisable dans un pipeline scikit-learn, comme prétraitement avant un classifieur ou un algorithme de clustering.

UMAP + HDBSCAN : le pipeline de clustering moderne

Combiner UMAP (réduction) et HDBSCAN (clustering par densité) est devenu un standard pour le clustering de données de haute dimension :

import hdbscan

# UMAP optimisé pour le clustering
reducer = umap.UMAP(n_neighbors=30, min_dist=0.0,
                     n_components=2, random_state=42)
embedding = reducer.fit_transform(X_scaled)

# HDBSCAN sur l'embedding
clusterer = hdbscan.HDBSCAN(min_cluster_size=50, min_samples=10)
labels = clusterer.fit_predict(embedding)

n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
print(f"Clusters trouvés : {n_clusters}")
print(f"Points non classés : {(labels == -1).sum()}")

UMAP vs t-SNE : comparaison détaillée

Notre verdict : UMAP domine t-SNE sur pratiquement tous les critères objectifs. L’unique avantage résiduel de t-SNE est son ancienneté (plus de littérature de référence) et son statut de standard dans certains domaines. Pour tout nouveau projet, commencez par UMAP.

UMAP vs PCA : deux rôles complémentaires

UMAP et PCA ne sont pas en concurrence mais complémentaires. La PCA est linéaire, déterministe, interprétable et offre une transformation inverse. UMAP est non linéaire, stochastique, non interprétable mais révèle des structures que la PCA ne peut pas capturer.

Le pipeline standard combine les deux : PCA réduit d’abord de N dimensions à 50-100 (élimine le bruit, accélère le calcul), puis UMAP affine à 2D pour la visualisation. Ce duo est le workflow de facto en single-cell RNA-seq, en NLP et en computer vision.

Applications de UMAP

Bioinformatique single-cell

Le domaine où UMAP a eu le plus d’impact. Pipeline standard : normalisation → PCA (50 composantes) → UMAP (2D). Visualise des centaines de milliers de cellules (chacune avec 20 000+ gènes) pour identifier les types cellulaires. A largement remplacé t-SNE grâce à sa vitesse et sa meilleure préservation des trajectoires de différenciation cellulaire.

NLP : visualisation d’embeddings

Projeter des embeddings de documents ou de phrases (issus de BERT, Sentence Transformers ou des LLM) en 2D pour explorer les clusters thématiques, valider la qualité des représentations et identifier les outliers. La métrique cosinus est recommandée pour les embeddings normalisés.

Prétraitement pour le clustering

UMAP avec min_dist=0.0 produit des embeddings très clustérisables. Combiné avec HDBSCAN, c’est le pipeline de référence pour le clustering de données complexes de haute dimension. Plus efficace que le clustering direct en haute dimension, où les algorithmes basés sur la densité souffrent du fléau de la dimensionnalité.

Détection d’anomalies visuelle

Les anomalies apparaissent comme des points isolés dans l’embedding UMAP. Combiné avec Isolation Forest ou LOF dans l’espace UMAP, c’est une approche efficace pour la détection d’outliers.

Classification et régression (supervisé)

UMAP supporte un mode supervisé et semi-supervisé via le paramètre y dans .fit(X, y). Les labels orientent la réduction pour mieux séparer les classes. Utile comme prétraitement avant un classifieur quand les frontières de décision sont non linéaires.

Limites et pièges

UMAP ne préserve pas parfaitement la densité

Comme t-SNE, UMAP peut dilater les clusters denses et compresser les clusters épars. Les tailles visuelles des clusters ne reflètent pas nécessairement les densités réelles. La variante densMAP (intégrée dans umap-learn) tente de corriger ce problème en ajoutant un terme de préservation de densité dans l’optimisation.

Fausses séparations entre clusters

UMAP peut créer des « déchirures » artificielles dans des clusters continus, fragmentant un groupe unique en sous-groupes apparents. Validez toujours les séparations observées avec des métriques de clustering et une connaissance du domaine.

Sensibilité aux hyperparamètres

Des valeurs différentes de n_neighbors et min_dist peuvent produire des embeddings visuellement très différents. Comme pour t-SNE, testez plusieurs combinaisons et fiez-vous aux structures qui persistent à travers les réglages.

Reproductibilité

UMAP est stochastique : des initialisations différentes produisent des embeddings différents. Fixez random_state pour la reproductibilité. Même avec un seed fixe, la position absolue et l’orientation des clusters peuvent varier entre versions de la librairie.

Verdict

UMAP est le meilleur outil polyvalent de réduction de dimensionnalité non linéaire disponible. Il combine vitesse, qualité d’embedding, flexibilité (visualisation + prétraitement + clustering) et facilité d’utilisation. Pour la visualisation exploratoire, il a remplacé t-SNE dans la plupart des cas d’usage. Pour le prétraitement, il complète la PCA quand les relations sont non linéaires.

La combinaison PCA (50 composantes) → UMAP (2D ou n composantes) est le pipeline standard pour l’exploration de données de haute dimension. Ajoutez HDBSCAN après UMAP pour du clustering. C’est le trio moderne qui a remplacé le duo PCA + K-Means dans de nombreux workflows.