Visualizar embeddings
En esta página
Objetivos
- Reducir vectores de alta dimensionalidad para visualización en 2D/3D
- Utilizar t-SNE y UMAP para la visualización
- Interpretar los clústeres visuales
El reto: 3.072 dimensiones
Los embeddings residen en un espacio de 3.072 dimensiones que nadie puede visualizar directamente. Para inspeccionarlos, debes proyectarlos en dos o tres dimensiones. Esto acepta cierta pérdida de información, pero preserva la estructura esencial: los puntos que estaban cercanos deben permanecer cercanos. Esta es una herramienta de diagnóstico potente. Una división de clústeres o temas solapados saltan a la vista de un vistazo, mientras que las métricas agregadas podrían pasarlos por alto por completo.
Reducción de dimensionalidad con t-SNE
t-SNE (t-distributed Stochastic Neighbor Embedding) es el método clásico. Encuentra una disposición en 2D donde cada punto conserva su vecindad original. El ejemplo siguiente construye deliberadamente un corpus con tres temas distintos (IA, cocina y deportes) para que puedas verificar que la proyección recupera la estructura esperada.
from openai import OpenAI
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import numpy as np
client = OpenAI()
# Corpus de ejemplo
textes = [
# Clúster de IA
"El aprendizaje profundo utiliza redes neuronales",
"El aprendizaje automático transforma la ciencia de datos",
"Los transformadores revolucionaron el PLN",
"GPT-5 es un modelo de lenguaje grande",
# Clúster de Cocina
"Receta de tarta de chocolate",
"Cómo preparar ratatouille",
"Fundamentos de la repostería francesa",
"Técnicas de horneado en horno",
# Clúster de Deportes
"El maratón de París atrae a miles de corredores",
"Entrenamiento por intervalos para correr",
"Reglas del fútbol explicadas",
"Nutrición deportiva y rendimiento",
]
categories = (["AI"] * 4 + ["Cooking"] * 4 + ["Sports"] * 4)
# Generar embeddings
response = client.embeddings.create(
input=textes,
model="text-embedding-3-large"
)
embeddings = np.array([d.embedding for d in response.data])
# Reducción t-SNE a 2D
tsne = TSNE(n_components=2, random_state=42, perplexity=4)
coords = tsne.fit_transform(embeddings)
# Visualización
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("Visualización t-SNE de Embeddings")
plt.tight_layout()
plt.savefig("tsne_embeddings.png", dpi=150)
plt.show()
Tres parámetros determinan el resultado. perplexity equilibra la estructura local frente a la global, con valores típicos entre 5 y 50; aquí se establece en 4 porque el corpus contiene solo doce puntos, y una perplejidad superior al número de vecinos disponibles produciría una proyección incoherente. n_iter fija el número de iteraciones de optimización, con un mínimo de 250 e idealmente más de 1.000. random_state garantiza la reproducibilidad: sin él, dos ejecuciones sucesivas generan figuras diferentes, lo que hace imposible la comparación.
Reducción con UMAP
UMAP (Uniform Manifold Approximation and Projection) se prefiere a menudo sobre t-SNE porque es más rápido y preserva mejor la estructura global. En otras palabras, la distancia entre dos clústeres en un gráfico UMAP tiene significado, mientras que con t-SNE es arbitraria.
import umap
# Reducción UMAP a 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("Visualización UMAP de Embeddings")
plt.tight_layout()
plt.savefig("umap_embeddings.png", dpi=150)
plt.show()
La siguiente tabla resume las compensaciones entre ambos métodos.
| Criterio | t-SNE | UMAP |
|---|---|---|
| Velocidad | Lenta (O(n²)) | Rápida |
| Estructura global | Mal preservada | Bien preservada |
| Reproducibilidad | Variable | Estable |
| Parámetros | perplexity | n_neighbors, min_dist |
Visualización interactiva en 3D
En un corpus de unos pocos cientos de puntos, una figura estática se vuelve ilegible: las etiquetas se solapan y no puedes distinguir qué texto corresponde a qué punto. Plotly resuelve esto trasladando la información a tooltips y permitiendo rotar la nube de puntos.
import plotly.express as px
import pandas as pd
# Reducción a 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="Embeddings 3D"
)
fig.write_html("embeddings_3d.html")
fig.show()
El archivo HTML resultante está listo para compartir. Es una forma excelente de mostrar a un equipo de negocio cómo se distribuyen sus documentos sin escribir una sola línea de código.
Visualizar el efecto de la reducción de dimensionalidad
La lección 2 afirmaba que truncar un vector a 256 dimensiones retiene aproximadamente el 88 % de su calidad. Esa cifra permanece abstracta hasta que la ves. Al generar el mismo corpus en cuatro tamaños diferentes y proyectar cada versión, observas directamente cuándo los clústeres empiezan a tocarse. Esto te permite decidir basándote en pruebas y no en una regla general.
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} dimensiones")
ax.legend(fontsize=7)
plt.tight_layout()
plt.savefig("comparaison_dimensions.png", dpi=150)
plt.show()
Una advertencia antes de interpretar estas figuras: la proyección siempre distorsiona. Un punto aislado en el gráfico no está necesariamente aislado en el espacio original, y dos clústeres pegados en 2D pueden estar perfectamente separados en 3.072 dimensiones. La visualización te ayuda a formular una hipótesis, nunca a validarla. La validación depende de las métricas que cubriremos en la lección 10.
Resumen
- t-SNE y UMAP proyectan embeddings en 2D/3D para su visualización
- UMAP se prefiere generalmente por su velocidad y fidelidad
- Plotly permite visualizaciones 3D interactivas
- La visualización ayuda a validar la calidad de los embeddings y detectar anomalías