Todo el curso hasta acá vivió en el mundo supervisado: cada ejemplo traía su respuesta correcta (la etiqueta) y el modelo aprendía a predecirla. En el módulo 9 medimos y afinamos esos modelos con validación cruzada y tuning. Pero gran parte de los datos del mundo real no vienen etiquetados: tienes una tabla de 50.000 clientes y nadie te dijo a qué segmento pertenece cada uno. Nadie tiene la respuesta correcta porque no existe una. Este módulo va de encontrar estructura donde no hay etiquetas: agrupar lo parecido y comprimir lo redundante.

La tesis del módulo

En el aprendizaje no supervisado no hay respuesta correcta que copiar: el modelo busca estructura por su cuenta. Agrupar clientes parecidos (clustering) o comprimir muchas columnas en pocas (PCA) no es predecir — es descubrir patrones que estaban escondidos en los datos. Y todo empieza por escalar, porque acá se mide distancia.

Sin etiquetas: descubrir en vez de predecir

En el supervisado le muestras al modelo “esto es fraude, esto no” y aprende la frontera. En el no supervisado no le muestras nada: le das los datos crudos y el algoritmo organiza solo. Dos grandes familias, ambas centrales en la práctica:

Clustering (agrupamiento): juntar los datos en grupos donde los de adentro se parecen entre sí y se diferencian de los otros grupos. Sirve para segmentar clientes, agrupar productos, detectar comportamientos raros.
Reducción de dimensionalidad: comprimir muchas columnas (features) en unas pocas que capturan lo esencial. Sirve para visualizar datos de 30 dimensiones en un gráfico de 2, y para acelerar otros modelos.

K-means: agrupar en torno a centroides

K-means es el algoritmo de clustering más usado. La idea: le dices cuántos grupos quieres (k) y él ubica k centroides (los centros de cada grupo, un punto promedio) e itera hasta acomodarlos. El baile es simple y elegante:

Pone k centroides al azar.
Asigna cada dato al centroide más cercano.
Mueve cada centroide al promedio de los datos que le tocaron.
Repite 2 y 3 hasta que los centroides dejan de moverse.

El centroide es literalmente el punto promedio de su grupo: si un cluster tiene tres clientes, el centroide está en el gasto promedio y la edad promedio de esos tres.

 Antes                 Después de k-means (k=3)

  ● ●   ● ●             ┌─ A ─┐   ┌─ B ─┐
 ● ● ● ● ● ●            │ ● ● │   │ ● ● │
  ●  ● ●  ●     ──►     │ ●+● │   │ ●+● │
    ● ● ●               └─────┘   └─────┘
  ●  ●   ● ●               ┌─ C ─┐
 ● ●  ● ● ●                │ ● ● │
                          │ ●+● │     + = centroide
                          └─────┘

from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

# CRÍTICO: escalar antes. K-means mide distancias; sin escalar,
# la feature con números más grandes (ej. ingreso) domina todo.
X_esc = StandardScaler().fit_transform(X)

km = KMeans(n_clusters=3, n_init=10, random_state=42)
etiquetas = km.fit_predict(X_esc)   # a qué cluster cayó cada fila

print("Centroides:", km.cluster_centers_)
print("Inercia:", km.inertia_)       # qué tan compactos son los grupos

El problema de k-means: tú tienes que decirle k. Y rara vez sabes cuántos grupos hay de verdad. Dos herramientas para elegirlo:

El método del codo (elbow method): corres k-means con k=2, 3, 4, 5… y graficas la inercia (qué tan apretados quedan los grupos; baja siempre al subir k). Buscas el “codo”: el punto donde agregar otro cluster ya casi no mejora. Ahí está tu k.

Silhouette (silueta): mide, para cada punto, qué tan bien encaja en su grupo comparado con el vecino más cercano. Va de −1 (mal ubicado) a +1 (clarísimo). Eliges el k que maximiza el silhouette promedio.

from sklearn.metrics import silhouette_score

for k in range(2, 8):
    km = KMeans(n_clusters=k, n_init=10, random_state=42)
    labels = km.fit_predict(X_esc)
    sil = silhouette_score(X_esc, labels)
    print(f"k={k}: inercia={km.inertia_:.0f}  silhouette={sil:.3f}")

DBSCAN: agrupar por densidad

DBSCAN ataca los puntos débiles de k-means. No le dices cuántos grupos hay: agrupa por densidad, juntando puntos que están apretados y dejando afuera los que quedan solos. Esos puntos solitarios los marca como outliers (valores atípicos) — por eso DBSCAN es la herramienta natural para detección de anomalías.

Se controla con dos parámetros: eps (qué tan cerca deben estar dos puntos para considerarse vecinos) y min_samples (cuántos vecinos necesita un punto para ser “denso”). Los puntos que no alcanzan densidad ni pertenecen a ningún grupo se etiquetan como -1: ruido.

from sklearn.cluster import DBSCAN

X_esc = StandardScaler().fit_transform(X)   # también escalar, mide distancia

db = DBSCAN(eps=0.5, min_samples=5)
etiquetas = db.fit_predict(X_esc)

n_clusters = len(set(etiquetas)) - (1 if -1 in etiquetas else 0)
n_outliers = (etiquetas == -1).sum()
print(f"Clusters encontrados: {n_clusters}")
print(f"Outliers (ruido): {n_outliers}")   # los -1: candidatos a anomalía

	K-means	DBSCAN
¿Le dices cuántos grupos?	Sí, k obligatorio	No, lo descubre
Forma de los clusters	Redondeados, tamaño similar	Cualquier forma
Outliers	Los mete a la fuerza en un grupo	Los marca como ruido (−1)
Detección de anomalías	No directamente	Sí, es su fuerte
Parámetros clave	`n_clusters`	`eps`, `min_samples`
Escala mal cuando	Grupos alargados o de tamaños muy distintos	La densidad varía mucho entre zonas

Ojo: k-means asume clusters redondeados y parejos, y te obliga a elegir k. Si tus grupos tienen formas raras o hay muchos outliers, k-means los deforma; DBSCAN los respeta. No hay ganador universal: dependen de cómo se ven tus datos.

PCA: comprimir muchas features en pocas

PCA (Principal Component Analysis, análisis de componentes principales) comprime muchas columnas correlacionadas en unas pocas nuevas —las componentes principales— que capturan la mayor parte de la información (la varianza) de los datos. Si tienes 30 features y muchas dicen lo mismo, PCA las resume en 2 o 3 que concentran lo esencial.

Su uso más común es visualizar: reduces de 30 dimensiones a 2 y ahí sí puedes graficar tus clusters en un plano. También acelera modelos y reduce ruido, aunque a costa de perder interpretabilidad (las componentes son mezclas, no columnas originales).

from sklearn.decomposition import PCA

X_esc = StandardScaler().fit_transform(X)   # PCA también exige escalar antes

pca = PCA(n_components=2)      # comprimir a 2 dimensiones para graficar
X_2d = pca.fit_transform(X_esc)

# Cuánta información (varianza) conserva cada componente
print("Varianza explicada:", pca.explained_variance_ratio_)
print("Total conservado:", pca.explained_variance_ratio_.sum())
# ej. [0.62, 0.24] -> 2 componentes guardan el 86% de la info original

El truco clásico: aplicas PCA a 2D y sobre ese plano dibujas los clusters que encontró k-means o DBSCAN. Así el clustering (que trabaja en todas las dimensiones) se vuelve visible en un gráfico que un humano puede leer.

Casos reales

Segmentación de clientes: k-means sobre gasto, frecuencia y antigüedad revela grupos como “compradores frecuentes de bajo ticket” o “esporádicos de alto ticket”. Marketing les habla distinto a cada uno.
Detección de anomalías: DBSCAN marca como outliers las transacciones que no se parecen a ninguna aglomeración normal — candidatas a fraude o a error de sistema.
Compresión para visualizar: PCA lleva datos de sensores de 40 dimensiones a un gráfico 2D donde a ojo se ven los regímenes de operación de una máquina.

Errores comunes

No escalar antes. El error número uno. K-means, DBSCAN y PCA miden distancia o varianza; sin escalar, la feature con números grandes (ingreso en pesos) aplasta a las chicas (edad, cantidad de compras). Siempre StandardScaler primero.
Elegir k a ojo. K-means te da grupos con cualquier k, incluso uno absurdo. Usa el codo o silhouette; no inventes k porque “se ven como tres”.
Esperar que DBSCAN adivine todo solo. No pide k, pero sí pide eps y min_samples, y es sensible a ellos. Un eps mal puesto te da un solo cluster gigante o puro ruido.
Interpretar componentes de PCA como columnas reales. Una componente es una mezcla de features originales, no “la edad”. PCA gana compresión y pierde interpretabilidad.
Buscar la respuesta correcta. No hay una. En clustering el “resultado bueno” es el que te sirve para el negocio, no el que coincide con una verdad que no existe. Valídalo con criterio de dominio, no solo con silhouette.

La frase para llevarse

“Sin etiquetas no hay respuesta correcta que copiar: el algoritmo agrupa lo parecido y aísla lo raro. Y como todo se mide en distancia, si no escalaste, no mediste nada.”

Qué viene

Módulo 11: problemas del mundo real — desbalance, interpretabilidad y sesgo. Salimos del terreno limpio de los tutoriales. Qué pasa cuando una clase es el 0,1% de los datos (fraude), cómo explicar qué miró el modelo para decidir (SHAP), cómo detectar que discrimina, y por qué un modelo con 99% de accuracy puede ser completamente inútil.

Machine Learning — Módulo 10: aprendizaje no supervisado — clustering y PCA