Explorando o Algoritmo de Agrupamento HDBSCAN

Introdução

Neste laboratório, aprenderemos sobre o algoritmo de agrupamento HDBSCAN, que é uma melhoria em relação ao algoritmo DBSCAN. Compararemos ambos os algoritmos em conjuntos de dados específicos e avaliaremos a sensibilidade do HDBSCAN a certos hiperparâmetros.

Dicas da Máquina Virtual

Após o arranque da VM, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Importar Bibliotecas Necessárias e Gerar Dados de Amostra

Primeiro, importamos as bibliotecas necessárias e geramos dados de amostra. Criaremos um conjunto de dados a partir de uma mistura de três distribuições gaussianas bidimensionais 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()

Invariância à Escala

Demonstraremos que o HDBSCAN é invariante à escala, ao contrário do DBSCAN. O DBSCAN requer que o parâmetro eps seja ajustado para o conjunto de dados específico em uso. Compararemos o agrupamento obtido com o mesmo valor, mas aplicado a versões redimensionadas do conjunto de dados.

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

Agrupamento Multi-Escala

Demonstraremos que o HDBSCAN é capaz de realizar agrupamento multi-escala, o que considera clusters com densidades variáveis. O DBSCAN tradicional assume que quaisquer clusters potenciais são homogêneos em densidade.

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 a Hiperparâmetros

Demonstraremos que o HDBSCAN é relativamente robusto a vários exemplos do mundo real, graças aos parâmetros min_cluster_size e min_samples, cuja significação clara facilita a sua afinação.

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

Resumo

Neste laboratório, aprendemos sobre o algoritmo de agrupamento HDBSCAN e suas vantagens em relação ao algoritmo DBSCAN. Vimos que o HDBSCAN é invariante à escala, capaz de agrupamento multi-escala e relativamente robusto a vários exemplos do mundo real, graças aos parâmetros min_cluster_size e min_samples.

Demonstração do Algoritmo de Agrupamento HDBSCAN