Visualización de espacios latentes de alta dimensión

Cada modelo de embedding mapea la entrada a un espacio de alta dimensión donde la proximidad significa similitud. Ver cómo se ve ese espacio es tan útil como complicado.

Qué es un espacio latente

Un espacio latente es una representación de datos aprendida y comprimida. Cuando un modelo codifica una oración, una imagen o cualquier otro punto de datos, mapea esa entrada a un vector en un espacio continuo donde las relaciones geométricas coinciden con las semánticas.

En un modelo de text embedding bien entrenado, el vector para "king" menos "man" más "woman" aterriza cerca de "queen". Las oraciones sobre temas similares se agrupan en clusters. Los documentos sobre machine learning se sitúan en una región diferente a los documentos sobre cocina. El modelo ha aprendido a organizar la información espacialmente.

El espacio es "latente" porque no es observable directamente. Es una representación interna que emerge del entrenamiento. El modelo nunca aprendió explícitamente a "poner la cocina aquí y el ML allá"; esa estructura apareció porque organizar cosas similares juntas resultó útil para el objetivo del entrenamiento.

El problema: estos espacios suelen tener 384, 768 o 1536 dimensiones. Los humanos pueden visualizar tres. Cerrar esa brecha requiere reducción de dimensionalidad, y cada técnica implica un compromiso.

PCA: la línea base lineal

El Análisis de Componentes Principales (PCA) encuentra las direcciones de máxima varianza en los datos y se proyecta sobre ellas. Es lineal, determinista y rápido.

from sklearn.decomposition import PCA
import numpy as np

# embeddings: shape (n_samples, 768)
pca = PCA(n_components=3)
reduced = pca.fit_transform(embeddings)  # shape (n_samples, 3)

# How much variance is captured?
print(f"Explained variance: {{pca.explained_variance_ratio_.sum():.2%}}")

La fortaleza de PCA es preservar la estructura global: la forma general y la dispersión de los datos. Si dos clusters están muy separados en el espacio original, estarán muy separados en la proyección.

Su debilidad es que es lineal. Las relaciones reales en espacios de alta dimensión rara vez lo son. PCA podría decirte que existen dos clusters pero desdibujar su límite. Si los tres primeros componentes principales capturan el 15% de la varianza total (común con embeddings de alta dimensión), estás viendo una proyección con mucha pérdida.

Cuándo usar PCA: como un primer paso para la estructura gruesa. Como preprocesamiento antes de un método no lineal (PCA a 50 dimensiones, luego t-SNE a 2). Cuando necesitas resultados reproducibles y deterministas.

t-SNE: preservando vecindarios locales

t-Distributed Stochastic Neighbor Embedding optimiza un mapeo no lineal que preserva los vecindarios locales. Los puntos cercanos en el espacio de alta dimensión permanecen cercanos en la visualización.

from sklearn.manifold import TSNE

tsne = TSNE(
    n_components=2,
    perplexity=30,        # Effective number of local neighbors
    learning_rate='auto',
    n_iter=1000,
    random_state=42
)
reduced = tsne.fit_transform(embeddings)

t-SNE funciona construyendo distribuciones de probabilidad sobre pares de puntos en ambos espacios. Los vecinos en el espacio original obtienen una probabilidad alta, los puntos distantes una baja. El algoritmo minimiza la divergencia KL entre las dos distribuciones.

Resultado: clusters compactos y bien separados que muestran agrupamientos locales. Si tus embeddings contienen categorías distintas, t-SNE las encuentra y las muestra claramente.

El parámetro perplexity es el control clave. Se mapea aproximadamente al número de vecinos más cercanos considerados para cada punto:

Perplejidad baja (5-10): muy local. Micro-clusters compactos, pero la disposición global carece de sentido.
Perplejidad media (30-50): el rango por defecto. Equilibra la estructura local y la de escala moderada.
Perplejidad alta (100+): se preserva más la estructura global, pero los clusters pueden fusionarse.

Advertencias críticas:

Las distancias entre clusters en un gráfico t-SNE no son significativas. Dos clusters que parecen estar lejos podrían no estarlo en el espacio original.
El tamaño de los clusters no es significativo. t-SNE expande las regiones densas y comprime las dispersas.
El algoritmo es no determinista. Diferentes semillas aleatorias producen diferentes disposiciones. Establece siempre una semilla para la reproducibilidad.
No escala bien más allá de los ~50,000 puntos sin métodos aproximados.

UMAP: el estándar moderno

Uniform Manifold Approximation and Projection se basa en principios similares a t-SNE pero con una base matemática más sólida en el análisis de datos topológicos. En la práctica, es más rápido, escala mejor y preserva más la estructura global.

import umap

reducer = umap.UMAP(
    n_components=2,
    n_neighbors=15,       # Local neighborhood size
    min_dist=0.1,         # Minimum distance between points in embedding
    metric='cosine',      # Match the embedding's native metric
    random_state=42
)
reduced = reducer.fit_transform(embeddings)

n_neighbors controla el equilibrio entre la estructura local y global, de forma similar a la perplejidad en t-SNE. Los valores bajos capturan una estructura local detallada, mientras que los valores altos preservan más la topología global.

min_dist controla qué tan apretados se agrupan los puntos. Los valores bajos (0.0-0.1) crean clusters densos con una separación clara. Los valores más altos (0.5-1.0) dispersan los puntos de manera más uniforme, lo que puede ser mejor para entender gradientes continuos en los datos.

Ventajas de UMAP sobre t-SNE:

Más rápido. Minutos en datasets que a t-SNE le toman horas.
Preserva mejor la estructura global. Las posiciones relativas de los clusters son más significativas que en t-SNE.
Escala a millones de puntos con métodos aproximados de vecinos más cercanos.
Soporta la transformación de nuevos datos. Una vez ajustado, puedes proyectar nuevos puntos sin volver a ejecutar todo el ajuste.

# UMAP can transform new points — t-SNE can't
new_embeddings = model.encode(["new document text"])
new_reduced = reducer.transform(new_embeddings)

Ejemplo práctico: visualización de embeddings de artículos

Supongamos que tienes una colección de artículos de blog convertidos en embeddings con un sentence transformer. Un pipeline de visualización completo sería:

import numpy as np
import umap
import plotly.express as px
from sentence_transformers import SentenceTransformer

# Generate embeddings
model = SentenceTransformer('all-MiniLM-L6-v2')  # 384 dimensions
embeddings = model.encode(articles_text)

# Reduce with UMAP
reducer = umap.UMAP(n_components=2, n_neighbors=10, min_dist=0.1, metric='cosine')
coords = reducer.fit_transform(embeddings)

# Visualize with plotly
fig = px.scatter(
    x=coords[:, 0], y=coords[:, 1],
    color=article_tags,       # Color by category/tag
    hover_name=article_titles,
    title="Article Embedding Space",
    labels={{'x': 'UMAP-1', 'y': 'UMAP-2'}}
)
fig.update_traces(marker=dict(size=8, opacity=0.7))
fig.show()

En el gráfico resultante, esperarías ver:

Artículos sobre transformers y mecanismos de atención agrupados entre sí.
Artículos sobre RAG formando un grupo cercano pero distinto.
Artículos de visualización de datos en su propia región.
Algunos artículos sirviendo de puente entre clusters (por ejemplo, un artículo sobre "visualización de la atención" situado entre el cluster de transformers y el de visualización).

Interpretación de clusters

Lo que ves en un gráfico reducido te dice algo real, pero debes interpretarlo con cuidado.

Clusters compactos = señal compartida fuerte. Si 20 artículos sobre aprendizaje por refuerzo forman una masa compacta, el modelo de embedding ha capturado con alta confianza que comparten un tema común.

Gradientes entre clusters = continuo semántico. Si el cluster de artículos de "arquitectura neuronal" transiciona gradualmente hacia artículos de "optimización", esos temas comparten vocabulario y conceptos que el modelo de embedding representa mediante proximidad.

Outliers = contenido único. Un punto alejado de cualquier cluster es un artículo que no comparte mucho contenido semántico con el resto. O bien está fuera de tema, o cubre un nicho que nadie más toca.

Traslape de clusters = categorización ambigua. Si los artículos de "MLOps" y "software engineering" se traslapan, el modelo de embedding los considera semánticamente similares. Eso podría significar que tu sistema de etiquetas establece distinciones que el contenido real no respalda.

Cuando la visualización induce a error

La reducción de dimensionalidad tiene pérdida. Mantente alerta ante estos modos de fallo:

Clusters fantasma. t-SNE puede crear clusters aparentes en datos uniformes. Proyecta ruido aleatorio y t-SNE seguirá mostrando agrupaciones. Siempre verifica los clusters con silhouette scores o métricas similares en los datos originales de alta dimensión.

Separación artificial. Dos grupos que se traslapan en el espacio de alta dimensión pueden aparecer separados después de la proyección. El algoritmo podría encontrar un ángulo de visión que divida una sola nube en dos.

Distorsión de la distancia. La distancia euclidiana entre dos puntos en un gráfico UMAP no es proporcional a la distancia coseno entre sus embeddings originales. Usa las visualizaciones para comprensión cualitativa, no para mediciones cuantitativas.

Sensibilidad a los hiperparámetros. Diferentes valores de perplexity / n_neighbors pueden producir gráficos radicalmente distintos a partir de los mismos datos. Prueba siempre múltiples configuraciones e informa cuál utilizaste.

Una buena práctica: ejecuta la misma visualización con 3-5 configuraciones de parámetros diferentes. La estructura que aparezca en todas ellas es probablemente real. La estructura que aparezca solo en una es probablemente un artefacto.

Herramientas

scikit-learn: implementaciones de PCA y t-SNE, sólidas para datasets pequeños y medianos.
umap-learn: la implementación de referencia de UMAP, instalable vía pip.
plotly: gráficos de dispersión interactivos con etiquetas al pasar el cursor, zoom y exportación.
matplotlib: gráficos estáticos, ideales para publicaciones.
TensorBoard Embedding Projector: visualización 3D interactiva con PCA, t-SNE y UMAP integrados, cargable directamente desde datos de checkpoint.
Atlas (Nomic): herramienta web para visualizar y explorar grandes datasets de embeddings.

Los espacios latentes son donde el significado se convierte en geometría. La visualización no te mostrará cada relación codificada en 768 dimensiones, pero te mostrará lo suficiente para construir intuición, depurar modelos y explicar a otros qué han aprendido tus embeddings.