Tutorial ScikitLearn: Clustering de densidad con DBSCAN

¿Qué es el clustering de densidad?

El clustering de densidad es una técnica de agrupamiento que identifica grupos de datos basándose en regiones de alta densidad en el espacio de características. A diferencia de métodos como K-Means, que asumen formas esféricas y requieren especificar el número de clústeres previamente, el clustering de densidad puede descubrir estructuras de formas arbitrarias y no necesita conocer de antemano la cantidad de clústeres.

En el clustering de densidad, un clúster se define como una región contigua donde la densidad de puntos es superior a un umbral especificado. Este enfoque permite identificar patrones complejos en los datos, ya que agrupa puntos cercanos y densamente conectados, mientras que considera como ruido aquellos puntos aislados o en áreas de baja densidad.

Una de las ventajas principales de esta técnica es su capacidad para detectar clústeres de forma arbitraria, lo que la hace especialmente útil en conjuntos de datos que contienen estructuras no lineales o formas irregulares. Además, es robusta frente a valores atípicos, ya que éstos pueden ser fácilmente identificados y excluidos del análisis sin afectar significativamente al resultado.

El clustering de densidad utiliza parámetros como la distancia máxima entre puntos para considerarlos vecinos (ε, epsilon) y el número mínimo de puntos requeridos para formar un clúster (min_samples). Estos parámetros permiten ajustar la sensibilidad del algoritmo a la densidad local de los datos, facilitando la detección de agrupaciones significativas sin imponer restricciones estrictas sobre su forma o tamaño.

Esta técnica es especialmente eficaz en contextos donde los datos presentan distribuciones complejas o cuando existe la necesidad de identificar anomalías. Por ejemplo, en la detección de fraudes, análisis de distribución espacial en geología, o segmentación avanzada en imágenes médicas, el clustering de densidad proporciona herramientas para extraer información valiosa de patrones que otros métodos podrían pasar por alto.

En resumen, el clustering de densidad es una herramienta potente para el análisis exploratorio de datos, ofreciendo flexibilidad y robustez en la identificación de estructuras subyacentes en conjuntos de datos variados. En las siguientes secciones, exploraremos cómo implementar esta técnica utilizando el algoritmo DBSCAN en Scikit-Learn, y cómo ajustar sus parámetros para optimizar los resultados según las necesidades específicas del análisis.

¿Qué es DBSCAN?

DBSCAN (Density-Based Spatial Clustering of Applications with Noise) es un algoritmo de clustering que agrupa datos basándose en la densidad de puntos en el espacio. A diferencia de métodos como K-Means, DBSCAN no requiere especificar el número de clústeres previamente y es capaz de identificar estructuras de forma arbitraria y ruido en los datos.

El algoritmo utiliza dos parámetros clave:

• ε (epsilon): define el radio de la vecindad alrededor de un punto.
• min_samples: es el número mínimo de puntos requeridos para formar un clúster denso.

Un punto central es aquel que tiene al menos min_samples puntos dentro de su vecindad de radio ε. Los puntos que no cumplen esta condición pueden ser clasificados como puntos frontera si están dentro de la vecindad de un punto central, o como puntos de ruido si no lo están.

DBSCAN agrupa los puntos conectando densamente los puntos centrales. Dos puntos están conectados por densidad si existe una cadena de puntos centrales que los une. Este enfoque permite que el algoritmo detecte clústeres separados por regiones de baja densidad, manejando eficientemente valores atípicos.

A continuación se muestra un ejemplo de cómo utilizar DBSCAN con Scikit-Learn:

from sklearn.cluster import DBSCAN
import numpy as np

# Datos de ejemplo
X = np.array([
    [1, 2], [2, 2], [2, 3],
    [8, 7], [8, 8], [25, 80]
])

# Crear el modelo DBSCAN
dbscan = DBSCAN(eps=3, min_samples=2)

# Ajustar el modelo a los datos
dbscan.fit(X)

# Etiquetas de clúster asignadas a cada punto
labels = dbscan.labels_
print(labels)

En este código, se importan las necesarias bibliotecas y se crea un conjunto de datos X. Se instancia el modelo DBSCAN con eps=3 y min_samples=2, y se ajusta a los datos. Las etiquetas resultantes se almacenan en labels, donde cada número entero representa un clúster diferente y -1 indica un punto de ruido.

Salida esperada:

[ 0  0  0  1  1 -1]

Esto significa que los tres primeros puntos pertenecen al clúster 0, los siguientes dos al clúster 1, y el último punto es considerado ruido.

Una ventaja significativa de DBSCAN es su capacidad para descubrir clústeres de cualquier forma, ya que no asume ninguna estructura predeterminada. Esto es especialmente útil en conjuntos de datos donde los clústeres no son esféricos o tienen densidades variables.

Sin embargo, la selección de los parámetros ε y min_samples es crucial. Valores inadecuados pueden llevar a que el algoritmo identifique demasiados clústeres pequeños o que agrupe todos los puntos en un único clúster. Es importante realizar un análisis exploratorio para determinar los valores óptimos de estos parámetros.

DBSCAN también es robusto frente a outliers, ya que los puntos de baja densidad que no se ajustan a ningún clúster son etiquetados como ruido. Esto facilita la detección de anomalías en los datos sin afectar la estructura general de los clústeres.

Al aplicar DBSCAN, es recomendable escalar o normalizar los datos si las características tienen unidades o escalas diferentes. Esto asegura que la distancia euclidiana utilizada para calcular las vecindades sea significativa.

Uso de DBSCAN en scikit learn

El algoritmo DBSCAN en scikit-learn permite identificar clústeres de forma eficiente basándose en la densidad de los datos. A continuación, se muestra cómo implementarlo utilizando conjuntos de datos y ajustando sus parámetros clave.

Para empezar, importamos las bibliotecas necesarias y generamos un conjunto de datos que contenga estructuras no lineales. Utilizaremos el conjunto de datos make_moons, que es adecuado para visualizar las capacidades de DBSCAN.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import DBSCAN
from sklearn.datasets import make_moons

# Generar datos con forma de media luna
X, y = make_moons(n_samples=300, noise=0.05, random_state=42)

# Visualizar los datos
plt.scatter(X[:, 0], X[:, 1], s=50)
plt.title('Datos originales')
plt.xlabel('Característica 1')
plt.ylabel('Característica 2')
plt.show()

Aplicamos el algoritmo DBSCAN sin preprocesamiento para observar su rendimiento inicial.

# Instanciar el modelo DBSCAN con parámetros predeterminados
dbscan = DBSCAN()

# Ajustar el modelo a los datos
dbscan.fit(X)

# Obtener las etiquetas de los clústeres
labels = dbscan.labels_

Las etiquetas asignadas pueden ser visualizadas para analizar los resultados del clustering.

# Visualizar los resultados del clustering
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', s=50)
plt.title('Resultados de DBSCAN con parámetros predeterminados')
plt.xlabel('Característica 1')
plt.ylabel('Característica 2')
plt.show()

Observamos que con los parámetros predeterminados, el algoritmo puede no separar adecuadamente los clústeres deseados. Por ello, es esencial ajustar los parámetros eps (epsilon) y min_samples para mejorar la agrupación.

Podemos realizar una búsqueda empírica de eps mediante un gráfico de distancias k-vecinas.

from sklearn.neighbors import NearestNeighbors

# Calcular las distancias a los vecinos más cercanos
nearest_neighbors = NearestNeighbors(n_neighbors=4)
neighbors = nearest_neighbors.fit(X)
distances, indices = neighbors.kneighbors(X)

# Ordenar las distancias para visualizar el codo
distances = np.sort(distances[:, 3])
plt.plot(distances)
plt.title('Gráfico para estimar eps')
plt.xlabel('Puntos de datos ordenados')
plt.ylabel('Distancia al 4º vecino más cercano')
plt.show()

El punto donde la pendiente del gráfico cambia significativamente indica un valor apropiado para eps. Supongamos que del gráfico estimamos un eps de 0.2.

Actualizamos el modelo con los nuevos parámetros.

# Instanciar DBSCAN con eps ajustado
dbscan = DBSCAN(eps=0.2, min_samples=5)

# Ajustar el modelo a los datos
dbscan.fit(X)

# Obtener las nuevas etiquetas
labels = dbscan.labels_

# Visualizar los resultados ajustados
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', s=50)
plt.title('DBSCAN con eps ajustado')
plt.xlabel('Característica 1')
plt.ylabel('Característica 2')
plt.show()

Con el ajuste adecuado de eps, DBSCAN puede separar correctamente los clústeres en datos con formas complejas.

Es recomendable escalar los datos antes de aplicar DBSCAN, especialmente si las características tienen escalas diferentes.

from sklearn.preprocessing import StandardScaler

# Escalar los datos
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Aplicar DBSCAN a los datos escalados
dbscan_scaled = DBSCAN(eps=0.3, min_samples=5)
dbscan_scaled.fit(X_scaled)
labels_scaled = dbscan_scaled.labels_

# Visualizar los resultados
plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=labels_scaled, cmap='plasma', s=50)
plt.title('DBSCAN con datos escalados')
plt.xlabel('Característica 1 escalada')
plt.ylabel('Característica 2 escalada')
plt.show()

El uso de datos escalados puede mejorar la detección de clústeres al eliminar el efecto de las diferencias en las unidades de medida.

Para evaluar la calidad del clustering, utilizamos la puntuación de silhouette, que mide qué tan similares son los puntos dentro del mismo clúster en comparación con otros clústeres.

from sklearn.metrics import silhouette_score

# Calcular la puntuación de silhouette
if len(set(labels_scaled)) > 1:
    score = silhouette_score(X_scaled, labels_scaled)
    print(f'Puntuación de silhouette: {score}')
else:
    print('No se pudieron formar clústeres distintos.')

Finalmente, podemos integrar el escalado y el clustering en un pipeline para simplificar el proceso.

from sklearn.pipeline import Pipeline

# Crear un pipeline con escalado y DBSCAN
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('dbscan', DBSCAN(eps=0.3, min_samples=5))
], memory = None)

# Ajustar el pipeline
pipeline.fit(X)

# Obtener las etiquetas del modelo
labels_pipeline = pipeline['dbscan'].labels_

# Visualizar los resultados del pipeline
plt.scatter(X[:, 0], X[:, 1], c=labels_pipeline, cmap='inferno', s=50)
plt.title('Resultado del Pipeline de DBSCAN')
plt.xlabel('Característica 1')
plt.ylabel('Característica 2')
plt.show()

El uso de pipelines garantiza que los pasos de preprocesamiento y modelado se apliquen de manera consistente y facilita la reproducibilidad del análisis.

Determinación del número óptimo de clústers

En el algoritmo DBSCAN, el número de clústeres no se especifica directamente, sino que emerge como resultado de la configuración de los parámetros ε (epsilon) y min_samples. La selección adecuada de estos parámetros clave es fundamental para obtener un agrupamiento significativo y representa un desafío importante en el uso de este algoritmo.

Para determinar el valor óptimo de ε, se utiliza comúnmente el gráfico de distancia k-vecinos. Este método implica calcular la distancia al _k_-ésimo vecino más cercano para cada punto del conjunto de datos y luego ordenar estas distancias de menor a mayor. Al representar gráficamente estas distancias, se busca identificar el punto de inflexión o "codo" en la curva, que corresponde al valor apropiado de ε.

A continuación, se muestra cómo implementar este método utilizando Scikit-Learn:

from sklearn.neighbors import NearestNeighbors
import numpy as np
import matplotlib.pyplot as plt

# Supongamos que X es nuestro conjunto de datos
# Calcular las distancias a los 4 vecinos más cercanos
neighbors = NearestNeighbors(n_neighbors=4)
neighbors_fit = neighbors.fit(X)
distances, indices = neighbors_fit.kneighbors(X)

# Ordenar las distancias para visualizar el codo
distances = np.sort(distances[:, 3])
plt.plot(distances)
plt.title('Gráfico de distancia k-vecinos')
plt.xlabel('Puntos de datos ordenados')
plt.ylabel('Distancia al 4º vecino más cercano')
plt.show()

En este ejemplo, se utiliza NearestNeighbors para calcular las distancias a los 4 vecinos más cercanos (k = min_samples). La elección de min_samples depende del conocimiento del dominio y del tamaño del conjunto de datos, pero un valor común es 4 o 5. El gráfico resultante ayuda a identificar el valor de ε donde existe un aumento pronunciado en las distancias, indicando la separación entre puntos dentro de los clústeres y puntos aislados.

Una vez determinado el valor óptimo de ε, se procede a ajustar el modelo DBSCAN con los parámetros seleccionados:

from sklearn.cluster import DBSCAN

# Supongamos que el valor óptimo de ε es 0.5
dbscan = DBSCAN(eps=0.5, min_samples=4)
dbscan.fit(X)

# Obtener las etiquetas de los clústeres
labels = dbscan.labels_

Es importante destacar que la elección de min_samples también influye en el número de clústeres detectados y en la sensibilidad del algoritmo al ruido. Un valor más alto de min_samples puede resultar en menos clústeres y más puntos considerados como ruido, mientras que un valor más bajo puede provocar clústeres más pequeños y sensibles a variaciones locales en la densidad.

Para evaluar la calidad del agrupamiento obtenido, se puede utilizar la puntuación de silhouette, que mide qué tan similares son los puntos dentro de un clúster en comparación con otros clústeres. Aunque este método tiene limitaciones en algoritmos basados en densidad, proporciona una medida cuantitativa útil:

from sklearn.metrics import silhouette_score

# Calcular la puntuación de silhouette
score = silhouette_score(X, labels)
print(f'Puntuación de silhouette: {score}')

Sin embargo, debemos ser cautelosos al interpretar la puntuación de silhouette en el contexto de DBSCAN, ya que este algoritmo puede identificar clústeres de formas arbitrarias y tamaños variables, lo que puede afectar la interpretación de esta métrica. Por ello, es recomendable complementar la evaluación con análisis visuales y conocimiento del dominio.

Otra técnica útil es la validación cruzada visual, que implica visualizar los resultados del agrupamiento para diferentes valores de ε y min_samples, y comparar cómo cambian los clústeres detectados. Este enfoque permite apreciar de manera intuitiva el impacto de los parámetros en el algoritmo.

Por ejemplo:

import matplotlib.pyplot as plt

# Valores candidatos para epsilon
eps_values = [0.3, 0.5, 0.7]

# Crear una figura para visualizar resultados
fig, axes = plt.subplots(1, len(eps_values), figsize=(15, 5))

for i, eps in enumerate(eps_values):
    # Ajustar DBSCAN con el valor de epsilon
    dbscan = DBSCAN(eps=eps, min_samples=4)
    dbscan.fit(X)
    labels = dbscan.labels_
    
    # Graficar los resultados
    axes[i].scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', s=50)
    axes[i].set_title(f'ε = {eps}')
    axes[i].set_xlabel('Característica 1')
    axes[i].set_ylabel('Característica 2')

plt.tight_layout()
plt.show()

En este código, se prueba DBSCAN con diferentes valores de ε y se visualizan los resultados en gráficos separados. Este ejercicio facilita la selección del ε óptimo al permitir comparar directamente cómo afectan los distintos valores a la estructura de los clústeres.

Además, la densidad estimada de los datos puede proporcionar información valiosa para ajustar min_samples. Si los datos tienen regiones con densidad variable, es posible que se requiera ajustar este parámetro para capturar adecuadamente los clústeres más dispersos sin perder detalles en las regiones más densas.

En situaciones donde el conjunto de datos es de alta dimensionalidad, es recomendable aplicar técnicas de reducción de dimensionalidad como PCA antes de utilizar DBSCAN. Esto ayuda a mitigar el efecto de la maldición de la dimensionalidad y puede mejorar la identificación de clústeres significativos.

Por último, es esencial recordar que no existe un método único para determinar el número óptimo de clústeres en DBSCAN, ya que depende en gran medida de la naturaleza de los datos y del análisis específico que se realice. La combinación de técnicas cuantitativas y cualitativas, junto con la experiencia y comprensión del dominio, es clave para un agrupamiento eficaz.

Casos de uso de DBSCAN

El algoritmo DBSCAN es ampliamente utilizado en diversas áreas debido a su capacidad para identificar clústeres de forma arbitraria y manejar eficientemente valores atípicos. A continuación, exploramos algunos casos de uso donde DBSCAN demuestra ser especialmente útil.

En el análisis geoespacial, DBSCAN sirve para identificar agrupaciones en datos geográficos. Por ejemplo, en la detección de zonas sismológicas, el algoritmo puede agrupar eventos sísmicos basándose en su proximidad geográfica y temporal. Esto permite identificar áreas de alta actividad sísmica sin presuponer la forma o el número de clústeres.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import DBSCAN
from haversine import haversine_vector, haversine

# Cargar datos de eventos sísmicos con coordenadas geográficas
data = pd.read_csv('eventos_sismicos.csv')  # El archivo debe contener columnas 'latitud' y 'longitud'

# Convertir latitudes y longitudes a una matriz de coordenadas
coordinates = data[['latitud', 'longitud']].to_numpy()

# Definir una función de distancia geográfica utilizando la fórmula de haversine
def geo_distance(coord1, coord2):
    return haversine(coord1, coord2)

# Crear el modelo DBSCAN con una métrica personalizada
dbscan = DBSCAN(eps=10, min_samples=5, metric=haversine)

# Ajustar el modelo a los datos geográficos (convertidos a radianes)
dbscan.fit(np.radians(coordinates))

# Añadir las etiquetas al dataframe original
data['cluster'] = dbscan.labels_

# Visualizar los clústeres geográficos
plt.scatter(data['longitud'], data['latitud'], c=data['cluster'], cmap='tab20', s=50)
plt.title('Agrupación de eventos sísmicos con DBSCAN')
plt.xlabel('Longitud')
plt.ylabel('Latitud')
plt.show()

En este ejemplo, se utiliza una métrica personalizada basada en la distancia de haversine para calcular distancias sobre la superficie terrestre. Esto es esencial cuando se trabaja con coordenadas geográficas y se desea obtener una agrupación significativa de los datos.

Otro ámbito donde DBSCAN es eficaz es en la detección de anomalías. Debido a que el algoritmo identifica puntos que no pertenecen a ninguna agrupación como ruido, es ideal para detectar comportamientos anómalos en conjuntos de datos. Por ejemplo, en el análisis de transacciones financieras, DBSCAN puede ayudar a identificar operaciones sospechosas que se desvían de los patrones normales.

from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_breast_cancer

# Cargar un conjunto de datos de ejemplo
data = load_breast_cancer()
X = data.data

# Escalar los datos para mejorar el rendimiento del algoritmo
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Aplicar DBSCAN para detectar anomalías
dbscan = DBSCAN(eps=0.5, min_samples=10)
dbscan.fit(X_scaled)

# Contar el número de puntos etiquetados como ruido (-1)
n_anomalies = np.sum(dbscan.labels_ == -1)
print(f'Número de anomalías detectadas: {n_anomalies}')

En el código anterior, se emplea DBSCAN para analizar un conjunto de datos de cáncer de mama, detectando posibles anomalías en los datos médicos que podrían representar errores de medición o casos atípicos relevantes para un diagnóstico.

En el campo del procesamiento de imágenes, DBSCAN puede utilizarse para la segmentación basada en la densidad de los píxeles en imágenes con patrones complejos. Esto es útil en aplicaciones como la identificación de objetos en imágenes satelitales o médicas.

from sklearn.cluster import DBSCAN
from skimage import io, color
import numpy as np

# Cargar una imagen y convertirla al espacio de color LAB
image = io.imread('imagen_satellite.png')
image_lab = color.rgb2lab(image)

# Remodelar la imagen para aplicar clustering
X = image_lab.reshape((-1, 3))

# Aplicar DBSCAN para segmentación
dbscan = DBSCAN(eps=2.5, min_samples=50)
dbscan.fit(X)

# Reasignar las etiquetas a la forma original de la imagen
labels = dbscan.labels_.reshape(image.shape[:2])

# Visualizar la segmentación resultante
plt.imshow(labels, cmap='nipy_spectral')
plt.title('Segmentación de imagen con DBSCAN')
plt.axis('off')
plt.show()

Imagen original:

Segmentación de imagen con DBSCAN:

Este ejemplo demuestra cómo DBSCAN puede segmentar una imagen en regiones basadas en la densidad de colores, lo que es particularmente útil cuando las formas de los objetos no son regulares o están distribuidos de manera compleja.

En astronomía, DBSCAN se utiliza para identificar agrupaciones de estrellas y galaxias en datos espaciales. Su capacidad para manejar datos con ruido significativo lo hace ideal para analizar catálogos estelares y detectar estructuras como cúmulos abiertos o globulares.

La biología computacional es otro campo donde DBSCAN encuentra aplicaciones, especialmente en el análisis de datos de secuenciación genética. Puede ayudar a agrupar secuencias genéticas similares y detectar variantes genéticas que son relevantes para la investigación médica.

En situaciones donde los datos presentan clústeres con densidades variables, DBSCAN puede adaptarse mediante técnicas como OPTICS (Ordering Points To Identify the Clustering Structure), que extiende las capacidades de DBSCAN para manejar estas variaciones.

from sklearn.cluster import OPTICS

# Aplicar OPTICS en lugar de DBSCAN para manejar densidades variables
optics = OPTICS(min_samples=5)
optics.fit(X_scaled)

# Obtener las etiquetas de clúster
labels_optics = optics.labels_

# Visualizar los resultados de OPTICS
plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=labels_optics, cmap='plasma', s=50)
plt.title('Clustering con OPTICS')
plt.xlabel('Característica 1 escalada')
plt.ylabel('Característica 2 escalada')
plt.show()

Con OPTICS, es posible identificar clústeres en datos donde la densidad no es uniforme, manteniendo la capacidad de detectar valores atípicos.

En el ámbito de las redes sociales, DBSCAN se emplea para detectar comunidades basadas en interacciones o similitudes entre usuarios. Al no requerir especificar el número de clústeres, es adecuado para el análisis exploratorio en grandes redes donde la estructura comunitaria no es conocida previamente.

Por último, en logística y gestión de flotas, DBSCAN ayuda a optimizar rutas y detectar patrones en datos de geolocalización de vehículos. Esto permite mejorar la eficiencia en el transporte y distribución de mercancías al identificar puntos de concentración y rutas más utilizadas.

La versatilidad de DBSCAN lo convierte en una herramienta esencial en numerosos campos que requieren análisis de agrupamiento en datos complejos. Su capacidad para manejar formas arbitrarias, densidades variables y ruido lo hace indispensable para profesionales que buscan extraer conocimiento de conjuntos de datos heterogéneos y sin estructuras predefinidas.