Visualisering af embeddings
På denne side
Mål
- Reducere højdimensionale vektorer til 2D/3D-visualisering
- Anvende t-SNE og UMAP til visualisering
- Fortolke visuelle klynger
Udfordringen: 3.072 dimensioner
Embeddings eksisterer i et 3.072-dimensionalt rum, som ingen kan visualisere direkte. For at inspicere dem skal du projicere dem ned i to eller tre dimensioner. Dette accepterer et vist informationstab, men bevarer den essentielle struktur: punkter, der lå tæt på hinanden, bør forblive tæt på hinanden. Dette er et kraftfuldt diagnoseværktøj. En splittet klynge eller overlappende temaer springer i øjnene ved første øjekast, hvorimod aggregerede målinger måske slet ikke fanger dem.
Dimensionsreduktion med t-SNE
t-SNE (t-distributed Stochastic Neighbor Embedding) er den klassiske metode. Den finder et 2D-layout, hvor hvert punkt beholder sit oprindelige nabolag. Eksemplet nedenfor opbygger bevidst et korpus med tre distinkte temaer – AI, madlavning og sport – så du kan verificere, at projektionen gendanner den forventede struktur.
from openai import OpenAI
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import numpy as np
client = OpenAI()
# Example corpus
textes = [
# AI Cluster
"Deep learning uses neural networks",
"Machine learning transforms data science",
"Transformers revolutionized NLP",
"GPT-5 is a large language model",
# Cooking Cluster
"Chocolate cake recipe",
"How to prepare ratatouille",
"Basics of French pastry",
"Oven baking techniques",
# Sports Cluster
"Paris Marathon attracts thousands of runners",
"Interval training for running",
"Soccer rules explained",
"Sports nutrition and performance",
]
categories = (["AI"] * 4 + ["Cooking"] * 4 + ["Sports"] * 4)
# Generate embeddings
response = client.embeddings.create(
input=textes,
model="text-embedding-3-large"
)
embeddings = np.array([d.embedding for d in response.data])
# t-SNE reduction to 2D
tsne = TSNE(n_components=2, random_state=42, perplexity=4)
coords = tsne.fit_transform(embeddings)
# Visualization
couleurs = {"AI": "#2563eb", "Cooking": "#dc2626", "Sports": "#16a34a"}
fig, ax = plt.subplots(figsize=(10, 8))
for cat in couleurs:
mask = [c == cat for c in categories]
ax.scatter(
coords[mask, 0], coords[mask, 1],
c=couleurs[cat], label=cat, s=100, alpha=0.8
)
for i, (x, y) in enumerate(coords[mask]):
idx = [j for j, m in enumerate(mask) if m][i]
ax.annotate(
textes[idx][:30] + "...",
(x, y), fontsize=7, alpha=0.7
)
ax.legend()
ax.set_title("t-SNE Visualization of Embeddings")
plt.tight_layout()
plt.savefig("tsne_embeddings.png", dpi=150)
plt.show()
Tre parametre styrer resultatet. perplexity balancerer lokal versus global struktur med typiske værdier mellem 5 og 50; her er den sat til 4, fordi korpusset kun indeholder tolv punkter, og en perplexity højere end antallet af tilgængelige naboer ville producere en inkohærent projektion. n_iter angiver antallet af optimeringsiterationer med et minimum på 250 og ideelt mere end 1.000. random_state sikrer reproducerbarhed: uden den vil to successive kørsler give forskellige figurer, hvilket gør sammenligning umulig.
Reduktion med UMAP
UMAP (Uniform Manifold Approximation and Projection) foretrækkes ofte frem for t-SNE, fordi det er hurtigere og bedre bevarer den globale struktur. Med andre ord betyder afstanden mellem to klynger på et UMAP-plot noget, hvorimod den med t-SNE er vilkårlig.
import umap
# UMAP reduction to 2D
reducer = umap.UMAP(n_components=2, random_state=42, n_neighbors=5)
coords_umap = reducer.fit_transform(embeddings)
fig, ax = plt.subplots(figsize=(10, 8))
for cat in couleurs:
mask = [c == cat for c in categories]
ax.scatter(
coords_umap[mask, 0], coords_umap[mask, 1],
c=couleurs[cat], label=cat, s=100, alpha=0.8
)
ax.legend()
ax.set_title("UMAP Visualization of Embeddings")
plt.tight_layout()
plt.savefig("umap_embeddings.png", dpi=150)
plt.show()
Følgende tabel opsummerer afvejningerne mellem de to metoder.
| Kriterium | t-SNE | UMAP |
|---|---|---|
| Hastighed | Langsom (O(n²)) | Hurtig |
| Global struktur | Dårligt bevaret | Godt bevaret |
| Reproducerbarhed | Variabel | Stabil |
| Parametre | perplexity | n_neighbors, min_dist |
Interaktiv 3D-visualisering
På et korpus med nogle få hundrede punkter bliver en statisk figur ulæselig: etiketter overlapper, og du kan ikke se, hvilken tekst der svarer til hvilket punkt. Plotly løser dette ved at flytte informationen ind i værktøjstips og tillade dig at rotere punktskyen.
import plotly.express as px
import pandas as pd
# Reduction to 3D
reducer_3d = umap.UMAP(n_components=3, random_state=42, n_neighbors=5)
coords_3d = reducer_3d.fit_transform(embeddings)
df = pd.DataFrame({
"x": coords_3d[:, 0],
"y": coords_3d[:, 1],
"z": coords_3d[:, 2],
"category": categories,
"text": [t[:50] for t in textes]
})
fig = px.scatter_3d(
df, x="x", y="y", z="z",
color="category",
hover_data=["text"],
title="3D Embeddings"
)
fig.write_html("embeddings_3d.html")
fig.show()
Den resulterende HTML-fil er klar til deling. Det er en fremragende måde at vise et forretningsteam, hvordan deres dokumenter er fordelt, uden at skrive en eneste linje kode.
Visualisering af effekten af dimensionsreduktion
Lektion 2 nævnte, at beskæring af en vektor til 256 dimensioner bevarer ca. 88 % af dens kvalitet. Det tal forbliver abstrakt, indtil du ser det. Ved at generere det samme korpus i fire forskellige størrelser og projicere hver version, observerer du direkte, hvornår klynger begynder at røre hinanden. Dette lader dig træffe beslutninger baseret på evidens snarere end en generel regel.
dimensions_a_tester = [256, 512, 1536, 3072]
fig, axes = plt.subplots(1, 4, figsize=(24, 5))
for ax, dim in zip(axes, dimensions_a_tester):
resp = client.embeddings.create(
input=textes,
model="text-embedding-3-large",
dimensions=dim
)
embs = np.array([d.embedding for d in resp.data])
tsne = TSNE(n_components=2, random_state=42, perplexity=4)
coords = tsne.fit_transform(embs)
for cat in couleurs:
mask = [c == cat for c in categories]
ax.scatter(coords[mask, 0], coords[mask, 1],
c=couleurs[cat], label=cat, s=60)
ax.set_title(f"{dim} dimensions")
ax.legend(fontsize=7)
plt.tight_layout()
plt.savefig("comparaison_dimensions.png", dpi=150)
plt.show()
En advarsel før fortolkning af disse figurer: projektion forvrænger altid. Et isoleret punkt på grafen er ikke nødvendigvis isoleret i det oprindelige rum, og to klynger, der sidder fast sammen i 2D, kan være perfekt adskilte i 3.072 dimensioner. Visualisering hjælper dig med at formulere en hypotese, aldrig med at validere den. Validering afhænger af de målinger, vi vil dække i lektion 10.
Vigtige pointer
- t-SNE og UMAP projicerer embeddings ned i 2D/3D til visualisering
- UMAP foretrækkes generelt på grund af sin hastighed og nøjagtighed
- Plotly muliggør interaktive 3D-visualiseringer
- Visualisering hjælper med at validere embedding-kvalitet og opdage anomalier