Dimensionsreduktion: PCA, t-SNE, UMAP

Tre metoder, tre olika syften — de är inte utbytbara.

Metod	Bevarar	Används till	Deterministisk
PCA	globala avstånd, linjärt	förbehandling, komprimering	ja
t-SNE	lokala grannskap	visualisering	nej
UMAP	lokalt + en del globalt	visualisering, ibland features	nej (men mer stabil)

Den avgörande skillnaden: PCA:s utdata kan matas vidare in i en modell. t-SNE:s kan det inte — den har ingen transform för nya punkter, resultatet ändras mellan körningar, och avstånden i bilden betyder inte vad de ser ut att betyda.

t-SNE och UMAP är för ögat. De gör vackra kluster, och det är lätt att läsa in mer i bilden än vad som finns där.

Vad t-SNE faktiskt gör: den definierar sannolikheter för att punkter är grannar i högdimensionen, gör detsamma i lågdimensionen (med en tyngre svans, Student-t), och minimerar KL-divergensen mellan de två fördelningarna.

Den tunga svansen är det som skapar de tydliga klustren — den tillåter att punkter som inte är grannar skjuts långt isär.

Fyra saker t-SNE-bilder INTE säger — och som nästan alltid övertolkas:

Vad man tror	Vad som gäller
Klusterstorleken betyder något	nej — t-SNE expanderar glesa kluster och komprimerar täta
Avstånden mellan kluster betyder något	nej — globala avstånd bevaras inte
Bilden är stabil	nej — olika frön ger olika bilder
Kluster i bilden är verkliga kluster	inte nödvändigtvis — t-SNE kan skapa kluster i ren slumpdata

Den sista är värd att prova själv: kör t-SNE på gaussiskt brus och du får ofta något som ser ut som struktur.

Perplexity är t-SNE:s viktigaste parameter (typiskt 5–50) och styr hur många grannar som räknas som lokala. Låg perplexity ger många små kluster, hög ger färre stora. Kör alltid flera värden — ser strukturen likadan ut vid 5, 30 och 50 är den troligen verklig.

UMAP bygger på en grafteoretisk formulering, är snabbare, skalar bättre och bevarar mer global struktur. Den har dessutom en transform för nya punkter. Men samma varningar gäller i huvudsak: klusteravstånd ska inte övertolkas.

Praktisk arbetsordning:

1. PCA först till 30–50 dimensioner. Det tar bort brus och gör t-SNE/UMAP dramatiskt snabbare.
2. Kör t-SNE eller UMAP på PCA-utdatan.
3. Färglägg med en känd variabel (etikett, tid, källa). Utan färg är bilden nästan alltid otolkbar.
4. Verifiera med flera frön och parametrar innan du drar en slutsats.
5. Använd aldrig t-SNE-koordinater som features i en modell.

Punkt 3 är den som gör visualiseringen användbar: en bild där klustren sammanfaller med en variabel du inte matade in är ett verkligt fynd.

import numpy as np
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE

rng = np.random.default_rng(0)

# 1. Arbetsordningen: PCA först, sedan t-SNE
def visualisera(X, n_pca=50, perplexity=30, fro=0):
    Xp = PCA(n_components=min(n_pca, X.shape[1]), random_state=fro).fit_transform(X)
    return TSNE(n_components=2, perplexity=perplexity, random_state=fro,
                init="pca").fit_transform(Xp)

# 2. VARNING: t-SNE hittar kluster även i rent brus. Prova själv.
brus = rng.normal(size=(500, 50))
inbaddning = visualisera(brus, perplexity=30)
print("t-SNE på rent brus gav en bild med synlig struktur — den betyder ingenting")

# 3. Stabilitetskontroll: samma data, olika frön
def stabil(X, fron=(0, 1, 2), perplexity=30):
    """Hur lika blir grannskapen mellan körningar? 1.0 = identiska."""
    from sklearn.neighbors import NearestNeighbors
    grannar = []
    for f in fron:
        E = visualisera(X, perplexity=perplexity, fro=f)
        nn = NearestNeighbors(n_neighbors=11).fit(E)
        grannar.append([set(r[1:]) for r in nn.kneighbors(E, return_distance=False)])
    overlapp = [len(a & b) / 10 for g1, g2 in zip(grannar, grannar[1:])
                for a, b in zip(g1, g2)]
    return round(float(np.mean(overlapp)), 3)

# 4. Parameterkontroll: samma struktur vid olika perplexity?
for p in (5, 30, 50):
    E = visualisera(X, perplexity=p)
    print(f"  perplexity={p}: kör och jämför bilderna visuellt")

# 5. PCA är det enda av de tre som får matas vidare in i en modell
p = PCA(n_components=20).fit(X_train)     # fit på TRÄNING
Z_train = p.transform(X_train)
Z_test = p.transform(X_test)              # samma transform på test — t-SNE kan inte detta

Rad 2-blocket är det viktigaste i hela noden. Kör t-SNE på 500 slumpmässiga punkter i 50 dimensioner och titta på resultatet. Att bilden ser strukturerad ut trots att ingen struktur finns är den bästa vaccinationen mot övertolkning som finns.