Algoritmo de Agrupamento DBSCAN

Introdução

Neste laboratório, utilizaremos o algoritmo DBSCAN (Density-Based Spatial Clustering of Applications with Noise) para agrupar um conjunto de dados sintético. O DBSCAN é um algoritmo de agrupamento que identifica amostras centrais em regiões de alta densidade e expande os clusters a partir delas. Este algoritmo é útil para dados contendo clusters de densidade semelhante.

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, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Geração de Dados

Usaremos a função make_blobs do módulo sklearn.datasets para gerar um conjunto de dados sintético com três clusters. O conjunto de dados consistirá em 750 amostras com um desvio padrão de cluster de 0,4. Também padronizaremos os dados usando o StandardScaler do módulo 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)

Visualização de Dados

Podemos visualizar os dados resultantes usando o módulo matplotlib.pyplot.

import matplotlib.pyplot as plt

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

Computar DBSCAN

Usaremos a classe DBSCAN do módulo sklearn.cluster para calcular os clusters. Definiremos o parâmetro eps como 0,3 e o parâmetro min_samples como 10. Podemos acessar as etiquetas atribuídas pelo DBSCAN usando o atributo labels_. Amostras ruidosas recebem a etiqueta -1. Também calcularemos o número de clusters e o número de pontos ruidosos.

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("Número estimado de clusters: %d" % n_clusters_)
print("Número estimado de pontos ruidosos: %d" % n_noise_)

Métricas de Avaliação

Podemos usar métricas de avaliação para quantificar a qualidade dos clusters resultantes. Usaremos as métricas de homogeneidade, completude, V-measure, índice Rand ajustado, informação mútua ajustada e coeficiente de silhueta. Acederemos a estas métricas através do módulo sklearn.metrics. Se as etiquetas de verdade fundamental não forem conhecidas, a avaliação só pode ser realizada usando os próprios resultados do modelo. Nesse caso, o coeficiente de silhueta é útil.

print(f"Homogeneidade: {metrics.homogeneity_score(labels_true, labels):.3f}")
print(f"Completude: {metrics.completeness_score(labels_true, labels):.3f}")
print(f"V-measure: {metrics.v_measure_score(labels_true, labels):.3f}")
print(f"Índice Rand Ajustado: {metrics.adjusted_rand_score(labels_true, labels):.3f}")
print(f"Informação Mútua Ajustada: {metrics.adjusted_mutual_info_score(labels_true, labels):.3f}")
print(f"Coeficiente de Silhueta: {metrics.silhouette_score(X, labels):.3f}")

Plotar Resultados

Usaremos o módulo matplotlib.pyplot para plotar os resultados. As amostras principais (pontos grandes) e as amostras não principais (pontos pequenos) são codificadas por cores de acordo com o cluster atribuído. As amostras rotuladas como ruído são representadas em preto.

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"Número estimado de clusters: {n_clusters_}")
plt.show()

Sumário

Neste laboratório, utilizamos o algoritmo de agrupamento DBSCAN para agrupar um conjunto de dados sintético. Gerámos um conjunto de dados, visualizámos os dados, calculámos os clusters, avaliámos as métricas e plotámos os resultados.