Aprendizaje no supervisado

Sin etiquetas no hay una respuesta correcta que copiar. El aprendizaje no supervisado busca estructura: grupos, direcciones de varianza, densidades, factores latentes o ejemplos atípicos. Es más difícil de evaluar y, por eso, exige más criterio humano.

Tres familias de problemas

La distancia define el resultado

Todo algoritmo de clustering necesita una noción de similitud. Cambiar la distancia cambia los grupos. Las más comunes son:

Un ejemplo numérico mínimo

import numpy as np
from sklearn.preprocessing import StandardScaler

X = np.array([[30, 200], [40, 260], [29, 190], [55, 420]], dtype=float)

def distancias(X, escalar=True):
    Z = StandardScaler().fit_transform(X) if escalar else X
    D = np.sqrt(((Z[:, None, :] - Z[None, :, :]) ** 2).sum(axis=2))
    return D

print("sin escalar:\n", np.round(distancias(X, False), 2))
print("estandarizado:\n", np.round(distancias(X, True), 2))

Cómo se evalúa lo no supervisado

No hay etiquetas, así que no hay accuracy. Se usan dos familias de criterios:

• Internos: silhouette, Davies–Bouldin, inercia, varianza explicada. Miden cohesión y separación, pero favorecen ciertas formas.
• Externos: estabilidad ante remuestreo, coherencia con conocimiento del dominio, utilidad en una tarea posterior (por ejemplo, segmentación que mejora una campaña).

Un agrupamiento es valioso si es estable, interpretable y accionable. Si cambia por completo al repetir con otra semilla, no es un descubrimiento: es ruido.

K-Means es el algoritmo de clustering más usado y el más malinterpretado. Es rápido, simple y funciona bien cuando los grupos son aproximadamente esféricos y tienen tamaño similar. Fuera de ese régimen puede producir resultados engañosos.

El objetivo

El algoritmo paso a paso

1. Elegir $K$ y inicializar $K$ centroides.
2. Asignación: cada punto va al centroide con menor distancia al cuadrado.
3. Actualización: cada centroide se mueve a la media de los puntos asignados.
4. Repetir hasta que las asignaciones no cambien o se alcance un máximo de iteraciones.

El resultado depende de la inicialización. Una mala elección puede dejar dos centroides en el mismo grupo y otro capturando dos grupos reales. K-Means++ elige centroides iniciales separados con probabilidad proporcional a la distancia al centroide más cercano, lo que mejora mucho la convergencia.

Ejemplo numérico en una dimensión

Implementación desde cero y con Scikit-learn

import numpy as np
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
from sklearn.preprocessing import StandardScaler

X, _ = make_blobs(n_samples=500, centers=4, cluster_std=1.2, random_state=42)
X = StandardScaler().fit_transform(X)

def kmeans_desde_cero(X, k, iters=30, seed=0):
    rng = np.random.default_rng(seed)
    centros = X[rng.choice(len(X), k, replace=False)]
    for _ in range(iters):
        d = ((X[:, None, :] - centros[None, :, :]) ** 2).sum(axis=2)
        etiquetas = d.argmin(axis=1)
        nuevos = np.array([X[etiquetas == j].mean(axis=0) if np.any(etiquetas == j) else centros[j]
                           for j in range(k)])
        if np.allclose(nuevos, centros):
            break
        centros = nuevos
    inercia = ((X - centros[etiquetas]) ** 2).sum()
    return etiquetas, centros, inercia

etiq, centros, inercia = kmeans_desde_cero(X, 4)
print("inercia desde cero:", round(inercia, 2))

modelo = KMeans(n_clusters=4, n_init=10, random_state=42).fit(X)
print("inercia sklearn:", round(modelo.inertia_, 2))
print("silhouette:", round(__import__("sklearn.metrics", fromlist=["silhouette_score"]).silhouette_score(X, modelo.labels_), 3))

Ventajas y limitaciones

No existe un $K$ «verdadero» esperando ser descubierto. Existe un $K$ útil para una decisión. Los criterios cuantitativos ayudan, pero la última palabra la tiene el uso que se dará a los grupos.

Método del codo

Se calcula la inercia para varios valores de $K$ y se busca el punto donde la curva deja de caer abruptamente. Es una heurística visual, no una prueba estadística, y a menudo el «codo» es ambiguo.

Coeficiente de silhouette

Un silhouette global alto indica clusters compactos y separados. Pero también favorece clusters convexos: un agrupamiento por densidad con formas arbitrarias puede tener silhouette mediocre y ser correcto.

Otras herramientas

• Davies–Bouldin: menor es mejor; compara dispersión intra-cluster con separación entre centroides.
• Calinski–Harabasz: mayor es mejor; cociente entre dispersión entre clusters y dentro de ellos.
• Gap statistic: compara la inercia observada con la esperada bajo datos sin estructura.
• Estabilidad: repite el clustering sobre submuestras y mide cuánto se conservan las asignaciones (por ejemplo, con adjusted Rand index).

import numpy as np
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score, davies_bouldin_score, calinski_harabasz_score

for k in range(2, 9):
    modelo = KMeans(n_clusters=k, n_init=20, random_state=42).fit(X)
    sil = silhouette_score(X, modelo.labels_)
    db = davies_bouldin_score(X, modelo.labels_)
    ch = calinski_harabasz_score(X, modelo.labels_)
    print(f"k={k}: inercia={modelo.inertia_:.1f} silhouette={sil:.3f} DB={db:.3f} CH={ch:.1f}")

Cuando K-Means no es la herramienta

Si los grupos tienen forma de media luna, densidades muy distintas o hay ruido, K-Means fuerza una partición incorrecta. En esos casos conviene DBSCAN, clustering jerárquico o modelos de mezcla gaussianos.

K-Means impone una forma. El clustering jerárquico construye una jerarquía completa de grupos y DBSCAN descubre regiones densas de forma arbitraria. Ambos amplían el repertorio cuando los supuestos de K-Means no se cumplen.

Clustering aglomerativo

Se empieza con cada punto como un cluster y se fusionan iterativamente los dos más cercanos hasta formar uno solo. El resultado se visualiza como un dendrograma: cortar a cierta altura produce una partición.

Su coste es mayor que K-Means ($O(n^2\log n)$ o $O(n^3)$ según implementación), pero para datasets medianos ofrece una visión global muy informativa.

DBSCAN: densidad

DBSCAN define un punto como núcleo si tiene al menos min_samples vecinos dentro de un radio eps. Los puntos núcleo conectados forman un cluster; los puntos alcanzables desde un núcleo se incorporan; el resto es ruido.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import AgglomerativeClustering, DBSCAN
from scipy.cluster.hierarchy import dendrogram, linkage

X, _ = make_moons(n_samples=400, noise=0.06, random_state=42)
X = StandardScaler().fit_transform(X)

# Jerárquico con enlace Ward
jer = AgglomerativeClustering(n_clusters=2, linkage="ward").fit(X)
print("jerárquico:", np.bincount(jer.labels_))

# Dendrograma (sobre una submuestra para legibilidad)
Z = linkage(X[:120], method="ward")
plt.figure(figsize=(10, 4))
dendrogram(Z, no_labels=True)
plt.title("Dendrograma (Ward)")
plt.show()

# DBSCAN
db = DBSCAN(eps=0.25, min_samples=8).fit(X)
print("DBSCAN etiquetas:", np.unique(db.labels_, return_counts=True))

Elegir eps en DBSCAN

Una heurística útil es el gráfico de k-distancias: para cada punto se calcula la distancia a su $k$-ésimo vecino, se ordenan y se busca el codo. Ese valor sugiere un eps razonable. También se puede usar el silhouette ignorando los puntos de ruido, aunque no es una medida perfecta.

PCA encuentra las direcciones ortogonales en las que los datos varían más. Es una técnica lineal, no supervisada y muy útil para visualizar, comprimir y eliminar redundancia antes de modelar.

La idea geométrica

Centramos los datos y buscamos una dirección unitaria $\mathbf{u}$ que maximice la varianza de las proyecciones $\mathbf{u}^\top\mathbf{x}_i$. La solución es el autovector principal de la matriz de covarianza.

Ejemplo numérico

Varianza explicada y elección de componentes

import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
X_std = StandardScaler().fit_transform(X)  # PCA es sensible a la escala

pca = PCA().fit(X_std)
print("varianza explicada:", np.round(pca.explained_variance_ratio_, 3))
print("acumulada:", np.round(np.cumsum(pca.explained_variance_ratio_), 3))

Z = PCA(n_components=2).fit_transform(X_std)
plt.scatter(Z[:, 0], Z[:, 1], c=y, cmap="viridis", s=18)
plt.xlabel("PC1"); plt.ylabel("PC2")
plt.title("Iris proyectado en dos componentes")
plt.show()

Qué hace y qué no hace PCA

PCA es lineal. t-SNE y UMAP capturan estructura local no lineal y producen visualizaciones sorprendentes. También son las técnicas más malinterpretadas del curso: están diseñadas para mirar, no para medir distancias globales.

t-SNE en una frase

t-SNE convierte distancias entre puntos en probabilidades de vecindad en el espacio original y busca una configuración 2D/3D cuyas probabilidades de vecindad se parezcan lo más posible, minimizando la divergencia KL.

La perplejidad controla el número efectivo de vecinos. Valores típicos: 5–50. Perplejidad baja enfatiza estructura local; alta, estructura más global, pero no garantiza distancias globales correctas.

Qué no concluir de un t-SNE

• El tamaño de los grupos no significa nada: t-SNE expande grupos densos y comprime otros.
• Las distancias entre grupos no son interpretables: dos clusters lejanos pueden ser similares en el espacio original.
• La forma y orientación son arbitrarias: cambian con la semilla.
• No es una reducción para alimentar un modelo: su objetivo es visual; para eso usa PCA o un autoencoder.

UMAP

UMAP construye un grafo de vecinos y lo proyecta preservando tanto estructura local como algo de global. Suele ser más rápido y más estable que t-SNE, y puede transformar puntos nuevos si se entrena con esa capacidad. Aun así, sigue siendo una visualización: no demuestres conclusiones solo con el mapa.

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

X, y = load_digits(return_X_y=True)
X = StandardScaler().fit_transform(X)

Z = TSNE(n_components=2, perplexity=30, init="pca",
         learning_rate="auto", random_state=42).fit_transform(X)

plt.figure(figsize=(7, 6))
plt.scatter(Z[:, 0], Z[:, 1], c=y, cmap="tab10", s=12)
plt.title("t-SNE de dígitos (perplejidad 30)")
plt.axis("off")
plt.show()

# UMAP requiere: pip install umap-learn
# import umap
# Z2 = umap.UMAP(n_neighbors=15, min_dist=0.1, random_state=42).fit_transform(X)

Una anomalía es un ejemplo que se desvía del patrón esperado. El reto es que «normal» es difícil de definir y las anomalías son raras por construcción: hay pocos ejemplos para aprender.

Enfoques según las etiquetas disponibles

Métodos estadísticos

El z-score marca valores alejados de la media en unidades de desviación estándar. Es simple, pero asume una distribución aproximadamente normal y es sensible a outliers que contaminan la media.

Isolation Forest

Construye árboles que aíslan puntos mediante cortes aleatorios. Las anomalías, al estar en regiones poco densas, se aíslan con menos cortes. El score se basa en la profundidad media del punto en los árboles.

Local Outlier Factor

Compara la densidad local de un punto con la de sus vecinos. Un punto es anómalo si su densidad es mucho menor que la de su entorno, incluso si su distancia absoluta no es grande. Funciona bien con densidades heterogéneas, pero no está pensado para predecir puntos nuevos sin reajuste.

import numpy as np
from sklearn.ensemble import IsolationForest
from sklearn.neighbors import LocalOutlierFactor
from sklearn.preprocessing import StandardScaler

# X: matriz de features; se asume que las anomalías son raras
X_std = StandardScaler().fit_transform(X)

iso = IsolationForest(contamination=0.02, random_state=42)
etiquetas_iso = iso.fit_predict(X_std)       # -1 = anomalía
scores_iso = iso.decision_function(X_std)    # menor = más anómalo

lof = LocalOutlierFactor(n_neighbors=20, contamination=0.02)
etiquetas_lof = lof.fit_predict(X_std)

print("Isolation Forest:", np.bincount(etiquetas_iso == -1))
print("LOF:", np.bincount(etiquetas_lof == -1))
print("Top 5 scores:", np.argsort(scores_iso)[:5])

Evaluar detección de anomalías

La exactitud es inútil con clases extremadamente desbalanceadas. Usa precisión en el top-k, recall a una tasa de alertas fija, curva precision–recall y coste de negocio (falso positivo vs. falso negativo). Además, valida con datos de un periodo distinto para detectar drift.

Un autoencoder aprende a comprimir una entrada en un espacio latente y reconstruirla. Si solo se entrena con datos normales, aprende a reconstruir lo normal; cuando llega algo distinto, el error de reconstrucción sube. Esa es la base de su uso para anomalías y representaciones.

Arquitectura

Tipos y usos

• Autoencoder bajo el cuello de botella: compresión para reducción de dimensionalidad o denoising.
• Denoising autoencoder: se corrompe la entrada y se pide reconstruir la original; aprende representaciones robustas.
• Variational autoencoder (VAE): modela una distribución latente y permite generar muestras nuevas.
• Autoencoder para anomalías: se entrena solo con datos normales y se usa el error de reconstrucción como score.

import torch
import torch.nn as nn

class Autoencoder(nn.Module):
    def __init__(self, n_features, latent=8):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Linear(n_features, 32), nn.ReLU(),
            nn.Linear(32, latent)
        )
        self.decoder = nn.Sequential(
            nn.Linear(latent, 32), nn.ReLU(),
            nn.Linear(32, n_features)
        )

    def forward(self, x):
        z = self.encoder(x)
        return self.decoder(z), z

modelo = Autoencoder(n_features=X.shape[1], latent=8)
opt = torch.optim.Adam(modelo.parameters(), lr=1e-3)
loss_fn = nn.MSELoss()

for epoch in range(100):
    opt.zero_grad()
    reconstruccion, _ = modelo(X_train_tensor)
    loss = loss_fn(reconstruccion, X_train_tensor)
    loss.backward()
    opt.step()

# Score de anomalía = error de reconstrucción por ejemplo
with torch.no_grad():
    reconstruccion, _ = modelo(X_test_tensor)
    score = ((X_test_tensor - reconstruccion) ** 2).mean(dim=1)

Riesgos prácticos

• Si entrenas con datos que ya contienen anomalías, el modelo aprenderá a reconstruirlas y perderá sensibilidad.
• El error de reconstrucción no es una probabilidad: hay que calibrar el umbral con validación.
• Con datos de alta dimensión y pocos ejemplos, el autoencoder puede memorizar; usa regularización y aumenta datos.