Analyse de regroupement avec la méthode de silhouette

Introduction

Le regroupement en grappes est une technique d'apprentissage non supervisé populaire qui consiste à regrouper des points de données similaires ensemble sur la base de leurs caractéristiques. La méthode de silhouette est une technique couramment utilisée pour déterminer le nombre optimal de grappes dans un ensemble de données. Dans ce laboratoire, nous utiliserons la méthode de silhouette pour déterminer le nombre optimal de grappes à l'aide de l'algorithme KMeans.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet d'adresses pour accéder au carnet Jupyter pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations du carnet Jupyter.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques

Nous commencerons par importer les bibliothèques nécessaires pour effectuer l'analyse.

from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np

Générer des données

Nous allons générer des données d'échantillonnage à l'aide de la fonction make_blobs de la bibliothèque sklearn.datasets. Cette fonction génère des grappes gaussiennes isotropes pour le regroupement en grappes.

X, y = make_blobs(
    n_samples=500,
    n_features=2,
    centers=4,
    cluster_std=1,
    center_box=(-10.0, 10.0),
    shuffle=True,
    random_state=1,
)  ## Pour la reproductibilité

Déterminer le nombre optimal de grappes

Nous utiliserons la méthode de silhouette pour déterminer le nombre optimal de grappes pour l'algorithme KMeans. Nous allons itérer sur une plage de valeurs pour n_clusters et tracer les scores de silhouette pour chaque valeur.

range_n_clusters = [2, 3, 4, 5, 6]

for n_clusters in range_n_clusters:
    ## Crée un sous-graphique avec 1 ligne et 2 colonnes
    fig, (ax1, ax2) = plt.subplots(1, 2)
    fig.set_size_inches(18, 7)

    ## Le premier sous-graphique est le graphique de silhouette
    ax1.set_xlim([-0.1, 1])
    ax1.set_ylim([0, len(X) + (n_clusters + 1) * 10])

    ## Initialise le clusterer avec la valeur de n_clusters et un générateur
    ## de graines aléatoires de 10 pour la reproductibilité.
    clusterer = KMeans(n_clusters=n_clusters, n_init="auto", random_state=10)
    cluster_labels = clusterer.fit_predict(X)

    ## Le silhouette_score donne la valeur moyenne pour tous les échantillons.
    silhouette_avg = silhouette_score(X, cluster_labels)

    ## Calcule les scores de silhouette pour chaque échantillon
    sample_silhouette_values = silhouette_samples(X, cluster_labels)

    y_lower = 10
    for i in range(n_clusters):
        ## Agrège les scores de silhouette pour les échantillons appartenant à
        ## au cluster i, et les trie
        ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]

        ith_cluster_silhouette_values.sort()

        size_cluster_i = ith_cluster_silhouette_values.shape[0]
        y_upper = y_lower + size_cluster_i

        color = cm.nipy_spectral(float(i) / n_clusters)
        ax1.fill_betweenx(
            np.arange(y_lower, y_upper),
            0,
            ith_cluster_silhouette_values,
            facecolor=color,
            edgecolor=color,
            alpha=0.7,
        )

        ## Affiche les numéros de cluster au milieu des graphiques de silhouette
        ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))

        ## Calcule la nouvelle y_lower pour le prochain graphique
        y_lower = y_upper + 10  ## 10 pour les 0 échantillons

    ax1.set_title("Le graphique de silhouette pour les différents clusters.")
    ax1.set_xlabel("Les valeurs du coefficient de silhouette")
    ax1.set_ylabel("Étiquette de cluster")

    ## La ligne verticale pour le score de silhouette moyen de toutes les valeurs
    ax1.axvline(x=silhouette_avg, color="red", linestyle="--")

    ax1.set_yticks([])  ## Efface les étiquettes / les repères de l'axe y
    ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])

    ## 2ème graphique montrant les grappes réelles formées
    colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)
    ax2.scatter(
        X[:, 0], X[:, 1], marker=".", s=30, lw=0, alpha=0.7, c=colors, edgecolor="k"
    )

    ## Étiquetage des grappes
    centers = clusterer.cluster_centers_
    ## Dessine des cercles blancs au centre des grappes
    ax2.scatter(
        centers[:, 0],
        centers[:, 1],
        marker="o",
        c="white",
        alpha=1,
        s=200,
        edgecolor="k",
    )

    for i, c in enumerate(centers):
        ax2.scatter(c[0], c[1], marker="$%d$" % i, alpha=1, s=50, edgecolor="k")

    ax2.set_title("La visualisation des données regroupées.")
    ax2.set_xlabel("Espace de caractéristiques pour la première caractéristique")
    ax2.set_ylabel("Espace de caractéristiques pour la deuxième caractéristique")

    plt.suptitle(
        "Analyse de silhouette pour le regroupement KMeans sur des données d'échantillonnage avec n_clusters = %d"
        % n_clusters,
        fontsize=14,
        fontweight="bold",
    )

plt.show()

Interpréter les résultats

Nous allons interpréter les résultats de la méthode de silhouette. Nous examinerons le score de silhouette moyen pour chaque valeur de n_clusters et choisirons la valeur qui donne le score le plus élevé.

Sommaire

Dans ce laboratoire, nous avons utilisé la méthode de silhouette pour déterminer le nombre optimal de grappes pour l'algorithme KMeans. Nous avons généré des données d'échantillonnage à l'aide de la fonction make_blobs et avons tracé les scores de silhouette pour une plage de valeurs de n_clusters. Nous avons interprété les résultats et avons choisi la valeur optimale pour n_clusters.