Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Visualisera inbäddningar

Lektion 5 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Mål
  2. Utmaningen: 3 072 dimensioner
  3. Dimensionsreducering med t-SNE
  4. Reducering med UMAP
  5. Interaktiv 3D-visualisering
  6. Visualisera effekten av dimensionsreducering
  7. Viktiga punkter

Mål

  • Reducera högdimensionella vektorer för visualisering i 2D/3D
  • Använda t-SNE och UMAP för visualisering
  • Tolka visuella kluster

Utmaningen: 3 072 dimensioner

Inbäddningar existerar i ett rum med 3 072 dimensioner som ingen kan visualisera direkt. För att granska dem måste du projicera dem ner till två eller tre dimensioner. Detta innebär viss informationsförlust men bevarar den essentiella strukturen: punkter som låg nära varandra bör förbli nära. Detta är ett kraftfullt diagnostiskt verktyg. Ett splittrat kluster eller överlappande teman syns vid en första anblick, medan aggregerade metrider helt kan missa dem.

Dimensionsreducering med t-SNE

t-SNE (t-distributed Stochastic Neighbor Embedding) är den klassiska metoden. Den hittar en 2D-layout där varje punkt behåller sitt ursprungliga grannskap. Exemplet nedan bygger medvetet upp en korpus med tre distinkta teman – AI, matlagning och sport – så att du kan verifiera att projektionen återskapar den förväntade strukturen.

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 parametrar styr resultatet. perplexity balanserar lokal kontra global struktur, med typiska värden mellan 5 och 50; här är det satt till 4 eftersom korpusen bara innehåller tolv punkter, och en perplexity högre än antalet tillgängliga grannar skulle ge en inkohärent projektion. n_iter anger antalet optimeringsiterationer, med ett minimum på 250 och helst fler än 1 000. random_state säkerställer reproducerbarhet: utan den ger två successiva körningar olika figurer, vilket gör jämförelser omöjliga.

Reducering med UMAP

UMAP (Uniform Manifold Approximation and Projection) föredras ofta framför t-SNE eftersom det är snabbare och bättre bevarar den globala strukturen. Med andra ord betyder avståndet mellan två kluster i ett UMAP-diagram något, medan det med t-SNE är godtyckligt.

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öljande tabell sammanfattar avvägningarna mellan de två metoderna.

Kriteriumt-SNEUMAP
HastighetLångsam (O(n²))Snabb
Global strukturDåligt bevaradVäl bevarad
ReproducerbarhetVariabelStabil
Parametrarperplexityn_neighbors, min_dist

Interaktiv 3D-visualisering

På en korpus med några hundra punkter blir en statisk figur oläslig: etiketter överlappar och du kan inte se vilken text som motsvarar vilken punkt. Plotly löser detta genom att flytta information till verktygstips och låta dig rotera punktmolnet.

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 resulterande HTML-filen är redo att delas. Det är ett utmärkt sätt att visa ett affärsteam hur deras dokument är fördelade utan att skriva en enda rad kod.

Visualisera effekten av dimensionsreducering

Lektion 2 angav att trunkering av en vektor till 256 dimensioner behåller cirka 88 % av dess kvalitet. Den siffran förblir abstrakt tills du ser den. Genom att generera samma korpus i fyra olika storlekar och projicera varje version ser du direkt när kluster börjar nudda varandra. Detta låter dig besluta baserat på bevis snarare än en generell 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 varning innan du tolkar dessa figurer: projektion förvränger alltid. En isolerad punkt i grafen är inte nödvändigtvis isolerad i det ursprungliga rummet, och två kluster som sitter ihop i 2D kan vara perfekt separerade i 3 072 dimensioner. Visualisering hjälper dig att formulera en hypotes, aldrig att validera den. Validering förlitar sig på de metrider vi kommer att gå igenom i lektion 10.

Viktiga punkter

  • t-SNE och UMAP projicerar inbäddningar till 2D/3D för visualisering
  • UMAP föredras generellt för sin hastighet och trogenhet
  • Plotly möjliggör interaktiva 3D-visualiseringar
  • Visualisering hjälper till att validera inbäddningskvalitet och upptäcka anomalier