Démonstration de l'algorithme de regroupement HDBSCAN

Introduction

Dans ce laboratoire, nous allons apprendre à connaître l'algorithme de regroupement HDBSCAN, qui est une amélioration de l'algorithme DBSCAN. Nous allons comparer les deux algorithmes sur des jeux de données spécifiques et évaluer la sensibilité d'HDBSCAN à certains hyperparamètres.

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 pratiquer.

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 limites 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églerons rapidement le problème pour vous.

Skills Graph

Importez les bibliothèques requises et générez des données d'échantillonnage

Nous allons tout d'abord importer les bibliothèques nécessaires et générer des données d'échantillonnage. Nous allons créer un ensemble de données à partir d'un mélange de trois distributions gaussiennes bidimensionnelles et isotrope.

import numpy as np
from sklearn.cluster import HDBSCAN, DBSCAN
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

centers = [[1, 1], [-1, -1], [1.5, -1.5]]
X, labels_true = make_blobs(n_samples=750, centers=centers, cluster_std=[0.4, 0.1, 0.75], random_state=0)
plt.scatter(X[:,0], X[:,1])
plt.show()

Invariance à l'échelle

Nous allons démontrer que HDBSCAN est invariant à l'échelle, contrairement à DBSCAN. DBSCAN nécessite que le paramètre eps soit ajusté pour le jeu de données spécifique utilisé. Nous allons comparer les regroupements obtenus avec la même valeur mais appliquée à des versions redimensionnées du jeu de données.

fig, axes = plt.subplots(3, 1, figsize=(10, 12))
dbs = DBSCAN(eps=0.3)
for idx, scale in enumerate((1, 0.5, 3)):
    dbs.fit(X * scale)
    plot(X * scale, dbs.labels_, parameters={"scale": scale, "eps": 0.3}, ax=axes[idx])

fig, axis = plt.subplots(1, 1, figsize=(12, 5))
dbs = DBSCAN(eps=0.9).fit(3 * X)
plot(3 * X, dbs.labels_, parameters={"scale": 3, "eps": 0.9}, ax=axis)

fig, axes = plt.subplots(3, 1, figsize=(10, 12))
hdb = HDBSCAN()
for idx, scale in enumerate((1, 0.5, 3)):
    hdb.fit(X)
    plot(X, hdb.labels_, hdb.probabilities_, ax=axes[idx], parameters={"scale": scale})

Regroupement multi-échelle

Nous allons démontrer que HDBSCAN est capable de réaliser un regroupement multi-échelle, ce qui permet de prendre en compte des grappes à densité variable. Le DBSCAN traditionnel suppose que toutes les grappes potentielles ont une densité homogène.

centers = [[-0.85, -0.85], [-0.85, 0.85], [3, 3], [3, -3]]
X, labels_true = make_blobs(n_samples=750, centers=centers, cluster_std=[0.2, 0.35, 1.35, 1.35], random_state=0)

fig, axes = plt.subplots(2, 1, figsize=(10, 8))
params = {"eps": 0.7}
dbs = DBSCAN(**params).fit(X)
plot(X, dbs.labels_, parameters=params, ax=axes[0])
params = {"eps": 0.3}
dbs = DBSCAN(**params).fit(X)
plot(X, dbs.labels_, parameters=params, ax=axes[1])

hdb = HDBSCAN().fit(X)
plot(X, hdb.labels_, hdb.probabilities_)

Robustesse aux hyperparamètres

Nous allons démontrer que HDBSCAN est relativement robuste à diverses situations du monde réel grâce aux paramètres min_cluster_size et min_samples dont la signification claire facilite leur réglage.

PARAM = ({"min_cluster_size": 5}, {"min_cluster_size": 3}, {"min_cluster_size": 25})
fig, axes = plt.subplots(3, 1, figsize=(10, 12))
for i, param in enumerate(PARAM):
    hdb = HDBSCAN(**param).fit(X)
    labels = hdb.labels_

    plot(X, labels, hdb.probabilities_, param, ax=axes[i])

PARAM = (
    {"min_cluster_size": 20, "min_samples": 5},
    {"min_cluster_size": 20, "min_samples": 3},
    {"min_cluster_size": 20, "min_samples": 25},
)
fig, axes = plt.subplots(3, 1, figsize=(10, 12))
for i, param in enumerate(PARAM):
    hdb = HDBSCAN(**param).fit(X)
    labels = hdb.labels_

    plot(X, labels, hdb.probabilities_, param, ax=axes[i])

PARAM = (
    {"cut_distance": 0.1},
    {"cut_distance": 0.5},
    {"cut_distance": 1.0},
)
hdb = HDBSCAN()
hdb.fit(X)
fig, axes = plt.subplots(len(PARAM), 1, figsize=(10, 12))
for i, param in enumerate(PARAM):
    labels = hdb.dbscan_clustering(**param)

    plot(X, labels, hdb.probabilities_, param, ax=axes[i])

Sommaire

Dans ce laboratoire, nous avons appris sur l'algorithme de regroupement HDBSCAN et ses avantages par rapport à l'algorithme DBSCAN. Nous avons vu que HDBSCAN est invariant à l'échelle, capable de réaliser un regroupement multi-échelle et relativement robuste à diverses situations du monde réel grâce aux paramètres min_cluster_size et min_samples.