Machine Learning Academy · Lektion

t-SNE: Bevara grannskap för visualisering

Ni kommer att tillämpa t-SNE med olika perplexitetsinställningar på MNIST-inbäddningar och förstå att t-SNE-avstånd inte är meningsfulla för efterföljande modellering.

Lektion 3 av 413 steg

t-SNE: Bevara grannskap för visualisering är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.

Bortom PCA: icke-linjär visualisering

PCA projicerar data linjärt och bevarar den globala variansen, men kan misslyckas med att visa lokala klusterstrukturer. t-SNE (t-distributed Stochastic Neighbour Embedding) är en icke-linjär teknik för dimensionsreduktion som är särskilt utformad för visualisering i två och tre dimensioner. Den prioriterar att bevara lokala grannskap: punkter som ligger nära varandra i ett högdimensionellt rum bör också ligga nära varandra i 2D-diagrammet.

Grundidén: likhetsfördelningar

t-SNE definierar en sannolikhetsfördelning över punktpar i ett högdimensionellt rum: närliggande punkter har hög likhet. Därefter definierar algoritmen en liknande fördelning i den lågdimensionella inbäddningen. Algoritmen minimerar KL-divergensen mellan de två fördelningarna med hjälp av gradientnedstigning och flyttar punkterna i 2D tills grannskapsstrukturen motsvarar strukturen i hög dimension.

Parametern perplexity

Perplexity är t-SNE:s viktigaste hyperparameter. Den styr ungefär hur många grannar varje punkt tar hänsyn till när likhetsfördelningen i hög dimension skapas – vanligtvis mellan 5 och 50. Låg perplexity fokuserar på mycket lokal struktur (många små kluster), medan hög perplexity fångar mer global struktur (bredare och mer utspridda kluster). Samma datamängd kan se mycket olika ut med olika perplexity-värden.

Köra t-SNE i scikit-learn

Använd sklearn.manifold.TSNE. Viktiga parametrar är n_components (nästan alltid 2), perplexity, n_iter (standardvärde 1000) och random_state. t-SNE är beräkningsmässigt kostsamt – O(n² log n) – så reducera först datamängden med PCA för stora indata (till exempel PCA till 50 dimensioner och därefter t-SNE till 2D).

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

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

# Pre-reduce with PCA for speed
X_pca = PCA(n_components=30).fit_transform(X_scaled)

# t-SNE to 2D
tsne = TSNE(n_components=2, perplexity=30, n_iter=1000, random_state=42)
X_tsne = tsne.fit_transform(X_pca)

print('t-SNE shape:', X_tsne.shape)

Visualisera t-SNE-inbäddningar

Rita de tvådimensionella t-SNE-koordinaterna med klassfärger för att synliggöra klusterstrukturen. För MNIST-siffror med lämplig perplexity ser ni vanligtvis väl separerade sifferkluster, där siffror som liknar varandra (till exempel 3 och 8) placeras nära varandra. Detta bekräftar att t-SNE fångar semantiskt meningsfulla grupperingar.

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 6))
scatter = ax.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap='tab10', s=8, alpha=0.7)
fig.colorbar(scatter, ax=ax, label='Digit')
ax.set_title('MNIST digits — t-SNE (perplexity=30)')
ax.set_xlabel('t-SNE 1')
ax.set_ylabel('t-SNE 2')
plt.tight_layout()
plt.show()

Perplexitys påverkan på inbäddningen

Det är viktigt att prova flera perplexity-värden och jämföra diagrammen. En perplexity som är för låg skapar många små, frånkopplade fläckar även inom samma verkliga kluster. En perplexity som är för hög suddar ihop klustren. En god praxis är att testa perplexity i [5, 15, 30, 50] och välja den inbäddning där den kända klusterstrukturen framträder tydligast.

import matplotlib.pyplot as plt
from sklearn.manifold import TSNE

perplexities = [5, 15, 30, 50]
fig, axes = plt.subplots(1, 4, figsize=(16, 4))

for ax, perp in zip(axes, perplexities):
    tsne = TSNE(n_components=2, perplexity=perp, n_iter=800, random_state=0)
    X_emb = tsne.fit_transform(X_pca[:300])  # subset for speed
    ax.scatter(X_emb[:, 0], X_emb[:, 1], c=y[:300], cmap='tab10', s=10)
    ax.set_title(f'Perplexity={perp}')
    ax.axis('off')
plt.tight_layout()
plt.show()

Avstånd i t-SNE saknar betydelse

En viktig varning: avstånd mellan kluster i t-SNE kan inte tolkas. Att ett kluster verkar ligga långt från ett annat betyder inte att de är globalt avlägsna; algoritmen optimerar bevarandet av lokala grannskap, inte globala avstånd. Ni kan inte jämföra klusterstorlekar eller avstånd mellan kluster i olika körningar eller med olika perplexity-inställningar. Använd endast t-SNE för utforskning, inte för kvantitativ analys.

t-SNE är stokastiskt och icke-deterministiskt

Varje t-SNE-körning med ett annat random_state ger en annan layout – inbäddningen kan rotera, spegla eller arrangera om klustren. Ange alltid random_state för reproducerbarhet. t-SNE har dessutom ingen transform-metod för punkter utanför urvalet: ni måste träna om modellen på hela datamängden varje gång, vilket gör den olämplig som förbehandlingssteg i en produktionsmodell.

UMAP: ett modernt alternativ till t-SNE

UMAP (Uniform Manifold Approximation and Projection) är en nyare teknik som är snabbare än t-SNE, bevarar både lokal och mer global struktur och stöder transform för nya punkter. Den ingår inte i scikit-learn, men installeras med pip install umap-learn. För stora datamängder eller produktionspipelines föredras UMAP vanligtvis framför t-SNE.

# pip install umap-learn
import umap

reducer = umap.UMAP(n_components=2, n_neighbors=15, min_dist=0.1, random_state=42)
X_umap = reducer.fit_transform(X_pca)

import matplotlib.pyplot as plt
plt.scatter(X_umap[:, 0], X_umap[:, 1], c=y, cmap='tab10', s=8)
plt.title('MNIST — UMAP embedding')
plt.colorbar(label='Digit')
plt.show()

När ska ni använda t-SNE respektive PCA

Använd PCA för förbehandling före modellering, komprimering, avvikelsedetektering med rekonstruktionsfel eller när ni behöver en deterministisk och reversibel transformering. Använd t-SNE för att utforska klusterstrukturer i högdimensionella data, skapa visualiseringar för presentationer eller bekräfta att en datamängd innehåller meningsfulla grupperingar innan ni använder en klustrings- eller klassificeringsalgoritm.

Komplett pipeline för t-SNE-visualisering

Här är den rekommenderade pipelinen för t-SNE på en valfri högdimensionell datamängd: skala data, reducera med PCA till cirka 50 dimensioner, tillämpa sedan t-SNE till 2D och rita resultatet med klassetiketter.

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.datasets import load_digits
import matplotlib.pyplot as plt

X, y = load_digits(return_X_y=True)

# Step 1: scale
X_s = StandardScaler().fit_transform(X)

# Step 2: PCA pre-reduction
X_pca = PCA(n_components=30, random_state=0).fit_transform(X_s)

# Step 3: t-SNE
X_tsne = TSNE(n_components=2, perplexity=30, random_state=0).fit_transform(X_pca)

# Step 4: plot
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap='tab10', s=10)
plt.title('Digits t-SNE')
plt.colorbar(label='Digit')
plt.show()

Snabb kontroll

Testa er förståelse av t-SNE från den här lektionen.

Sammanfattning av lektionen

I den här lektionen har ni lärt er att t-SNE bevarar lokala grannskap genom att minimera KL-divergensen mellan likhetsfördelningar i hög och låg dimension, att perplexity styr det effektiva antalet grannar och bör justeras mellan 5 och 50, samt att avstånd mellan kluster i t-SNE saknar kvantitativ betydelse – använd därför tekniken endast för utforskning. Härnäst bäddar vi in PCA i en scikit-learn Pipeline som förbehandlingssteg för klassificerare.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
30
Lektioner
120

Vanliga frågor

Är lektionen ”t-SNE: Bevara grannskap för visualisering” gratis?

Ja – hela texten till ”t-SNE: Bevara grannskap för visualisering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”t-SNE: Bevara grannskap för visualisering”?

Ni kommer att tillämpa t-SNE med olika perplexitetsinställningar på MNIST-inbäddningar och förstå att t-SNE-avstånd inte är meningsfulla för efterföljande modellering. Ni övar på Machine Learning Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Machine Learning Academy?

Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”t-SNE: Bevara grannskap för visualisering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Machine Learning Academy-lektionen?

Ja. Varje Machine Learning Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. PCA: Varians, egenvektorer och huvudkomponenter
  2. Projicera data och återskapa dem från komponenter
  3. t-SNE: Bevara grannskap för visualisering
  4. PCA som förbehandling: Hastighet och brusreducering i pipelines
← Tillbaka till Machine Learning Academy