Scikit K-means mesure de la performance de clustering
J'essaie de faire un clustering avec la méthode K-means mais j'aimerais mesurer la performance de mon clustering ... Je ne suis pas un expert, mais je suis désireux d'en apprendre plus sur le clustering.
Voici mon code:
import pandas as pd
from sklearn import datasets
#loading the dataset
iris = datasets.load_iris()
df = pd.DataFrame(iris.data)
#K-Means
from sklearn import cluster
k_means = cluster.KMeans(n_clusters=3)
k_means.fit(df) #K-means training
y_pred = k_means.predict(df)
#We store the K-means results in a dataframe
pred = pd.DataFrame(y_pred)
pred.columns = ['Species']
#we merge this dataframe with df
prediction = pd.concat([df,pred], axis = 1)
#We store the clusters
clus0 = prediction.loc[prediction.Species == 0]
clus1 = prediction.loc[prediction.Species == 1]
clus2 = prediction.loc[prediction.Species == 2]
k_list = [clus0.values, clus1.values,clus2.values]
Maintenant que mes KMeans et mes trois clusters sont stockés, j'essaie d'utiliser le Dunn Index pour mesurer les performances de mon cluster (nous cherchons le plus grand index) Pour cela, j'importe le jqm_cvi package (disponible ici )
from jqmcvi import base
base.dunn(k_list)
Ma question est la suivante: existe-t-il déjà une évaluation interne de clustering dans Scikit Learn (sauf à partir de silhouette_score)? Ou dans une autre bibliothèque bien connue?
Merci pour votre temps
Normalement, le regroupement est considéré comme une méthode non supervisée et il est donc difficile d’établir une bonne mesure de performance (comme suggéré également dans les commentaires précédents).
Néanmoins, beaucoup d’informations utiles peuvent être extrapolées à partir de ces algorithmes (par exemple, k-means). Le problème est de savoir comment attribuer une sémantique à chaque cluster et mesurer ainsi la "performance" de votre algorithme. Dans de nombreux cas, une bonne façon de procéder consiste à visualiser vos clusters. Évidemment, si vos données ont des caractéristiques de grandes dimensions, comme cela arrive souvent, la visualisation n’est pas aussi simple. Permettez-moi de suggérer deux solutions: utiliser k-means et un autre algorithme de classification.
K-mean: dans ce cas, vous pouvez réduire la dimensionnalité de vos données en utilisant par exemple PCA . En utilisant cet algorithme, vous pouvez tracer les données dans un tracé 2D, puis visualiser vos grappes. Cependant, ce que vous voyez dans ce graphique est une projection dans un espace 2D de vos données. Par conséquent, cela peut ne pas être très précis, mais vous donner une idée de la répartition de vos clusters.
Carte auto-organisée, il s’agit d’un algorithme de classification basé sur des réseaux de neurones, qui crée une représentation discrétisée de l’espace d’entrée des échantillons d’apprentissage, appelée carte, et constitue donc une méthode permettant de réduire les dimensions ( SOM ). Vous pouvez trouver un paquetage python très agréable appelé somoclu qui a implémenté cet algorithme et un moyen simple de visualiser le résultat. Cet algorithme est très bon pour le clustering également car il ne nécessite pas de sélection a priori du nombre de cluster (dans k-mean, vous devez choisir k, ici non).
Outre le score Silhouette, le critère Elbow Criterion peut être utilisé pour évaluer la classification K-Mean. Il n’est pas disponible en tant que fonction/méthode dans Scikit-Learn. Nous devons calculer SSE pour évaluer la classification K-Means à l'aide du critère de coude.
L'idée de la méthode Elbow Criterion est de choisir la variable k (no of cluster) à laquelle le SSE diminue brusquement. Le SSE est défini comme la somme de la distance au carré entre chaque membre du groupe et son centre de gravité.
Calculez la somme de l'erreur au carré (SSE) pour chaque valeur de k, où k est no. of cluster et tracez le graphique linéaire. SSE tend à décroître vers 0 à mesure que nous augmentons k (SSE = 0, lorsque k est égal au nombre de points de données dans le jeu de données, car chaque point de données est son propre cluster et il n'y a pas d'erreur entre et le centre de son cluster).
L’objectif est donc de choisir une petite valeur de k qui a toujours un low SSE, et le coude représente généralement, où nous commençons à avoir des rendements décroissants en augmentant k.
Exemple de jeu de données Iris:
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris['feature_names'])
#print(X)
data = X[['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)']]
sse = {}
for k in range(1, 10):
kmeans = KMeans(n_clusters=k, max_iter=1000).fit(data)
data["clusters"] = kmeans.labels_
#print(data["clusters"])
sse[k] = kmeans.inertia_ # Inertia: Sum of distances of samples to their closest cluster center
plt.figure()
plt.plot(list(sse.keys()), list(sse.values()))
plt.xlabel("Number of cluster")
plt.ylabel("SSE")
plt.show()
Si le graphique linéaire ressemble à un bras - un cercle rouge dans le graphique linéaire ci-dessus (comme un angle), le "coude" du bras correspond à la valeur de optimal k (nombre de groupes). Selon le graphique ci-dessus, le nombre de groupes optimaux est 3.
Remarque: Le critère de coude est de nature heuristique et peut ne pas fonctionner pour votre ensemble de données. Suivez l'intuition en fonction du jeu de données et du problème que vous essayez de résoudre .
J'espère que ça aide!