Concept30 minBefore this:Principal Component Analysis

t-SNE & UMAP

How do you see 768-dimensional data, and what are the plots lying about?

The situation

You've trained customer embeddings and made a 2-D plot. A teammate points at the gaps and sizes of the clusters and draws conclusions from them. The interviewer asks:

How does t-SNE build its 2-D map?

Running example: the food-delivery app has ten features per customer. In the simulated data there are three groups of 50: group A is tight (spread 0.3), group B is wide (spread 2.0, about 6.7 times A), and group C is far away (B is 4 times farther from C than from A). We know these facts because we built the data; the question is which of them survive the trip down to 2-D. Every map on this page is computed live by a small exact t-SNE.

You can't look at ten dimensions

Before clustering customers, or after training an embedding model, you want to see the data: are there groups? outliers? mislabelled points? A 2-D scatter plot is the most powerful tool a human has, but the data has 10, 300 or 768 dimensions. PCA's best flat projection often piles groups on top of each other: on MNIST digits a 2-D PCA map keeps so little neighbourhood structure that a k-NN classifier on it gets about 46% accuracy, against about 97% on t-SNE or UMAP maps UMAP paper, Table 2. We need a non-linear map that keeps local structure.

The idea

Think of arranging people on a floor so that friends stand together. You'll keep the friend groups intact, but how big each group looks, and how far apart the groups stand, means very little.

Illustrative, based on the lesson's groups A and B. Maps keep neighbours, not sizes.

Play

Try to break it. Run perplexity from 2 up to 50, then change the seed. Compare the size and distance readouts with their true values.

Run t-SNE yourself

Perplexity changes the picture

Perplexity

Random seed

B's size ÷ A's size on the map (true 6.7)

–

dist(B, C) ÷ dist(A, B) on the map (true 4.0)

–

KL divergence (lower = better fit)

–

150 customers, 10 features, exact t-SNE, 700 iterations, computed in your browser (the first run of each setting takes a moment). Axes have no units: only who sits near whom matters.

Group B is 6.7 times wider than A in the data, but on the map it looks about the same size (0.97–1.07×) at perplexity 2–30, and 2.1× at 50. C is 4 times farther from B than A is, but at perplexity 2–5 the map shows all three groups roughly equidistant (ratio 0.97–1.06), at 15–30 the ratio is 1.0–1.6, and only at perplexity 50 (with 50 points per group, each point's neighbourhood now spans its whole group) does it climb to 2.9–3.5, still short of 4. Both seeds agree on the pattern. All three groups stay cleanly separated at every setting: that part is reliable.

Now say why: if the picture changes this much, what can you safely conclude from it?

Maths

In one breath

t-SNE and UMAP squash high-dimensional data (embeddings, gene profiles, customer features) into 2-D so that points that were neighbours stay neighbours. t-SNE turns distances into probabilities of "being neighbours" (with perplexity ≈ how many neighbours each point considers), then moves 2-D points to match them, using a heavy-tailed Student-t in 2-D so clusters separate cleanly. UMAP builds a weighted k-nearest-neighbour graph and lays it out with attraction and repulsion; it's much faster, scales to millions, and can embed into more than 2 dimensions. Both are excellent for seeing clusters and both mislead: cluster sizes and distances between clusters are often not meaningful, results change with hyperparameters and seeds, and random noise can look like clusters.What you'll be able to do after this: explain how t-SNE works and what perplexity does, compare it with UMAP and PCA, and list exactly what you may and may not conclude from one of these plots.

group A (tight)group B (wide)group C (far away)numbersdistortion / failure

Similarities as probabilities

t-SNE (van der Maaten & Hinton, 2008) describes the high-dimensional data by how likely each point is to "pick" each other point as its neighbour:

scikit-learn: t-SNE "converts affinities of data points to probabilities. The affinities in the original space are represented by Gaussian joint probabilities and the affinities in the embedded space are represented by Student's t-distributions" manifold guide.

Perplexity sets σ_i. scikit-learn: "The perplexity of a k-sided die is k, so that k is effectively the number of nearest neighbors t-SNE considers" manifold guide. The original paper's guidance: "typical values are between 5 and 50", quoted by Distill, which adds that perplexity "really should be smaller than the number of points" Distill 2016.

One principle

Match the neighbour probabilities, with heavy tails in 2-D

van der Maaten & Hinton (2008), JMLR 9. scikit-learn: "the KL divergence is not convex, i.e. multiple restarts with different initializations will end up in local minima … it is sometimes useful to try different seeds and select the embedding with the lowest KL divergence" manifold guide.

The map is found by gradient descent: start from tiny random (or PCA) positions, and repeatedly pull together pairs whose q is too small and push apart pairs whose q is too large. Two practical tricks: early exaggeration (multiply P by ~12 for the first iterations so clusters form and separate early) and momentum.

UMAP

A neighbour graph, laid out with springs

Swipe sideways to see the whole diagram.

Start from the high-dimensional points (drawn flat here).
Connect each point to its n_neighbors nearest neighbours (found approximately, fast). Edge weights fall off with distance, scaled per point by the distance to its nearest neighbour, so dense and sparse regions both get well-connected local graphs. Two clusters may be joined by a few weak edges.
Initialise a 2-D layout, by default with the spectral embedding (Laplacian eigenmaps) of that graph.
Optimise with stochastic gradient descent: for each sampled edge, pull its two endpoints together.
For each pull, push a few random (probably unrelated) points apart: negative sampling, borrowed from word2vec. The objective is a cross-entropy between the high-D graph and the 2-D one, and needs no global normalisation, which is why it is fast.

Two knobs: n_neighbors (like perplexity: small = local detail, large = more global shape; default 15) and min_dist (how tightly points may pack in the map; 0 for clustering). The paper's claim: UMAP "is competitive with t-SNE for visualization quality, and arguably preserves more of the global structure with superior run time performance" McInnes et al., p. 1.

Update · my check: the "global structure" claim

Later work by Kobak & Linderman showed that much of UMAP's apparent global-structure advantage comes from its initialisation: with the same (e.g. PCA or spectral) initialisation, t-SNE preserves global structure about as well. The UMAP authors themselves acknowledge this in their paper's weaknesses section: "a significant contributor to UMAP's relative global structure preservation is derived from the Laplacian Eigenmaps initialization" p. 49. Practical lesson: initialise t-SNE with PCA (init="pca", scikit-learn's default), and don't choose UMAP over t-SNE for global fidelity alone.

In practice

Three ways to get a 2-D picture

	PCA	t-SNE	UMAP
Keeps	Global variance (linear)	Local neighbourhoods	Local neighbourhoods; arguably more global structure
Speed	Seconds	O(N log N) with Barnes–Hut; slow at millions	Empirically ~O(N^1.14); millions feasible
New points	Yes (matrix multiply)	No (refit)	Yes (`transform`)
Output dims	Any	2–3 in practice (Barnes–Hut)	Any
Deterministic	Yes	No (seed)	No (seed)

t-SNE complexity and the 3-D limit of Barnes–Hut: scikit-learn manifold guide. UMAP's O(N^1.14) empirical scaling and arbitrary embedding dimension: McInnes et al. p. 22.

Good practice

Using these maps for real work

Reduce first: run PCA to ~50 dimensions before t-SNE to cut noise and time (the t-SNE paper did this too); UMAP copes with high ambient dimension directly.
Try several settings and seeds; trust structure that survives all of them.
Clustering on UMAP output: the UMAP docs show HDBSCAN on a UMAP embedding of MNIST clustering over 99% of points, versus about 17% when run on 50-dimensional PCA. They advise min_dist=0, a larger n_neighbors (e.g. 30), and caution: it "should be attempted with care", since UMAP "can also create false tears in clusters" UMAP docs.
Never cluster on t-SNE coordinates for decisions without validating in the original space; the map's distances are distorted by design. my take
Interpretability: map axes mean nothing; the UMAP authors recommend PCA, NMF or similar "if strong interpretability is critical" p. 45.

The whole recipe

Scale features; for embeddings use cosine distance.
PCA to ~50 dims (for t-SNE; optional for UMAP).
Run t-SNE (perplexity 5–50, init="pca", learning_rate="auto") or UMAP (n_neighbors 15–50, min_dist 0.1, or 0 for clustering).
Repeat with 2–3 settings and seeds; colour by known labels or metadata.
Conclude only about neighbourhoods and separations that persist; check any cluster in the original space.

When to use it

Use t-SNE / UMAP when

Exploring high-dimensional data or embeddings visually
Checking whether classes or clusters separate
UMAP: preprocessing for density clustering, or large datasets

Reach for something else when

You need features for a model: PCA, or UMAP with care
You need faithful global distances: PCA or MDS
You need interpretable axes: PCA, NMF, factor analysis

The answer that sounds right

The trap

"Use a Gaussian in 2-D too" (the crowding problem)

The first version, SNE (Hinton & Roweis, 2002), matched the high-D probabilities with Gaussian similarities in 2-D. But there is far more room in 10 dimensions than in 2: a point can have many neighbours at roughly the same moderate distance, and they can't all fit at that distance in a plane. To keep the near neighbours near, the moderately distant points get squeezed into the middle, and every cluster collapses into one crowded ball. van der Maaten & Hinton named this the crowding problem.

How to misread it

What a t-SNE (or UMAP) plot does and doesn't tell you

Usually safe to read

Which points are neighbours: tight local groups are real neighbourhoods
That well-separated clusters exist (check across settings and seeds)
Outliers and mislabelled points sitting inside another class's cluster

Not safe to read

Cluster sizes: "Cluster sizes in a t-SNE plot mean nothing"
Gaps between clusters: "distances between well-separated clusters in a t-SNE plot may mean nothing"
Clumps in noise: "Random noise doesn't always look random"
Results from one perplexity: "For topology, you may need more than one plot"

Quotes are section titles and sentences from Wattenberg, Viégas & Johnson, "How to Use t-SNE Effectively" Distill 2016, which also stresses iterating "until reaching a stable configuration". Why sizes vanish: σ_i adapts to local density, so every cluster is described by "my ~30 nearest neighbours", whether they're packed tight or spread wide. Density is normalised away by design. my take

Caveats

Strengths

Reveal cluster and neighbourhood structure PCA hides
UMAP: fast, scales, any output dimension, transforms new points
Standard tools for embeddings, single-cell biology, data QA

Weaknesses

Sizes and between-cluster distances unreliable
Hyperparameter- and seed-dependent; can invent structure in noise
t-SNE: slow at scale, no transform for new points
Axes have no meaning

Say it

How does t-SNE build its 2-D map?

Say your answer out loud

Aim for 30 seconds. It feels different from reading it, and that's the point.

Tick what you covered

t-SNE turns high-dimensional distances into neighbour probabilities, with a width set by perplexity.
It finds 2-D positions with matching similarities, using a heavy-tailed Student-t.
It minimises KL divergence with gradient descent.
The heavy tail solves the crowding problem.
It keeps local neighbourhoods, not cluster sizes or distances between clusters.
UMAP builds a neighbour graph, is much faster and has the same reading caveats.