t-SNE

Setup#

pip install scikit-learn

Outputs verified with scikit-learn 1.7.2. t-SNE is stochastic: exact numbers below vary across versions and platforms even with a fixed seed, though the conclusions hold.

Do the islands mean anything? Measure it.#

A picture can lie, so score the embedding: if a point's nearest neighbours on the page share its label, the islands reflect reality. The digits dataset ships with sklearn — 1,797 tiny images, no download.

import numpy as np
from sklearn.datasets import load_digits
from sklearn.manifold import TSNE
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score

digits = load_digits()                     # 1,797 tiny 8x8 digit images
X, y = digits.data, digits.target          # each image = 64 numbers

emb = TSNE(n_components=2, perplexity=30, random_state=0).fit_transform(X)
print("shape:", X.shape, "->", emb.shape)

def neighbour_agreement(Z, y):
    """Do nearby points share a label? Higher = tighter, purer clusters."""
    return cross_val_score(KNeighborsClassifier(10), Z, y, cv=3).mean()

print(f"neighbour agreement in 64-D: {neighbour_agreement(X, y):.3f}")
print(f"neighbour agreement in 2-D:  {neighbour_agreement(emb, y):.3f}")

shape: (1797, 64) -> (1797, 2)
neighbour agreement in 64-D: 0.954
neighbour agreement in 2-D:  0.977

This takes under a minute on an ordinary laptop CPU.

The walkthrough#

2-D scored higher than 64-D. Ten-neighbour label agreement rose from 0.954 to 0.977 after crushing 64 numbers to 2. t-SNE did not preserve the space — it sharpened neighbourhoods, pulling same-digit points together more tightly than they sit in pixel space. That is the tool doing its job, and also your warning: the picture is an argument about neighbourhoods, not a faithful map.

To actually look, scatter-plot emb coloured by label with matplotlib — plt.scatter(emb[:, 0], emb[:, 1], c=y, s=5, cmap="tab10"). Ten islands appear.

random_state=0 pins the run, because different seeds produce different — equally valid — pictures. Rotations, flips and island rearrangements are all free moves for t-SNE.

Cost scales hard with rows. Tens of thousands of points are fine; hundreds of thousands get slow. Standard practice for wide data: PCA down to about 50 columns first, then t-SNE — sklearn recommends exactly this, and it also steadies the result by denoising.

Common mistakes#

Reading distances between islands. The gap between the "0" island and the "1" island is an artefact of the layout, not a measurement. The next lesson demonstrates this failure with numbers: reading an embedding plot honestly.

Reading island sizes. t-SNE expands dense clusters and compresses sparse ones to fit everything on the page. A big island is not a bigger or more varied class.

Using one perplexity. Run 5, 30, and 100. Structure that survives all three deserves belief; structure that appears at only one setting is probably that setting talking.

Transforming new points. sklearn's TSNE has no transform method — the map is optimised for one fixed dataset, and there is no function to apply to newcomers. Needing that is the classic reason to switch to UMAP.

Feeding the 2-D output into a classifier as features. The axes mean nothing, the layout changes per seed, and new data cannot be mapped. For downstream models, reduce with PCA or train a proper embedding instead.

Try it yourself#

Run with perplexity=5 and perplexity=100, computing the agreement score for each. Then plot all three embeddings side by side and note which islands merge, split, or wander — same data, three defensible pictures.

What to learn next#

• UMAP — faster, with new-point projection and somewhat better global structure.
• Reading an embedding plot honestly — the failure modes, measured.
• PCA — the pre-reduction step and the linear baseline to compare against.