Évaluation Interne

Comme dans toute tâche d'apprentissage automatique, nous nous appuyons sur des métriques spécifiques pour évaluer la qualité du clustering : l'une des classes de ces métriques est celle des métriques internes.

Les métriques internes dans le clustering sont utilisées pour évaluer la qualité des résultats de clustering basés sur les données sans utiliser d'informations ou d'étiquettes externes. Ces métriques fournissent une mesure quantitative de la qualité avec laquelle un algorithme de clustering a regroupé les points de données en clusters basés sur les caractéristiques intrinsèques des données : en particulier les distances intra- et inter-clusters.

Les métriques internes les plus couramment utilisées

Le score de silhouette mesure dans quelle mesure un point de données s'intègre dans son cluster assigné par rapport aux autres clusters.

Le score de silhouette est calculé comme suit :

Étape 1. Pour chaque point de données, calculez deux métriques :

a : La distance moyenne entre le point de données et tous les autres points du même cluster ;
b : La distance moyenne entre le point de données et tous les points du cluster le plus proche (c'est-à-dire le cluster qui est le plus similaire au point de données).

Étape 2. Calculez le score de silhouette pour chaque point de données en utilisant la formule suivante :

score de silhouette = (b - a) / max(a, b)

Étape 3. Calculez le score de silhouette global pour le clustering en prenant la moyenne de tous les scores pour tous les points.


              1234567891011121314151617181920212223242526272829303132333435363738394041424344
            
import matplotlib.pyplot as plt
from sklearn.metrics import silhouette_score
from sklearn.cluster import KMeans
from sklearn.datasets import make_moons, make_blobs, make_circles 
import warnings

warnings.filterwarnings('ignore')

# Create subplots for visualizations
fig, axes = plt.subplots(1, 3)
fig.set_size_inches(15, 5)  # Adjusted figure size

# Load circles dataset
X_circles, y = make_circles(n_samples=500, factor=0.2)

# Provide K-means clustering for circles dataset
clustering_circles = KMeans(n_clusters=2).fit(X_circles)

# Provide visualization and show silhouette for circles dataset
axes[0].scatter(X_circles[:, 0], X_circles[:, 1], c=clustering_circles.labels_, cmap='tab20b')
axes[0].set_title('Silhouette is: ' + str(round(silhouette_score(X_circles, clustering_circles.labels_), 3)))

# Load blobs dataset
X_blobs, y = make_blobs(n_samples=500, centers=2)

# Provide K-means clustering for blobs dataset
clustering_blobs = KMeans(n_clusters=2).fit(X_blobs)

# Provide visualization and show silhouette for blobs dataset
axes[1].scatter(X_blobs[:, 0], X_blobs[:, 1], c=clustering_blobs.labels_, cmap='tab20b')
axes[1].set_title('Silhouette is: ' + str(round(silhouette_score(X_blobs, clustering_blobs.labels_), 3)))

# Load moons dataset
X_moons, y = make_moons(n_samples=500)

# Provide K-means clustering for moons dataset
clustering_moons = KMeans(n_clusters=2).fit(X_moons)

# Provide visualization and show silhouette for moons dataset
axes[2].scatter(X_moons[:, 0], X_moons[:, 1], c=clustering_moons.labels_, cmap='tab20b')
axes[2].set_title('Silhouette is: ' + str(round(silhouette_score(X_moons, clustering_moons.labels_), 3)))

# Display the plots
plt.show()

Le coefficient de silhouette varie entre -1 et 1, avec :

-1 indiquant que le point de données n'est pas assigné au bon cluster ;
0 indiquant que les clusters se chevauchent ;
1 indique que le cluster est dense et bien séparé (donc la valeur souhaitable).

L'indice de Davies-Bouldin (DBI) est une métrique d'évaluation interne de clustering qui mesure la qualité du clustering en considérant à la fois la séparation entre les clusters et la compacité des clusters.

Le DBI est calculé comme suit :

Étape 1. Pour chaque cluster, calculez la distance moyenne entre son centroïde et tous les points de données dans ce cluster. Cela mesure la similarité du cluster ;

Étape 2. Pour chaque paire de clusters, calculez la distance entre leurs centroïdes. Cela mesure la dissimilarité entre les clusters ;

Étape 3. Pour chaque cluster, trouvez le cluster avec la plus grande similarité avec lui (en s'excluant lui-même) ;

Étape 4. Pour chaque cluster, calculez la somme de la similarité entre ce cluster et son voisin le plus proche, et divisez-la par le nombre de points de données dans le cluster. Cela vous donne le score DBI pour ce cluster ;

Étape 5. Enfin, calculez le score DBI global en prenant la moyenne des scores DBI pour tous les clusters.


              12345678910111213141516171819202122232425262728
            
import matplotlib.pyplot as plt
from sklearn.metrics import davies_bouldin_score
from sklearn.cluster import KMeans
from sklearn.datasets import make_moons, make_blobs, make_circles 
import warnings

warnings.filterwarnings('ignore')

fig, axes = plt.subplots(1, 3)
fig.set_size_inches(10, 5)

X_circles, y = make_circles(n_samples=500, factor=0.2)
clustering = KMeans(n_clusters=2).fit(X_circles)
# Provide visualization and show DBI for circles dataset
axes[0].scatter(X_circles[:, 0], X_circles[:, 1], c=clustering.labels_, cmap='tab20b')
axes[0].set_title('DBI is: '+ str(round(davies_bouldin_score(X_circles, clustering.labels_), 3)))

X_blobs, y = make_blobs(n_samples=500, centers=2)
clustering = KMeans(n_clusters=2).fit(X_blobs)
# Provide visualization and show DBI for blobs dataset
axes[1].scatter(X_blobs[:, 0], X_blobs[:, 1], c=clustering.labels_, cmap='tab20b')
axes[1].set_title('DBI is: '+ str(round(davies_bouldin_score(X_blobs, clustering.labels_), 3)))

X_moons, y = make_moons(n_samples=500)
clustering = KMeans(n_clusters=2).fit(X_moons)
# Provide visualization and show DBI for moons dataset
axes[2].scatter(X_moons[:, 0], X_moons[:, 1], c=clustering.labels_, cmap='tab20b')
axes[2].set_title('DBI is: '+ str(round(davies_bouldin_score(X_moons, clustering.labels_), 3)))

Une valeur DBI plus basse indique une meilleure performance de clustering, indiquant que les clusters sont bien séparés et compacts.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 1