Implementando K-means

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

Juan Esteban

student•

Detallen bien su escogencia del número de clusters cuando evalúen el rendimiento del modelo con el silhouette score. Aquí por ejemplo generé los datos con cuatro centroides como en la clase, e hice el entrenamiento del modelo con tres clusters y obtuve lo siguiente:

También realicé el entrenamiento con cuatro clusters y obtuve lo siguiente:

Observen que el silhouette score fue mejor (más cercano a 1) con tres clusters, pero de entrada sabemos que en realidad en los datos hay cuatro clusters diferentes, así que sí, no se confíen solo en la primera métrica que saquen, hay que detallar más los resultados :)

Sergio Andres Rios Gomez

student•

Es necesario hacer la instalación de: !pip install yellowbrick

Juan R. Vergara M.

student•

Gracias 📝

Alfonso Andres Zapata Guzman

student•

Si obtienes el error:

AttributeError: 'NoneType' object has no attribute 'split'

Soluciona con:

!pip install threadpoolctl==3.1.0

Giovany samaca

student•

Que gran aporte Alfonso. ¿usaste google colab?

Alfonso Andres Zapata Guzman

student•

No man, use jupyterlabs en un dockerfile. Creo que en las primeras clases en la seccion de comentarios lo deje, igualmente te dejo el enlace al repositorio de github, checalo que esta muy bueno.

https://github.com/MaastrichtU-IDS/jupyterlab

Juan José Mamani Tarqui

student•

En la clusterization es necesaria entrenar el modelo?

No, no siempre es necesario entrenar un modelo para la clusterización. Existen dos tipos principales de algoritmos de clusterización:

1. Algoritmos no supervisados:

Estos algoritmos no requieren un conjunto de datos de entrenamiento con etiquetas predefinidas.
En cambio, agrupan los datos en función de sus similitudes intrínsecas.
Algunos ejemplos comunes son:
- K-means: Divide los datos en un número predefinido de clusters.
- Algoritmo de jerarquía ascendente (HAC): Crea una jerarquía de clusters a partir de los datos.
- DBSCAN: Encuentra clusters de densidad variable.

2. Algoritmos supervisados:

Estos algoritmos sí requieren un conjunto de datos de entrenamiento con etiquetas de cluster predefinidas.
A partir del conjunto de entrenamiento, aprenden a agrupar nuevos datos en clusters similares.
Algunos ejemplos son:
- K-nearest neighbors (KNN): Clasifica los datos en función de sus vecinos más cercanos en el espacio de características.
- Redes neuronales convolucionales (CNN): Agrupan imágenes en función de características visuales.

¿Cuándo es necesario entrenar un modelo?

Si tiene un conjunto de datos con etiquetas de cluster predefinidas, puede utilizar un algoritmo supervisado para obtener una mayor precisión en la clusterización.
Si no tiene etiquetas de cluster predefinidas, o si desea explorar diferentes tipos de clusters, puede utilizar un algoritmo no supervisado.

En resumen:

La necesidad de entrenar un modelo depende del tipo de algoritmo de clusterización que se utilice y de la disponibilidad de un conjunto de datos de entrenamiento con etiquetas predefinidas.
Los algoritmos no supervisados son una buena opción cuando no se tiene un conjunto de datos de entrenamiento con etiquetas predefinidas.
Los algoritmos supervisados pueden ofrecer una mayor precisión, pero requieren un conjunto de datos de entrenamiento con etiquetas predefinidas.

sebastián Giraldo Vargas

student•

Hice el ensayo de hacer el Kmeans con el dataset iris y me surgió la duda:

El clustering siempre se mostrará en un scatterplot, o podemos hacerlo en diferentes graficas?

O mas bién mi pregunta es, siempre para hacer un clustering devemos de elegir dos features??

Alarcon7a

student•

Es solo para buscar una manera fácil de graficar

EDUARDO FLORES

student•

K-mean no solo se realiza para dos features, puedes tener muchas más, entonces si por ejemplo e el caso de iris dataset tiene 4 features y quiere verlo en 2 dimensiones lo puede realizar a través de la técnica principal component analysis (PCA) ya que no podriamos ver un cluster en 4 dimensiones.

Juan José Mamani Tarqui

student•

Es necesario estandarizar en Kmeans?

!🚀

No es obligatorio estandarizar en Kmeans, pero se recomienda en la mayoría de los casos. La estandarización, también llamada normalización, consiste en transformar las variables para que tengan una media de 0 y una desviación estándar de 1. Esto tiene varias ventajas:

Mejora la precisión de Kmeans:

Kmeans se basa en la distancia entre los puntos de datos y los centroides de los clusters.
Si las variables tienen diferentes escalas, la distancia no se calculará de forma precisa.
La estandarización asegura que todas las variables tengan la misma importancia en el cálculo de la distancia.

Acelera la convergencia de Kmeans:

Kmeans es un algoritmo iterativo que busca encontrar la mejor asignación de puntos a clusters.
La estandarización puede ayudar a que el algoritmo converja más rápido, ya que las variables estarán en la misma escala.

Facilita la interpretación de los resultados:

Si las variables no están estandarizadas, puede ser difícil interpretar los centroides de los clusters.
La estandarización permite comparar los centroides de forma más sencilla.

En resumen:

La estandarización no es obligatoria en Kmeans, pero se recomienda para mejorar la precisión, la velocidad de convergencia y la interpretabilidad de los resultados.

Excepciones:

En algunos casos, la estandarización puede no ser necesaria o incluso puede ser perjudicial.
Por ejemplo, si las variables ya tienen una distribución normal, la estandarización puede no tener un impacto significativo.
Si las variables son categóricas, la estandarización no es aplicable.

En caso de duda, es recomendable estandarizar las variables antes de aplicar Kmeans.

Alfonso Andres Zapata Guzman

student•

Alternativa al codigo de visualizacion usado.

    fig1 = go.Figure()



    fig1.add_traces(data=
                    go.Scatter(x=df_blobs["x1"], y=df_blobs["x2"],    
                               marker=dict(
                               size=10,
                               color=df_blobs['cluster'],
                                colorscale=px.colors.diverging.RdBu[::-1]
                                ), mode='markers', name='Data')
                   )

    fig1.add_traces(data=
                    go.Scatter(x=df_centers["x1"], y=df_centers["x2"], mode='markers', name='Centers', marker=dict(color='#ff6602', size=20, symbol="x-dot"))
                   )

    fig1.add_traces(data=
                    go.Scatter(x=df_k_means_center["x1"], y=df_k_means_center["x2"], mode='markers', name='k_means_centers', marker=dict(color='yellow', size=20, symbol="circle-x"))
                   )


    fig1.update_layout(showlegend=True)
    fig1.show()

Juan R. Vergara M.

student•

👍

Alfonso Andres Zapata Guzman

student•

~ Que tal Platzinauta, ya conectamos en LinkedIn? ~

¡Que estas esperando! Conectemos en LinkedIn, GitHub, Medium o Redes sociales

Juan Acevedo

student•

Mario Alexander Vargas Celis

student•

A continuación te muestro un ejemplo paso a paso de cómo implementar K-means en Python usando scikit-learn.

✅ Paso 1: Importar librerías necesarias

import numpy as np import matplotlib.pyplot as plt from sklearn.cluster import KMeans from sklearn.datasets import make_blobs

✅ Paso 2: Generar datos de ejemplo

# Creamos un conjunto de datos sintético con 3 clusters X, y = make_blobs(n_samples=300, centers=3, cluster_std=0.60, random_state=0)

# Visualizamos los datos plt.scatter(X[:, 0], X[:, 1], s=50) plt.title("Datos sin clasificar") plt.show()

✅ Paso 3: Aplicar K-means

# Creamos y ajustamos el modelo kmeans = KMeans(n_clusters=3, random_state=0) kmeans.fit(X)

# Obtenemos las predicciones (a qué grupo pertenece cada punto) y_kmeans = kmeans.predict(X)

# Centros de los clusters centros = kmeans.cluster_centers_

✅ Paso 4: Visualizar los resultados

# Graficamos los datos clasificados por cluster plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=50, cmap='viridis')

# Mostramos los centros de cada cluster plt.scatter(centros[:, 0], centros[:, 1], c='red', s=200, alpha=0.75, marker='X') plt.title("Resultados del clustering con K-means") plt.show()

✅ Paso 5 (Opcional): Evaluar el número óptimo de clusters (método del codo)

inertia = []

for k in range(1, 10): kmeans = KMeans(n_clusters=k, random_state=0) kmeans.fit(X) inertia.append(kmeans.inertia_)

plt.plot(range(1, 10), inertia, marker='o') plt.xlabel('Número de clusters') plt.ylabel('Inercia') plt.title('Método del Codo') plt.show()

Juan José Mamani Tarqui

student•

Para encontrar el k adecuado se implementa the Elbow Method

Julián Cárdenas

student•

El código:

sns.scatterplot (data= df_blobs, x= "X1", y= "X2")
sns.scatterplot (data= df_centers, x= "X1", y= "X2", marker= "X", s= 100)
plt.show()

Aplicar KMeans:

kmeans = KMeans (n_clusters = 4)
df_cluster = kmeans.fit_predict(X)
df_blobs['cluster'] = df_cluster 
k_means_centers = kmeans.cluster_centers_
df_k_means_center = pd.DataFrame ({
     'X1': k_means_centers [:,0],
     'X2': k_means_centers [:,1],                              

})

fig = plt.figure(figsize=(9,9))
sns.scatterplot(data=df_blobs,  x='X1', y='X2', hue= 'cluster', palette='coolwarm')
sns.scatterplot(data=df_centers,  x='X1', y='X2', marker='X', s=150 , color='red')
sns.scatterplot(data=df_k_means_center,  x='X1', y='X2', marker='o', s=150 , color='yellow')
plt.show()

    fig1 = go.Figure()



    fig1.add_traces(data=
                    go.Scatter(x=df_blobs["x1"], y=df_blobs["x2"],    
                               marker=dict(
                               size=10,
                               color=df_blobs['cluster'],
                                colorscale=px.colors.diverging.RdBu[::-1]
                                ), mode='markers', name='Data')
                   )

    fig1.add_traces(data=
                    go.Scatter(x=df_centers["x1"], y=df_centers["x2"], mode='markers', name='Centers', marker=dict(color='#ff6602', size=20, symbol="x-dot"))
                   )

    fig1.add_traces(data=
                    go.Scatter(x=df_k_means_center["x1"], y=df_k_means_center["x2"], mode='markers', name='k_means_centers', marker=dict(color='yellow', size=20, symbol="circle-x"))
                   )


    fig1.update_layout(showlegend=True)
    fig1.show()

kmeans = KMeans (n_clusters = 4)
df_cluster = kmeans.fit_predict(X)
df_blobs['cluster'] = df_cluster 
k_means_centers = kmeans.cluster_centers_
df_k_means_center = pd.DataFrame ({
     'X1': k_means_centers [:,0],
     'X2': k_means_centers [:,1],                              

}) 

fig = plt.figure(figsize=(9,9))
sns.scatterplot(data=df_blobs,  x='X1', y='X2', hue= 'cluster', palette='coolwarm')
sns.scatterplot(data=df_centers,  x='X1', y='X2', marker='X', s=150 , color='red')
sns.scatterplot(data=df_k_means_center,  x='X1', y='X2', marker='o', s=150 , color='yellow')
plt.show()

Implementando K-means

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