Maîtriser l'algorithme de clustering DBSCAN

Introduction

Dans ce laboratoire, nous utiliserons l'algorithme DBSCAN (Density-Based Spatial Clustering of Applications with Noise) pour regrouper un ensemble de données synthétiques. DBSCAN est un algorithme de regroupement qui identifie les échantillons centraux dans les régions de haute densité et étend les groupes à partir de ceux-ci. Cet algorithme est utile pour les données contenant des groupes de densité similaire.

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 Notebook pour accéder à Jupyter Notebook pour la pratique.

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

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.

Génération des données

Nous utiliserons la fonction make_blobs du module sklearn.datasets pour générer un ensemble de données synthétiques avec trois groupes. L'ensemble de données comprendra 750 échantillons avec une écart-type de groupe de 0,4. Nous allons également standardiser les données à l'aide de StandardScaler du module sklearn.preprocessing.

from sklearn.datasets import make_blobs
from sklearn.preprocessing import StandardScaler

centers = [[1, 1], [-1, -1], [1, -1]]
X, labels_true = make_blobs(
    n_samples=750, centers=centers, cluster_std=0.4, random_state=0
)

X = StandardScaler().fit_transform(X)

Visualisation des données

Nous pouvons visualiser les données résultantes à l'aide du module matplotlib.pyplot.

import matplotlib.pyplot as plt

plt.scatter(X[:, 0], X[:, 1])
plt.show()

Calcul de DBSCAN

Nous utiliserons la classe DBSCAN du module sklearn.cluster pour calculer les groupes. Nous définirons le paramètre eps sur 0,3 et le paramètre min_samples sur 10. Nous pouvons accéder aux étiquettes attribuées par DBSCAN à l'aide de l'attribut labels. Les échantillons bruyants sont donnés l'étiquette -1. Nous calculerons également le nombre de groupes et le nombre de points de bruit.

import numpy as np
from sklearn.cluster import DBSCAN
from sklearn import metrics

db = DBSCAN(eps=0.3, min_samples=10).fit(X)
labels = db.labels_

n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)
n_noise_ = list(labels).count(-1)

print("Estimated number of clusters: %d" % n_clusters_)
print("Estimated number of noise points: %d" % n_noise_)

Métriques d'évaluation

Nous pouvons utiliser des métriques d'évaluation pour quantifier la qualité des groupes résultants. Nous utiliserons les métriques d'homogénéité, de complétude, de V-mesure, d'indice de Rand ajusté, d'information mutuelle ajustée et de coefficient de silhouette. Nous accéderons à ces métriques à partir du module sklearn.metrics. Si les étiquettes de vérité terrain ne sont pas connues, l'évaluation ne peut être effectuée que à l'aide des résultats du modèle lui-même. Dans ce cas, le coefficient de silhouette est pratique.

print(f"Homogénéité: {metrics.homogeneity_score(labels_true, labels):.3f}")
print(f"Complétude: {metrics.completeness_score(labels_true, labels):.3f}")
print(f"V-mesure: {metrics.v_measure_score(labels_true, labels):.3f}")
print(f"Indice de Rand ajusté: {metrics.adjusted_rand_score(labels_true, labels):.3f}")
print(f"Information mutuelle ajustée: {metrics.adjusted_mutual_info_score(labels_true, labels):.3f}")
print(f"Coefficient de silhouette: {metrics.silhouette_score(X, labels):.3f}")

Tracer les résultats

Nous utiliserons le module matplotlib.pyplot pour tracer les résultats. Les échantillons centraux (gros points) et les échantillons non centraux (petits points) sont colorés selon le groupe attribué. Les échantillons étiquetés comme bruit sont représentés en noir.

unique_labels = set(labels)
core_samples_mask = np.zeros_like(labels, dtype=bool)
core_samples_mask[db.core_sample_indices_] = True

colors = [plt.cm.Spectral(each) for each in np.linspace(0, 1, len(unique_labels))]
for k, col in zip(unique_labels, colors):
    if k == -1:
        col = [0, 0, 0, 1]

    class_member_mask = labels == k

    xy = X[class_member_mask & core_samples_mask]
    plt.plot(
        xy[:, 0],
        xy[:, 1],
        "o",
        markerfacecolor=tuple(col),
        markeredgecolor="k",
        markersize=14,
    )

    xy = X[class_member_mask & ~core_samples_mask]
    plt.plot(
        xy[:, 0],
        xy[:, 1],
        "o",
        markerfacecolor=tuple(col),
        markeredgecolor="k",
        markersize=6,
    )

plt.title(f"Estimated number of clusters: {n_clusters_}")
plt.show()

Sommaire

Dans ce laboratoire, nous avons utilisé l'algorithme de clustering DBSCAN pour regrouper un ensemble de données synthétiques. Nous avons généré un ensemble de données, visualisé les données, calculé les groupes, évalué les métriques et tracé les résultats.

Algorithme de clustering DBSCAN