Tutorial ScikitLearn: Clustering con KMeans

¿Qué es el clustering?

El clustering es una técnica de aprendizaje no supervisado que tiene como objetivo agrupar datos similares en conjuntos llamados clústeres. A diferencia del aprendizaje supervisado, donde se utilizan etiquetas conocidas para entrenar modelos, el clustering busca descubrir estructuras ocultas en los datos sin información previa sobre las categorías existentes.

En el clustering, los algoritmos analizan las características de los datos para identificar patrones y similitudes. Los objetos dentro de un mismo clúster son más similares entre sí que a los de otros clústeres. Esta técnica es especialmente útil para explorar conjuntos de datos grandes y complejos, donde es difícil detectar relaciones a simple vista.

Existen diversos tipos de algoritmos de clustering, cada uno con enfoques y metodologías diferentes. Algunos de los más comunes son:

• Clustering de partición: divide el conjunto de datos en K clústeres no superpuestos. Un ejemplo de este tipo es el algoritmo KMeans.
• Clustering jerárquico: crea una estructura en forma de árbol donde los clústeres se forman mediante la unión o división de clústeres existentes.
• Clustering basado en densidad: identifica áreas densas de datos y las considera clústeres, como sucede con el algoritmo DBSCAN.

Una aplicación típica del clustering es en el análisis de clientes. Por ejemplo, una empresa puede utilizar clustering para segmentar a sus clientes en función de comportamientos de compra, permitiendo diseñar estrategias de marketing más efectivas. Otro ejemplo es en biología, donde se agrupan proteínas o genes similares para entender funciones biológicas.

A continuación, se presenta un ejemplo sencillo utilizando Scikit Learn para ilustrar cómo se prepara un conjunto de datos para clustering:

import numpy as np
from sklearn.preprocessing import StandardScaler

# Generación de datos de ejemplo
X = np.array([[1, 2], [1, 4], [1, 0],
              [10, 2], [10, 4], [10, 0]])

# Escalado de datos
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

En este código, primero importamos las bibliotecas necesarias y generamos un conjunto de datos de ejemplo. Luego, utilizamos StandardScaler para escalar los datos, lo cual es una práctica común antes de aplicar algoritmos de clustering, ya que muchos son sensibles a las escalas de las características.

Es importante destacar que el éxito del clustering depende en gran medida de la correcta selección de características y del preprocesamiento de los datos. Técnicas como la reducción de la dimensionalidad pueden ser útiles para eliminar ruido y simplificar el análisis.

El clustering también enfrenta desafíos, como determinar el número óptimo de clústeres o manejar datos con formas y densidades variadas. Para abordar estos problemas, se utilizan métricas de validación interna, como el coeficiente de silueta, y técnicas avanzadas de clustering.

¿Qué es KMeans?

KMeans es un algoritmo de clustering ampliamente utilizado en aprendizaje no supervisado. Su objetivo es agrupar un conjunto de datos en K clústeres distintos, donde cada observación pertenece al clúster con el centroide más cercano, definido como la media de los puntos dentro del clúster.

El funcionamiento de KMeans se basa en un proceso iterativo con dos pasos clave: primero, asignar cada punto de datos al clúster cuyo centroide esté más cercano; segundo, recalcular los centroides como la media de los puntos asignados al clúster. Este proceso se repite hasta que las asignaciones no cambian o hasta alcanzar un criterio de convergencia predefinido.

La inicialización de los centroides es un paso crítico en KMeans. Una opción común es seleccionar K puntos al azar del conjunto de datos. Sin embargo, técnicas como KMeans++ mejoran la inicialización seleccionando centroides iniciales que están lo más separados posible, lo que conduce a resultados más consistentes y evita converger en mínimos locales.

El número de clústeres K es un parámetro que debe definirse antes de ejecutar el algoritmo. Determinar el valor óptimo de K puede ser un desafío y generalmente se basa en métodos como el método del codo, que analiza la variación de la inercia en función de K, o el coeficiente de silueta, que evalúa la calidad de los clústeres en términos de cohesión y separación.

Una ventaja principal de KMeans es su eficiencia computacional, dado que su complejidad es $O(nkt)$, donde n es el número de puntos de datos, k es el número de clústeres y t es el número de iteraciones hasta la convergencia. Esto lo hace adecuado para conjuntos de datos de gran tamaño. Sin embargo, KMeans asume que los clústeres son de forma esférica y de tamaños similares, y puede verse afectado por la presencia de valores atípicos y por clústeres con formas no convexas.

El algoritmo KMeans minimiza la suma de las distancias cuadradas dentro de los clústeres, conocida como inercia o suma de los errores al cuadrado (SSE). El objetivo es encontrar la partición que minimice esta inercia, logrando clústeres más compactos y bien separados.

El proceso iterativo del algoritmo se detalla en los siguientes pasos:

1. Inicialización: seleccionar K centroides iniciales.
2. Asignación: asignar cada punto al clúster con el centroide más cercano.
3. Actualización: recalcular los centroides como la media de los puntos asignados.
4. Iteración: repetir los pasos 2 y 3 hasta que las asignaciones no cambien o se alcance el criterio de convergencia.

Es importante destacar que KMeans puede converger a mínimos locales, y sus resultados pueden variar según la inicialización de los centroides. Por ello, es común ejecutar el algoritmo varias veces con diferentes inicializaciones y seleccionar la solución con la menor inercia.

Una forma de visualizar KMeans es imaginar cómo se dividen los datos en regiones de Voronoi, donde cada región contiene todos los puntos más cercanos a un centroide determinado. Esta propiedad geométrica ilustra cómo KMeans particiona el espacio de características en función de las distancias euclidianas.

KMeans tiene múltiples aplicaciones prácticas, desde la segmentación de clientes en marketing hasta el reconocimiento de patrones en imágenes. Su capacidad para descubrir estructuras subyacentes en los datos lo convierte en una herramienta esencial en el análisis exploratorio.

Uso de KMeans en scikit learn

El algoritmo KMeans está implementado en Scikit Learn a través de la clase KMeans, que permite aplicar clustering a conjuntos de datos de manera eficiente. Para utilizarlo, es necesario importar la clase y configurar los parámetros esenciales.

A continuación, se muestra un ejemplo completo de cómo aplicar KMeans a un conjunto de datos:

import numpy as np
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# Generación de datos de ejemplo
X = np.array([[1, 2], [1, 4], [1, 0],
              [10, 2], [10, 4], [10, 0]])

# Definición del número de clústeres
n_clusters = 2

# Creación del modelo KMeans
kmeans = KMeans(n_clusters=n_clusters, random_state=42)

# Entrenamiento del modelo
kmeans.fit(X)

# Predicción de los clústeres
labels = kmeans.predict(X)

# Coordenadas de los centroides
centroids = kmeans.cluster_centers_

# Visualización de los clústeres
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', s=200, c='red')
plt.title('Clustering con KMeans')
plt.xlabel('Característica 1')
plt.ylabel('Característica 2')
plt.show()

En este ejemplo:

• Se importan las bibliotecas necesarias, incluyendo KMeans de Scikit Learn.
• Se generan datos de ejemplo en un array de NumPy, representando puntos en un espacio bidimensional.
• Se define el número de clústeres mediante la variable n_clusters.
• Se crea una instancia de KMeans especificando el número de clústeres y una semilla de aleatoriedad con random_state para asegurar la reproducibilidad.
• Se entrena el modelo con el método fit, aplicando el algoritmo a los datos X.
• Se obtienen las etiquetas de clúster para cada punto utilizando predict.
• Se extraen las coordenadas de los centroides de los clústeres con cluster_centers_.
• Se visualizan los datos y los centroides utilizando Matplotlib.

Es importante destacar que el preprocesamiento de los datos es fundamental antes de aplicar KMeans. Dado que el algoritmo utiliza distancias euclidianas, las características deben estar en la misma escala para evitar que alguna domine el cálculo de distancias. Por ello, es común utilizar técnicas de escalado o estandarización.

Un ejemplo que incluye el escalado de datos:

from sklearn.preprocessing import StandardScaler

# Escalado de los datos
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Aplicación de KMeans a los datos escalados
kmeans = KMeans(n_clusters=2, random_state=42)
kmeans.fit(X_scaled)
labels = kmeans.predict(X_scaled)
centroids = kmeans.cluster_centers_

# Visualización de los clústeres escalados
plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=labels, cmap='viridis')
plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', s=200, c='red')
plt.title('Clustering con KMeans (Datos Escalados)')
plt.xlabel('Característica 1 escalada')
plt.ylabel('Característica 2 escalada')
plt.show()

En este código:

• Se importa StandardScaler para estandarizar los datos.
• Se ajusta y transforma X utilizando fit_transform.
• Se aplica KMeans a los datos escalados X_scaled.
• Se visualizan los resultados en el espacio escalado.

La elección de los parámetros en KMeans es crucial para obtener resultados óptimos. Los parámetros más relevantes son:

• n_clusters: número de clústeres a formar.
• init: método para inicializar los centroides. Por defecto, es 'k-means++', que mejora la convergencia.
• max_iter: número máximo de iteraciones del algoritmo para una sola ejecución.
• n_init: número de veces que el algoritmo se ejecutará con centroides iniciales diferentes. El resultado final será el que tenga la mejor inercia.
• random_state: semilla para generar resultados reproducibles.

Por ejemplo, para modificar el número de inicializaciones y el método de inicialización:

kmeans = KMeans(n_clusters=3, init='random', n_init=10, random_state=42)
kmeans.fit(X_scaled)

La obtención de la inercia (suma de las distancias cuadradas dentro de los clústeres) es útil para evaluar la calidad del clustering:

inertia = kmeans.inertia_
print(f'Inercia del modelo: {inertia}')

Además, es posible acceder a otros atributos y métodos del modelo:

• labels_: etiquetas de clúster asignadas a cada punto tras el ajuste.
• cluster_centers_: coordenadas de los centroides.
• fit_predict(): combina fit y predict en un solo paso.

Un caso práctico utilizando fit_predict:

labels = kmeans.fit_predict(X_scaled)

Para utilizar KMeans en un conjunto de datos más complejo, como el conjunto de iris que proporciona Scikit Learn:

from sklearn.datasets import load_iris

# Carga del conjunto de datos iris
iris = load_iris()
X = iris.data

# Escalado de los datos
X_scaled = scaler.fit_transform(X)

# Aplicación de KMeans
kmeans = KMeans(n_clusters=3, random_state=42)
labels = kmeans.fit_predict(X_scaled)

# Visualización en dos dimensiones principales
from sklearn.decomposition import PCA

pca = PCA(n_components=2)
principal_components = pca.fit_transform(X_scaled)

plt.scatter(principal_components[:, 0], principal_components[:, 1], c=labels, cmap='viridis')
plt.title('Clustering de Iris con KMeans')
plt.xlabel('Componente Principal 1')
plt.ylabel('Componente Principal 2')
plt.show()

En este ejemplo:

• Se utiliza el conjunto de datos iris, que contiene cuatro características.
• Se escalan las características para aplicar KMeans adecuadamente.
• Se reducen las dimensiones a dos componentes principales con PCA para facilitar la visualización.
• Se visualizan los resultados en un gráfico bidimensional coloreado según las etiquetas de clúster.

Es esencial comprender que KMeans no utiliza las etiquetas verdaderas en aprendizaje no supervisado; sin embargo, al disponer de las etiquetas reales en conjuntos de datos como iris, es posible comparar el clustering obtenido con la clasificación real.

Para evaluar el rendimiento sin etiquetas verdaderas, se pueden usar métricas como el coeficiente de silueta, que se explorará en profundidad en secciones posteriores.

Al aplicar KMeans a datos reales, es recomendable:

• Analizar y preprocesar los datos, manejando valores atípicos y dimensiones irrelevantes.
• Escoger el número adecuado de clústeres mediante métodos como el método del codo.
• Realizar múltiples inicializaciones para evitar soluciones subóptimas.

Por último, es posible integrar KMeans en un pipeline de Scikit Learn, combinando pasos de preprocesamiento y modelado:

from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('kmeans', KMeans(n_clusters=3, random_state=42))
], memory = None)

pipeline.fit(X)
labels = pipeline.predict(X)

Esta práctica permite gestionar el flujo de datos de manera organizada y aplicar el mismo procesamiento a nuevos datos en el futuro.

Visualización de clústers

La visualización de clústeres es fundamental para interpretar y analizar los resultados obtenidos tras aplicar algoritmos de clustering como KMeans. Representar gráficamente los clústeres permite identificar patrones, validar la calidad de la agrupación y detectar posibles anomalías en los datos.

Para datos bidimensionales, la visualización es directa mediante gráficos de dispersión. A continuación, se presenta un ejemplo completo que ilustra cómo visualizar los clústeres obtenidos con KMeans utilizando Matplotlib:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

# Generación de datos de ejemplo
X = np.array([
    [1, 2], [1, 4], [1, 0],
    [4, 2], [4, 4], [4, 0]
])

# Aplicación del algoritmo KMeans
kmeans = KMeans(n_clusters=2, random_state=42)
kmeans.fit(X)

# Obtención de etiquetas y centroides
labels = kmeans.labels_
centroids = kmeans.cluster_centers_

# Visualización de los datos y los centroides
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', marker='o', edgecolor='k')
plt.scatter(centroids[:, 0], centroids[:, 1], s=200, c='red', marker='X')
plt.title('Visualización de Clústeres con KMeans')
plt.xlabel('Característica 1')
plt.ylabel('Característica 2')
plt.show()

En este código:

• Se importan las bibliotecas necesarias: NumPy para manipular datos numéricos, Matplotlib para la visualización y KMeans de Scikit Learn.
• Se generan datos de ejemplo con dos características para facilitar la representación bidimensional.
• Se aplica el algoritmo KMeans con n_clusters=2 y una semilla de aleatoriedad para reproducibilidad.
• Se obtienen las etiquetas de clúster con kmeans.labels_ y las coordenadas de los centroides con kmeans.cluster_centers_.
• Se crea un gráfico de dispersión donde:
• Los puntos de datos se colorean según su etiqueta de clúster.
• Los centroides se destacan con un marcador especial y mayor tamaño.

Cuando los datos tienen más de dos características, es necesario reducir la dimensionalidad para poder visualizarlos en dos dimensiones. Una técnica común es utilizar Análisis de Componentes Principales (PCA). A continuación, se muestra cómo combinar PCA con KMeans para visualizar clústeres en datos multidimensionales:

from sklearn.datasets import load_iris
from sklearn.decomposition import PCA

# Carga del conjunto de datos iris
iris = load_iris()
X = iris.data

# Reducción de dimensionalidad con PCA a dos componentes principales
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X)

# Aplicación de KMeans a los datos originales
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X)

# Obtención de etiquetas y transformación de centroides
labels = kmeans.labels_
centroids = kmeans.cluster_centers_
centroids_reduced = pca.transform(centroids)

# Visualización de los datos y los centroides en el espacio reducido
plt.scatter(X_reduced[:, 0], X_reduced[:, 1], c=labels, cmap='viridis', marker='o', edgecolor='k')
plt.scatter(centroids_reduced[:, 0], centroids_reduced[:, 1], s=200, c='red', marker='X')
plt.title('Visualización de Clústeres en el Conjunto Iris')
plt.xlabel('Componente Principal 1')
plt.ylabel('Componente Principal 2')
plt.show()

En este ejemplo:

• Se utiliza el conjunto de datos Iris, que contiene cuatro características.
• Se aplica PCA para reducir las cuatro dimensiones a dos componentes principales, preservando la mayor varianza posible.
• Se ajusta KMeans a los datos originales para evitar distorsiones en el clustering.
• Los centroides obtenidos se transforman al mismo espacio reducido utilizando pca.transform.
• Se representa el gráfico de dispersión con los datos y centroides en el espacio bidimensional.

Es importante destacar que la visualización en el espacio reducido puede introducir pérdida de información, pero suele ser suficiente para identificar tendencias y agrupaciones.

Otra alternativa para visualizar clústeres en alta dimensionalidad es emplear técnicas como t-SNE (t-distributed Stochastic Neighbor Embedding). Aunque t-SNE está diseñado para visualización más que para análisis cuantitativo, es útil para explorar estructuras complejas:

from sklearn.manifold import TSNE

# Reducción de dimensionalidad con t-SNE a dos dimensiones
tsne = TSNE(n_components=2, random_state=42)
X_embedded = tsne.fit_transform(X)

# Aplicación de KMeans a los datos originales
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X)

# Obtención de etiquetas
labels = kmeans.labels_

# Visualización de los datos en el espacio t-SNE
plt.scatter(X_embedded[:, 0], X_embedded[:, 1], c=labels, cmap='viridis', marker='o', edgecolor='k')
plt.title('Visualización de Clústeres con t-SNE')
plt.xlabel('Dimensión 1')
plt.ylabel('Dimensión 2')
plt.show()

En este caso:

• Se aplica t-SNE para reducir los datos a dos dimensiones, capturando relaciones no lineales.
• KMeans se ajusta a los datos originales para mantener la integridad del clustering.
• Los datos se visualizan en el espacio generado por t-SNE, lo que puede revelar agrupamientos más sutiles.

Al visualizar clústeres, es recomendable:

• Utilizar colores y marcadores distintivos para cada clúster.
• Representar los centroides o núcleos de los clústeres cuando sea posible.
• Incluir etiquetas y títulos descriptivos en los gráficos para facilitar la interpretación.

Además de Matplotlib, bibliotecas como Seaborn ofrecen funciones avanzadas para visualización. Por ejemplo, el uso de pairplot puede ayudar a explorar relaciones entre pares de características:

import seaborn as sns
import pandas as pd

# Creación de un DataFrame con los datos y las etiquetas
df = pd.DataFrame(X, columns=iris.feature_names)
df['Clúster'] = labels

# Visualización de pares de características
sns.pairplot(df, vars=iris.feature_names, hue='Clúster', palette='viridis', diag_kind='kde')
plt.suptitle('Visualización de Pares de Características por Clúster', y=1.02)
plt.show()

En este fragmento:

• Se convierte el conjunto de datos en un DataFrame de Pandas para facilitar la manipulación.
• Se añade la columna 'Clúster' con las etiquetas asignadas por KMeans.
• Se utiliza pairplot de Seaborn para generar una matriz de gráficos que muestra las relaciones entre las características, coloreadas por clúster.

La visualización tridimensional es otra opción cuando los datos tienen al menos tres características. Utilizando Matplotlib en 3D:

from mpl_toolkits.mplot3d import Axes3D

# Selección de tres características para la visualización
X_selected = X[:, :3]  # Usamos las tres primeras características

# Aplicación de KMeans
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X_selected)
labels = kmeans.labels_
centroids = kmeans.cluster_centers_

# Configuración del gráfico 3D
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# Visualización de los puntos y centroides
ax.scatter(X_selected[:, 0], X_selected[:, 1], X_selected[:, 2], c=labels, cmap='viridis', marker='o', edgecolor='k')
ax.scatter(centroids[:, 0], centroids[:, 1], centroids[:, 2], s=200, c='red', marker='X')
ax.set_title('Visualización 3D de Clústeres')
ax.set_xlabel('Característica 1')
ax.set_ylabel('Característica 2')
ax.set_zlabel('Característica 3')
plt.show()

Aquí:

• Se seleccionan las tres primeras características del conjunto de datos.
• Se ajusta KMeans y se obtienen las etiquetas y centroides correspondientes.
• Se configura un gráfico en tres dimensiones para visualizar los clústeres.

Es crucial recordar que la interpretación de los clústeres debe complementarse con métricas y análisis adicionales. La visualización es una herramienta que, junto con la evaluación cuantitativa, proporciona una comprensión más completa del comportamiento del algoritmo.

Para conjuntos de datos con un gran número de clústeres o alta densidad de puntos, pueden surgir desafíos en la visualización. En tales casos, es útil:

• Utilizar técnicas de subsampling para reducir la cantidad de puntos mostrados.
• Aplicar filtros o segmentar la visualización por regiones de interés.
• Emplear visualizaciones interactivas con bibliotecas como Plotly o Bokeh.

Por ejemplo, una visualización interactiva básica con Plotly:

import plotly.express as px

# Creación de un DataFrame con los componentes principales
df_pca = pd.DataFrame(X_reduced, columns=['Componente 1', 'Componente 2'])
df_pca['Clúster'] = labels.astype(str)

# Gráfico interactivo
fig = px.scatter(df_pca, x='Componente 1', y='Componente 2', color='Clúster', title='Visualización de Clústeres con Plotly')
fig.show()

En este caso:

• Se utiliza Plotly Express para generar un gráfico interactivo.
• El gráfico permite al usuario interactuar con los datos, ofreciendo una exploración más dinámica.

La elección de la técnica de visualización dependerá del contexto y las características del conjunto de datos. Es importante experimentar con distintas opciones para encontrar la más adecuada que facilite la interpretación y el análisis de los clústeres obtenidos.

Métricas de evaluación: inercia y silhouette score

Al aplicar KMeans para clustering, es esencial evaluar la calidad de las agrupaciones obtenidas. Dado que el clustering es una técnica de aprendizaje no supervisado, no disponemos de etiquetas reales para comparar. Por ello, utilizamos métricas internas como la inercia y el coeficiente de silueta para determinar qué tan bien se han formado los clústeres.

La inercia, también conocida como suma de las distancias al cuadrado dentro de los clústeres, mide la cohesión de los clústeres. Se define como la suma total de las distancias al cuadrado de cada punto a su centroide respectivo. Matemáticamente:

$$
\text{Inercia} = \sum_{i=1}^{n} \left| x_i - \mu_{c(i)} \right|^2
$$

donde $( x_i )$ es un punto de datos, y $( \mu_{c(i)} )$ es el centroide del clúster al que pertenece $( x_i )$.

Una inercia menor indica clústeres más compactos. Sin embargo, la inercia siempre disminuye cuando aumentamos el número de clústeres $( K )$. Por ello, no es suficiente evaluar la inercia de forma aislada; debemos considerar cómo varía al cambiar $( K )$.

Para ilustrar el uso de la inercia, consideremos el siguiente ejemplo:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

# Crear una instancia del generador de números aleatorios con una semilla
rng = np.random.default_rng(seed=42)

# Generación de datos aleatorios
X = rng.random((300, 2))

# Lista para almacenar las inercias
inercias = []

# Rango de valores de K
rango_K = range(1, 10)

for k in rango_K:
    kmeans = KMeans(n_clusters=k, random_state=42)
    kmeans.fit(X)
    inercias.append(kmeans.inertia_)

# Gráfico del método del codo
plt.figure(figsize=(8, 4))
plt.plot(rango_K, inercias, 'bx-')
plt.xlabel('Número de clústeres K')
plt.ylabel('Inercia')
plt.title('Método del codo para determinar K óptimo')
plt.show()

En este código, calculamos la inercia para diferentes valores de $( K )$ y la representamos gráficamente. El método del codo consiste en buscar el punto donde la disminución de la inercia se ralentiza significativamente, indicando un K óptimo.

Por otro lado, el coeficiente de silueta mide tanto la cohesión como la separación de los clústeres. Para cada punto, el coeficiente de silueta $( s )$ se calcula como:

$$
s = \frac{b - a}{\max(a, b)}
$$

donde:

• $( a )$ es la distancia media entre un punto y los demás puntos del mismo clúster (cohesión).
• $( b )$ es la distancia media entre un punto y los puntos del clúster más cercano al que no pertenece (separación).

El valor de $( s )$ oscila entre -1 y 1:

• Un valor cercano a 1 indica que el punto está bien asignado a su clúster y está lejos de los otros clústeres.
• Un valor cercano a 0 indica que el punto está en el límite entre dos clústeres.
• Un valor negativo indica que el punto podría haberse asignado a otro clúster.

Veamos cómo calcular el coeficiente de silueta en Scikit Learn:

from sklearn.metrics import silhouette_score

# Aplicación de KMeans con K=3
kmeans = KMeans(n_clusters=3, random_state=42)
labels = kmeans.fit_predict(X)

# Cálculo del coeficiente de silueta
silhouette_avg = silhouette_score(X, labels)
print(f'Coeficiente de silueta para K=3: {silhouette_avg:.4f}')

En este ejemplo, utilizamos silhouette_score para obtener el valor promedio del coeficiente de silueta de todos los puntos. Un valor más alto indica una mejor definición de clústeres.

Para visualizar cómo varía el coeficiente de silueta según $( K )$:

from sklearn.metrics import silhouette_samples
import matplotlib.cm as cm

# Rango de valores de K
rango_K = range(2, 10)
silhouette_avgs = []

for k in rango_K:
    kmeans = KMeans(n_clusters=k, random_state=42)
    labels = kmeans.fit_predict(X)
    silhouette_avg = silhouette_score(X, labels)
    silhouette_avgs.append(silhouette_avg)
    print(f'Para n_clusters = {k}, el coeficiente de silueta medio es de {silhouette_avg:.4f}')

# Gráfico del coeficiente de silueta medio
plt.figure(figsize=(8, 4))
plt.plot(rango_K, silhouette_avgs, 'bx-')
plt.xlabel('Número de clústeres K')
plt.ylabel('Coeficiente de silueta medio')
plt.title('Análisis del coeficiente de silueta para distintos K')
plt.show()

Este código muestra cómo el coeficiente de silueta promedio varía con diferentes números de clústeres, ayudándonos a elegir un $( K )$ que maximice este valor.

Además, podemos visualizar la distribución de los coeficientes de silueta por clúster:

import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np

# Elegir un K específico
k = 3
kmeans = KMeans(n_clusters=k, random_state=42)
labels = kmeans.fit_predict(X)
silhouette_vals = silhouette_samples(X, labels)

y_lower = 10
fig, ax1 = plt.subplots(1, 1)
fig.set_size_inches(8, 6)

for i in range(k):
    ith_silhouette_vals = silhouette_vals[labels == i]
    ith_silhouette_vals.sort()
    size_cluster_i = ith_silhouette_vals.shape[0]
    y_upper = y_lower + size_cluster_i
    color = cm.viridis(float(i) / k)
    ax1.fill_betweenx(np.arange(y_lower, y_upper),
                      0, ith_silhouette_vals,
                      facecolor=color, edgecolor=color, alpha=0.7)
    ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
    y_lower = y_upper + 10  # 10 para espacio entre clústeres

ax1.set_title("Gráfico de los coeficientes de silueta para cada clúster")
ax1.set_xlabel("Coeficiente de silueta")
ax1.set_ylabel("Etiqueta de clúster")

ax1.axvline(x=silhouette_avg, color="red", linestyle="--")
ax1.set_yticks([])  # Limpiar el eje y
ax1.set_xticks(np.arange(-0.1, 1.1, 0.2))

plt.show()

Este gráfico muestra la distribución de los coeficientes de silueta para cada clúster, permitiendo identificar clústeres con baja cohesión o separación.

Es importante recordar que tanto la inercia como el coeficiente de silueta son métricas internas y no necesariamente indican cómo se ajustan los clústeres a una posible estructura subyacente en los datos. Por ello, es recomendable utilizarlas en conjunto y complementarlas con interpretaciones específicas del dominio.

Al usar Scikit Learn, estas funciones están actualizadas y ofrecen un rendimiento óptimo para evaluar modelos de clustering.

Las métricas de evaluación como la inercia y el coeficiente de silueta son herramientas fundamentales para medir la calidad de las agrupaciones en KMeans. Su aplicación correcta nos ayuda a tomar decisiones informadas sobre el número óptimo de clústeres y la interpretación de los resultados.

Selección del número óptimo de clústers

Determinar el número óptimo de clústeres es un paso crucial en el proceso de clustering con KMeans. Elegir un valor inadecuado para $( K )$ puede llevar a agrupaciones que no reflejan la estructura subyacente de los datos. A pesar de que métodos como la inercia y el coeficiente de silueta proporcionan información valiosa, existen técnicas adicionales que ayudan a tomar una decisión más informada sobre el número de clústeres adecuado.

Uno de los métodos complementarios es el índice de Calinski-Harabasz. Este índice evalúa la densidad y la separación entre clústeres, calculando la relación entre la varianza entre clústeres y la varianza dentro de los clústeres. Un valor más alto del índice indica una mejor formación de clústeres. Podemos calcular este índice utilizando la función calinski_harabasz_score de Scikit Learn:

from sklearn.metrics import calinski_harabasz_score

# Asumiendo que ya hemos definido X y labels
score = calinski_harabasz_score(X, labels)
print(f'Índice de Calinski-Harabasz para K={k}: {score:.2f}')

El índice de Davies-Bouldin es otra métrica que facilita la evaluación. Este índice mide la similitud entre clústeres, teniendo en cuenta la distancia entre ellos y la dispersión dentro de cada clúster. Un valor más bajo del índice indica clústeres más compactos y separados. Para calcularlo, se utiliza davies_bouldin_score:

from sklearn.metrics import davies_bouldin_score

score = davies_bouldin_score(X, labels)
print(f'Índice de Davies-Bouldin para K={k}: {score:.2f}')

Ambos índices pueden representarse gráficamente para diferentes valores de $( K )$, facilitando la identificación del número óptimo de clústeres. A continuación, se muestra un ejemplo completo que ilustra este proceso:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.metrics import calinski_harabasz_score, davies_bouldin_score

# Generación de datos sintéticos
from sklearn.datasets import make_blobs
X, y_true = make_blobs(n_samples=500, centers=4, cluster_std=0.60, random_state=0)

# Rango de K a evaluar
rango_K = range(2, 10)
calinski_scores = []
davies_scores = []

for k in rango_K:
    kmeans = KMeans(n_clusters=k, random_state=42)
    labels = kmeans.fit_predict(X)
    calinski = calinski_harabasz_score(X, labels)
    davies = davies_bouldin_score(X, labels)
    calinski_scores.append(calinski)
    davies_scores.append(davies)
    print(f'Para K={k}, Calinski-Harabasz: {calinski:.2f}, Davies-Bouldin: {davies:.2f}')

# Gráfico de los índices
fig, ax1 = plt.subplots()
ax1.plot(rango_K, calinski_scores, 'bx-')
ax1.set_xlabel('Número de clústeres K')
ax1.set_ylabel('Calinski-Harabasz', color='b')
ax2 = ax1.twinx()
ax2.plot(rango_K, davies_scores, 'rx-')
ax2.set_ylabel('Davies-Bouldin', color='r')
plt.title('Evaluación de K mediante índices Calinski-Harabasz y Davies-Bouldin')
plt.show()

En este código:

• Se generan datos sintéticos con cuatro centros utilizando make_blobs.
• Se evalúan los índices para valores de $( K )$ entre 2 y 9.
• Se representa gráficamente cómo varían los índices con respecto a $( K )$, facilitando la visualización de tendencias.

Otra técnica es el método del Gap Statistic, que compara la inercia observada con la esperada si los datos se distribuyeran aleatoriamente. Este método ayuda a determinar si la estructura encontrada es significativa o podría haberse obtenido por azar. Aunque Scikit Learn no implementa directamente esta función, podemos utilizar la biblioteca externa gap_statistic o implementar nuestra propia versión.

A continuación, se muestra un ejemplo simplificado del método del Gap Statistic:

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

# Crear una instancia del generador de números aleatorios con una semilla
rng = np.random.default_rng(seed=42)

# Generación de datos sintéticos
x, y_true = make_blobs(n_samples=500, centers=4, cluster_std=0.60, random_state=42)

# Definición de la función para calcular el Gap Statistic
def calcular_gap_statistic(x, n_refs=10, max_k=10):
    shape = x.shape
    gaps = np.zeros(max_k - 1)
    ref_disps = np.zeros((n_refs, max_k - 1))
    for i in range(n_refs):
        # Generar datos aleatorios de referencia dentro del hipercubo de los datos originales
        random_reference = rng.uniform(x.min(axis=0), x.max(axis=0), size=shape)
        for k in range(1, max_k):
            # Clustering en los datos de referencia
            kmeans = KMeans(n_clusters=k+1, random_state=42)
            kmeans.fit(random_reference)
            ref_dispersion = np.log(kmeans.inertia_)
            ref_disps[i, k - 1] = ref_dispersion
    for k in range(1, max_k):
        # Clustering en los datos originales
        kmeans = KMeans(n_clusters=k+1, random_state=42)
        kmeans.fit(x)
        orig_dispersion = np.log(kmeans.inertia_)
        # Calcular la brecha (gap)
        gap = np.mean(ref_disps[:, k - 1]) - orig_dispersion
        gaps[k - 1] = gap
    return gaps

# Aplicación del método del Gap Statistic
gaps = calcular_gap_statistic(x, n_refs=5, max_k=10)
k_vals = np.arange(2, 11)

# Gráfico del Gap Statistic
plt.figure(figsize=(8, 6))
plt.plot(k_vals, gaps, 'bx-')
plt.xlabel('Número de clústeres K')
plt.ylabel('Gap Statistic')
plt.title('Método del Gap Statistic para determinar K óptimo')
plt.grid(True)
plt.show()

En este ejemplo:

• Se define una función calcular_gap_statistic que estima el Gap Statistic para diferentes valores de $( K )$.
• Se comparan las dispersiones intraclúster de los datos reales con las de datos de referencia aleatorios.
• El valor óptimo de $( K )$ es aquel donde el Gap Statistic alcanza un máximo, indicando una mejor separación entre clústeres que lo esperado por azar.

Es importante mencionar que la selección del número óptimo de clústeres no siempre se resuelve con una única métrica. Es recomendable combinar diferentes métodos y considerar el conocimiento previo sobre los datos y el contexto del problema.

Además de las métricas mencionadas, otra estrategia es utilizar el Análisis de Componentes Principales (PCA) para visualizar la estructura de los datos en dimensiones reducidas. Aunque PCA no determina el número de clústeres, puede revelar patrones que ayuden en la decisión.

Un ejemplo de cómo combinar PCA con la evaluación de $( K )$:

from sklearn.decomposition import PCA

# Reducción de dimensionalidad a dos componentes
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# Aplicación de KMeans con el K seleccionado
k_optimo = 4  # Supongamos que K=4 es el óptimo según las métricas
kmeans = KMeans(n_clusters=k_optimo, random_state=42)
labels = kmeans.fit_predict(X)

# Visualización de los clústeres en el espacio reducido
plt.figure(figsize=(8, 6))
scatter = plt.scatter(X_pca[:, 0], X_pca[:, 1], c=labels, cmap='viridis', edgecolor='k')
plt.title(f'Clustering con KMeans para K={k_optimo}')
plt.xlabel('Componente Principal 1')
plt.ylabel('Componente Principal 2')
plt.grid(True)
plt.legend(*scatter.legend_elements(), title="Clústeres")
plt.show()

En este código:

• Se proyectan los datos a dos dimensiones con PCA.
• Se aplica KMeans con el número de clústeres seleccionado previamente.
• Se visualizan los clústeres resultantes, facilitando la interpretación de la estructura encontrada.

Finalmente, es esencial tener en cuenta las limitaciones de cada método. Por ejemplo, los índices de Calinski-Harabasz y Davies-Bouldin asumen clústeres convexos y esféricos, lo cual puede no ser adecuado para todos los conjuntos de datos. Además, factores como el tamaño del conjunto de datos y la presencia de ruido pueden influir en las métricas.

En situaciones donde los datos presentan complejidad, es útil complementar el análisis con técnicas como:

• Validación cruzada en clustering, aunque es un concepto más complejo en aprendizaje no supervisado.
• Algoritmos de clustering que estiman $( K )$ automáticamente, como DBSCAN, aunque esto implica cambiar de algoritmo.
• Análisis de estabilidad del clustering, evaluando cómo cambian los clústeres ante pequeñas perturbaciones en los datos.

En conclusión, la selección del número óptimo de clústeres es un proceso que requiere una combinación de métricas cuantitativas, visualizaciones y conocimiento del dominio. Emplear múltiples enfoques proporciona una visión más completa y aumenta la confianza en la decisión tomada.

Casos de uso de KMeans

El algoritmo KMeans es ampliamente utilizado en diversos campos gracias a su capacidad para agrupar datos de manera eficiente. A continuación se presentan algunos casos de uso donde KMeans aporta valor en el análisis y procesamiento de datos.

• Segmentación de clientes en marketing: En el ámbito del marketing, es fundamental entender y segmentar a los clientes para personalizar estrategias y ofertas. Utilizando KMeans, es posible agrupar clientes según sus comportamientos de compra, preferencias y características demográficas. Por ejemplo, agrupando a los clientes en función de su frecuencia de compra, monto gastado y tipos de productos adquiridos.

import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

# Carga de datos de clientes
data = pd.read_csv('datos_clientes.csv')

# Selección de características relevantes
features = data[['frecuencia_compra', 'monto_gastado', 'numero_productos']]

# Escalado de las características
scaler = StandardScaler()
X_scaled = scaler.fit_transform(features)

# Aplicación de KMeans
kmeans = KMeans(n_clusters=4, random_state=42)
data['segmento'] = kmeans.fit_predict(X_scaled)

# Análisis de resultados
print(data.groupby('segmento').mean())

En este ejemplo, se carga un conjunto de datos con información de clientes, se seleccionan las características relevantes y se aplican técnicas de escalado. Posteriormente, KMeans asigna a cada cliente un segmento, permitiendo a la empresa adaptar sus estrategias de marketing a cada grupo específico.

• Compresión y segmentación de imágenes: KMeans es útil en procesamiento de imágenes para la reducción de colores y segmentación. Al reducir el número de colores en una imagen, se obtiene una representación más simple sin perder información esencial. Esto se logra agrupando los píxeles con valores de color similares.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from skimage import io

# Carga de la imagen
imagen = io.imread('imagen.jpg')
ancho, alto, canales = imagen.shape
datos_imagen = imagen.reshape(ancho * alto, canales)

# Aplicación de KMeans para reducir colores
kmeans = KMeans(n_clusters=8, random_state=42)
kmeans.fit(datos_imagen)
colores_comprimidos = kmeans.cluster_centers_.astype('uint8')
píxeles_etiquetados = kmeans.labels_

# Reconstrucción de la imagen comprimida
imagen_comprimida = colores_comprimidos[píxeles_etiquetados]
imagen_comprimida = imagen_comprimida.reshape(ancho, alto, canales)

# Visualización de la imagen original y comprimida
fig, axs = plt.subplots(1, 2, figsize=(10, 5))
axs[0].imshow(imagen)
axs[0].set_title('Imagen Original')
axs[0].axis('off')

axs[1].imshow(imagen_comprimida)
axs[1].set_title('Imagen Comprimida con KMeans')
axs[1].axis('off')

plt.show()

En este código, se carga una imagen y se reorganiza en una matriz donde cada fila representa un píxel y sus valores RGB. Al aplicar KMeans, se agrupan los colores similares. La imagen se reconstruye utilizando los centroides de los clústeres, resultando en una imagen con una paleta de colores reducida.

• Análisis de comportamiento en redes sociales: Las plataformas de redes sociales generan grandes cantidades de datos sobre el comportamiento de los usuarios. KMeans permite agrupar usuarios según su interacción, publicaciones y preferencias, facilitando el análisis de tendencias y la detección de comunidades.
• Agrupación de documentos en procesamiento de lenguaje natural: En el campo del NLP (Natural Language Processing), KMeans se utiliza para agrupar documentos o textos similares. Al transformar los textos en vectores numéricos mediante técnicas como TF-IDF, es posible aplicar KMeans para identificar temas o categorías comunes.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans

# Lista de documentos de ejemplo
documentos = [
    "El gato se sentó en la alfombra",
    "El perro ladró toda la noche",
    "La economía global está en crecimiento",
    "Los mercados financieros registran ganancias",
    # Más documentos...
]

# Vectorización TF-IDF
vectorizador = TfidfVectorizer()
X = vectorizador.fit_transform(documentos)

# Aplicación de KMeans
kmeans = KMeans(n_clusters=2, random_state=42)
labels = kmeans.fit_predict(X)

# Visualización de resultados
for i, documento in enumerate(documentos):
    print(f'Documento {i}: Clúster {labels[i]}')

Este ejemplo muestra cómo se pueden agrupar documentos según su contenido temático. Los textos se convierten en una matriz de características utilizando TfidfVectorizer, y KMeans asigna cada documento a un clúster.

• Segmentación de clientes en telecomunicaciones: Las empresas de telecomunicaciones pueden utilizar KMeans para identificar patrones de uso entre sus clientes. Al analizar datos como duración de llamadas, uso de datos y servicios adicionales, es posible crear perfiles que ayuden en la retención de clientes y en la oferta de servicios personalizados.
• Agrupación de datos geográficos: En sistemas de información geográfica, KMeans puede agrupar ubicaciones geoespaciales para identificar regiones con características similares. Esto es útil en planificación urbana, análisis de mercados y estudios ambientales.

import pandas as pd
from sklearn.cluster import KMeans
import folium

# Datos de ubicaciones (ejemplo con latitud y longitud)
ubicaciones = pd.read_csv('datos_geograficos.csv')

# Selección de características
coordenadas = ubicaciones[['latitud', 'longitud']]

# Aplicación de KMeans
kmeans = KMeans(n_clusters=5, random_state=42)
ubicaciones['clúster'] = kmeans.fit_predict(coordenadas)

# Visualización en mapa
mapa = folium.Map(location=[coordenadas['latitud'].mean(), coordenadas['longitud'].mean()], zoom_start=5)
colores = ['red', 'blue', 'green', 'purple', 'orange']

for _, row in ubicaciones.iterrows():
    folium.CircleMarker(
        location=[row['latitud'], row['longitud']],
        radius=5,
        color=colores[row['clúster']],
        fill=True,
        fill_color=colores[row['clúster']]
    ).add_to(mapa)

mapa.save('mapa_clústeres.html')

En este caso, se utilizan las coordenadas geográficas para agrupar ubicaciones. Después de aplicar KMeans, los resultados se visualizan en un mapa interactivo utilizando la biblioteca Folium, donde cada clúster se representa con un color diferente.

• Análisis de datos genómicos y bioinformática: KMeans se emplea para agrupar genes o muestras biológicas según patrones de expresión genética. Esto ayuda a identificar grupos funcionales o a descubrir enfermedades relacionadas.
• Detección de anomalías en seguridad informática: En ciberseguridad, KMeans puede ayudar a detectar comportamientos anómalos al agrupar actividades normales y resaltar aquellas que no encajan en ningún clúster, lo que indica posibles amenazas o intrusiones.
• Planificación de redes y logística: Las empresas de logística utilizan KMeans para optimizar rutas y ubicar centros de distribución al agrupar destinos cercanos, mejorando la eficiencia y reduciendo costos.
• Análisis financiero y bursátil: En finanzas, KMeans ayuda a agrupar activos o comportamientos de mercado similares, facilitando la creación de portafolios diversificados y el análisis de riesgos.