Tutorial PySpark: Modelos de clustering

KMeans

El algoritmo KMeans es una técnica de clustering ampliamente utilizada en aprendizaje automático no supervisado. En PySpark MLlib, KMeans permite agrupar datos en clusters basados en similitud, facilitando la identificación de patrones y estructuras ocultas en grandes volúmenes de datos.

Para aplicar KMeans con PySpark, es necesario preparar los datos adecuadamente. Los datos deben estar en un DataFrame y las características deben combinarse en un vector único utilizando VectorAssembler:

from pyspark.ml.feature import VectorAssembler

# Supongamos que 'data' es un DataFrame con columnas numéricas 'caracteristica1', 'caracteristica2', 'caracteristica3'
assembler = VectorAssembler(inputCols=['caracteristica1', 'caracteristica2', 'caracteristica3'], outputCol='features')
data_features = assembler.transform(data)

Una vez preparadas las características, se puede configurar y entrenar el modelo KMeans:

from pyspark.ml.clustering import KMeans

# Configuración del modelo KMeans
kmeans = KMeans(k=4, seed=42, featuresCol='features')
model = kmeans.fit(data_features)

# Realizar predicciones y asignar clusters
predicciones = model.transform(data_features)

En este ejemplo, se establece k=4, es decir, se buscan cuatro clusters en los datos. El parámetro seed asegura la reproducibilidad de los resultados al inicializar el algoritmo de manera consistente.

Para evaluar la calidad del clustering, se utiliza el costo dentro del conjunto (Within Set Sum of Squared Errors, WSSSE), que mide la suma de las distancias al cuadrado de los puntos al centroide de sus clusters:

costo = model.summary.trainingCost
print(f"Costo WSSSE del modelo KMeans: {costo}")

Es posible acceder a los centroides de cada cluster para analizar las características de cada grupo:

centroides = model.clusterCenters()
for idx, centroide in enumerate(centroides):
    print(f"Centroide del cluster {idx}: {centroide}")

Si se desea mejorar el rendimiento del modelo, es recomendable ajustar los hiperparámetros o preprocesar los datos. Una práctica común es escalar o normalizar las características, especialmente si están en diferentes escalas:

from pyspark.ml.feature import StandardScaler

scaler = StandardScaler(inputCol='features', outputCol='scaledFeatures', withStd=True, withMean=False)
scaler_model = scaler.fit(data_features)
data_scaled = scaler_model.transform(data_features)

Después de escalar las características, se entrena nuevamente el modelo utilizando la columna scaledFeatures:

kmeans = KMeans(k=4, seed=42, featuresCol='scaledFeatures')
model = kmeans.fit(data_scaled)
predicciones = model.transform(data_scaled)

PySpark MLlib también permite utilizar la inicialización k-means||, que es una mejora del método tradicional para seleccionar centros iniciales y puede conducir a mejores resultados:

kmeans = KMeans(k=4, seed=42, initMode='k-means||', featuresCol='scaledFeatures')
model = kmeans.fit(data_scaled)

Para determinar el número óptimo de clusters k, se puede realizar un análisis de la curva del codo (elbow method), iterando sobre diferentes valores de k y observando el comportamiento del costo WSSSE.

El uso de KMeans en PySpark MLlib permite aprovechar las capacidades de procesamiento distribuido de Spark, lo que es especialmente útil al trabajar con grandes conjuntos de datos en entornos de Big Data.

Gaussian Mixture Models

Los Gaussian Mixture Models (GMMs) son modelos probabilísticos utilizados para representar la presencia de subpoblaciones dentro de un conjunto de datos sin necesidad de conocer a priori a qué subpoblación pertenece cada observación. En el contexto de PySpark MLlib, los GMMs permiten realizar clustering asumiendo que los datos provienen de una combinación de distribuciones gaussianas.

A diferencia de KMeans, que asigna cada punto al cluster más cercano basándose en la distancia euclidiana, los GMMs proporcionan una probabilidad de pertenencia de cada punto a cada cluster. Esto es especialmente útil cuando los clusters tienen formas elipsoidales, tamaños diferentes o cuando existe solapamiento entre ellos.

Para utilizar GMMs en PySpark, es necesario preparar los datos y ensamblar las características en un vector utilizando VectorAssembler:

from pyspark.ml.feature import VectorAssembler

# Supongamos que 'data' es un DataFrame con columnas numéricas 'feature1' y 'feature2'
assembler = VectorAssembler(inputCols=['feature1', 'feature2'], outputCol='features')
data_features = assembler.transform(data)

Una vez preparadas las características, se puede configurar y entrenar el modelo GaussianMixture:

from pyspark.ml.clustering import GaussianMixture

# Configuración del modelo GMM
gmm = GaussianMixture(featuresCol='features', k=3, seed=42)
model = gmm.fit(data_features)

En este ejemplo, se establece k=3, indicando que se buscan tres componentes gaussianas en los datos. El parámetro seed garantiza la reproducibilidad del modelo al inicializar los parámetros de manera consistente.

Después de entrenar el modelo, es posible obtener las predicciones y las probabilidades de pertenencia:

# Obtener predicciones y probabilidades
predicciones = model.transform(data_features)
predicciones.select('feature1', 'feature2', 'prediction', 'probability').show(truncate=False)

La columna 'prediction' indica el cluster asignado a cada punto, mientras que 'probability' muestra un vector con las probabilidades de pertenencia a cada cluster, proporcionando una visión más detallada de la estructura de los datos.

Los parámetros de las distribuciones gaussianas pueden ser accesibles para análisis adicionales:

# Obtener parámetros de los componentes gaussianos
for i in range(model.getK()):
    mean = model.gaussiansDF.collect()[i]['mean']
    cov = model.gaussiansDF.collect()[i]['cov']
    print(f"Componente {i}:")
    print(f" - Media: {mean}")
    print(f" - Covarianza:\n{cov}\n")

Estos parámetros permiten comprender la forma y orientación de cada componente gaussiana, siendo útiles para la interpretación del modelo y la visualización de los clusters.

Se entrena el modelo utilizando la columna 'scaledFeatures' (las características previamente escaladas):

# Entrenar el modelo GMM con características escaladas
gmm = GaussianMixture(featuresCol='scaledFeatures', k=3, seed=42)
model = gmm.fit(data_scaled)

El uso de Gaussian Mixture Models en PySpark MLlib es especialmente valioso en aplicaciones donde los datos presentan estructuras complejas. Al proporcionar una asignación probabilística de los puntos a los clusters, los GMMs ofrecen una mayor flexibilidad y una comprensión más profunda de los patrones subyacentes en conjuntos de datos de gran tamaño.

Evaluación de modelos de clustering

Evaluar la calidad de los modelos de clustering es esencial para entender la validez y utilidad de los grupos formados en el aprendizaje automático no supervisado. Dado que no se dispone de etiquetas predefinidas, es necesario utilizar métricas que midan la cohesión interna de los clusters y la separación entre ellos.

Una de las métricas más utilizadas es el índice de Silhouette, que cuantifica qué tan similar es un punto a su propio cluster en comparación con otros clusters. Los valores del índice de Silhouette oscilan entre -1 y 1, donde valores cercanos a 1 indican una asignación adecuada. En PySpark MLlib, se puede calcular este índice utilizando la clase ClusteringEvaluator.

Para calcular el índice de Silhouette, primero se ajusta el modelo de clustering y se generan las predicciones. A continuación, se emplea ClusteringEvaluator para evaluar el modelo:

from pyspark.ml.evaluation import ClusteringEvaluator

# 'predicciones' es el DataFrame resultante tras aplicar el clustering
evaluator = ClusteringEvaluator(featuresCol='features', metricName='silhouette', distanceMeasure='squaredEuclidean')

silhouette = evaluator.evaluate(predicciones)
print(f"Índice de Silhouette: {silhouette}")

En este ejemplo, se especifica la columna de características 'features', se elige 'silhouette' como métrica y 'squaredEuclidean' como medida de distancia. El resultado proporciona una medida de la cohesión de los clusters y la separación entre ellos.

Otra métrica relevante es el Within Set Sum of Squared Errors (WSSSE), que mide la suma de las distancias al cuadrado de los puntos al centroide de sus clusters. Esta métrica es útil para comparar modelos con diferentes números de clusters y puede ayudar a identificar el número óptimo de clusters al aplicar el método del codo.

El método del codo consiste en entrenar modelos con diferentes valores de k (número de clusters) y representar la variación de WSSSE o el índice de Silhouette en función de k. El punto donde la mejora comienza a ser marginal (formando un "codo" en la gráfica) sugiere el número apropiado de clusters.

Además de las métricas cuantitativas, es importante considerar la interpretabilidad de los clusters. Visualizar los clusters y analizar las características principales de cada grupo puede proporcionar información valiosa sobre la naturaleza de los datos y la relevancia práctica del modelo.

La evaluación de modelos de clustering en PySpark MLlib es un proceso integral que combina métricas internas, como el índice de Silhouette, con análisis cualitativos. El uso de herramientas integradas como ClusteringEvaluator facilita la implementación de estas métricas y la comparación de diferentes modelos para optimizar los resultados en proyectos de Big Data.