Projetez des données de grande dimension sur une carte 2-D avec uwot::umap(), colorez-la selon une étiquette, et ajustez n_neighbors et min_dist
Un guide pratique de UMAP en R. Découvrez ce que fait UMAP (Uniform Manifold Approximation and Projection), exécutez-le sur vos données avec uwot::umap(), colorez la carte 2-D selon une étiquette connue, ajustez les deux hyperparamètres qui comptent le plus (n_neighbors et min_dist), et lisez la représentation honnêtement — y compris ce que ses distances et ses écarts signifient ou non, comparé à l’ACP et t-SNE. Réalisé sur les données iris avec ggpubr.
uwot::umap() — un seul appel transforme une matrice ou un data frame numérique en une représentation (embedding) à deux colonnes que vous pouvez tracer.n_neighbors (petit → détail local, grand → forme globale) et min_dist (petit → amas serrés, grand → répartition uniforme).set.seed() avant umap() rend la carte reproductible d’une exécution à l’autre.Vous avez un tableau comportant de nombreuses colonnes numériques — expression génique, relevés de capteurs, caractéristiques d’images, items de sondage — et une seule question : a-t-il une structure ? Y a-t-il des groupes, des gradients, des valeurs aberrantes ? Vous ne pouvez pas tracer dix dimensions à la fois, il vous faut donc comprimer les données à deux tout en conservant leur forme.
L’ACP fait cela avec des lignes droites : elle trouve les directions de variance maximale et projette dessus. C’est rapide et interprétable, mais c’est linéaire — si la structure intéressante repose sur une surface courbe, l’ACP l’aplatit et les groupes se confondent.
UMAP emprunte une voie différente. C’est une méthode non linéaire qui construit d’abord un graphe des plus proches voisins de chaque point dans l’espace original de grande dimension, puis dispose ce graphe en 2-D de sorte que les voisins restent voisins. Le résultat est une représentation (embedding) — un ensemble de coordonnées en faible dimension, une ligne par observation — où les points qui étaient similaires dans les données complètes se retrouvent proches sur la carte. Parce qu’elle travaille à partir des voisinages locaux plutôt que de la variance globale, elle sépare souvent les vrais groupes bien plus nettement que l’ACP.
Choisissez UMAP lorsque vous voulez visualiser des données de grande dimension, repérer des regroupements ou un continuum, ou produire une disposition 2-D sur laquelle superposer une étiquette. Cette leçon exécute UMAP en R avec uwot — l’implémentation rapide et légère en dépendances de James Melville — trace chaque carte avec ggpubr, et vous apprend à lire le résultat sans tomber dans ses pièges. Elle fait partie de la série Réduction de dimension.
UMAP procède en deux étapes.
Construire un graphe de voisinage. Pour chaque point, trouver ses n_neighbors points les plus proches dans l’espace original et les relier, en pondérant chaque arête selon la proximité des voisins. Ce graphe capture la structure locale — qui est proche de qui — sur la variété sous-jacente des données (la surface courbe sur laquelle les données sont supposées reposer).
Disposer le graphe en 2-D. Trouver un agencement bidimensionnel des mêmes points dont les relations de voisinage correspondent au graphe aussi fidèlement que possible : les points reliés sont attirés l’un vers l’autre, les points non reliés sont repoussés, jusqu’à ce que la disposition se stabilise.
Voilà toute l’intuition — préserver qui est proche de qui. UMAP ne cherche jamais à préserver la distance exacte entre deux points éloignés, ce qui explique précisément pourquoi vous ne devez pas lire ces distances au pied de la lettre. La construction complète (ensembles simpliciaux flous, optimisation par entropie croisée) figure dans l’article original de McInnes, Healy & Melville (2018) ; la version pratique ci-dessus est tout ce dont vous avez besoin pour bien l’utiliser.
Nous utiliserons le jeu de données intégré iris : quatre mesures florales (longueur et largeur des sépales et des pétales) pour 150 iris répartis en trois espèces. Les étiquettes d’espèce sont parfaites pour cette leçon — nous exécutons UMAP sur les quatre mesures uniquement, puis nous colorons la carte selon l’espèce pour vérifier si la représentation retrouve des groupes qu’elle n’a jamais vus.
data("iris")
head(iris) Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1 5.1 3.5 1.4 0.2 setosa
2 4.9 3.0 1.4 0.2 setosa
3 4.7 3.2 1.3 0.2 setosa
4 4.6 3.1 1.5 0.2 setosa
5 5.0 3.6 1.4 0.2 setosa
6 5.4 3.9 1.7 0.4 setosaChaque ligne est une fleur décrite par quatre nombres. UMAP transformera ces quatre colonnes en deux, en positionnant chaque fleur de sorte que les fleurs aux mesures similaires soient proches.
Tout le calcul tient en un seul appel de fonction. uwot::umap() prend les colonnes numériques (retirez l’étiquette — ce n’est pas une entrée) et renvoie une matrice avec une ligne par fleur et une colonne par dimension de sortie (deux par défaut). Nous fixons d’abord une graine parce que la disposition est stochastique, puis nous mettons le résultat en forme dans un data frame :
library(uwot)
data("iris")
# UMAP on the four measurements only (columns 1:4); set a seed for reproducibility
set.seed(42)
embedding <- umap(iris[, 1:4], n_neighbors = 15, min_dist = 0.1)
# Tidy into a data frame: one row per flower, two coordinates + the species label
umap_df <- data.frame(
UMAP1 = embedding[, 1],
UMAP2 = embedding[, 2],
Species = iris$Species
)
head(umap_df) UMAP1 UMAP2 Species
1 -10.309549 -10.59203 setosa
2 -8.051796 -10.29594 setosa
3 -8.459328 -11.00878 setosa
4 -8.365959 -10.87398 setosa
5 -10.032135 -10.62880 setosa
6 -11.371042 -10.93288 setosaChaque fleur a désormais une coordonnée UMAP1 et UMAP2 — sa position sur la carte 2-D. Voilà toute la recette : une matrice numérique en entrée, une représentation à deux colonnes en sortie.
UMAP mesure les distances entre les points, donc une colonne exprimée en grandes unités (par exemple un revenu en dollars) dominerait une colonne en petites unités (l’âge en années). Les mesures d’iris sont toutes en centimètres et comparables, nous les utilisons donc telles quelles. Pour des données aux unités mixtes, standardisez d’abord : umap(scale(my_data)).
La carte ne devient utile qu’une fois que vous la tracez et y superposez ce que vous savez. Colorez chaque point selon son espèce avec ggpubr::ggscatter(), en utilisant une palette de revue adaptée au daltonisme, et entourez chaque groupe d’une ellipse de confiance :
library(uwot)
library(ggpubr)
data("iris")
set.seed(42)
embedding <- umap(iris[, 1:4], n_neighbors = 15, min_dist = 0.1)
umap_df <- data.frame(
UMAP1 = embedding[, 1], UMAP2 = embedding[, 2],
Species = iris$Species
)
ggscatter(umap_df, x = "UMAP1", y = "UMAP2",
color = "Species", palette = "jco",
size = 1.5, alpha = 0.7,
ellipse = TRUE, ellipse.type = "norm")
Lisez la carte selon les points qui se regroupent. UMAP a rassemblé les fleurs en regroupements nets, et la coloration par espèce confirme qu’ils sont réels : setosa forme un îlot serré et complètement isolé, tandis que versicolor et virginica forment deux regroupements adjacents qui se touchent là où les deux espèces se chevauchent réellement dans leurs mesures. UMAP a retrouvé la structure en trois groupes à partir des quatre mesures seules — il n’a jamais vu les étiquettes.
UMAP a deux boutons que vous tournerez réellement. Tous deux arbitrent entre le détail local et la forme globale.
n_neighbors — structure locale vs globalen_neighbors est le nombre de plus proches voisins utilisés pour construire le graphe. Des petites valeurs (par ex. 5) font que UMAP se concentre sur une structure très locale — il voit le détail fin et les petits amas mais peut fragmenter un groupe. Des grandes valeurs (par ex. 50) le font moyenner sur un voisinage plus large — il capture la forme globale d’ensemble mais brouille le détail fin. La valeur par défaut de 15 est un juste milieu raisonnable.
Nous construisons la même représentation avec trois réglages et les affichons côte à côte en facettes. Pour garder chaque bloc autonome et en base R uniquement, nous empilons les trois exécutions avec do.call(rbind, ...) :
library(uwot)
library(ggpubr)
data("iris")
# Run UMAP at three n_neighbors settings, stacking the results with base R
nn_values <- c(5, 15, 50)
sweep_df <- do.call(rbind, lapply(nn_values, function(nn) {
set.seed(42)
emb <- umap(iris[, 1:4], n_neighbors = nn, min_dist = 0.1)
data.frame(
UMAP1 = emb[, 1], UMAP2 = emb[, 2],
Species = iris$Species,
setting = factor(paste0("n_neighbors = ", nn),
levels = paste0("n_neighbors = ", nn_values))
)
}))
ggscatter(sweep_df, x = "UMAP1", y = "UMAP2",
color = "Species", palette = "jco",
size = 0.8, alpha = 0.7,
facet.by = "setting", scales = "free")
La structure en trois espèces survit à chaque réglage — bon signe qu’elle est réelle — mais la disposition change : un n_neighbors plus petit donne des amas plus serrés et plus morcelés ; un n_neighbors plus grand donne une carte plus lisse et plus étalée. Essayez quelques valeurs ; si vos groupes tiennent bon d’un réglage à l’autre, faites-leur confiance.
min_dist — à quel point les points se serrentmin_dist contrôle l’espacement minimal entre les points dans la représentation. Des petites valeurs (par ex. 0.01) permettent à UMAP de tasser les points en amas serrés et denses — utile pour voir des regroupements distincts. Des grandes valeurs (par ex. 0.8) écartent les points, en étalant chaque regroupement — mieux pour voir la structure interne d’un groupe. La valeur par défaut dans uwot est 0.01 (le réglage le plus serré — notez qu’elle diffère de la valeur par défaut de 0.1 du umap-learn Python).
library(uwot)
library(ggpubr)
data("iris")
md_values <- c(0.01, 0.1, 0.8)
md_df <- do.call(rbind, lapply(md_values, function(md) {
set.seed(42)
emb <- umap(iris[, 1:4], n_neighbors = 15, min_dist = md)
data.frame(
UMAP1 = emb[, 1], UMAP2 = emb[, 2],
Species = iris$Species,
setting = factor(paste0("min_dist = ", md),
levels = paste0("min_dist = ", md_values))
)
}))
ggscatter(md_df, x = "UMAP1", y = "UMAP2",
color = "Species", palette = "jco",
size = 0.8, alpha = 0.7,
facet.by = "setting", scales = "free")
Remarquez que min_dist est purement cosmétique en un sens — il change à quel point les points se tassent, pas quels points sont voisins — c’est donc un choix de visualisation : resserrez-le pour souligner des regroupements distincts, relâchez-le pour inspecter l’étalement au sein d’un regroupement.
Les trois se placent sur un spectre allant de « honnête mais linéaire » à « expressive mais non métrique ».
| ACP | UMAP | t-SNE | |
|---|---|---|---|
| Type | Linéaire | Non linéaire | Non linéaire |
| Vitesse | La plus rapide | Rapide | La plus lente |
| Axes interprétables ? | Oui (saturations, variance) | Non | Non |
| Distances honnêtes ? | Oui | En partie (local) | Local seulement |
| Structure globale | Préservée | Mieux que t-SNE | Faible / peu fiable |
| Usage principal | Interpréter, prétraiter | Visualiser, regrouper | Visualiser |
perplexity, et ses distances entre regroupements portent encore moins de sens que celles de UMAP.Un flux de travail professionnel courant utilise à la fois l’ACP et UMAP : l’ACP pour comprendre et débruiter, UMAP pour visualiser. Ils répondent à des questions différentes.
Un dernier avantage de UMAP pour la production : il peut projeter de nouveaux points inédits dans une carte existante avec uwot::umap_transform() (ajustez une fois avec ret_model = TRUE, puis projetez les nouvelles données) — ce que t-SNE de base ne fait pas proprement. Cela fait de UMAP le choix le plus commode lorsque la carte 2-D fait partie d’un pipeline qui doit placer de nouvelles observations.
UMAP modélise les données comme reposant sur une variété et l’approxime par un graphe pondéré. Pour chaque point \(x_i\), il calcule une appartenance floue pour ses voisins : le poids de l’arête vers le voisin \(x_j\) décroît avec la distance,
\[ w_{ij} = \exp\!\left( -\frac{d(x_i, x_j) - \rho_i}{\sigma_i} \right), \]
où \(\rho_i\) est la distance au plus proche voisin de \(x_i\) et \(\sigma_i\) est choisi de sorte que le voisinage de chaque point ait une « taille » fixe (liée à n_neighbors). Les poids orientés sont symétrisés en un graphe unique.
UMAP cherche ensuite une disposition en faible dimension \(y_i\) dont les propres poids d’arête \(q_{ij}\) (une fonction lisse de \(\lVert y_i - y_j \rVert\), façonnée par min_dist) correspondent aux poids en grande dimension. Il minimise une entropie croisée entre les deux graphes pondérés par descente de gradient stochastique — des forces attractives rapprochent les points reliés, des forces répulsives écartent les autres. L’optimisation est stochastique, ce qui explique pourquoi set.seed() est nécessaire pour un résultat reproductible. Détails complets : McInnes, Healy & Melville (2018).
set.seed() juste avant umap() (comme le fait chaque bloc ici) pour obtenir la même disposition à chaque exécution.umap(scale(my_data)).umap(). UMAP ne prend que les colonnes de caractéristiques numériques ; gardez l’étiquette de côté et servez-vous-en pour colorer le graphique ensuite (iris[, 1:4], pas iris). Pour un UMAP supervisé, uwot dispose d’un argument y = distinct.n_neighbors (plus grand pour la forme globale, plus petit pour le détail local). Si un regroupement n’apparaît qu’à un réglage étroit, soyez sceptique.UMAP (Uniform Manifold Approximation and Projection) sert à réduire des données de grande dimension à deux ou trois dimensions pour la visualisation, et à révéler des regroupements ou des gradients difficiles à voir autrement. Il est populaire pour la génomique single-cell, les représentations (embeddings) d’images et de texte, et tout tableau numérique large où vous voulez voir la structure. Exécutez-le en R avec uwot::umap().
Ni l’un ni l’autre n’est strictement meilleur — ils répondent à des questions différentes. L’ACP est linéaire, rapide, et donne des axes interprétables avec des distances honnêtes, mais elle peut manquer la structure courbe. UMAP est non linéaire et sépare généralement les vrais groupes plus nettement pour la visualisation, mais ses axes ne sont pas interprétables et ses distances entre regroupements ne sont pas métriques. Un flux de travail courant utilise l’ACP pour comprendre et débruiter, puis UMAP pour visualiser.
n_neighbors arbitre entre le détail local et la forme globale. Des petites valeurs (autour de 5) mettent en avant la structure locale fine ; des grandes valeurs (autour de 50) mettent en avant la forme globale d’ensemble ; la valeur par défaut de 15 est un bon point de départ. Essayez-en quelques-unes et faites confiance aux regroupements qui persistent d’un réglage à l’autre. Cela n’a rien à voir avec le nombre de regroupements que vous attendez — il s’agit de l’échelle de voisinage que UMAP examine.
Pas directement — UMAP produit une disposition 2-D, pas des étiquettes de regroupement. Un schéma courant consiste à exécuter UMAP pour la visualisation et à lancer un algorithme de regroupement (comme les k-means ou HDBSCAN) soit sur les données originales, soit sur la représentation. Soyez prudent en regroupant sur la représentation, puisque UMAP déforme les distances ; regrouper les caractéristiques originales et colorer la carte UMAP est souvent plus sûr.
La disposition est optimisée par descente de gradient stochastique en partant d’une initialisation aléatoire, donc des exécutions différentes donnent des cartes légèrement différentes. Appelez set.seed() juste avant umap() pour rendre le résultat reproductible. La structure (quels points se regroupent) devrait être stable d’une graine à l’autre même lorsque les coordonnées exactes diffèrent.
Exécutez UMAP sur le jeu de données intégré USArrests (50 États américains, quatre variables de criminalité/urbanisation). Standardisez d’abord les variables (les colonnes sont à des échelles très différentes), calculez la représentation 2-D avec une graine, puis tracez-la avec ggscatter(). Comme il n’y a pas d’étiquette de groupe, colorez les points selon un rapide regroupement kmeans() en 3 groupes des données standardisées.
Standardisez avec scale(USArrests). Passez cela à umap(). Pour la couleur, exécutez kmeans(scale(USArrests), 3)$cluster, enveloppez-le dans as.factor(), et ajoutez-le comme colonne. Pensez à set.seed() avant les deux, kmeans() et umap(), pour la reproductibilité.
library(uwot)
library(ggpubr)
data("USArrests")
# Standardize, then UMAP (n_neighbors small — only 50 rows)
X <- scale(USArrests)
set.seed(42)
emb <- umap(X, n_neighbors = 8, min_dist = 0.1)
# Colour by a 3-group k-means on the standardized data
set.seed(42)
clusters <- as.factor(kmeans(X, 3)$cluster)
umap_df <- data.frame(
UMAP1 = emb[, 1], UMAP2 = emb[, 2],
cluster = clusters
)
ggscatter(umap_df, x = "UMAP1", y = "UMAP2",
color = "cluster", palette = "jco",
size = 2, alpha = 0.8,
label = rownames(USArrests), repel = TRUE)Les États aux profils de criminalité/urbanisation similaires se retrouvent proches, et les couleurs k-means marquent les grands groupes. Avec seulement 50 lignes, gardez n_neighbors petit.
Vérification rapide. Sur une carte UMAP, le regroupement A est deux fois plus loin du regroupement B que du regroupement C. Pouvez-vous conclure que A est plus similaire à C qu’à B ?
Non. UMAP ne préserve pas les distances absolues entre regroupements bien séparés — ces écarts ne sont pas métriques. Vous pouvez lire que A, B et C sont des regroupements distincts, et quelles paires sont adjacentes, mais vous ne pouvez pas classer les distances entre regroupements en les mesurant sur la carte. Pour comparer honnêtement la similarité, revenez aux caractéristiques originales (ou utilisez une méthode aux distances honnêtes, comme l’ACP ou le MDS).
Vous avez exécuté UMAP en R avec un seul appel uwot::umap(), coloré la représentation 2-D selon une étiquette connue pour confirmer qu’elle retrouvait de vrais groupes, et réglé les deux hyperparamètres qui comptent — n_neighbors (structure locale vs globale) et min_dist (à quel point les points se serrent). Plus important encore, vous avez appris à lire la carte honnêtement : l’appartenance et l’adjacence ont du sens ; les distances absolues et la taille des regroupements, non. UMAP est l’outil de référence pour voir la structure en grande dimension ; associez-le à l’ACP lorsque vous avez aussi besoin d’axes interprétables et honnêtes, et comparez-le à sa cousine classique t-SNE.
Vous préférez un livre ? Principal Component Methods in R est disponible en PDF téléchargeable — toutes les leçons de cette série, hors ligne et à vous.
Prouvez que vous savez le faire. Maîtrisez toute la série Réduction de dimension en R — suivez votre parcours, construisez des projets et obtenez un certificat.
Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.
dès 15 $/mois facturé annuellement
✓ Vous êtes Pro — continuez. The runtime is the judge.
Prêt à passer à la vitesse supérieure ?
Cette leçon est reproductible : chaque figure et chaque nombre de cette page ont été produits par le code montré — copiez n’importe quel bloc et exécutez-le pour les reproduire. Parce que UMAP est stochastique, les appels set.seed() rendent chaque résultat identique d’une exécution à l’autre.
@online{2026,
author = {},
title = {UMAP en R : réduction de dimension non linéaire},
date = {2026-07-03},
url = {https://www.datanovia.com/learn/machine-learning/dimension-reduction/umap},
langid = {fr}
}