Embeddingute visualiseerimine
Sellel lehel
Eesmärgid
- Taandada kõrge mõõtmega vektorid 2D/3D visualiseerimiseks
- Kasutada visualiseerimiseks t-SNE ja UMAP meetodeid
- Tõlgendada visuaalseid klastreid
Väljakutse: 3072 mõõdet
Embeddingud eksisteerivad 3072-mõõtmelises ruumis, mida keegi ei suuda otseselt visualiseerida. Nende uurimiseks pead need projitseerima kahe või kolme mõõtmesse. See eeldab teatud info kadu, kuid säilitab olulise struktuuri: punktid, mis olid lähedal, peaksid jääma lähedale. See on võimas diagnostikavahend. Lahknev klaster või kattuvad teemad hüppavad silma pilguheituga, samas kui agregeeritud mõõdikud võivad need täiesti märkamata jätta.
Mõõtmete taandamine t-SNE abil
t-SNE (t-distributed Stochastic Neighbor Embedding) on klassikaline meetod. See leiab 2D paigutuse, kus iga punkt säilitab oma algse naabruse. Allpool toodud näide loob tahtlikult korpuse kolme erineva teemaga – tehisintellekt, toiduvalmistamine ja sport –, et saaksid kontrollida, kas projektsioon taastab oodatava struktuuri.
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()
Tulemust määravad kolm parameetrit. perplexity tasakaalustab lokaalset ja globaalset struktuuri, tüüpilised väärtused jäävad vahemikku 5–50; siin on see seatud väärtusele 4, kuna korpus sisaldab vaid kaksteist punkti ja perplexity, mis ületab olemasolevate naabrite arvu, tekitaks ebaloogilise projektsiooni. n_iter määrab optimeerimise iteratsioonide arvu, miinimum on 250, ideaalis üle 1000. random_state tagab korratavuse: ilma selleta annavad kaks järjestikust käivitamist erinevad joonised, muutes võrdluse võimatuks.
Taandamine UMAP abil
UMAP (Uniform Manifold Approximation and Projection) on sageli eelistatud t-SNE-le, kuna see on kiirem ja säilitab paremini globaalset struktuuri. Teisisõnu, kahe klastri vaheline kaugus UMAP diagrammil tähendab midagi, samas kui t-SNE puhul on see suvaline.
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()
Järgnev tabel võtab kokku kahe meetodi vahelised kompromissid.
| Kriteerium | t-SNE | UMAP |
|---|---|---|
| Kiirus | Aeglane (O(n²)) | Kiire |
| Globaalne struktuur | Halvasti säilinud | Hästi säilinud |
| Korratavus | Muutlik | Stabiilne |
| Parameetrid | perplexity | n_neighbors, min_dist |
Interaktiivne 3D visualiseerimine
Mõnesaja punkti suuruse korpuse puhul muutub staatiline joonis loetamatuks: sildid kattuvad ja sa ei saa aru, milline tekst vastab millisele punktile. Plotly lahendab selle, viies info tööriistavihjetesse ja võimaldades punktide pilve pöörata.
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()
Saadud HTML-fail on jagamiseks valmis. See on suurepärane viis näidata äritiimile, kuidas nende dokumendid jaotuvad, ilma ühtegi koodirida kirjutamata.
Mõõtmete taandamise mõju visualiseerimine
- õppetund väitis, et vektori lühendamine 256 mõõtmeni säilitab umbes 88% selle kvaliteedist. See number jääb abstraktseks, kuni seda näed. Genereerides sama korpuse nelja erineva suurusega ja projitseerides iga versiooni, näed otse, millal klastrid hakkavad kokku puutuma. See võimaldab sul teha otsuseid tõendite põhjal, mitte üldreegli järgi.
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()
Hoiatus enne nende jooniste tõlgendamist: projektsioon moonutab alati. Graafikul isoleeritud punkt ei ole tingimata isoleeritud algsest ruumist ja kaks 2D-s koos olevat klastrit võivad olla 3072 mõõtmes täiuslikult eraldatud. Visualiseerimine aitab sul formuleerida hüpoteesi, mitte seda kinnitada. Kinnitamine tugineb mõõdikutele, mida käsitleme 10. õppetunnis.
Peamised punktid
- t-SNE ja UMAP projitseerivad embeddingud visualiseerimiseks 2D/3D ruumi
- UMAP on üldiselt eelistatud oma kiiruse ja täpsuse tõttu
- Plotly võimaldab interaktiivseid 3D visualiseerimisi
- Visualiseerimine aitab valideerida embeddingute kvaliteeti ja tuvastada anomaaliaid