Regroupement hiérarchique avec Python | Tutoriel Scikit-Learn

Introduction

Dans ce laboratoire, nous utiliserons la bibliothèque scikit-learn de Python pour effectuer un regroupement hiérarchique sur quelques jeux de données de démonstration. Le regroupement hiérarchique est une méthode de regroupement dans laquelle vous construisez une hiérarchie de groupes, soit de manière descendante soit ascendante. L'objectif du regroupement hiérarchique est de trouver des groupes de points qui sont similaires les uns aux autres et dissimilaires des points des autres groupes.

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 de notes 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.

Importation des bibliothèques et chargement des données

Nous commencerons par importer les bibliothèques nécessaires et charger les jeux de données de démonstration que nous utiliserons pour nos exemples de regroupement hiérarchique.

import time
import warnings

import numpy as np
import matplotlib.pyplot as plt

from sklearn import cluster, datasets
from sklearn.preprocessing import StandardScaler
from itertools import cycle, islice

np.random.seed(0)

## %%
## Génération des jeux de données. Nous choisissons une taille suffisamment grande pour voir la
## capacité d'échelle des algorithmes, mais pas trop grande pour éviter des temps d'exécution trop longs

n_samples = 1500
noisy_circles = datasets.make_circles(n_samples=n_samples, factor=0.5, noise=0.05)
noisy_moons = datasets.make_moons(n_samples=n_samples, noise=0.05)
blobs = datasets.make_blobs(n_samples=n_samples, random_state=8)
no_structure = np.random.rand(n_samples, 2), None

## Données distribuées de manière anisotrope
random_state = 170
X, y = datasets.make_blobs(n_samples=n_samples, random_state=random_state)
transformation = [[0.6, -0.6], [-0.4, 0.8]]
X_aniso = np.dot(X, transformation)
aniso = (X_aniso, y)

## Blobs avec des variances variées
varied = datasets.make_blobs(
    n_samples=n_samples, cluster_std=[1.0, 2.5, 0.5], random_state=random_state
)

Effectuer un regroupement hiérarchique

Nous allons maintenant effectuer un regroupement hiérarchique sur les jeux de données de démonstration que nous avons chargés dans l'étape 1. Nous utiliserons différentes méthodes de liaison telles que la liaison unique, la liaison moyenne, la liaison complète et la méthode de Ward pour construire nos groupes.

## Configurez les paramètres du regroupement
plt.figure(figsize=(9 * 1.3 + 2, 14.5))
plt.subplots_adjust(
    left=0.02, right=0.98, bottom=0.001, top=0.96, wspace=0.05, hspace=0.01
)

plot_num = 1

default_base = {"n_neighbors": 10, "n_clusters": 3}

datasets = [
    (noisy_circles, {"n_clusters": 2}),
    (noisy_moons, {"n_clusters": 2}),
    (varied, {"n_neighbors": 2}),
    (aniso, {"n_neighbors": 2}),
    (blobs, {}),
    (no_structure, {}),
]

for i_dataset, (dataset, algo_params) in enumerate(datasets):
    ## mettez à jour les paramètres avec des valeurs spécifiques au jeu de données
    params = default_base.copy()
    params.update(algo_params)

    X, y = dataset

    ## normalisez le jeu de données pour faciliter la sélection des paramètres
    X = StandardScaler().fit_transform(X)

    ## ============
    ## Créez des objets de regroupement
    ## ============
    ward = cluster.AgglomerativeClustering(
        n_clusters=params["n_clusters"], linkage="ward"
    )
    complete = cluster.AgglomerativeClustering(
        n_clusters=params["n_clusters"], linkage="complete"
    )
    average = cluster.AgglomerativeClustering(
        n_clusters=params["n_clusters"], linkage="average"
    )
    single = cluster.AgglomerativeClustering(
        n_clusters=params["n_clusters"], linkage="single"
    )

    clustering_algorithms = (
        ("Liaison unique", single),
        ("Liaison moyenne", average),
        ("Liaison complète", complete),
        ("Liaison de Ward", ward),
    )

    for name, algorithm in clustering_algorithms:
        t0 = time.time()

        ## capturez les avertissements liés à kneighbors_graph
        with warnings.catch_warnings():
            warnings.filterwarnings(
                "ignore",
                message="le nombre de composantes connectées de la "
                + "matrice de connectivité est [0-9]{1,2}"
                + " > 1. La complétant pour éviter d'arrêter l'arbre tôt.",
                category=UserWarning,
            )
            algorithm.fit(X)

        t1 = time.time()
        if hasattr(algorithm, "labels_"):
            y_pred = algorithm.labels_.astype(int)
        else:
            y_pred = algorithm.predict(X)

        plt.subplot(len(datasets), len(clustering_algorithms), plot_num)
        if i_dataset == 0:
            plt.title(name, size=18)

        colors = np.array(
            list(
                islice(
                    cycle(
                        [
                            "#377eb8",
                            "#ff7f00",
                            "#4daf4a",
                            "#f781bf",
                            "#a65628",
                            "#984ea3",
                            "#999999",
                            "#e41a1c",
                            "#dede00",
                        ]
                    ),
                    int(max(y_pred) + 1),
                )
            )
        )
        plt.scatter(X[:, 0], X[:, 1], s=10, color=colors[y_pred])

        plt.xlim(-2.5, 2.5)
        plt.ylim(-2.5, 2.5)
        plt.xticks(())
        plt.yticks(())
        plt.text(
            0.99,
            0.01,
            ("%.2fs" % (t1 - t0)).lstrip("0"),
            transform=plt.gca().transAxes,
            size=15,
            horizontalalignment="right",
        )
        plot_num += 1

plt.show()

Analyser les résultats

Nous allons maintenant analyser les résultats de notre regroupement hiérarchique. Sur la base des jeux de données de démonstration que nous avons utilisés, nous pouvons faire les observations suivantes :

La liaison unique est rapide et peut fonctionner bien sur des données non globulaires, mais elle fonctionne mal en présence de bruit.
La liaison moyenne et la liaison complète fonctionnent bien sur des grappes globulaires bien séparées, mais donnent des résultats mitigés dans les autres cas.
La méthode de Ward est la plus efficace pour les données bruitées.

Il est important de noter que si ces observations nous donnent une certaine intuition sur les algorithmes, cette intuition peut ne pas s'appliquer aux données de très haute dimension.

Sommaire

Dans ce laboratoire, nous avons appris à effectuer un regroupement hiérarchique à l'aide de la bibliothèque scikit-learn de Python. Nous avons utilisé différentes méthodes de liaison telles que la liaison unique, la liaison moyenne, la liaison complète et la méthode de Ward pour construire nos groupes, et avons analysé les résultats sur la base de quelques jeux de données de démonstration. Le regroupement hiérarchique est une technique puissante qui peut être utilisée pour identifier des groupes de points de données similaires et peut être utile dans divers domaines tels que la biologie, le marketing et la finance.

Regroupement hiérarchique avec Scikit-Learn