Vizualizarea embedding-urilor
Pe această pagină
Obiective
- Reducerea vectorilor cu dimensiuni mari pentru vizualizare 2D/3D
- Utilizarea t-SNE și UMAP pentru vizualizare
- Interpretarea clusterelor vizuale
Provocarea: 3.072 de dimensiuni
Embedding-urile există într-un spațiu cu 3.072 de dimensiuni pe care nimeni nu îl poate vizualiza direct. Pentru a le inspecta, trebuie să le proiectați în două sau trei dimensiuni. Aceasta implică o anumită pierdere de informații, dar păstrează structura esențială: punctele care erau apropiate ar trebui să rămână apropiate. Acesta este un instrument de diagnostic puternic. O clusteră divizată sau teme care se suprapun devin evidente cu o simplă privire, în timp ce metricile agregate ar putea să nu le detecteze deloc.
Reducerea dimensionalității cu t-SNE
t-SNE (t-distributed Stochastic Neighbor Embedding) este metoda clasică. Aceasta găsește o dispunere 2D în care fiecare punct își păstrează vecinătatea originală. Exemplul de mai jos construiește în mod deliberat un corpus cu trei teme distincte—IA, gătit și sport—pentru a verifica dacă proiecția recuperează structura așteptată.
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()
Trei parametri conduc rezultatul. perplexity echilibrează structura locală cu cea globală, cu valori tipice între 5 și 50; aici este setat la 4 deoarece corpusul conține doar doisprezece puncte, iar o perplexitate mai mare decât numărul de vecini disponibili ar produce o proiecție incoerentă. n_iter stabilește numărul de iterații de optimizare, cu un minim de 250 și ideal peste 1.000. random_state asigură reproductibilitatea: fără acesta, două rulări succesive produc figuri diferite, făcând comparația imposibilă.
Reducerea cu UMAP
UMAP (Uniform Manifold Approximation and Projection) este adesea preferat în detrimentul t-SNE deoarece este mai rapid și păstrează mai bine structura globală. Cu alte cuvinte, distanța dintre două clustere pe un grafic UMAP are un sens, în timp ce cu t-SNE este arbitrară.
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()
Tabelul următor rezumă compromisurile dintre cele două metode.
| Criteriu | t-SNE | UMAP |
|---|---|---|
| Viteză | Lentă (O(n²)) | Rapidă |
| Structura globală | Slab păstrată | Bine păstrată |
| Reproductibilitate | Variabilă | Stabilă |
| Parametri | perplexity | n_neighbors, min_dist |
Vizualizare interactivă 3D
Pe un corpus de câteva sute de puncte, o figură statică devine ilizibilă: etichetele se suprapun și nu puteți distinge care text corespunde cărui punct. Plotly rezolvă această problemă mutând informațiile în baloane de tip tooltip și permițându-vă să rotiți norul de puncte.
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()
Fișierul HTML rezultat este gata de partajare. Este o modalitate excelentă de a arăta unei echipe de afaceri cum sunt distribuite documentele lor fără a scrie o singură linie de cod.
Vizualizarea efectului reducerii dimensionalității
Lecția 2 afirma că trunchierea unui vector la 256 de dimensiuni păstrează aproximativ 88% din calitatea sa. Această cifră rămâne abstractă până când o vedeți. Generând același corpus la patru dimensiuni diferite și proiectând fiecare versiune, observați direct momentul în care clusterele încep să se atingă. Acest lucru vă permite să decideți pe baza dovezilor, nu a unei reguli generale.
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()
O avertizare înainte de a interpreta aceste figuri: proiecția distorsionează întotdeauna. Un punct izolat pe grafic nu este neapărat izolat în spațiul original, iar două clustere lipite în 2D pot fi perfect separate în 3.072 de dimensiuni. Vizualizarea vă ajută să formulați o ipoteză, niciodată să o validați. Validarea se bazează pe metricile pe care le vom aborda în Lecția 10.
Puncte cheie
- t-SNE și UMAP proiectează embedding-urile în 2D/3D pentru vizualizare
- UMAP este generalmente preferat pentru viteza și fidelitatea sa
- Plotly permite vizualizări 3D interactive
- Vizualizarea ajută la validarea calității embedding-urilor și la detectarea anomaliilor