Reducción de dimensionalidad con t-SNE

¿Qué es t-SNE?

t-SNE (t-Distributed Stochastic Neighbor Embedding) es un algoritmo de reducción de dimensionalidad no lineal especialmente diseñado para la visualización de datos de alta dimensión. A diferencia de PCA, que busca las direcciones de máxima varianza global, t-SNE preserva las relaciones locales entre puntos: los puntos que están cerca en el espacio original tienden a estar cerca en la proyección 2D.

El algoritmo fue propuesto por Laurens van der Maaten y Geoffrey Hinton (2008) y se ha convertido en la técnica de referencia para explorar visualmente conjuntos de datos complejos como imágenes, texto vectorizado o datos genómicos.

Diferencias clave entre PCA y t-SNE

| Característica | PCA | t-SNE | |----------------|-----|-------| | Tipo de transformación | Lineal | No lineal | | Conserva | Varianza global | Estructura local | | Determinista | Sí (misma semilla = mismo resultado) | Depende del random_state | | Escalable a producción | Sí (.transform() reutilizable) | No (hay que reentrenar) | | Velocidad | Rápido | Lento en datasets grandes | | Uso típico | Preprocesado + producción | Solo exploración/visualización |

Aplicando t-SNE con Scikit-learn

from sklearn.manifold import TSNE
from sklearn.datasets import load_digits
import numpy as np

# Cargar dataset Digits (64 características por imagen)
digits = load_digits()
X = digits.data       # (1797, 64)
y = digits.target     # etiquetas 0-9

print(f"Dimensiones originales: {X.shape}")

# Reducir a 2D con t-SNE
tsne = TSNE(n_components=2, random_state=42, perplexity=30, max_iter=1000)
X_tsne = tsne.fit_transform(X)

print(f"Dimensiones reducidas: {X_tsne.shape}")
print(f"KL divergencia final: {tsne.kl_divergence_:.4f}")

Visualización básica

from sklearn.manifold import TSNE
from sklearn.datasets import load_digits
import matplotlib.pyplot as plt

digits = load_digits()
X, y = digits.data, digits.target

tsne = TSNE(n_components=2, random_state=42, perplexity=30)
X_emb = tsne.fit_transform(X)

plt.figure(figsize=(10, 8))
scatter = plt.scatter(X_emb[:, 0], X_emb[:, 1], c=y, cmap='tab10', alpha=0.7, s=10)
plt.colorbar(scatter, label='Dígito')
plt.title('t-SNE en el dataset Digits')
plt.xlabel('t-SNE 1')
plt.ylabel('t-SNE 2')
plt.tight_layout()
plt.show()

Cada color representa un dígito diferente. Si t-SNE funciona bien, los puntos del mismo dígito aparecerán agrupados.

El parámetro perplexity

perplexity es el hiperparámetro más importante de t-SNE. Controla el balance entre la estructura local y global: valores pequeños dan más peso a los vecinos inmediatos, mientras que valores grandes consideran vecindades más amplias.

La documentación oficial recomienda valores entre 5 y 50. El valor por defecto es 30.

from sklearn.manifold import TSNE
from sklearn.datasets import load_iris

iris = load_iris()
X, y = iris.data, iris.target

print(f"{'Perplexity':>12} {'KL divergencia':>16}")
for perp in [5, 10, 30, 50]:
    tsne = TSNE(n_components=2, perplexity=perp, random_state=42, max_iter=500)
    tsne.fit_transform(X)
    print(f"{perp:>12}  {tsne.kl_divergence_:>16.4f}")

Una menor divergencia KL indica un mejor ajuste de la distribución de probabilidades. Sin embargo, la métrica por sí sola no determina la mejor visualización; es necesario inspeccionarla visualmente.

Comparación PCA vs t-SNE

from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.datasets import load_digits
from sklearn.preprocessing import StandardScaler

digits = load_digits()
X = digits.data
y = digits.target

# Escalar antes de aplicar las técnicas
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# PCA a 2 componentes
pca = PCA(n_components=2, random_state=42)
X_pca = pca.fit_transform(X_scaled)
print(f"PCA - varianza explicada: {pca.explained_variance_ratio_.sum():.3f}")

# t-SNE a 2 componentes
tsne = TSNE(n_components=2, random_state=42, perplexity=30)
X_tsne = tsne.fit_transform(X_scaled)

print(f"PCA shape: {X_pca.shape}")
print(f"t-SNE shape: {X_tsne.shape}")

PCA puede explicar un porcentaje de la varianza total, mientras que t-SNE no tiene una métrica equivalente de varianza explicada; su objetivo es la separación visual de grupos.

Estrategia combinada: PCA + t-SNE

Para conjuntos de datos muy grandes, se recomienda primero reducir con PCA a 50 componentes y luego aplicar t-SNE. Esto acelera el cómputo sin perder demasiada información:

from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.datasets import load_digits
from sklearn.preprocessing import StandardScaler

digits = load_digits()
X = StandardScaler().fit_transform(digits.data)

# Paso 1: PCA para reducir ruido y acelerar t-SNE
pca_50 = PCA(n_components=30, random_state=42)
X_pca = pca_50.fit_transform(X)
print(f"Varianza acumulada con 30 PCs: {pca_50.explained_variance_ratio_.sum():.3f}")

# Paso 2: t-SNE sobre la reducción PCA
tsne = TSNE(n_components=2, random_state=42, perplexity=30, max_iter=1000)
X_final = tsne.fit_transform(X_pca)
print(f"Shape final: {X_final.shape}")

Limitaciones de t-SNE

• No escalable a producción: no se puede usar .transform() con datos nuevos; hay que reentrenar todo el modelo. Para despliegue, usar UMAP u otros métodos.
• Lento: la complejidad cuadrática hace que sea lento con más de 10 000 muestras sin estrategias adicionales (como reducción previa con PCA).
• No determinista: cambiar random_state produce resultados visualmente distintos aunque estadísticamente equivalentes.
• Las distancias absolutas no son interpretables: t-SNE preserva las relaciones locales pero no las globales; no se puede concluir que dos grupos estén "lejos" entre sí.
• Puede crear clusters artificiales: con ciertos valores de perplexity o pocas iteraciones puede fragmentar o fundir grupos reales.

Resumen

t-SNE es la herramienta estándar de visualización exploratoria en machine learning. Su mayor valor está en revelar la estructura interna de los datos antes de diseñar los modelos, no en ser parte del pipeline de producción. Combinar PCA para una reducción inicial con t-SNE para la visualización final es la práctica recomendada en datasets de más de unos pocos miles de muestras.