t-SNE

t-Distributed Stochastic Neighbor Embedding (t-SNE)

t-SNE is a non-linear dimensionality-reduction method used mainly to visualize high-dimensional data in two or three dimensions. Its central idea is simple: if two samples are close neighbors in the original feature space, t-SNE tries to place them close together on the map.

t-SNE is commonly used to inspect embeddings, image features, text representations, biological measurements and other datasets where each sample may have tens, hundreds or thousands of values. It is an exploratory visualization tool, not a classifier and not proof that visible groups are real-world classes.

Why t-SNE Is Useful

Humans can easily inspect a scatter plot with two or three axes, but not a point described by 64, 500 or 1,000 features. t-SNE gives us a low-dimensional map that can make local relationships easier to inspect.

PCA and t-SNE answer different questions

PCA can be a useful first step before t-SNE when the original feature count is very high. Reducing to a moderate number of dimensions first can remove some noise and make t-SNE faster.

Core Philosophy of t-SNE

Think of a classroom friendship map. If Alice's closest friends are Bob and Carla, a useful map should try to keep Bob and Carla near Alice. But the exact distance between the “football group” and the “music group” should not automatically be interpreted as a precise real-world distance.

Fundamental Concepts in t-SNE

Distance & high-dimensional similarity

With the default metric, t-SNE starts from Euclidean-style relationships between samples and converts distances into neighborhood probabilities. A smaller distance generally means a stronger neighborhood relationship.

High-dimensional probabilities

t-SNE does not try to copy every raw distance into 2D. It converts high-dimensional affinities into probabilities: close neighbors get larger probability mass than distant points. Different samples can use different Gaussian bandwidths so that the neighborhood scale matches the chosen perplexity.

Student t-distribution and the crowding problem

In the low-dimensional map, t-SNE uses a Student t-distribution with heavy tails. The heavy tail gives moderately distant points more room in the map and reduces the tendency for many points to crowd into the center.

Step-by-Step Working of t-SNE

KL Divergence

t-SNE minimizes the mismatch between high-dimensional neighborhood probabilities P and low-dimensional neighborhood probabilities Q using Kullback-Leibler divergence:

Gradient-based optimization repeatedly changes the low-dimensional coordinates to reduce this objective. Because the objective is non-convex, different initializations or random seeds can end at different local solutions.

Understanding perplexity

Perplexity is related to the effective neighborhood size t-SNE considers. It is not simply “the number of clusters” and it does not directly tell t-SNE how many groups to create.

What must not be over-interpreted?

Preprocessing Before t-SNE

Because neighborhood methods depend on distances, feature scale matters. If one meaningful numerical feature ranges from 0–1 and another from 0–1,000,000, the larger-scale feature can dominate the distance calculation unless that scale difference is intentional.

Python Implementation of t-SNE

Scikit-learn provides TSNE. The built-in handwritten-digits dataset used below has 64 input features per image, not 784. The target labels are used only to color the final plot; t-SNE itself does not train on those labels.

import matplotlib.pyplot as plt

from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler

# 1. Load data
digits = load_digits()
X = digits.data      # 1797 samples, 64 features
y = digits.target    # used only for plot colors

# 2. Put numerical features on a comparable scale
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 3. Optional pre-reduction before t-SNE
pca = PCA(n_components=40, random_state=42)
X_reduced = pca.fit_transform(X_scaled)

# 4. Build a 2D t-SNE embedding
tsne = TSNE(
    n_components=2,
    perplexity=30,
    init="pca",
    learning_rate="auto",
    max_iter=1000,
    random_state=42
)
X_tsne = tsne.fit_transform(X_reduced)

print("Original shape:", X.shape)
print("After PCA:", X_reduced.shape)
print("t-SNE shape:", X_tsne.shape)
print("Final KL divergence:", round(tsne.kl_divergence_, 3))

# 5. Visualize
plt.figure(figsize=(10, 8))
plt.scatter(
    X_tsne[:, 0],
    X_tsne[:, 1],
    c=y,
    cmap="tab10",
    s=12
)
plt.title("t-SNE Visualization of Handwritten Digits")
plt.show()

Original shape: (1797, 64)
After PCA: (1797, 40)
t-SNE shape: (1797, 2)
Final KL divergence: 0.83

Advantages, Limitations & Comparisons

t-SNE vs PCA

Common t-SNE Mistakes

1. Treating every island as a confirmed cluster. A t-SNE map is evidence for exploration, not automatic semantic clustering.
2. Reading between-cluster distance literally. Large gaps in 2D are not precise measurements of original-space separation.
3. Using only one perplexity or seed. The map can change; inspect stability rather than trusting one attractive image.
4. Ignoring feature scale. Distance-based neighborhoods can be dominated by large numerical units.
5. Using t-SNE as a normal production feature transformer. Scikit-learn TSNE does not expose the same out-of-sample transform workflow as PCA.