Como podemos medir el performance de este modelo?

En el curso de clustering con Python y Scikit-learn enseñan varias formas, la más común es el coeficiente de silueta (Silhouette Coefficient): Esta métrica cuantifica cuán bien separados están los clusters. Puede tomar valores entre -1 y 1, donde un valor más cercano a 1 indica que los puntos en un cluster están más cerca entre sí y más lejos de los puntos en otros clusters. También sirve visualizar los datos graficando los centroides si es kmeans o si es jerárquico (aglomerativo o divisivo) el diagrama de dendrograma.

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)

Buena info! Gracias DataEngel :D

Normalmente, la agrupación en clústeres se considera un método no supervisado, por lo que es difícil establecer una buena métrica de rendimiento (como también se sugirió en los comentarios anteriores).

No obstante, se puede extrapolar mucha información útil de estos algoritmos (por ejemplo, k-medias). El problema es cómo asignar una semántica a cada grupo y así medir el "rendimiento" de su algoritmo. En muchos casos, una buena forma de proceder es mediante una visualización de sus clústeres. Obviamente, si sus datos tienen características de alta dimensión, como sucede en muchos casos, la visualización no es tan fácil. Permítanme sugerir dos caminos a seguir, usando k-means y otro algoritmo de agrupamiento.

• K-mean : en este caso, puede reducir la dimensionalidad de sus datos utilizando, por ejemplo, PCA . Con dicho algoritmo, puede trazar los datos en un gráfico 2D y luego visualizar sus grupos. Sin embargo, lo que ve en este gráfico es una proyección en un espacio 2D de sus datos, por lo que puede no ser muy preciso, pero puede darle una idea de cómo se distribuyen sus clústeres.

• Self-organizing map: es un algoritmo de agrupamiento basado en redes neuronales que crea una representación discretizada del espacio de entrada de las muestras de entrenamiento, llamado mapa, y es, por lo tanto, un método para realizar la reducción de dimensionalidad ( SOM ). Puede encontrar un paquete de Python muy agradable llamado somoclu que tiene este algoritmo implementado y una forma fácil de visualizar el resultado. Este algoritmo también es muy bueno para la agrupación en clústeres porque no requiere una selección a priori del número de clústeres (en k-mean debe elegir k, aquí no).