Projetez des données de grande dimension sur une carte 2-D avec Rtsne::Rtsne(), colorez-la selon une étiquette, et réglez la perplexité
Un guide pratique de t-SNE en R. Découvrez ce que fait t-SNE (t-distributed Stochastic Neighbor Embedding), exécutez-le avec Rtsne::Rtsne(), colorez la carte 2-D selon une étiquette connue, choisissez la perplexité, rendez-le reproductible avec set.seed(), et lisez la représentation honnêtement — y compris pourquoi la taille des regroupements et les distances entre regroupements n’ont pas de sens — face à l’ACP et UMAP. Réalisé sur les données iris avec ggpubr.
Rtsne::Rtsne() — passez une matrice numérique, obtenez une représentation (embedding) à deux colonnes dans l’élément $Y.check_duplicates = FALSE ; t-SNE échoue par défaut sur les doublons exacts.set.seed() avant Rtsne() rend la carte reproductible.perplexity — grossièrement, le nombre de voisins que chaque point équilibre (plage typique 5–50). Il doit être inférieur à (n-1)/3.Vous avez un tableau numérique large — des dizaines de colonnes — et vous voulez voir s’il a des groupes. Deux dimensions, vous pouvez les tracer ; dix, non. Il vous faut comprimer les données à 2-D tout en gardant proches les points qui sont similaires.
t-SNE est la méthode qui a rendu cela célèbre. C’est une technique non linéaire qui transforme les similarités en grande dimension en une carte 2-D où les proches voisins de chaque point dans l’espace original restent proches sur la carte, et tout le reste est repoussé. Le résultat est une représentation (embedding) — un ensemble de coordonnées en faible dimension, une ligne par observation — qui tend à montrer des amas serrés et bien séparés lorsque de vrais regroupements existent. Depuis une décennie, c’est l’image par défaut en biologie single-cell, en analyse de caractéristiques d’images, et partout où des données de grande dimension ont besoin d’un aperçu visuel rapide.
t-SNE est conçu pour la visualisation — pas pour des axes interprétables, pas pour le prétraitement, pas pour des distances honnêtes. Cette leçon l’exécute en R avec l’implémentation rapide Rtsne, trace chaque carte avec ggpubr, vous montre comment régler le seul hyperparamètre qui compte, et — plus important encore — vous apprend à lire le résultat sans tomber dans ses pièges bien documentés. Elle fait partie de la série Réduction de dimension ; sa cousine moderne est UMAP.
Rtsne est la référence de l’écosystème R. C’est une fine surcouche du t-SNE C++ Barnes-Hut officiel de van der Maaten, qui approxime le calcul en O(N log N) au lieu du naïf O(N²) — rapide, correct, sur CRAN, et sans dépendance Python (le RunTSNE() de Seurat l’utilise en coulisses). Évitez l’ancien paquet tsne en R pur : c’est l’implémentation naïve en O(N²) et il est de fait obsolète — bon pour une démo jouet, bien trop lent pour de vraies données.
t-SNE fonctionne en faisant correspondre des probabilités de voisinage dans deux espaces.
Dans l’espace original de grande dimension, pour chaque point il demande : quelle est la probabilité que chaque autre point soit choisi comme proche voisin ? Les points voisins reçoivent une forte probabilité, les points éloignés une probabilité proche de zéro. Le réglage perplexity contrôle le nombre de voisins que cette bande « proche » couvre effectivement.
Dans la carte 2-D, il définit le même type de probabilités de voisinage, puis déplace les points jusqu’à ce que les probabilités 2-D correspondent à celles en grande dimension aussi fidèlement que possible.
Parce qu’il ne cherche qu’à reproduire qui est un proche voisin de qui, t-SNE excelle à séparer les regroupements locaux — mais il ne promet rien quant à la distance entre deux regroupements ni à l’espace qui les sépare. Une distribution à queue lourde (Student-t) dans la carte 2-D est ce qui lui donne la marge d’écarter les regroupements sans les écraser les uns contre les autres, et c’est de là que vient le « t » du nom. La dérivation complète figure dans l’article original de van der Maaten & Hinton (2008) ; l’intuition ci-dessus suffit 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. Nous exécutons t-SNE 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. t-SNE positionnera chaque fleur de sorte que les fleurs aux mesures similaires se retrouvent ensemble.
Rtsne::Rtsne() attend une matrice numérique (pas un data frame), et iris contient une poignée de lignes en double, que t-SNE rejette par défaut — nous passons donc check_duplicates = FALSE. Fixez d’abord une graine, puisque la disposition est stochastique. Les coordonnées reviennent dans l’élément $Y :
library(Rtsne)
data("iris")
# t-SNE on the four measurements only; matrix input; iris has duplicate rows
set.seed(42)
tsne <- Rtsne(as.matrix(iris[, 1:4]),
perplexity = 30,
check_duplicates = FALSE)
# The 2-D coordinates live in $Y — tidy into a data frame with the species label
tsne_df <- data.frame(
TSNE1 = tsne$Y[, 1],
TSNE2 = tsne$Y[, 2],
Species = iris$Species
)
head(tsne_df) TSNE1 TSNE2 Species
1 -15.30494 -4.242190 setosa
2 -13.22669 -3.586189 setosa
3 -12.91921 -4.424025 setosa
4 -12.72532 -4.262937 setosa
5 -15.36637 -4.616382 setosa
6 -17.03405 -4.867805 setosaChaque fleur a désormais une coordonnée TSNE1 et TSNE2 — sa position sur la carte 2-D. Voilà la recette : une matrice numérique en entrée, une représentation à deux colonnes en sortie via $Y.
Rtsne() veut une matrice — enveloppez un data frame dans as.matrix() et retirez d’abord les colonnes non numériques. Et il s’arrête sur les lignes en double exactes sauf si vous fixez check_duplicates = FALSE ; iris a des doublons, donc nous le faisons. Si vos colonnes utilisent des unités différentes, standardisez d’abord (Rtsne(scale(as.matrix(my_data)))), puisque t-SNE repose sur les distances.
Tracez la carte et 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(Rtsne)
library(ggpubr)
data("iris")
set.seed(42)
tsne <- Rtsne(as.matrix(iris[, 1:4]),
perplexity = 30, check_duplicates = FALSE)
tsne_df <- data.frame(
TSNE1 = tsne$Y[, 1], TSNE2 = tsne$Y[, 2],
Species = iris$Species
)
ggscatter(tsne_df, x = "TSNE1", y = "TSNE2",
color = "Species", palette = "jco",
size = 1.5, alpha = 0.7,
ellipse = TRUE, ellipse.type = "norm")
Lisez la carte selon les points qui se regroupent. t-SNE a séparé les fleurs en regroupements, et la coloration par espèce les confirme : setosa forme un îlot isolé, tandis que versicolor et virginica se placent en deux regroupements adjacents qui se touchent là où les deux espèces se chevauchent réellement. t-SNE a retrouvé la structure en trois groupes à partir des quatre mesures seules — il n’a jamais vu les étiquettes.
t-SNE a un bouton que vous devez régler avec soin : perplexity. Grossièrement, c’est le nombre de proches voisins que chaque point équilibre — les petites valeurs se concentrent sur une structure très locale, les plus grandes prennent une vue plus large. La plage habituelle est de 5 à 50, et elle doit être inférieure à (n-1)/3 (avec les 150 lignes d’iris, (n-1)/3 ≈ 49.7, donc 49 est le maximum pratique).
Le hic, c’est que l’image peut changer avec la perplexité, vous devriez donc toujours en essayer quelques-unes. Nous construisons la représentation avec trois réglages et les affichons côte à côte en facettes, en empilant les exécutions avec base R :
library(Rtsne)
library(ggpubr)
data("iris")
# Run t-SNE at three perplexity settings, stacking the results with base R
perp_values <- c(5, 30, 45)
sweep_df <- do.call(rbind, lapply(perp_values, function(p) {
set.seed(42)
emb <- Rtsne(as.matrix(iris[, 1:4]),
perplexity = p, check_duplicates = FALSE)$Y
data.frame(
TSNE1 = emb[, 1], TSNE2 = emb[, 2],
Species = iris$Species,
setting = factor(paste0("perplexity = ", p),
levels = paste0("perplexity = ", perp_values))
)
}))
ggscatter(sweep_df, x = "TSNE1", y = "TSNE2",
color = "Species", palette = "jco",
size = 0.8, alpha = 0.7,
facet.by = "setting", scales = "free")
À faible perplexité, t-SNE se fixe sur une structure très locale et peut briser un vrai groupe en plusieurs petits amas ; à perplexité modérée à élevée (30–45 ici) les trois espèces ressortent en regroupements stables et nets. La leçon : essayez quelques perplexités et faites confiance à la structure qui persiste, pas à un motif qui n’apparaît qu’à un seul réglage. Si une valeur est trop grande pour votre taille d’échantillon, Rtsne() échoue avec “perplexity is too large for the number of samples” — abaissez-la.
La perplexité est la vedette, mais trois autres arguments de Rtsne() comptent en pratique :
theta (par défaut 0.5) — le compromis vitesse/précision de Barnes-Hut. Plus petit est plus précis mais plus lent (theta = 0 est le t-SNE exact en O(N²)) ; la valeur par défaut est un bon équilibre. Ne l’abaissez que pour de petites données où vous voulez le résultat exact.pca = TRUE (par défaut) avec initial_dims — t-SNE réduit d’abord les données avec l’ACP (à 50 dimensions par défaut) avant la représentation. Sur des données larges (beaucoup de colonnes), c’est une vraie accélération et un débruiteur ; gardez-le activé, et abaissez initial_dims pour une entrée de très grande dimension.is_distance = TRUE — passez une matrice de distances précalculée au lieu des caractéristiques brutes, utile lorsque vous avez une dissimilarité personnalisée (beaucoup de surcouches t-SNE ne peuvent pas le faire). Combinez avec pca = FALSE.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 |
| Déterministe ? | Oui | Oui, avec une graine | Oui, avec une graine |
| Projeter de nouveaux points ? | Oui | Oui (umap_transform()) |
Pas dans Rtsne de base |
| Usage principal | Interpréter, prétraiter | Visualiser, regrouper | Visualiser |
perplexity, et sa géométrie entre regroupements est la moins fiable.Une dernière différence pratique : projeter de nouveaux points. Rtsne() de base n’a aucun moyen propre de placer des points inédits sur une carte existante, tandis que UMAP le prend en charge nativement via uwot::umap_transform() — un vrai avantage lorsqu’une carte t-SNE/UMAP fait partie d’un pipeline de production qui doit placer de nouvelles observations.
Si vous ne pouvez apprendre en profondeur qu’une seule méthode non linéaire, le domaine s’est largement tourné vers UMAP ; apprenez aussi t-SNE, car vous le rencontrerez dans une décennie de figures publiées.
Le t-SNE Barnes-Hut ralentit sur de très grands N. Pour des centaines de milliers à des millions de points — routine en génomique single-cell — utilisez le t-SNE interpolé par FFT (FIt-SNE), qui est quasi linéaire en N. En R, deux voies : snifter (Bioconductor) enveloppe le openTSNE Python pour offrir FIt-SNE et une méthode project() qui projette de nouveaux points dans une carte existante (le coût est une dépendance Python via basilisk/reticulate) ; et l’implémentation de référence FIt-SNE (KlugerLab, moins clé en main). Restez sur Rtsne jusqu’à ce que vos données le dépassent. (Sur les processeurs multicœurs, un Barnes-Hut parallélisé aide aussi — voir Chaudhary et al. 2022.)
Dans l’espace original, t-SNE transforme les distances en probabilités de voisinage conditionnelles. La probabilité que le point \(i\) choisisse le point \(j\) comme voisin est une gaussienne autour de \(i\) :
\[ p_{j \mid i} = \frac{\exp(-\lVert x_i - x_j \rVert^2 / 2\sigma_i^2)}{\sum_{k \ne i} \exp(-\lVert x_i - x_k \rVert^2 / 2\sigma_i^2)}, \]
où chaque \(\sigma_i\) est choisi de sorte que le voisinage ait la perplexité demandée. Celles-ci sont symétrisées en probabilités jointes \(p_{ij}\).
Dans la carte 2-D, les similarités utilisent un noyau Student-t à queue lourde (un degré de liberté) :
\[ q_{ij} = \frac{(1 + \lVert y_i - y_j \rVert^2)^{-1}}{\sum_{k \ne l} (1 + \lVert y_k - y_l \rVert^2)^{-1}} . \]
t-SNE déplace ensuite les \(y_i\) pour minimiser la divergence de Kullback–Leibler \(\mathrm{KL}(P \parallel Q) = \sum_{ij} p_{ij} \log \tfrac{p_{ij}}{q_{ij}}\) par descente de gradient. La queue lourde permet à des points modérément éloignés de se placer loin l’un de l’autre en 2-D sans pénalité — ce qui explique exactement pourquoi les distances entre regroupements n’ont pas de sens. L’optimisation est stochastique, donc set.seed() est nécessaire pour la reproductibilité. Détails complets : van der Maaten & Hinton (2008).
set.seed() juste avant Rtsne() (comme le fait chaque bloc ici) pour une disposition reproductible.Rtsne() échoue sur les lignes en double — “Remove duplicates before running TSNE”. iris a des lignes en double exactes, c’est donc une première erreur courante. Deux solutions : passez check_duplicates = FALSE (comme nous le faisons), ou dédupliquez d’abord — X <- unique(as.matrix(iris[, 1:4])) — et exécutez t-SNE sur X.Rtsne() signale que la perplexité est trop grande. La perplexité doit être inférieure à (n-1)/3. Abaissez-la, surtout sur de petits échantillons.pca = TRUE par défaut (une ACP initiale à ~50 dimensions débruite et l’accélère), abaissez initial_dims, ou passez au plus rapide UMAP. Pour de très grands N, voir la note FIt-SNE ci-dessus.tsne. Utilisez Rtsne, pas l’ancien paquet tsne en R pur — ce dernier est l’implémentation naïve en O(N²) et est de fait obsolète (données jouets seulement).t-SNE (t-distributed Stochastic Neighbor Embedding) sert à visualiser des données de grande dimension en deux ou trois dimensions, en révélant des regroupements ou des groupes autrement impossibles à voir. C’est un incontournable en génomique single-cell, en analyse de représentations (embeddings) d’images et de texte, et pour tout tableau numérique large dont vous voulez un aperçu visuel rapide. Exécutez-le en R avec Rtsne::Rtsne(). C’est un outil de visualisation, pas une méthode de prétraitement ni de regroupement.
La perplexité est grossièrement le nombre de proches voisins que chaque point équilibre ; la plage habituelle est de 5 à 50, avec 30 en valeur par défaut courante. Elle doit être inférieure à (n-1)/3 pour votre taille d’échantillon. Puisque l’image peut se déplacer avec la perplexité, essayez quelques valeurs et faites confiance à la structure qui reste stable — un motif qui n’apparaît qu’à un seul réglage est suspect.
L’ACP est linéaire, rapide, et donne des axes interprétables avec des distances honnêtes, mais elle peut manquer la structure courbe et superpose souvent de vrais groupes. t-SNE est non linéaire et sépare généralement les regroupements locaux bien plus nettement pour la visualisation — mais ses axes ne sont pas interprétables, ses distances ne sont pas métriques, et il est bien plus lent. Un flux de travail courant exécute d’abord l’ACP pour débruiter, puis t-SNE sur les composantes principales pour visualiser.
Pour beaucoup de flux de travail modernes, oui — UMAP est plus rapide, préserve plus de structure globale, et est déterministe une fois la graine fixée, ce qui en a fait la référence pour les grands jeux de données. Mais t-SNE reste un excellent visualiseur bien compris que vous verrez partout dans la littérature publiée. Ils partagent la même mise en garde centrale : la taille des regroupements et les distances entre regroupements n’ont de sens dans aucun des deux.
La disposition est optimisée par descente de gradient à partir d’un départ aléatoire, donc chaque exécution diffère. Appelez set.seed() juste avant Rtsne() pour la rendre reproductible. La structure d’ensemble (quels points se regroupent) devrait être stable d’une graine à l’autre même lorsque les coordonnées exactes et l’orientation changent.
Exécutez t-SNE 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), puis calculez la représentation 2-D avec une graine. Avec seulement 50 lignes, gardez la perplexité petite (elle doit être inférieure à (50-1)/3 ≈ 16). Colorez les points selon un rapide regroupement kmeans() en 3 groupes des données standardisées et tracez avec ggscatter().
Construisez la matrice avec scale(USArrests) et passez-la à Rtsne() avec perplexity = 8. Pour la couleur, exécutez kmeans(scale(USArrests), 3)$cluster, enveloppez-le dans as.factor(). Pensez à set.seed() avant kmeans() et Rtsne(), et prenez les coordonnées depuis $Y.
library(Rtsne)
library(ggpubr)
data("USArrests")
# Standardize, then t-SNE with a small perplexity (only 50 rows)
X <- scale(USArrests)
set.seed(42)
tsne <- Rtsne(X, perplexity = 8, check_duplicates = FALSE) # X is already a matrix (from scale())
# Colour by a 3-group k-means on the standardized data
set.seed(42)
clusters <- as.factor(kmeans(X, 3)$cluster)
tsne_df <- data.frame(
TSNE1 = tsne$Y[, 1], TSNE2 = tsne$Y[, 2],
cluster = clusters
)
ggscatter(tsne_df, x = "TSNE1", y = "TSNE2",
color = "cluster", palette = "jco",
size = 2, alpha = 0.8,
label = rownames(USArrests), repel = TRUE)Les États aux profils de criminalité/urbanisation similaires se regroupent, et les couleurs k-means marquent les grands groupes. Sur un petit échantillon, une petite perplexité est essentielle.
Vérification rapide. Vous exécutez t-SNE deux fois avec des graines différentes et une carte est l’image miroir de l’autre, pivotée. Y a-t-il un problème ?
Non. t-SNE ne fixe que quels points sont voisins, donc la carte entière peut être librement pivotée ou réfléchie entre les exécutions sans changer de sens — tout comme le signe arbitraire d’une composante d’ACP. Tant que les mêmes points se regroupent, les deux cartes concordent. Lisez l’appartenance, pas l’orientation.
Vous avez exécuté t-SNE en R avec Rtsne::Rtsne() — en vous souvenant de l’entrée en matrice et de check_duplicates = FALSE — coloré la représentation 2-D selon une étiquette connue pour confirmer qu’elle retrouvait de vrais groupes, et balayé la perplexité pour voir à quel point l’image en dépend. Surtout, vous avez appris à lire la carte honnêtement : l’appartenance a du sens ; la taille des regroupements et les distances entre regroupements, non. t-SNE est un superbe visualiseur aux pièges bien connus ; tournez-vous vers sa cousine plus rapide et préservant mieux la structure globale, UMAP, sur de plus grandes données, et vers l’ACP lorsque vous avez besoin d’axes interprétables et honnêtes.
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 t-SNE est stochastique, les appels set.seed() rendent chaque résultat identique d’une exécution à l’autre.
@online{2026,
author = {},
title = {t-SNE en R : visualiser des données de grande dimension},
date = {2026-07-03},
url = {https://www.datanovia.com/learn/machine-learning/dimension-reduction/t-sne},
langid = {fr}
}