Tu primer clustering con scikit-learn

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

Clase anteriorSiguiente clase

Giovany samaca

student•

Hola Les comparto una manera de graficar los clusters un poco mas sencilla.

Federico Mario

student•

Espectacular! Igual me parece mejor utilizar un scatterplot que no te hace la regresion lineal (que en este caso no tiene sentido)

Octavio De Paula

student•

Con un simple fit_reg=False puede sacarse la regresion lineal.

sns.lmplot(x='x1', y='x2', hue='y', data=df_blobs, fit_reg=False)

Jhon David Vanegas Guerrero

student•

Hola, no me queria funcionar el codigo en la linea

fig, ax = plt.subplots(1,1, figsize=(15,10))

Si alguien tiene ese mismo error, mi solucion fue importar subplots

from matplotlib.pyplot import subplots

Y luego eliminar "plt" de la linea de codigo.

fig, ax = subplots(1,1, figsize=(15,10))

Espero le sirva a alguien

Juan R. Vergara M.

student•

Machine Learning: allá voy 🚀🔥

Julián Cárdenas

student•

Así es!!

Alfonso Andres Zapata Guzman

student•

Template para plotly que colocaremos en un notebook en el mismo directorio

import plotly.graph_objects as go
import plotly.io as pio

pio.templates['new_template'] = go.layout.Template()
pio.templates['new_template']['layout']['font'] = {'family': 'verdana', 'size': 16, 'color': 'white'}
pio.templates['new_template']['layout']['paper_bgcolor'] = 'black'
pio.templates['new_template']['layout']['plot_bgcolor'] = 'black'
pio.templates['new_template']['layout']['xaxis'] = {'title_standoff': 10, 'linecolor': 'black', 'mirror': True, 'gridcolor': '#EEEEEE'}
pio.templates['new_template']['layout']['yaxis'] = {'title_standoff': 10, 'linecolor': 'black', 'mirror': True, 'gridcolor': '#EEEEEE'}
pio.templates['new_template']['layout']['legend_bgcolor'] = 'rgb(117, 112, 179)'
pio.templates['new_template']['layout']['height'] = 700
pio.templates['new_template']['layout']['width'] = 1000
pio.templates['new_template']['layout']['autosize'] = False

pio.templates.default = 'new_template'

Ejecutamos con funciones magicas el notebook del template

%run "template_visualitation.ipynb"

Funcion para visualizar los scatter plot con plotlly

import plotly.graph_objects as go
import plotly.express as px


def graficar_clusters_plotly(x,y, color, show=True):
    global fig1
    fig1 = go.Figure()
    y_uniques = pd.Series(y).unique()

    for _ in y_uniques:
        fig1.add_traces(data=px.scatter(x=x[y==_][:,0], y=x[y==_][:,1],opacity=0.8, color_discrete_sequence=[color[_]]).data)

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

Ejecutamos nuestra funcion

graficar_clusters_plotly(x,y, ['red', 'blue', 'green', 'white'])

Eliminar o comentar la linea del notebook que contiene el siguiente codigo, no afecta la clusterizacion con KMeans:

x, y = df_blobls[['x1','x2']], df_blobls['y']

Agregamos un color ya que ahora tenemos 5 centroides

graficar_clusters_plotly(x,y_pred, ['red', 'blue', 'green', 'white', 'yellow'])

johan Stever Rodriguez Molina

student•

A modo de aporte para ir más allá de estos modelos básicos que se ven. Les recomiendo revisar

HDBSCAN: como saben DBSCAN es parametrico y requiere por ejemplo el valor de un valor epsilon. Este modelo trata de refinar y ayudarnos para evitar tratar de tunear dicho parametro
Gaussian mixtures: Estos modelos básicos tienen problemas para detectar datos anomalos. Este algoritmo permite deterctar datos anomalos, asignando una probabilidad a que cada dato pertenezca a una distribucion gaussina

Anuar Steven Garcia

student•

This is a function definition for a function called plot_2d_clusters that takes in three arguments: x, y, and ax.

The function does the following:

It first creates a Pandas Series object from the y argument, and then uses the unique method of the Series to find the unique values in y. It stores the resulting array of unique values in the variable y_uniques.

It then enters a loop, in which it iterates over the unique values in y_uniques. On each iteration of the loop, the function plots the data points in x where the corresponding value in y is equal to the current unique value being iterated over.

The plot is created using the plot method of the DataFrame object x, which is passed the following arguments:

title: a string that is the title of the plot, which is constructed using string interpolation to insert the number of unique values in y into the string. kind: the type of plot to create, which is set to 'scatter'. x: the name of the column in x to use as the x-axis data. y: the name of the column in x to use as the y-axis data. marker: a string that specifies the marker to use for the data points in the plot, which is constructed using string interpolation to insert the current unique value being iterated over into the string. ax: the Matplotlib Axes object to use for the plot. It's worth noting that this function does not return anything, but instead creates a plot using the ax argument.

Romel Manrique

student•

Otra forma de graficar los clusters:

plt.figure(figsize=(6,6))
def plot_blobs(x, y, ax, cmap='viridis'):
    labels = np.unique(y)
    cmap_ = plt.get_cmap(cmap, lut=len(labels))
    for label in labels:
        sub_idx = np.argwhere(y == label).ravel()
        sub_x = x[sub_idx]
        sub_y = y[sub_idx]
        ax.scatter(sub_x[:,0], sub_x[:,1], color=cmap_(label), label=label)

plot_blobs(x,y, plt.gca(), cmap='Dark2')
plt.legend()
plt.show()

Juan Manuel Betancur

student•

Si quieren graficar más fácil, después de aplicar y predecir usando el modelo pueden usar esta opción con seaborn.


X_plot = X.copy() #Creo una copia de de X
X_plot['Cluster'] = y_pred #a X le agrego las predicciones


#Ahora graficamos con seaborn
sns.scatterplot(data=X_plot, x='X1', y='X2', hue='Cluster', palette='Set2')
plt.title("Clusters encontrados por K-Means")
plt.xlabel("X1")
plt.ylabel("X2")
plt.legend(title="Cluster")
plt.show()
```#Ahora graficamos con seaborn



X\_plot = X.copy() #Creo una copia de de X

X\_plot\['Cluster'] = y\_pred #a X le agrego las predicciones





\#Ahora graficamos con seaborn

sns.scatterplot(data=X\_plot, x='X1', y='X2', hue='Cluster', palette='Set2')

plt.title("Clusters encontrados por K-Means")

plt.xlabel("X1")

plt.ylabel("X2")

plt.legend(title="Cluster")

plt.show()

Eugenio Schiavoni

student•

Para agilizar

import numpy as np
import pandas as pd
from sklearn.datasets import make_blobs
import seaborn as sns
import matplotlib.pyplot as plt

x, y = make_blobs(n_samples=100, centers=4, n_features=2, cluster_std=[1,1.5,2,2], random_state=7)

df_blobls = pd.DataFrame({
    'x1': x[:,0],
    'x2':x[:,1],
    'y':y

})

def plot_2d_clusters(x,y,ax):
    y_uniques = pd.Series(y).unique()

    for _ in y_uniques:
        x[y==_].plot(
            title=f'{len(y_uniques)} Clusters',
            kind='scatter',
            x='x1',
            y='x2',
            marker = f'${_}$',
            ax = ax
        )

fig, ax = plt.subplots(1,1, figsize=(15,10))
x, y = df_blobls[['x1','x2']], df_blobls['y']
plot_2d_clusters(x,y,ax)
plt.show()```

Julián Cárdenas

student•

Buena!

Erick Jacob Lugo Batalla

student•

Modificando un poco y mezclando un par de aportes, les comparto este modo de graficarlos, me parece que le da más visualización, solo se debe modificar desde el bloque anterior:

y_pred = kmeans.fit_predict(x)

df_plot = df_blobls.copy()
df_plot['y_pred'] = y_pred

import seaborn as sns

fig, axs = plt.subplots(1, 2, figsize=(20, 12))

plot_2d_clusters(x,y,axs[0])
plot_2d_clusters(x,y_pred,axs[1])

# Primer gráfico: datos reales
palette = sns.color_palette("tab10", n_colors=4)
sns.scatterplot(x='x1', y='x2', hue='y', data=df_plot, ax=axs[0], palette = palette)
axs[0].set_title(f'Actual {axs[0].get_title()}')

# Segundo gráfico: predicciones (KMeans)
palette = sns.color_palette("tab10", n_colors=5)
sns.scatterplot(x='x1', y='x2', hue='y_pred', data=df_plot, ax=axs[1], palette = palette)
axs[1].set_title(f'KMeans {axs[1].get_title()}')

plt.show()

Juan Acevedo

student•

Mario Alexander Vargas Celis

student•

¡Perfecto! Aquí tienes un ejemplo básico de cómo hacer tu primer clustering usando scikit-learn en Python, utilizando el algoritmo K-Means, uno de los más comunes y fáciles de usar.

📦 Requisitos previos

Primero, asegúrate de tener las siguientes librerías instaladas:

pip install scikit-learn matplotlib seaborn

✅ Ejemplo básico: Clustering con K-Means

import matplotlib.pyplot as plt from sklearn.cluster import KMeans from sklearn.datasets import make_blobs import seaborn as sns

# 1. Generamos datos de ejemplo X, y_true = make_blobs(n_samples=300, centers=3, cluster_std=0.60, random_state=42)

# 2. Aplicamos KMeans con 3 clústers kmeans = KMeans(n_clusters=3, random_state=42) kmeans.fit(X)

# 3. Obtenemos las predicciones y_kmeans = kmeans.predict(X)

# 4. Visualizamos el resultado plt.figure(figsize=(8, 6)) sns.scatterplot(x=X[:, 0], y=X[:, 1], hue=y_kmeans, palette="Set1", s=60) plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s=200, c='black', marker='X', label='Centroides') plt.title("Clustering con KMeans") plt.legend() plt.show()

🔍 ¿Qué hace este código?

Crea datos sintéticos con 3 clústers.
Aplica el algoritmo K-Means para agrupar los datos.
Visualiza los grupos asignados y los centroides de cada clúster.

¿Y luego?

Puedes intentar con tus propios datos o probar otros algoritmos de clustering como:

DBSCAN (detecta clústers de forma irregular)
AgglomerativeClustering (jerárquico)
MeanShift

LUIS GUILLERMO MONCADA RUIZ

student•

Los Clusters, se puede seleccionar como yo quiera?, en este caso digamos fueron 4, eso no lo define algo como el metodo del codo o asi?

Leandro Tenjo

student•

Justo ese es uno de los temas que se tocan m[as adelante en el curso

DIEGO ALEJANDRO BAUTISTA LINDARTE

student•

Tengo una pregunta y es como en este filtro 'x[y==_].plot', saben a que fila de x pertenece el respectivo y, ejemplo a cual fila de x saben que y es igual a cero o uno, si x no tiene la columna y. Es decir no están relacionados.

¿No se si me hice entender?

EDWING ALFONSO ARENAS RUEDA

student•

un tema que me agrada aprotar al tema de machine learning, es que ya entrenado el modelo y obtenido los parametros del mismo, este se pueda programar en un lenguaje que pueda ser usado en otro sistema mas dedicado (un microcontrolador, un PLC, un lenguaje un especifico), para el caso de clusterizacion, este se basa en la distacioa euclidiana entre cada conjunto de datos de entrada y la distancia respecto a los centroides de cada cluster, siendo la menor distancia el cluster al cual pertenece. les comparto el script propuesto:

# implementacion del script de k-means para clustering
# practico para programacion en procesadores o en sistemas mas dedicados usando lenguaje del equipo

# en base al modelo se tienen los centroides de cada cluster 
centroids = [[-1.60811992, 2.85881658],
 [ 1.95159369, 0.83467497],
 [ 0.95625704, 4.37226546]]

# funcion que realiza la prediccion del cluster
def predict_cluster(x):
    """
    Clasifica un punto x en el clúster más cercano según los centroides entrenados.

    Parámetros:
    - x: lista o array de 2 elementos [x1, x2]

    Retorna:
    - Índice del clúster más cercano
    """
    min_dist = float("inf")
    best_cluster = -1

    # se realiza la medicion de distancia
    # la menor distancia entre el punto y el centroide, se le asigna a ese valor de cluster o etiqueta
    for i, center in enumerate(centroids):
        dist = (x[0] - center[0]) ** 2 + (x[1] - center[1]) ** 2  # distancia euclidiana al cuadrado
        if dist < min_dist:
            min_dist = dist
            best_cluster = i

    return best_cluster


# Ejemplo de uso
nuevo_punto = [2.5, 3.0]
cluster_asignado = predict_cluster(nuevo_punto)
print(f"Punto {nuevo_punto} asignado al clúster: {cluster_asignado}")
```# implementacion del script de k-means para clustering# practico para programacion en procesadores o en sistemas mas dedicados usando lenguaje del equipo
\# en base al modelo se tienen los centroides de cada cluster centroids = \[\[-1.60811992, 2.85881658], \[ 1.95159369, 0.83467497], \[ 0.95625704, 4.37226546]]
\# funcion que realiza la prediccion del clusterdef predict\_cluster(x):    """    Clasifica un punto x en el clúster más cercano según los centroides entrenados.
    Parámetros:    - x: lista o array de 2 elementos \[x1, x2]
    Retorna:    - Índice del clúster más cercano    """    min\_dist = float("inf")    best\_cluster = -1
    # se realiza la medicion de distancia    # la menor distancia entre el punto y el centroide, se le asigna a ese valor de cluster o etiqueta    for i, center in enumerate(centroids):        dist = (x\[0] - center\[0]) \*\* 2 + (x\[1] - center\[1]) \*\* 2  # distancia euclidiana al cuadrado        if dist < min\_dist:            min\_dist = dist            best\_cluster = i
    return best\_cluster

\# Ejemplo de usonuevo\_punto = \[2.5, 3.0]cluster\_asignado = predict\_cluster(nuevo\_punto)print(f"Punto {nuevo\_punto} asignado al clúster: {cluster\_asignado}")

Jorge Miguel Diaz

student•

Emocionante!

Antonio Demarco Bonino

student•

Los que venimos del aprendizaje supervisado para el No supervisado empezamos a hacer "WooooooW" con este curso. Ya comenzamos paso a paso a dar saltos de alegría de ver lo que puede hacer la IA.

Juan José Mamani Tarqui

student•

<u>CLUSTERING </u>

El clustering es una técnica de aprendizaje no supervisado en el campo de la inteligencia artificial y el análisis de datos. El objetivo principal del clustering es agrupar un conjunto de datos en subconjuntos o "clusters", donde los elementos dentro de cada grupo son más similares entre sí que con aquellos en otros grupos. Los algoritmos de clustering buscan encontrar patrones intrínsecos en los datos sin necesidad de etiquetas previas.

Algunos algoritmos de clustering comunes incluyen:

K-Means:
- Divide el conjunto de datos en k grupos (clusters) basándose en la distancia entre los puntos y los centroides de los clusters.
Hierarchical Clustering:
- Agrupa los datos en una jerarquía de clusters, ya sea de manera aglomerativa (fusionando clusters en cada paso) o divisiva (dividiendo clusters en cada paso).
DBSCAN (Density-Based Spatial Clustering of Applications with Noise):
- Identifica clusters basándose en la densidad de los puntos. Es especialmente útil para detectar clusters de formas irregulares y manejar ruido en los datos.
Mean Shift:
- Busca los modos de densidad máxima en el espacio de características para identificar los clusters.
Gaussian Mixture Model (GMM):
- Modela el conjunto de datos como una mezcla de distribuciones gaussianas y asigna puntos a los clusters basándose en la probabilidad.
Agglomerative Clustering:
- Un algoritmo jerárquico que comienza considerando cada punto como un cluster individual y fusiona clusters en cada paso hasta que todos los puntos pertenecen a un único cluster.

La elección del algoritmo de clustering depende de la naturaleza de los datos y de los objetivos específicos del análisis. El número de clusters (k) también es un parámetro importante y puede ser fijo o determinado automáticamente por el algoritmo.

El clustering se utiliza en una variedad de campos, incluyendo la segmentación de clientes, análisis de documentos, genómica, reconocimiento de patrones, entre otros.

Noel Felipe Delgado Ortiz

student•

Hola.

Les comparto mi aporte,

g = sns.jointplot(data=df_blobls, x="x1", y="x2", hue='y')
g.plot_joint(sns.kdeplot, color="r", zorder=0, levels=6)
g.plot_marginals(sns.rugplot, color="r", height=-.15, clip_on=False)
```g = sns.jointplot(data=df\_blobls, x="x1", y="x2", hue='y')g.plot\_joint(sns.kdeplot, color="r", zorder=0, levels=6)g.plot\_marginals(sns.rugplot, color="r", height=-.15, clip\_on=False)

![]()

jhon Robert Matamoros

student•

Comparto el codigo para mostarlo más estetico!!

def plot_2d_clusters(x, y ,axe, title):
    y_uniques = pd.Series(y).unique()
    for y_unique in y_uniques:
        axe.scatter(x[y == y_unique, 0], x[y == y_unique, 1], label=y_unique)
        axe.set_title(title)
        axe.markers = [f"${y_unique}$"]
        axe.legend()