Învățare nesupervizată

3.3 Vizualizare avansată: t-SNE și UMAP

PCA e liniar și uneori nu ajunge. t-SNE și UMAP „despachetează" structuri complicate în hărți 2D unde grupurile devin vizibile cu ochiul liber.

Teorie

Reprezentări bidimensionale neliniare

Ambele metode urmăresc același scop: punctele apropiate în spațiul original să rămână apropiate în harta 2D. Spre deosebire de PCA, nu caută axe drepte, ci pot „desface" structuri curbate (spirale, clustere imbricate).

t-SNE transformă distanțele în probabilități de vecinătate și aranjează punctele în 2D astfel încât vecinătățile să se păstreze. Parametrul cheie: perplexity (~5–50) — aproximativ câți vecini contează pentru fiecare punct.

UMAP construiește graful vecinilor apropiați și îl proiectează în 2D. E mult mai rapid decât t-SNE, păstrează mai bine structura globală și poate transforma și date noi (transform). Parametri: n_neighbors și min_dist.

Analizarea relațiilor dintre grupuri — cum citești hărțile

Reguli de interpretare (des cerute la interpretarea vizualizărilor): clusterele care apar sunt reale, dar dimensiunea lor și distanțele dintre clustere nu înseamnă mare lucru la t-SNE. Axele nu au nicio semnificație. Rulări diferite pot da hărți diferite — fixează random_state.

Utilizare practică

from sklearn.manifold import TSNE
# pip install umap-learn
import umap

# t-SNE (doar fit_transform, nu are transform separat)
X2 = TSNE(n_components=2, perplexity=30,
          random_state=42).fit_transform(X_scalat)

# UMAP
reducer = umap.UMAP(n_neighbors=15, min_dist=0.1, random_state=42)
X2 = reducer.fit_transform(X_scalat)

plt.scatter(X2[:, 0], X2[:, 1], c=y, cmap="tab10", s=8)
Pe date cu sute de dimensiuni, aplică întâi PCA la ~50 de componente și abia apoi t-SNE — mai rapid și mai stabil. Combinația PCA → t-SNE/UMAP este standard.

Problemă rezolvată: PCA vs t-SNE vs UMAP pe digits

Trei hărți ale aceluiași dataset Mediu Rezolvată

Continuăm problema din lecția 3.2: aceleași cifre scrise de mână, trei metode de proiecție, comparație directă.

Codul comparației
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
import umap

X, y = load_digits(return_X_y=True)
X_s = StandardScaler().fit_transform(X)

proiectii = {
    "PCA": PCA(n_components=2).fit_transform(X_s),
    "t-SNE": TSNE(n_components=2, perplexity=30,
                  random_state=42).fit_transform(X_s),
    "UMAP": umap.UMAP(random_state=42).fit_transform(X_s),
}

fig, axes = plt.subplots(1, 3, figsize=(16, 5))
for ax, (nume, X2) in zip(axes, proiectii.items()):
    ax.scatter(X2[:, 0], X2[:, 1], c=y, cmap="tab10", s=6)
    ax.set_title(nume)
plt.show()

Rezultatul tipic: PCA — cifrele se suprapun masiv; t-SNE — 10 insule clare, dar rulare lentă; UMAP — insule la fel de clare, de câteva ori mai rapid. Concluzia de reținut: pentru vizualizare folosește t-SNE/UMAP, pentru reducere înaintea unui model folosește PCA.

Probleme propuse

1. Efectul perplexity Exercițiu

Rulează t-SNE pe digits cu perplexity ∈ {2, 5, 30, 100} și pune hărțile una lângă alta. Ce se întâmplă la extreme?

2. Capcana interpretării Exercițiu

Generează 3 clustere gaussiene cu distanțe cunoscute între centre și proiectează-le cu t-SNE. Verifică dacă distanțele dintre clustere din hartă respectă realitatea. Ce concluzie tragi?

3. t-SNE + K-Means Exercițiu

Pe un dataset fără etichete, folosește UMAP pentru vizualizare, alege vizual numărul de clustere, apoi confirmă cu K-Means + scor silhouette (lecția 3.1).

4. Hărți pentru embeddings de text Platformă

La problemele NLP de pe platformă, proiectează vectorii TF-IDF (lecția 5.1) cu UMAP, colorați după clasă — vezi instant dacă problema e ușoară sau grea.