Implementación de Batch K-Means

Les comparto una gráfica con las variables del dataset candy pareadas.

import seaborn as sns
sns.pairplot(dataset, hue='group')

Por otra parte acá también les comparto enfocadas las variables, sugarpercent, pricepercent y winpercent. Se puede observar como el algoritmo de clustering puede generar los grupos que son imposibles de notar a simple vista.

sns.pairplot(dataset[['sugarpercent','pricepercent','winpercent','group']], hue = 'group')

Hola, compañeros. Aquí les dejo una visualización de los datos coloreados por el grupo al que pertenecen. Hice un scatter con las variables que pueden ver en los ejes, por supuesto que pueden existir otras formas de visualizar cambiando los ejes de la scatter.
Saludos! 😃

Antes de implementar el algoritmo de clusterización es bueno normalizar los datos como habíamos visto en clases pasadas, ya que si se dan cuenta está tomando como referencia la columna con valores más grandes del dataframe, que en este caso es “winpercent” y clasificando por puntaje, y no es el objetivo del algoritmo.

les paso mi version del codigo:

import pandas as pd

from sklearn.cluster import MiniBatchKMeans


if __name__ == "__main__":
    
    path = './K-Means/data/candy.csv'
    dataset = pd.read_csv(path)

    print(dataset.head(5))

    x = dataset.drop('competitorname', axis=1)
    kmeans = MiniBatchKMeans(n_clusters=4, batch_size=8).fit(x)

    print('')
    print('Total de centros:', len(kmeans.cluster_centers_))

    print('')
    print('Predicciones:', kmeans.predict(x))

    dataset['Grupo'] = kmeans.predict(x)
    print(dataset)

    # Ahora mando los datos a un archivo excel :)

    writer = pd.ExcelWriter('./K-Means/data/candy_usuario.xlsx', engine='xlsxwriter')
    dataset.to_excel(writer, sheet_name='usuario')
    writer.save()

Le pregunté a ChatGPT que me ampliara un poquito la información sobre MiniBatchKmeans y esta fue su respuesta:

MiniBatchKMeans es una variante del clásico algoritmo de agrupamiento K-means diseñada para funcionar eficientemente con conjuntos de datos grandes. K-means es un algoritmo de aprendizaje no supervisado utilizado para agrupar datos en K grupos según sus similitudes de características. Su objetivo es minimizar la suma de las distancias al cuadrado entre los puntos de datos y los centroides de sus respectivos grupos.

El algoritmo K-means estándar puede ser computacionalmente costoso, especialmente para conjuntos de datos grandes, ya que requiere calcular las distancias entre todos los puntos de datos y todos los centroides de los grupos en cada iteración. Esto puede ser problemático cuando se trabaja con conjuntos de datos grandes que no caben en la memoria.

MiniBatchKMeans aborda este problema utilizando mini-batches de datos para cada iteración, en lugar de utilizar todo el conjunto de datos. Se toma una muestra aleatoria de puntos de datos (mini-batch) y se actualizan los centroides de los grupos utilizando esta muestra en cada iteración. Este enfoque es más eficiente computacionalmente, ya que requiere menos cálculos de distancias y permite procesar conjuntos de datos grandes sin consumir una cantidad excesiva de memoria.

Beneficios clave de MiniBatchKMeans:

Mayor velocidad de cálculo: Al utilizar mini-batches, el algoritmo puede procesar conjuntos de datos grandes de manera más eficiente, lo que lo hace adecuado para escenarios de big data.

Escalabilidad: Puede manejar conjuntos de datos que no caben en la memoria, ya que opera con subconjuntos más pequeños de datos a la vez.

Eficiencia de memoria: Debido a su naturaleza iterativa, consume menos memoria en comparación con el algoritmo K-means estándar.

Sin embargo, existe un equilibrio con MiniBatchKMeans. El uso de mini-batches introduce cierto nivel de aleatoriedad, lo que puede resultar en asignaciones de grupos menos estables y soluciones potencialmente subóptimas en comparación con el algoritmo K-means clásico. No obstante, en la práctica, MiniBatchKMeans suele proporcionar buenos resultados de agrupamiento mientras reduce significativamente los requisitos computacionales.

En resumen, MiniBatchKMeans es una herramienta valiosa cuando se trabaja con conjuntos de datos grandes y recursos de memoria limitados, proporcionando una solución eficiente y escalable para tareas de agrupamiento.

from matplotlib import pyplot as plt
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
import seaborn as sns
from xlsxwriter import Workbook

from sklearn.cluster import MiniBatchKMeans
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA


if __name__ == "__main__":

    dataset = pd.read_csv('./data/candy.csv')

    X_cols = list(set(dataset.columns)-set(['competitorname']))
    X = dataset[X_cols].values
    sc_x = StandardScaler()

    #standarizacion de los datos
    X_std = sc_x.fit_transform(X)

    kmeans = MiniBatchKMeans(n_clusters=4, batch_size=8).fit(X_std)
    print(f'Total de centros: {len(kmeans.cluster_centers_)}')
    print("="*64)
    print(f'Predicciones: {kmeans.predict(X_std)}')

    dataset['group'] = kmeans.predict(X_std)

    print(dataset['group'].value_counts())

    # Ahora mando los datos a un archivo excel :)
    # with pd.ExcelWriter('data/candy_usuario.xlsx', engine="xlsxwriter") as writer:
    #     dataset.to_excel(writer, sheet_name='usuario')

    # dataset.to_excel(r'data/candy_usuario.xlsx', sheet_name='usuario', index = False)
    #implementacion_k_means

    # sns.scatterplot(data=dataset, x="sugarpercent", y="winpercent", hue="group", palette="deep")
    #
    # sns.pairplot(dataset[['sugarpercent', 'pricepercent', 'winpercent', 'group']], hue='group')



    '''Realizado por mi para ver las graficas y los centroides de manera visual'''
    def pca_fun(n_components, data):
        pca = PCA(n_components=n_components).fit(data)
        data = pca.transform(data)
        return data

    pca_data = pca_fun(2,X_std)

    kmeans = MiniBatchKMeans(n_clusters=4, batch_size=8).fit(pca_data)

    fig = px.scatter(
        x=pca_data[:, 0],
        y=pca_data[:, 1],
        color=kmeans.predict(pca_data))
    # Aqui anexamos a la misma figura cada trazo

    fig.add_trace(go.Scatter(
        x=kmeans.cluster_centers_[:, 0],
        y=kmeans.cluster_centers_[:, 1],
        mode='markers', marker=dict(size=20,
        color= 'white'), name='Centroides'
    ))

    fig.update_layout(title=f'Visualizacion de centroides sobre PCA de 2 componentes, se escalo data antes de PCA', coloraxis_showscale=False)
    fig.show()



    ##################### PCA 3 componentes
    pca_data = pca_fun(3,X_std)

    kmeans = MiniBatchKMeans(n_clusters=4, batch_size=8).fit(pca_data)

    fig = px.scatter_3d(
        x=pca_data[:, 0],
        y=pca_data[:, 1],
        z=pca_data[:, 2],
        color=kmeans.predict(pca_data))
    # Aqui anexamos a la misma figura cada trazo

    fig.add_trace(go.Scatter3d(
        x=kmeans.cluster_centers_[:, 0],
        y=kmeans.cluster_centers_[:, 1],
        z=kmeans.cluster_centers_[:, 2],
        mode='markers', marker=dict(size=20,
        color= 'white'), name='Centroides'
    ))

    fig.update_layout(title=f'Visualizacion de centroides sobre PCA de 3 componentes, se escalo data antes de PCA', coloraxis_showscale=False)
    fig.show()

    '''No funciona somoclu al parecer por el python usado. 3.10. (no pienso bajar mi version de python ya que quiero aprender a usar match case) https://github.com/peterwittek/somoclu/issues/144,
    link de fuente para implementacion de esta libreria:
    https://www.kaggle.com/code/phyothuhtet/document-clustering-self-organizing-map-kmeans'''

    # import somoclu
    #
    # def som(data):
    #     som = somoclu.Somoclu(50, 50, data=data, maptype="toroid")
    #     %time som = som.train(data)
    #     print("Comonent Planes")
    #     return som
    #
    # som = som(pca_data)
    #
    # #Exploring Component Planes
    # #labels is 0 to n(document-0, document-1,...documentn)
    # labels = range(0,pca_data.shape[0])
    #
    # # Step4: Exploring Content Planes
    # som.view_component_planes()
    #
    # # Step 5: Exploring clusters by SOM reinforced with  Doc2Vec
    # som.view_umatrix(bestmatches = True)

Se me hace curioso el hecho de que la columna ‘winpercent’ parece ser la que hace todo el trabajo de agrupación. Si eliminamos esa columna, vemos con las gráficas que no se encuentra ningún patrón claro en el dataset.

Para los que usan colab:

candy.to_excel( “candy.xlsx”,index=False)

donde candy es el nombre de mi dataset y pongo index=False para que no me aparezca 0,1,2, a mi lado izquierdo del excel y tenga una mejor presentación

Ojo lo que esta haciendo de reemplazar la columna group por los valores predichos por el modelo lo esta haciendo porque K-means es un modelo de aprendizaje no supervisado, el modelo es el que se encarga de hacer la clasificacion.

La implementación de Batch K-Means es una variante eficiente del algoritmo de clustering K-Means tradicional. En el estándar K-Means, se actualizan los centroides en cada iteración para cada punto de datos, lo que puede ser costoso en términos computacionales cuando se con grandes conjuntos de datos. En Batch K-Means, en lugar de actualizar los centroides para cada punto de datos en cada iteración, se actualizan utilizando un conjunto de datos de muestra más pequeño o “mini lotes”.

Que importante la clusterización para el análisis de datos.

Así queda la visualización final cuando exportamos el archivo final en Excel

Y este es el código para exportar el archivo.

Debemos instalar → pip install openpyxl

Import os

    # Para exportar el archivo a Excel

    # Carpeta donde se guardará el archivo
    output_folder = 'C:/Users/ASUS/resultados_kmeans.xlsx'
    os.makedirs(output_folder, exist_ok=True)  # Crear la carpeta si no existe

    # Exportar el DataFrame a Excel en la carpeta especificada
    output_file = os.path.join(output_folder, 'resultados_kmeans.xlsx')
    dataset.to_excel(output_file, index=False)

Les comaprto el gráfico que obtuve con las 4 categorías comparando las variables de porcentaje de azucar y winnerpercent

    my_palette = ["#1abc9c", "#3498db", "#9b59b6", "#34495e"]
    sns.scatterplot(data=data,x='sugarpercent',y='winpercent', hue='grupos', palette=my_palette)
    plt.grid(color='gray', linestyle=':', linewidth=0.5, zorder=0)
    plt.savefig('plot.png')
    plt.show()

imprimir cluster en grafica 2D usando PCA

dataset = pd.read_csv('./datasets/candy.csv')

# eliminaremos los nombres de los caramelos ya que es categorica
X = dataset.drop('competitorname', axis=1)
X.head(3)
 

kmeans = MiniBatchKMeans(n_clusters=4,  #definiremos 4 grupos 
                            batch_size=8).fit(X) # la cantidad de datos por lote para aligerar el computo 

print('Total de centros: ', len(kmeans.cluster_centers_))
print('*'*64)

# guardamos la etiqueta de cada grupo en el DS
print(kmeans.predict(X))
print('*'*64)
X['cluster'] = kmeans.predict(X)

print(X.head(3))

aqui importamos el modulo de PCA es facil de usar

from sklearn.decomposition import PCA

model_PCA = PCA(n_components=2) # instanciamos el modelo 
data_PCA = model_PCA.fit_transform(X) # realizamos tranformacion
df_PCA = pd.DataFrame(data= data_PCA, columns= ["PCA1","PCA2"])
df_PCA = pd.concat([df_PCA, X['cluster']], axis=1)

x = sns.scatterplot(x = "PCA1", y = "PCA2", 
hue = "cluster", data = df_PCA, palette = ["red", "green", "blue", "black"])
plt.show()

Excelente clase

yo para exporta el dataset a excel primeto tuve que instalar openpyxl en Anaconda y de hay fue facil :
dataset.to_excel(r’data/candy_usuario.xlsx’,sheet_name=‘usuario’, index = False)