Algoritmo de Clustering DBSCAN

Introducción

En este laboratorio, usaremos el algoritmo DBSCAN (Density-Based Spatial Clustering of Applications with Noise) para agrupar un conjunto de datos sintéticos. DBSCAN es un algoritmo de agrupamiento que identifica muestras centrales en regiones de alta densidad y expande los grupos a partir de ellas. Este algoritmo es útil para datos que contienen grupos de densidad similar.

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 las 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 sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Generación de datos

Usaremos la función make_blobs del módulo sklearn.datasets para generar un conjunto de datos sintéticos con tres clusters. El conjunto de datos constará de 750 muestras con una desviación estándar de cluster de 0.4. También estandarizaremos los datos usando el StandardScaler del 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)

Visualización de datos

Podemos visualizar los datos resultantes usando el módulo matplotlib.pyplot.

import matplotlib.pyplot as plt

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

Calcular DBSCAN

Usaremos la clase DBSCAN del módulo sklearn.cluster para calcular los clusters. Estableceremos el parámetro eps en 0.3 y el parámetro min_samples en 10. Podemos acceder a las etiquetas asignadas por DBSCAN usando el atributo labels. Las muestras ruidosas se les da la etiqueta -1. También calcularemos el número de clusters y el número de puntos de ruido.

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étricas de evaluación

Podemos usar métricas de evaluación para cuantificar la calidad de los clusters resultantes. Usaremos las métricas de homogeneidad, completitud, V-medida, índice de Rand ajustado, información mutua ajustada y coeficiente de silueta. Accederemos a estas métricas desde el módulo sklearn.metrics. Si las etiquetas de verdad básica no son conocidas, la evaluación solo se puede realizar usando los propios resultados del modelo. En ese caso, el coeficiente de silueta resulta útil.

print(f"Homogeneidad: {metrics.homogeneity_score(labels_true, labels):.3f}")
print(f"Completitud: {metrics.completeness_score(labels_true, labels):.3f}")
print(f"V-medida: {metrics.v_measure_score(labels_true, labels):.3f}")
print(f"Índice de Rand Ajustado: {metrics.adjusted_rand_score(labels_true, labels):.3f}")
print(f"Información Mutua Ajustada: {metrics.adjusted_mutual_info_score(labels_true, labels):.3f}")
print(f"Coeficiente de Silueta: {metrics.silhouette_score(X, labels):.3f}")

Graficar los resultados

Usaremos el módulo matplotlib.pyplot para graficar los resultados. Las muestras centrales (puntos grandes) y las no centrales (puntos pequeños) se codifican por color de acuerdo con el cluster asignado. Las muestras etiquetadas como ruido se representan en negro.

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

Resumen

En este laboratorio, usamos el algoritmo de clustering DBSCAN para agrupar un conjunto de datos sintéticos. Generamos un conjunto de datos, visualizamos los datos, calculamos los clusters, evaluamos las métricas y graficamos los resultados.