Algorithme de clustering OPTICS

Introduction

Ce laboratoire démontre l'utilisation de l'algorithme de clustering OPTICS à l'aide de la bibliothèque scikit-learn. OPTICS est un sigle pour Ordering Points To Identify the Clustering Structure. C'est un algorithme de clustering basé sur la densité qui trouve les échantillons centraux de haute densité et les utilise pour développer des grappes. Dans ce laboratoire, nous allons générer des données d'échantillonnage, tracer le graphe de traçabilité et utiliser DBSCAN pour regrouper les données.

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.

Skills Graph

Importation des bibliothèques

Nous allons commencer par importer les bibliothèques nécessaires pour ce laboratoire - numpy, matplotlib.pyplot, et OPTICS et cluster_optics_dbscan de scikit-learn.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import OPTICS, cluster_optics_dbscan

Générer des données d'échantillonnage

Nous allons générer des données d'échantillonnage pour le clustering. Dans cet exemple, nous générons six grappes avec des densités différentes à l'aide de numpy.

np.random.seed(0)
n_points_per_cluster = 250

C1 = [-5, -2] + 0.8 * np.random.randn(n_points_per_cluster, 2)
C2 = [4, -1] + 0.1 * np.random.randn(n_points_per_cluster, 2)
C3 = [1, -2] + 0.2 * np.random.randn(n_points_per_cluster, 2)
C4 = [-2, 3] + 0.3 * np.random.randn(n_points_per_cluster, 2)
C5 = [3, -2] + 1.6 * np.random.randn(n_points_per_cluster, 2)
C6 = [5, 6] + 2 * np.random.randn(n_points_per_cluster, 2)
X = np.vstack((C1, C2, C3, C4, C5, C6))

Exécuter l'algorithme de clustering OPTICS

Nous allons maintenant exécuter l'algorithme de clustering OPTICS sur les données générées. Dans cet exemple, nous définissons min_samples = 50, xi = 0,05 et min_cluster_size = 0,05.

clust = OPTICS(min_samples=50, xi=0.05, min_cluster_size=0.05)
clust.fit(X)

Regrouper les données à l'aide de DBSCAN

Nous allons regrouper les données à l'aide de DBSCAN pour différentes valeurs d'epsilon. Dans cet exemple, nous définissons epsilon sur 0,5 et 2.

labels_050 = cluster_optics_dbscan(
    reachability=clust.reachability_,
    core_distances=clust.core_distances_,
    ordering=clust.ordering_,
    eps=0.5,
)
labels_200 = cluster_optics_dbscan(
    reachability=clust.reachability_,
    core_distances=clust.core_distances_,
    ordering=clust.ordering_,
    eps=2,
)

Tracer le graphe de la distance de proximité et les résultats du clustering

Nous allons tracer le graphe de la distance de proximité et les résultats du clustering pour OPTICS et DBSCAN avec différentes valeurs d'epsilon.

space = np.arange(len(X))
reachability = clust.reachability_[clust.ordering_]
labels = clust.labels_[clust.ordering_]

plt.figure(figsize=(10, 7))
G = gridspec.GridSpec(2, 3)
ax1 = plt.subplot(G[0, :])
ax2 = plt.subplot(G[1, 0])
ax3 = plt.subplot(G[1, 1])
ax4 = plt.subplot(G[1, 2])

## Graphe de la distance de proximité
colors = ["g.", "r.", "b.", "y.", "c."]
for klass, color in zip(range(0, 5), colors):
    Xk = space[labels == klass]
    Rk = reachability[labels == klass]
    ax1.plot(Xk, Rk, color, alpha=0.3)
ax1.plot(space[labels == -1], reachability[labels == -1], "k.", alpha=0.3)
ax1.plot(space, np.full_like(space, 2.0, dtype=float), "k-", alpha=0.5)
ax1.plot(space, np.full_like(space, 0.5, dtype=float), "k-.", alpha=0.5)
ax1.set_ylabel("Distance de proximité (distance epsilon)")
ax1.set_title("Graphe de la distance de proximité")

## OPTICS
colors = ["g.", "r.", "b.", "y.", "c."]
for klass, color in zip(range(0, 5), colors):
    Xk = X[clust.labels_ == klass]
    ax2.plot(Xk[:, 0], Xk[:, 1], color, alpha=0.3)
ax2.plot(X[clust.labels_ == -1, 0], X[clust.labels_ == -1, 1], "k+", alpha=0.1)
ax2.set_title("Regroupement automatique\nOPTICS")

## DBSCAN à 0,5
colors = ["g.", "r.", "b.", "c."]
for klass, color in zip(range(0, 4), colors):
    Xk = X[labels_050 == klass]
    ax3.plot(Xk[:, 0], Xk[:, 1], color, alpha=0.3)
ax3.plot(X[labels_050 == -1, 0], X[labels_050 == -1, 1], "k+", alpha=0.1)
ax3.set_title("Regroupement avec un seuil d'epsilon de 0,5\nDBSCAN")

## DBSCAN à 2,0
colors = ["g.", "m.", "y.", "c."]
for klass, color in zip(range(0, 4), colors):
    Xk = X[labels_200 == klass]
    ax4.plot(Xk[:, 0], Xk[:, 1], color, alpha=0.3)
ax4.plot(X[labels_200 == -1, 0], X[labels_200 == -1, 1], "k+", alpha=0.1)
ax4.set_title("Regroupement avec un seuil d'epsilon de 2,0\nDBSCAN")

plt.tight_layout()
plt.show()

注：这里gridspec未翻译，因为它是一个特定的Python绘图布局模块名，一般保留英文更合适。

Sommaire

Dans ce laboratoire, nous avons appris comment utiliser l'algorithme de clustering OPTICS pour regrouper des données et comment utiliser DBSCAN pour regrouper les données avec différentes valeurs d'epsilon. Nous avons également appris comment tracer le graphe de la distance de proximité et les résultats du clustering.