Cómo hacer clustering con K-Means en Python (scikit-learn)

El clustering con K-Means en Python permite agrupar automáticamente observaciones parecidas, sin necesidad de etiquetas. Es una de las técnicas de aprendizaje no supervisado más usadas en el día a día: sirve para segmentar clientes, organizar productos o explorar patrones ocultos en un conjunto de datos. Con la biblioteca scikit-learn, aplicarla es rápido y sencillo, como verás a continuación.

Requisitos previos

• Python 3 instalado en tu ordenador.
• Las bibliotecas scikit-learn y numpy (instálalas con pip install scikit-learn numpy).
• Conocimientos básicos de Python: listas, funciones y bucles.

Paso 1: Preparar los datos

Empieza por reunir los datos que quieres agrupar. Cada fila es una observación y cada columna es una característica (feature). En este ejemplo usamos puntos con dos características para que sean fáciles de visualizar, pero K-Means funciona igual de bien con muchas más.

import numpy as np

# Each row is an observation, each column a feature
X = np.array([
    [1.0, 2.0],
    [1.5, 1.8],
    [5.0, 8.0],
    [8.0, 8.0],
    [1.0, 0.6],
    [9.0, 11.0],
])

Paso 2: Escalar las variables

K-Means se basa en distancias entre puntos, por lo que las variables con escalas muy diferentes pueden sesgar los grupos. Usa StandardScaler para poner todas las características en la misma escala antes de entrenar el modelo.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Paso 3: Elegir el número de clusters

Tienes que decidir en cuántos grupos (k) dividir los datos. El método del codo ayuda en esa elección: entrenas el modelo para varios valores de k y observas la inercia, es decir, la suma de las distancias de cada punto al centro de su cluster. El punto donde la curva se dobla como un codo suele indicar un buen valor de k.

from sklearn.cluster import KMeans

inertias = []
for k in range(1, 6):
    model = KMeans(n_clusters=k, random_state=42, n_init=10)
    model.fit(X_scaled)
    inertias.append(model.inertia_)

print(inertias)

Al ejecutar este código, obtienes una lista de inercias, una por cada valor de k. Busca el k a partir del cual la inercia deja de bajar de forma pronunciada: ese suele ser el número de clusters más adecuado.

Paso 4: Entrenar el modelo K-Means

K-Means divide los datos en k grupos: coloca cada observación en el cluster cuyo centro está más cerca y va recalculando esos centros hasta que se estabilizan. Con el valor de k elegido (aquí, 2), crea y entrena el modelo. El parámetro n_init define cuántas veces se ejecuta el algoritmo con centros iniciales distintos, quedándose con el mejor resultado; random_state hace que el resultado sea reproducible.

model = KMeans(n_clusters=2, random_state=42, n_init=10)
model.fit(X_scaled)

print(model.labels_)           # cluster of each observation
print(model.cluster_centers_)  # centre of each cluster

Al imprimir model.labels_, cada número indica el cluster asignado a la observación en la misma posición; model.cluster_centers_, por su parte, muestra las coordenadas del centro de cada grupo, útiles para entender qué representa cada cluster.

Consejo: K-Means asume clusters más o menos esféricos y de tamaño similar. Si tus grupos tienen formas alargadas o densidades muy diferentes, algoritmos como DBSCAN pueden dar mejores resultados.

Paso 5: Predecir el cluster de nuevos datos

Una vez entrenado, el modelo puede asignar nuevos puntos a uno de los clusters existentes. No olvides aplicar el mismo escalado a los datos nuevos antes de predecir, o el resultado no será fiable.

new_point = scaler.transform([[2.0, 2.0]])
print(model.predict(new_point))

Comprobar el resultado

Para confirmar que la agrupación tiene sentido, comprueba que model.labels_ tenga una etiqueta (0, 1, ...) para cada observación y que los puntos que esperabas ver juntos hayan quedado en el mismo cluster. También puedes comparar las inercias del Paso 3: cuanto menor es la inercia, más compactos son los grupos. Ten en cuenta, no obstante, que aumentar siempre el número de clusters reduce la inercia de forma artificial, así que sigue el método del codo en lugar de elegir el k más alto.

Conclusión

Ya tienes un flujo completo para hacer clustering con K-Means en Python: preparar los datos, escalarlos, elegir el número de clusters, entrenar el modelo y predecir nuevos puntos. Un buen siguiente paso es visualizar los grupos en un gráfico de dispersión con matplotlib, para ver los clusters con tus propios ojos. Y tú, ¿qué conjunto de datos vas a intentar agrupar primero?