Resolviendo con DBSCAN

Clase 23 de 27 • Curso de Clustering con Python y scikit-learn

Mario Chavez

student•

Yo hice esto para encontrar mas rapido los coluster con mas grupos y mas silhouette_score

# El codigo de profe un poco modificado
from itertools import product

params = product(np.linspace(1.2, 2.6, 14), np.arange(2, 12))

params_mat = pd.DataFrame({
   'epsilon': [],
   'min_samples': [],
   'silhouette_score': [],
   'no_clusters': []
})

for epsilon, samples in params:
    y_pred = DBSCAN(eps=epsilon, min_samples=samples).fit_predict(X)
    params_mat.loc[len(params_mat)] = [epsilon, samples, silhouette_score(X, y_pred), len(np.unique(y_pred))]

# Encontar los mejores parametros

(
    params_mat
    [(params_mat.no_clusters == 3) | (params_mat.no_clusters == 4)]
    .sort_values(by='silhouette_score', ascending=False)
    .head(10)
)

Julián Cárdenas

student•

Excelente!

Anuar Steven Garcia

student•

por que razon np.arange(3,12), entiendo que hay cuatro features pero no entiendo que determina ese rango

Luis Alejandro Arellano Camacho

student•

La función np.arange(start, stop) de NumPy genera un array de valores enteros desde start hasta stop - 1. En tu caso, np.arange(3, 12) crea un array que inicia en 3 y termina en 11, generando los valores [3, 4, 5, 6, 7, 8, 9, 10, 11].

Este rango se refiere a las características (features) que se pueden analizar en tu modelo. Si mencionas cuatro características, es probable que estés trabajando con un conjunto de datos donde estas características representan dimensiones diferentes en el análisis de clustering.

Santiago Ahumada Lozano

student•

A la hora de optimizar el epsilon en el modelo, me gustaría saber en qué influye el numero de vecinos más cercanos para el método de la rodilla

neighbors = NearestNeighbors(n_neighbors=12)

Fernando Jesús Núñez Valdez

student•

Básicamente lo que se hace es tomar cada punto y calcularle el vecino mas cercano a este mismo (puede ser 1 vecino o 2,3,4,5), pero para calcular el epsilon que necesitamos simplemente lo podriamos realizar para un vecino, es decir:

neighbors = NearestNeighbors(n_neighbors=1)

ya que aunque calculemos 2,3,4, etc. El único que estamos usando es el primero (el mas cercano). Yo lo realice así:

from sklearn.neighbors import NearestNeighbors
neighbors = NearestNeighbors(n_neighbors=1)
neighbors_fit = neighbors.fit(pca_data_standard)
distances, index = neighbors_fit.kneighbors()

distances = np.sort(distances, axis=0)

fig = plt.figure(figsize=(5,5))
plt.axhline(0.6, color='r', linestyle='--' )
plt.axhline(2, color='r', linestyle='--' )
plt.plot(distances, linewidth=2, label="Distances")
plt.legend(fontsize=14)

En conclusión: Calculando el primer vecino es suficiente.

Sebastian Serna Jimenez

student•

No entiendo por qué se calcula la distancia de tantos vecinos si sólo se usa el #1 (más cercano)

david jurado

student•

Cómo se sabe el número de min_samples?

Juan Acevedo

student•

Les comparto mi grafica , con los coeficiente de silueta y la cantidad de cluster que nos da

Juan Acevedo

student•

Por si e de pronto se preguntan el manejo de ese error, se debe a que el coeficiente de silueta necesita mínimo dos clusterpara poder funcionar , un a y un b , entonces si tiene 1 cluster este no puede funcionar y normalmente cuando estamos iterando puede que el radio o la cantidad mínima de vecinos que tenga es tan baja que realmente no llegamos a mas de 1 cluster entonces eso detendría nuestra iteración y no podríamos ver los valores

Mario Alexander Vargas Celis

student•

Resolver un problema con DBSCAN (Density-Based Spatial Clustering of Applications with Noise) es ideal cuando esperas encontrar clusters de forma irregular o quieres detectar outliers (valores atípicos) de forma automática. Aquí te muestro cómo implementarlo paso a paso en Python, usando como ejemplo autos disponibles en Colombia bajo ciertos criterios.

✅ 1. Importar librerías

import pandas as pd import numpy as np from sklearn.preprocessing import StandardScaler from sklearn.cluster import DBSCAN import matplotlib.pyplot as plt

✅ 2. Datos de ejemplo

Simulamos datos representativos de autos:

data = { 'Modelo': ['Onix', 'Kia Soluto', 'Swift', 'S-Cross', 'Picanto', 'K3 Cross', 'Kardian'], 'Precio': [82320000, 69990000, 85000000, 125000000, 65000000, 120000000, 110000000], 'Consumo_kmgl': [65, 60, 70, 55, 68, 58, 62], 'Longitud_mm': [4474, 4300, 3840, 4300, 3595, 4365, 4115] } df = pd.DataFrame(data)

✅ 3. Normalización

scaler = StandardScaler() X_scaled = scaler.fit_transform(df[['Precio', 'Consumo_kmgl', 'Longitud_mm']])

✅ 4. Aplicar DBSCAN

dbscan = DBSCAN(eps=1.0, min_samples=2) labels = dbscan.fit_predict(X_scaled) df['Cluster'] = labels

✅ 5. Visualizar resultados

plt.figure(figsize=(8, 5)) plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=labels, cmap='Set1') for i, modelo in enumerate(df['Modelo']): plt.annotate(modelo, (X_scaled[i, 0], X_scaled[i, 1])) plt.title('Clusters con DBSCAN') plt.xlabel('Precio (normalizado)') plt.ylabel('Consumo (normalizado)') plt.grid(True) plt.show()

✅ 6. Interpretar resultados

El campo Cluster en df indica el grupo al que pertenece cada auto.
Los valores -1 son outliers: DBSCAN los identifica como puntos que no pertenecen a ningún cluster.
Puedes ajustar eps y min_samples para modificar la densidad mínima requerida para formar un grupo.

🔧 Ajuste de Hiperparámetros

Para encontrar buenos valores de eps y min_samples, puedes usar:

from sklearn.neighbors import NearestNeighbors

neighbors = NearestNeighbors(n_neighbors=2) neighbors_fit = neighbors.fit(X_scaled) distances, indices = neighbors_fit.kneighbors(X_scaled)

distances = np.sort(distances[:, 1]) plt.plot(distances) plt.title('K-distance plot') plt.xlabel('Puntos ordenados') plt.ylabel('Distancia al 2° vecino más cercano') plt.grid(True) plt.show()

Busca el “codo” en el gráfico para elegir el valor de eps.

Matías Collado

student•

What?

Fenis Toro

student•

Yo hice el DBSCAN con in diferente método y me salió un índice de silueta más alto de 5.8. utilice este code

from itertools import product
dbscan_params = list(product(eps_values,min_samples))
sil_scores = []
best_score = -1
best_eps = None
best_min_samples = None 

for i in dbscan_params:
    y = DBSCAN(eps=i[0],min_samples=i[1]).fit_predict(pca_data_stamdard)
    score = silhouette_score(pca_data_stamdard,y) 

    if score > best_score:

        best_score = score
        best_eps = i[0]
        best_min_samples = i[1] 

print('El mejor silhouette_score : ',best_score.round(2))
print('El mejor eps : ',best_eps)
print('El mejor min_sample : ',best_min_samples)
```from itertools import productdbscan\_params = list(product(eps\_values,min\_samples))sil\_scores = \[]best\_score = -1best\_eps = Nonebest\_min\_samples = None&#x20;
for i in dbscan\_params:    y = DBSCAN(eps=i\[0],min\_samples=i\[1]).fit\_predict(pca\_data\_stamdard)    score = silhouette\_score(pca\_data\_stamdard,y)&#x20;
    if score > best\_score:
        best\_score = score        best\_eps = i\[0]        best\_min\_samples = i\[1]&#x20;
print('El mejor silhouette\_score : ',best\_score.round(2))print('El mejor eps : ',best\_eps)print('El mejor min\_sample : ',best\_min\_samples)

Fenis Toro

student•

ya me di de cuenta de lo que sucede pero no se como borrar el comentario

Julián Cárdenas

student•

La verdad ni idea, pregunta en la parte de comentarios, cómo borrar un comentario

# El codigo de profe un poco modificado
from itertools import product

params = product(np.linspace(1.2, 2.6, 14), np.arange(2, 12))

params_mat = pd.DataFrame({
   'epsilon': [],
   'min_samples': [],
   'silhouette_score': [],
   'no_clusters': []
})

for epsilon, samples in params:
    y_pred = DBSCAN(eps=epsilon, min_samples=samples).fit_predict(X)
    params_mat.loc[len(params_mat)] = [epsilon, samples, silhouette_score(X, y_pred), len(np.unique(y_pred))]

# Encontar los mejores parametros

(
    params_mat
    [(params_mat.no_clusters == 3) | (params_mat.no_clusters == 4)]
    .sort_values(by='silhouette_score', ascending=False)
    .head(10)
)

from sklearn.neighbors import NearestNeighbors
neighbors = NearestNeighbors(n_neighbors=1)
neighbors_fit = neighbors.fit(pca_data_standard)
distances, index = neighbors_fit.kneighbors()

distances = np.sort(distances, axis=0)

fig = plt.figure(figsize=(5,5))
plt.axhline(0.6, color='r', linestyle='--' )
plt.axhline(2, color='r', linestyle='--' )
plt.plot(distances, linewidth=2, label="Distances")
plt.legend(fontsize=14)

from itertools import product
dbscan_params = list(product(eps_values,min_samples))
sil_scores = []
best_score = -1
best_eps = None
best_min_samples = None 

for i in dbscan_params:
    y = DBSCAN(eps=i[0],min_samples=i[1]).fit_predict(pca_data_stamdard)
    score = silhouette_score(pca_data_stamdard,y) 

    if score > best_score:

        best_score = score
        best_eps = i[0]
        best_min_samples = i[1] 

print('El mejor silhouette_score : ',best_score.round(2))
print('El mejor eps : ',best_eps)
print('El mejor min_sample : ',best_min_samples)
```from itertools import productdbscan\_params = list(product(eps\_values,min\_samples))sil\_scores = \[]best\_score = -1best\_eps = Nonebest\_min\_samples = None&#x20;
for i in dbscan\_params:    y = DBSCAN(eps=i\[0],min\_samples=i\[1]).fit\_predict(pca\_data\_stamdard)    score = silhouette\_score(pca\_data\_stamdard,y)&#x20;
    if score > best\_score:
        best\_score = score        best\_eps = i\[0]        best\_min\_samples = i\[1]&#x20;
print('El mejor silhouette\_score : ',best\_score.round(2))print('El mejor eps : ',best\_eps)print('El mejor min\_sample : ',best\_min\_samples)

Resolviendo con DBSCAN

Fundamentos de clustering

¿Qué es el clustering en machine learning?

Tu primer clustering con scikit-learn

¿Cuándo usar clustering?

¿Cómo evaluar modelos de clustering?

K-means

¿Qué es el algoritmo de K-means y cómo funciona?

¿Cuándo usar K-means?

Implementando K-means

Encontrando K

Evaluando resultados de K-means

Hierarchical clustering

¿Qué es hierarchical clustering y cómo funciona?

¿Cuándo usar hierarchical clustering?

Implementando hierarchical clustering

Evaluando resultados de hierarchical clustering

DBSCAN

¿Qué es DBSCAN y cómo funciona?

¿Cuándo usar DBSCAN?

Implementando DBSCAN

Encontrar híper-parámetros

Evaluando resultados de DBSCAN

Proyecto: resolviendo un problema con clustering

Preparar datos para clusterizar

Aplicando PCA para clustering

Resolviendo con K-means

Resolviendo con hierarchical clustering

Resolviendo con DBSCAN

Resolviendo con DBSCAN (sin PCA)

Evaluación resultados de distintos modelos de clustering

Conclusiones

Proyecto final y cierre

Comparte tu proyecto de segmentación con clustering y certifícate