Image for post K-Means Clustering desde Cero: Tu Primer Paso en el Aprendizaje No Supervisado con Scikit-learn

K-Means Clustering desde Cero: Tu Primer Paso en el Aprendizaje No Supervisado con Scikit-learn

Escrito por Sergio Márquez

Contexto del Problema: Agrupando Datos sin Etiquetas

En el mundo del Machine Learning, a menudo nos encontramos con datos que no tienen una "respuesta" o "etiqueta" predefinida. Imagina que tienes una base de datos de clientes y quieres entender diferentes segmentos de mercado sin saber de antemano cuántos grupos existen o cómo se definen. Aquí es donde entra en juego el aprendizaje no supervisado. A diferencia del aprendizaje supervisado (donde entrenamos modelos con datos etiquetados para predecir resultados), el aprendizaje no supervisado busca patrones, estructuras o agrupaciones inherentes en los datos por sí mismo.

El K-Means Clustering es uno de los algoritmos de agrupamiento (clustering) más populares y sencillos de entender. Su objetivo es dividir un conjunto de datos en 'K' grupos distintos, donde 'K' es un número que nosotros definimos. Cada punto de datos se asigna al grupo cuyo "centro" (o centroide) es el más cercano. Es una herramienta poderosa para la exploración de datos, la segmentación de clientes, la compresión de imágenes, y mucho más.

Conceptos Clave: El ABC del K-Means

Para entender K-Means, necesitamos familiarizarnos con algunos términos:

  • Clustering (Agrupamiento): Es la tarea de dividir el conjunto de datos en grupos de objetos similares. Los objetos dentro de un grupo son más similares entre sí que con los objetos de otros grupos.
  • K: Representa el número de clústeres o grupos que queremos formar. Elegir el valor correcto de K es crucial y a menudo se hace mediante técnicas como el "método del codo" (Elbow Method).
  • Centroide: Es el punto central de un clúster. En K-Means, el centroide es la media de todos los puntos de datos que pertenecen a ese clúster. Es el "representante" de cada grupo.
  • Inercia (Inertia): También conocida como la suma de los cuadrados de las distancias de cada punto a su centroide más cercano. Es una métrica que K-Means intenta minimizar. Una menor inercia generalmente indica clústeres más compactos, pero no es la única métrica a considerar.
  • Distancia Euclidiana: La forma más común de medir la "cercanía" entre puntos y centroides. Es la distancia en línea recta entre dos puntos en un espacio multidimensional.

Mini Glosario

  • Aprendizaje No Supervisado: Tipo de ML donde el modelo aprende patrones de datos sin etiquetas.
  • K-Means: Algoritmo de clustering que agrupa datos en K clústeres.
  • Centroide: Punto medio de un clúster.
  • Inercia: Medida de la cohesión de los clústeres (distancia de puntos a sus centroides).

Implementación Paso a Paso con Scikit-learn

Vamos a implementar K-Means usando la librería scikit-learn de Python. Necesitarás tener Python instalado (versión 3.8+) y las siguientes librerías:

pip install scikit-learn matplotlib pandas numpy

Paso 1: Preparar el Entorno y Generar Datos Sintéticos

Para empezar, generaremos un conjunto de datos sintético que ya tiene agrupaciones claras. Esto nos permitirá visualizar fácilmente cómo K-Means encuentra estos grupos.

import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
import pandas as pd
import numpy as np

# Configuración para reproducibilidad
np.random.seed(42)

# Generar datos sintéticos con 3 "blobs" (grupos)
# n_samples: número total de puntos de datos
# centers: número de centros a generar (nuestro K "real")
# cluster_std: desviación estándar de los clústeres (qué tan dispersos están)
# random_state: para asegurar que los datos generados sean los mismos cada vez
X, y_true = make_blobs(n_samples=300, centers=3, cluster_std=0.60, random_state=42)

# Convertir a DataFrame para mejor manejo (opcional, pero útil)
df = pd.DataFrame(X, columns=['Feature_1', 'Feature_2'])

print("Primeras 5 filas de los datos generados:")
print(df.head())
print(f"Forma de los datos: {df.shape}")

# Visualizar los datos generados (sin etiquetas)
plt.figure(figsize=(8, 6))
plt.scatter(df['Feature_1'], df['Feature_2'], s=50, alpha=0.8)
plt.title('Datos Sintéticos Generados (sin etiquetas)')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.grid(True)
plt.show()

Este código genera 300 puntos de datos distribuidos alrededor de 3 centros, simulando 3 grupos naturales. La visualización inicial muestra los puntos sin ninguna distinción de color, ya que K-Means opera sobre datos sin etiquetas.

Paso 2: Aplicar el Algoritmo K-Means

Ahora, aplicaremos el algoritmo K-Means a nuestros datos. Elegiremos un valor de K (en este caso, 3, ya que sabemos que hay 3 grupos subyacentes en nuestros datos sintéticos).

# Inicializar el modelo K-Means
# n_clusters: el número de clústeres (K) que queremos encontrar
# init: método de inicialización de los centroides ('k-means++' es el predeterminado y recomendado)
# n_init: número de veces que el algoritmo K-Means se ejecutará con diferentes semillas de centroides.
#         El resultado final será el mejor de estas ejecuciones en términos de inercia.
# max_iter: número máximo de iteraciones para una sola ejecución.
# random_state: para reproducibilidad de la inicialización de los centroides.
kmeans = KMeans(n_clusters=3, init='k-means++', n_init=10, max_iter=300, random_state=42)

# Entrenar el modelo (ajustar los datos a los clústeres)
kmeans.fit(X)

# Obtener las etiquetas de clúster para cada punto de datos
labels = kmeans.labels_

# Obtener las coordenadas de los centroides de los clústeres
centroids = kmeans.cluster_centers_

print("Primeras 10 etiquetas de clúster asignadas:")
print(labels[:10])
print("\nCentroides de los clústeres:")
print(centroids)

Aquí, creamos una instancia de KMeans, especificando n_clusters=3. El método fit(X) es donde el algoritmo hace su magia, iterativamente asignando puntos a clústeres y recalculando centroides hasta que converge. kmeans.labels_ nos da la asignación de clúster para cada punto, y kmeans.cluster_centers_ nos da las coordenadas de los centroides finales.

Paso 3: Visualizar los Resultados del Clustering

La visualización es clave para entender los resultados de K-Means.

# Visualizar los clústeres y sus centroides
plt.figure(figsize=(10, 8))

# Graficar cada punto de datos, coloreado por su clúster asignado
# c=labels: usa las etiquetas de clúster para colorear los puntos
plt.scatter(X[:, 0], X[:, 1], c=labels, s=50, cmap='viridis', alpha=0.8)

# Graficar los centroides
# marker='X': usa una 'X' como marcador
# s=200: tamaño del marcador
# linewidths=2: ancho de la línea del marcador
# edgecolors='black': color del borde del marcador
plt.scatter(centroids[:, 0], centroids[:, 1], marker='X', s=200, linewidths=2, 
            color='red', edgecolors='black', label='Centroides')

plt.title('Clústeres K-Means y sus Centroides')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
plt.grid(True)
plt.show()

Esta gráfica muestra los puntos de datos coloreados según el clúster al que fueron asignados por K-Means, y los centroides de cada clúster marcados con una 'X' roja. Deberías ver que los puntos se agrupan lógicamente alrededor de los centroides.

Paso 4: Elegir el Número Óptimo de Clústeres (Método del Codo)

En un escenario real, no siempre sabemos cuántos clústeres existen. El "método del codo" es una técnica heurística común para estimar el valor óptimo de K.

# Calcular la inercia para diferentes valores de K
inertias = []
# Probamos K desde 1 hasta 10
K_range = range(1, 11)

for k in K_range:
    # n_init=10 es importante para obtener un buen resultado
    kmeans_model = KMeans(n_clusters=k, init='k-means++', n_init=10, random_state=42)
    kmeans_model.fit(X)
    inertias.append(kmeans_model.inertia_)

# Graficar el método del codo
plt.figure(figsize=(8, 6))
plt.plot(K_range, inertias, marker='o')
plt.title('Método del Codo para K-Means')
plt.xlabel('Número de Clústeres (K)')
plt.ylabel('Inercia')
plt.xticks(K_range)
plt.grid(True)
plt.show()

El método del codo consiste en graficar la inercia (suma de las distancias cuadradas de cada punto a su centroide) en función del número de clústeres (K). El "codo" es el punto en la gráfica donde la disminución de la inercia se ralentiza significativamente. Este punto es a menudo considerado el K óptimo, ya que añadir más clústeres más allá de este punto no reduce sustancialmente la inercia.

Mini Proyecto / Aplicación Sencilla: Segmentación de Clientes

Imaginemos que somos una tienda online y tenemos datos de la cantidad de compras y el valor promedio de cada compra de nuestros clientes. Queremos segmentarlos para campañas de marketing personalizadas.

# Datos de ejemplo de clientes (Compras Mensuales, Valor Promedio Compra)
# Estos datos no tienen etiquetas de segmento
clientes_data = np.array([
    [5, 50], [6, 55], [4, 45], [5, 60], [7, 65], # Grupo 1: Compradores frecuentes, valor medio
    [1, 10], [2, 15], [1, 12], [2, 18], [3, 20], # Grupo 2: Compradores ocasionales, valor bajo
    [8, 200], [9, 220], [7, 180], [10, 250], [8, 190] # Grupo 3: Compradores VIP, valor alto
])

df_clientes = pd.DataFrame(clientes_data, columns=['Compras_Mensuales', 'Valor_Promedio_Compra'])

print("Datos de Clientes:")
print(df_clientes)

# Aplicar K-Means para encontrar 3 segmentos de clientes
# Primero, escalamos los datos para que ambas características tengan un rango similar.
# Esto es crucial para K-Means, ya que se basa en distancias.
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
clientes_scaled = scaler.fit_transform(df_clientes)

kmeans_clientes = KMeans(n_clusters=3, init='k-means++', n_init=10, random_state=42)
kmeans_clientes.fit(clientes_scaled)

# Asignar las etiquetas de clúster de vuelta al DataFrame original
df_clientes['Segmento'] = kmeans_clientes.labels_

print("\nClientes con Segmento Asignado:")
print(df_clientes)

# Visualizar los segmentos
plt.figure(figsize=(10, 8))
plt.scatter(df_clientes['Compras_Mensuales'], df_clientes['Valor_Promedio_Compra'], 
            c=df_clientes['Segmento'], s=100, cmap='viridis', alpha=0.8)

# Graficar los centroides (transformados inversamente para estar en la escala original)
centroids_original_scale = scaler.inverse_transform(kmeans_clientes.cluster_centers_)
plt.scatter(centroids_original_scale[:, 0], centroids_original_scale[:, 1], 
            marker='X', s=300, linewidths=3, color='red', edgecolors='black', label='Centroides')

plt.title('Segmentación de Clientes con K-Means')
plt.xlabel('Compras Mensuales')
plt.ylabel('Valor Promedio Compra')
plt.legend()
plt.grid(True)
plt.show()

# Interpretación de los segmentos
print("\nCaracterísticas promedio de cada segmento:")
print(df_clientes.groupby('Segmento').mean())

En este mini-proyecto, hemos simulado datos de clientes y aplicado K-Means para segmentarlos. Es importante notar el paso de StandardScaler. K-Means es sensible a la escala de las características, ya que calcula distancias. Si una característica tiene un rango mucho mayor que otra, dominará el cálculo de la distancia. Escalar los datos (por ejemplo, a media 0 y desviación estándar 1) asegura que todas las características contribuyan equitativamente.

Al final, agrupamos por el segmento asignado y calculamos la media de las características para cada grupo. Esto nos permite interpretar qué tipo de clientes hay en cada segmento (por ejemplo, "compradores VIP", "compradores ocasionales", etc.).

Errores Comunes y Depuración

  • Elegir un K Incorrecto:

    Problema: Si eliges un K demasiado bajo, los clústeres serán demasiado grandes y heterogéneos. Si es demasiado alto, los clústeres serán pequeños y fragmentados, o incluso vacíos. El método del codo es una guía, pero no una solución definitiva. A veces, la interpretación del dominio es más importante.

    Solución: Experimenta con diferentes valores de K. Visualiza los resultados. Considera la interpretabilidad de los clústeres en el contexto de tu problema. Métricas como el Coeficiente de Silueta pueden ofrecer una visión más cuantitativa, aunque son más complejas de interpretar para principiantes.

  • Sensibilidad a la Inicialización de Centroides:

    Problema: K-Means es un algoritmo iterativo que comienza con centroides aleatorios. Diferentes inicializaciones pueden llevar a diferentes resultados finales (óptimos locales).

    Solución: Usa n_init en KMeans (como hicimos en los ejemplos). scikit-learn por defecto usa 'k-means++' para la inicialización, que ya es una mejora sobre la inicialización puramente aleatoria, y n_init ejecuta el algoritmo múltiples veces con diferentes inicializaciones y elige la mejor. Asegúrate de usar un random_state para reproducibilidad en tus experimentos.

  • No Escalar los Datos:

    Problema: Si las características tienen escalas muy diferentes (ej. una característica de 0 a 1000 y otra de 0 a 1), la característica con el rango más grande dominará el cálculo de la distancia, haciendo que K-Means ignore la contribución de las características con rangos más pequeños.

    Solución: Siempre escala tus datos antes de aplicar K-Means. StandardScaler o MinMaxScaler de scikit-learn.preprocessing son excelentes opciones.

  • Clústeres No Esféricos o de Densidad Variable:

    Problema: K-Means asume que los clústeres son esféricos y de tamaño similar. Si tus datos tienen formas complejas (ej. clústeres en forma de media luna) o densidades muy diferentes, K-Means no funcionará bien.

    Solución: K-Means no es la solución para todo. Para clústeres de formas arbitrarias o basados en densidad, considera otros algoritmos como DBSCAN o Agglomerative Clustering.

Aprendizaje Futuro

Has dado tu primer paso sólido en el aprendizaje no supervisado con K-Means. Aquí hay algunas áreas para explorar a continuación:

  • Otros Algoritmos de Clustering: Investiga DBSCAN (para clústeres basados en densidad y detección de ruido), Agglomerative Clustering (jerárquico), y Gaussian Mixture Models (GMMs, que asumen que los datos provienen de una mezcla de distribuciones gaussianas).
  • Métricas de Evaluación de Clustering: Aprende sobre el Coeficiente de Silueta, el Índice de Davies-Bouldin, y el Índice de Calinski-Harabasz para evaluar la calidad de tus clústeres cuando no tienes etiquetas verdaderas.
  • Reducción de Dimensionalidad: Técnicas como PCA (Análisis de Componentes Principales) pueden ser muy útiles antes del clustering para reducir el número de características y hacer los datos más manejables y visualizables, especialmente en conjuntos de datos de alta dimensión.
  • Aplicaciones Reales: Busca casos de uso de K-Means en la industria, como segmentación de imágenes, detección de anomalías, o sistemas de recomendación.

El clustering es una herramienta fundamental en el análisis de datos y el Machine Learning. ¡Sigue experimentando y construyendo!

Volver al blog