Explorando el algoritmo de agrupamiento HDBSCAN

Introducción

En este laboratorio, aprenderemos sobre el algoritmo de clustering HDBSCAN, que es una mejora sobre el algoritmo DBSCAN. Compararemos ambos algoritmos en conjuntos de datos específicos y evaluaremos la sensibilidad de HDBSCAN a ciertos hiperparámetros.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje su retroalimentación después de la sesión y resolveremos rápidamente el problema para usted.

Importar las bibliotecas necesarias y generar datos de muestra

Primero importaremos las bibliotecas necesarias y generaremos datos de muestra. Crearemos un conjunto de datos a partir de una mezcla de tres distribuciones gaussianas bidimensionales e isotrópicas.

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()

Invarianza a la escala

Demostraremos que HDBSCAN es invariante a la escala, a diferencia de DBSCAN. DBSCAN requiere que se ajuste el parámetro eps para el conjunto de datos específico en uso. Compararemos la agrupación obtenida con el mismo valor pero aplicado a versiones reescaladas del conjunto de datos.

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})

Agrupamiento multi-escala

Demostraremos que HDBSCAN es capaz de realizar un agrupamiento multi-escala, lo que aborda los grupos con diferentes densidades. El DBSCAN tradicional asume que cualquier posible grupo es homogéneo en densidad.

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_)

Robustez de los hiperparámetros

Demostraremos que HDBSCAN es relativamente robusto a varios ejemplos del mundo real gracias a los parámetros min_cluster_size y min_samples, cuya clara significación ayuda a ajustarlos.

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])

Resumen

En este laboratorio, aprendimos sobre el algoritmo de agrupamiento HDBSCAN y sus ventajas en comparación con el algoritmo DBSCAN. Vimos que HDBSCAN es invariante a la escala, es capaz de realizar un agrupamiento multi-escala y es relativamente robusto a varios ejemplos del mundo real gracias a los parámetros min_cluster_size y min_samples.

Demostración del algoritmo de agrupamiento HDBSCAN