Manifold Learning: Desenrollando Datos con t-SNE y UMAP#
Objetivos#
Comprender la limitación fundamental de PCA: su incapacidad para modelar relaciones no lineales.
Introducir el concepto de Manifold Learning (Aprendizaje de Variedades) para “desenrollar” datos complejos.
Comparar visual y computacionalmente t-SNE y UMAP en un problema de alta dimensionalidad.
Criterio de Ingeniería: Entender por qué estas herramientas son vitales para el Análisis Exploratorio (EDA) y la depuración de modelos, pero rara vez se utilizan en Pipelines de producción en tiempo real.
Prerrequisitos#
Entendimiento de la reducción de dimensionalidad lineal.
Haber completado: Reducción de Dimensionalidad: PCA y Reconstrucción.
Configuración del Entorno#
Introducción Teórica#
En el notebook anterior vimos que PCA es excelente para comprimir información. Sin embargo, PCA tiene un punto ciego masivo: asume que el mundo es plano (lineal).
Imaginemos que nuestros datos tienen la forma de un papel arrugado o un espiral tridimensional (el clásico problema del Swiss Roll). Si se usa PCA, el algoritmo intentará aplastar ese espiral proyectándolo sobre una línea recta. El resultado será un desastre donde puntos que estaban muy lejos en el espiral terminarán superpuestos.
Necesitamos algoritmos que no “aplasten” los datos, sino que los desenrollen. A esta familia de algoritmos se le conoce como Manifold Learning.
1. t-SNE (t-Distributed Stochastic Neighbor Embedding)#
Desarrollado en 2008, revolucionó la visualización de datos. Su filosofía es simple:
Mide las distancias entre todos los puntos en el espacio original de alta dimensión.
Crea un espacio 2D vacío.
Mueve los puntos en el espacio 2D intentando que los puntos que estaban cerca en alta dimensión sigan estando cerca en 2D.
El problema: A t-SNE solo le importa la estructura local. Agrupa muy bien las cosas similares, pero la distancia entre dos grupos diferentes en el gráfico final no significa absolutamente nada (estructura global destruida). Además, es computacionalmente costoso (lento).
2. UMAP (Uniform Manifold Approximation and Projection)#
Desarrollado en 2018, es el estándar moderno. Basado en topología matemática profunda, UMAP logra lo mismo que t-SNE pero con dos ventajas masivas para la ingeniería:
Es drásticamente más rápido (escala muy bien con millones de filas).
Preserva la estructura global. Si el Grupo A está más cerca del Grupo B que del Grupo C en el gráfico 2D de UMAP, es porque realmente se parecen más en la alta dimensión.
Va un pequeño ejemplo visual:
/usr/local/lib/python3.12/dist-packages/umap/umap_.py:1952: UserWarning: n_jobs value 1 overridden to 1 by setting random_state. Use no seed for parallelism.
warn(
Ver como “los grupos” densos permanecen juntos en el espacio 2D (para Manifold Learning), para PCA, simplemente se superponen.
Desarrollo e Implementación#
Para demostrar el poder de estas herramientas, no usamos datos tabulares simples. Usaremos el Digits Dataset, que contiene imágenes de 8x8 píxeles de números escritos a mano.
Cada píxel es una columna. Por lo tanto, nuestros datos viven en un espacio de 64 dimensiones. Nuestro objetivo es reducirlos a 2 dimensiones para ver si los algoritmos logran agrupar los números iguales sin que nosotros les digamos qué número es cuál (Aprendizaje No Supervisado).
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import time
from sklearn.datasets import load_digits
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
import umap
# 1. Carga de datos (Imágenes 8x8 = 64 dimensiones)
digits = load_digits()
X = digits.data
y = digits.target # Solo usamos 'y' para colorear el gráfico final, los algoritmos NO lo verán.
print(f"Dimensiones originales: {X.shape} (1797 imágenes, 64 píxeles cada una)")
# 2. Estandarización (Vital para algoritmos basados en distancias como t-SNE y UMAP)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
Dimensiones originales: (1797, 64) (1797 imágenes, 64 píxeles cada una)
La Gran Comparativa: PCA vs t-SNE vs UMAP#
Vamos a ejecutar los tres algoritmos sobre las mismas 1797 imágenes y medimos cuánto tardan.
# --- 1. PCA (Baseline Lineal) ---
start_time = time.time()
pca = PCA(n_components=2, random_state=42)
X_pca = pca.fit_transform(X_scaled)
time_pca = time.time() - start_time
# --- 2. t-SNE (Manifold Clásico) ---
# Nota: t-SNE es estocástico (aleatorio), fijamos la semilla para reproducibilidad
start_time = time.time()
tsne = TSNE(n_components=2, random_state=42, n_jobs=-1)
X_tsne = tsne.fit_transform(X_scaled)
time_tsne = time.time() - start_time
# --- 3. UMAP (Manifold Moderno) ---
start_time = time.time()
umap_model = umap.UMAP(n_components=2, random_state=42, n_jobs=-1)
X_umap = umap_model.fit_transform(X_scaled)
time_umap = time.time() - start_time
print(f"Tiempos de ejecución:")
print(f"PCA: {time_pca:.4f} segundos")
print(f"UMAP: {time_umap:.4f} segundos")
print(f"t-SNE: {time_tsne:.4f} segundos")
/usr/local/lib/python3.12/dist-packages/umap/umap_.py:1952: UserWarning: n_jobs value 1 overridden to 1 by setting random_state. Use no seed for parallelism.
warn(
Tiempos de ejecución:
PCA: 0.0341 segundos
UMAP: 9.5255 segundos
t-SNE: 28.0009 segundos
Nota de Ingeniería: En este dataset pequeño (~1800 filas), UMAP y t-SNE tardan un par de segundos. Pero si se tuvieran 500000 filas, t-SNE podría tardar horas, mientras que UMAP terminaría en minutos.
Visualizando el Espacio Latente (Embeddings)#
Ahora, graficamos los resultados. Coloreamos los puntos según el número real que representan (del 0 al 9) para ver si los algoritmos lograron agruparlos correctamente en 2D.
# Función auxiliar para graficar
def plot_embedding(X_emb, y, title, ax):
scatter = ax.scatter(X_emb[:, 0], X_emb[:, 1], c=y, cmap='tab10', s=15, alpha=0.8)
ax.set_title(title, fontsize=14)
ax.set_xticks([])
ax.set_yticks([])
return scatter
fig, axes = plt.subplots(1, 3, figsize=(18, 6))
plot_embedding(X_pca, y, f"PCA\n(Lineal - {time_pca:.2f}s)", axes[0])
plot_embedding(X_tsne, y, f"t-SNE\n(No Lineal - {time_tsne:.2f}s)", axes[1])
scatter = plot_embedding(X_umap, y, f"UMAP\n(No Lineal - {time_umap:.2f}s)", axes[2])
# Añadimos una leyenda global
legend = fig.legend(*scatter.legend_elements(), title="Dígitos", loc="lower center", ncol=10, bbox_to_anchor=(0.5, -0.05))
plt.tight_layout()
plt.show()
Resultados y Discusión#
Analizar los tres gráficos con ojo crítico:
PCA (Izquierda): Es un desastre. Al intentar aplastar 64 dimensiones en 2 usando líneas rectas, los números se mezclan en una gran mancha central. Es imposible separar un 3 de un 9 o un 5.
t-SNE (Centro): ¡Magia! Sin saber qué número era cuál, t-SNE logró agrupar las imágenes idénticas en “islas” perfectamente separadas. Sin embargo, observa la distancia entre las islas: están dispersas casi al azar.
UMAP (Derecha): Logra una separación equivalente a la de t-SNE, pero preserva la estructura global. Observar cómo el grupo de los
1(naranja) está muy cerca del grupo de los7(gris), porque visualmente un 1 y un 7 se parecen mucho. Los4y los9también suelen estar cerca. UMAP entendió la semántica de los datos.
⚠️ Alerta de Ingeniería: ¿Por qué no usar esto en Producción?#
Si UMAP y t-SNE son tan increíbles separando datos, ¿por qué no los ponemos en un Pipeline antes de un Random Forest para mejorar el Accuracy?
1. El Problema Transductivo (t-SNE):
La implementación estándar de t-SNE en Scikit-Learn no tiene el método .transform(). Solo tiene .fit_transform(). Esto significa que no puede aprender una regla matemática y aplicarla a un dato nuevo. Si llega un nuevo usuario a la API en producción, t-SNE tendría que recalcular las distancias de ese usuario contra toda la base de datos histórica para ubicarlo en el mapa 2D. Esto es inviable en tiempo real.
2. El Costo Computacional (UMAP):
UMAP sí posee un método .transform(), lo que permite proyectar datos nuevos. Sin embargo, la matemática topológica subyacente es pesada. Añadir UMAP como paso de preprocesamiento en una API de alta concurrencia añadirá una latencia inaceptable (milisegundos vs microsegundos de PCA).
Entonces, ¿Para qué sirven en la vida real?#
En la industria, UMAP y t-SNE son herramientas de Análisis y Depuración, no de preprocesamiento en tiempo real. Sus casos de uso estrella son:
Descubrimiento de Clusters (EDA Avanzado): Antes de aplicar algoritmos de Clustering (como K-Means), se proyectan los datos con UMAP (visualización pura, bajamos de N dimensiones a 2 o 3). Si en UMAP se ve una sola mancha gigante, es probable que no existan clusters naturales en los datos. Si se ven islas claras (como en nuestro gráfico), el clustering será un éxito.
Depuración de Redes Neuronales (Deep Learning): Las redes neuronales son cajas negras. Una técnica común es extraer la última capa oculta de la red (que puede tener 512 dimensiones) y graficarla con UMAP. Si la red ha aprendido correctamente, se verán las clases perfectamente separadas. Si se ve una mezcla, la red no está aprendiendo, sin importar lo que diga la métrica de Loss.
Análisis de Embeddings (NLP): Para visualizar cómo un modelo de lenguaje (como Word2Vec o BERT) agrupa palabras o documentos semánticamente similares.
Conexiones y Próximos Pasos#
Hemos visto cómo UMAP y t-SNE revelan agrupaciones ocultas en los datos de forma visual. Pero en ingeniería, no nos basta con “ver” los grupos; necesitamos que un algoritmo asigne una etiqueta matemática a cada punto (Ej. “Tú perteneces al Cluster 0”).
➡️ Siguiente: En el notebook K-Means y sus Limitaciones, entramos de lleno en el mundo del Clustering. Aprendemos a agrupar datos automáticamente y, más importante aún, descubriremos por qué el algoritmo más famoso del mundo (K-Means) fracasa si los datos no tienen forma de esfera.
🔄 Relacionado: Si te interesa cómo una Red Neuronal puede aprender a reducir dimensionalidad de forma no lineal y paramétrica (apta para producción), investiga sobre los Autoencoders. Los abordamos en el capítulo de deep learning en el notebook Autoencoders y el Espacio Latente: Más allá de PCA y Detección de Anomalías.
Referencias#
McInnes, L., Healy, J., & Melville, J. (2018). UMAP: Uniform Manifold Approximation and Projection for Dimension Reduction. arXiv preprint arXiv:1802.03426.
Wattenberg, et al., (2016). How to Use t-SNE Effectively. Distill. Enlace interactivo