Evaluando resultados de hierarchical clustering

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

Alfonso Andres Zapata Guzman

student•

Lo mismo pero con plotly, me guie de este codigo https://chart-studio.plotly.com/~Diksha_Gabha/2853.embed, pero le solucione errores que tenia que no permitian visualizar algunas funciones y sustitui librerias antiguas por sus equivalentes actuales.

import plotly.graph_objects as go
from plotly.subplots import make_subplots


from __future__ import print_function

from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score

import matplotlib
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np

range_n_clusters = [2, 3, 4, 5, 6]

figures = []

for n_clusters in range_n_clusters:
    # Create a subplot with 1 row and 2 columns
    fig = make_subplots(rows=1, cols=2,
                        print_grid=False,
                        subplot_titles=('The silhouette plot for the various clusters.',
                                              'The visualization of the clustered data.'))

    # The 1st subplot is the silhouette plot
    # The silhouette coefficient can range from -1, 1 but in this example all
    # lie within [-0.1, 1]
    fig['layout']['xaxis1'].update(title='The silhouette coefficient values',
                                   range=[-0.1, 1])

    # The (n_clusters+1)*10 is for inserting blank space between silhouette
    # plots of individual clusters, to demarcate them clearly.
    fig['layout']['yaxis1'].update(title='Cluster label',
                                   showticklabels=False,
                                   range=[0, len(X) + (n_clusters + 1) * 10])



    # Initialize the clusterer with n_clusters value and a random generator
    # seed of 10 for reproducibility.
    clusterer = AgglomerativeClustering(n_clusters=n_clusters, metric='euclidean', linkage='ward')
    cluster_labels = clusterer.fit_predict(X)

    # The silhouette_score gives the average value for all the samples.
    # This gives a perspective into the density and separation of the formed
    # clusters
    silhouette_avg = silhouette_score(X, cluster_labels)
    print(
        "For n_clusters =",
        n_clusters,
        "The average silhouette_score is :",
        silhouette_avg,
    )

    # Compute the silhouette scores for each sample
    sample_silhouette_values = silhouette_samples(X, cluster_labels)

    y_lower = 10

    color = []

    for i in range(n_clusters):
        # Aggregate the silhouette scores for samples belonging to
        # cluster i, and sort them
        ith_cluster_silhouette_values = \
            sample_silhouette_values[cluster_labels == i]

        ith_cluster_silhouette_values.sort()

        size_cluster_i = ith_cluster_silhouette_values.shape[0]
        y_upper = y_lower + size_cluster_i


        colors = matplotlib.colors.colorConverter.to_rgb(cm.nipy_spectral(float(i) / n_clusters))
        colors = 'rgb'+str(colors)
        color.append(colors)
        filled_area = go.Scatter(y=np.arange(y_lower, y_upper),
                                 x=ith_cluster_silhouette_values,
                                 mode='lines',
                                 showlegend=False,
                                 line=dict(width=0.5,
                                          color=colors),
                                 fill='tozerox',
                                 name='Silhouette')
        fig.add_traces(filled_area, 1, 1)

        # Compute the new y_lower for next plot
        y_lower = y_upper + 10  # 10 for the 0 samples


    # The vertical line for average silhouette score of all the values
    axis_line = go.Scatter(x=[silhouette_avg, silhouette_avg],
                           y=[0, y_upper],
                           showlegend=False,
                           mode='lines',
                           line=dict(color="red", dash='dash',
                                     width =2) )


    fig.append_trace(axis_line, 1, 1)


    # 2nd Plot showing the actual clusters formed
    clusters = go.Scatter(x=X[:, 0], 
                          y=X[:, 1], 
                          showlegend=False,
                          mode='markers',
                          marker=dict(color=cluster_labels,
                                     size=4, colorscale=color),
                          name='Data'
                         )
    fig.append_trace(clusters, 1, 2)

#         # Labeling the clusters
#         centers_ = clusterer.cluster_centers_
#         # Draw white circles at cluster centers
#         centers = go.Scatter(x=centers_[:, 0], 
#                              y=centers_[:, 1],
#                              showlegend=False,
#                              mode='markers',
#                              marker=dict(color='green', size=10,
#                                          line=dict(color='black',
#                                                                  width=1))
#                             )

#     fig.append_trace(centers, 1, 2)

    fig['layout']['xaxis2'].update(title='Feature space for the 1st feature',
                                   zeroline=False)
    fig['layout']['yaxis2'].update(title='Feature space for the 2nd feature',
                                  zeroline=False)


    fig['layout'].update(title="Silhouette analysis for KMeans clustering on sample data "
                         "with n_clusters = %d" % n_clusters)

    fig.update_layout(showlegend=True)
    figures.append(fig)
    fig.show()

Quizas requieras:

# !pip install chart_studio

Luis Ernesto Domínguez Velásquez

student•

Excelente estimado Alfonso.

Alfonso Andres Zapata Guzman

student•

Gracias man.

~ Que tal Platzinauta, ya conectamos en LinkedIn? ~

¡Que estas esperando! Conectemos en LinkedIn, GitHub, Medium, Redes sociales o unete al mejor servidor de Discord sobre Python y ciencia de datos en español.

Jhon Sanchez

student•

seria interesante ver es sobre bases de datos no con la generacion aleatoria de datos.

johan Stever Rodriguez Molina

student•

Esta función tal vez pueda ser de ayuda para visualizar el silhouette_score(avg) y el silhouette_samples.

def plot_silhouette(df,X,y, clust_var_name=""):
    """
    Args:
        - clust_var_name:string  
            Nombre columna con el valor del cluster asignado a cada observacion(y_pred)
        - df: DataFrame con los features y la columna clust_var_name
        - X: np.Array
            Array con los features
        - y: np.Array
            Array con los valores de la prediccion del cluster
    """
    silhouette = round(silhouette_score(X,y),2)
    samples = silhouette_samples(X,y) 
    df["silhouette_samples"] = samples
    clusters = df[clust_var_name].unique()
    n_samples = len(df)
    y_pos = n_samples*0.05
    for i,cluster in enumerate(clusters):
        df_aux = df[df[clust_var_name] == cluster].sort_values("silhouette_samples")
        plt.figure(i)
        df_aux["silhouette_samples"].plot(kind="barh")
        plt.vlines(x=silhouette,ymin=0,ymax=n_samples,linestyles="--",color ='red')
        plt.text(x=0.8,y=y_pos,s=f"avg_silhouette_score: {silhouette}")
        plt.xlabel("silhouette_score")
        plt.ylabel("n_sample")
        plt.yticks([])
        plt.title(f"Sample silhouettes for custer {cluster}")

FELIX DAVID CORDOVA GARCIA

student•

Excelentes explicaciones, hacia falta curso¡

David Duque Uribe

student•

¿Por que suelen poner la letra X en mayusucula?

Eugenio Schiavoni

student•

Pasa que en el contexto de la inteligencia artificial y el aprendizaje automático, se utiliza la convención de usar "X" mayúscula para representar las características o variables independientes y "y" minúscula para representar la variable dependiente o la variable objetivo.

Esta convención se basa en la notación matemática tradicional, donde las variables independientes se representan comúnmente con letras mayúsculas (como "X") y la variable dependiente se representa con una letra minúscula (como "y"). Esta convención se aplica a muchas áreas de la ciencia y la estadística, y se ha adoptado en el campo del aprendizaje automático para mantener la consistencia y facilitar la comprensión de los conceptos.

Nixon Rolando García Ramírez

student•

Uff me encanto esta clase, mas que todo la forma tan clara de ver los K , con los graficos de velas y su respectiva clasificacion al lado.💪💪💪💪

Gerardo Jesus Ignacio Villacorta

student•

¡Buena clase! Sigo este curso con un dataset de transacciones con y sin fraude, comparto en la imagen la gráfica de mi índice de silhouette para 2 clusters, estoy aún dandole una explicación porque de los 400 puntos o trasacciones solo 2 corresponden al cluster 1 y 398 al cluster 2, y por ello el ancho tan delgado y grueso respectivamente. Entendería que aún debo seguir trabajando en la variables de mi dataset para tener mejores resultados. ¡Todo feedback es bienbenido! Gracias de antemano.

Julián Cárdenas

student•

Vea pues interesante DataSet!

Mario Alexander Vargas Celis

student•

Para evaluar los resultados del clustering jerárquico (hierarchical clustering), puedes aplicar métricas internas similares a las usadas en otros algoritmos como K-means. Aquí te muestro cómo hacerlo y con qué herramientas:

📊 1. Silhouette Score

Mide qué tan bien están separados los clústeres:

from sklearn.metrics import silhouette_score

score = silhouette_score(X_scaled, y_hc) print(f"Silhouette Score: {score:.3f}")

Rango: de -1 a 1. Mientras más cercano a 1, mejor definidos están los grupos.

🧮 2. Calinski-Harabasz Index

Mide la dispersión entre clústeres frente a la dispersión dentro del clúster:

from sklearn.metrics import calinski_harabasz_score

score = calinski_harabasz_score(X_scaled, y_hc) print(f"Calinski-Harabasz Index: {score:.2f}")

Interpretación: cuanto mayor el valor, mejor separados están los clústeres.

🔢 3. Davies-Bouldin Index

Mide la similitud entre clústeres; valores más bajos son mejores:

from sklearn.metrics import davies_bouldin_score

score = davies_bouldin_score(X_scaled, y_hc) print(f"Davies-Bouldin Index: {score:.3f}")

🌳 4. Visualización con dendrograma

Si usas scipy, puedes generar un dendrograma para inspección visual:

import scipy.cluster.hierarchy as sch import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6)) dendrogram = sch.dendrogram(sch.linkage(X_scaled, method='ward')) plt.title('Dendrograma') plt.xlabel('Muestras') plt.ylabel('Distancia') plt.show()

✅ Conclusión

Métrica¿Qué mide?IdealSilhouette ScoreSeparación y compactaciónCercano a 1Calinski-Harabasz IndexDispersión entre/intra gruposAltoDavies-Bouldin IndexSimilitud entre clústeresBajo

Daniel Andres Rojas Paredes

student•

la confirmacion visual no es la unica forma de evaluacion. puedes pedirle a chat gtp que te de un script con las metricas de coef de siluetta para evaluarlo si usas un lector de pantalla tambien teniendo en cuenta el numero de puntos por cluster para ver si estan balanceados , la altura de el dendograma y la media minima y maxima de cada coeficiente de silueta individual por cada sample

✅ High confidence answer — This is a standard question in clustering analysis.

To select the right number of clusters based on your metrics (like silhouette score and dendrogram cut height), you should use a combination of criteria:

✅ 1. Silhouette Score (Primary Metric)

Goal: Find the number of clusters with the highest average silhouette score.
Interpretation:
- Close to 1.0: points are well-matched to their cluster and far from others → ideal.
- Around 0.5: okay, clusters are present but overlapping.
- Below 0.3: clustering is probably meaningless or too fine-grained.
Watch out: The silhouette score tends to decrease as you increase the number of clusters (due to overfitting), so you want the peak, not just the highest number.

✅ 2. Silhouette Score Distribution (Per Cluster)

Check the mean, min, and max per cluster (as you’re printing).
Watch for:
- Very low or negative min values → some points are in the wrong cluster.
- Large variation between clusters → clustering may be imbalanced.
Ideal: Silhouette scores are consistently high across all clusters.

✅ 3. Dendrogram Cut Height

From the linkage_matrix, the average cut height gives a sense of separation between clusters.
Larger height differences in the final merges (i.e., when going from k+1 to k clusters) suggest that the new merge combines dissimilar clusters, which might be a bad sign.
You may look for an "elbow" or a sudden drop in cut height → that’s often a good place to stop merging.

✅ 4. Cluster Balance

Use Counter(cluster_ids) to check sample count per cluster.
Heavily unbalanced sizes (like 290 vs. 10) may suggest bad clustering, unless justified by domain knowledge.

🚫 What Not to Do

Never use test accuracy, because this is unsupervised learning (no labels).
Don't just blindly pick the n_clusters with the biggest number of clusters or sharpest cut unless other metrics agree.

🧠 Tip: Combine visually

If you generate:

Silhouette plots per cluster
Dendrograms …you can often visually confirm what the metrics suggest.

Would you like a summary table format or diagram to help track these values for each k?

Jorber Andrés Pardo Franco

student•

Son dos Algoritmos de gran relevancia en el Machine learning aprendizaje no supervisado, fáciles de comprender y usar acorde a nuestro dataframe, amplia la visión de dendrograma a conjunto de ven, un buen contraste para así comprender El proceso.

Antonio Demarco Bonino

student•

Me encantaron los dos, aunque creo que hierarchical clustering es más eficiente para averiguar cuantos tipos diferentes de grupos hay. En cambio, el K-means es más eficiente cuando tenemos ya la cantidad de centroides.

Evaluando resultados de hierarchical clustering

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