Agrupación de K-medias es un Aprendizaje automático no supervisado algoritmo, que agrupa el conjunto de datos sin etiquetar en diferentes grupos. El artículo tiene como objetivo explorar los fundamentos y el funcionamiento de la agrupación de k medias junto con su implementación.
Tabla de contenidos
- ¿Qué es la agrupación K-medias?
- ¿Cuál es el objetivo de la agrupación de k-medias?
- ¿Cómo funciona la agrupación de k-medias?
- Implementación de K-Means Clustering en Python
¿Qué es la agrupación K-medias?
Aprendizaje automático no supervisado es el proceso de enseñar a una computadora a utilizar datos sin etiquetar ni clasificar y permitir que el algoritmo opere con esos datos sin supervisión. Sin ningún entrenamiento previo en datos, el trabajo de la máquina en este caso es organizar datos desordenados según paralelos, patrones y variaciones.
K significa agrupación, asigna puntos de datos a uno de los K grupos dependiendo de su distancia desde el centro de los grupos. Comienza asignando aleatoriamente el centroide de los grupos en el espacio. Luego, cada punto de datos se asigna a uno del grupo en función de su distancia desde el centroide del grupo. Después de asignar cada punto a uno del grupo, se asignan nuevos centroides del grupo. Este proceso se ejecuta de forma iterativa hasta que encuentra un buen clúster. En el análisis asumimos que el número de grupos se proporciona de antemano y tenemos que poner puntos en uno del grupo.
En algunos casos, K no está claramente definido y tenemos que pensar en el número óptimo de K. K significa que la agrupación en clústeres funciona mejor cuando los datos están bien separados. Cuando los puntos de datos se superponen, esta agrupación no es adecuada. K Means es más rápido en comparación con otras técnicas de agrupación. Proporciona un fuerte acoplamiento entre los puntos de datos. Los conglomerados de K-Means no proporcionan información clara sobre la calidad de los conglomerados. Una asignación inicial diferente del centroide del grupo puede conducir a grupos diferentes. Además, el algoritmo K Means es sensible al ruido. Es posible que se haya atascado en los mínimos locales.
¿Cuál es el objetivo de la agrupación de k-medias?
El objetivo de agrupamiento es dividir la población o colocar de puntos de datos en varios grupos para que los puntos de datos dentro de cada grupo sean más comparable entre sí y diferentes de los puntos de datos dentro de los otros grupos. Es esencialmente una agrupación de cosas basada en cuán similares y diferentes son entre sí.
¿Cómo funciona la agrupación de k-medias?
Se nos proporciona un conjunto de datos de elementos, con ciertas características y valores para estas características (como un vector). La tarea es clasificar esos elementos en grupos. Para conseguirlo utilizaremos el algoritmo K-means, un algoritmo de aprendizaje no supervisado. 'K' en el nombre del algoritmo representa la cantidad de grupos/clústeres en los que queremos clasificar nuestros elementos.
(Será útil pensar en los elementos como puntos en un espacio de n dimensiones). El algoritmo clasificará los elementos en k grupos o grupos de similitud. Para calcular esa similitud, usaremos la distancia euclidiana como medida.
El algoritmo funciona de la siguiente manera:
- Primero, inicializamos aleatoriamente k puntos, llamados medias o centroides de grupo.
- Categorizamos cada elemento según su media más cercana y actualizamos las coordenadas de la media, que son los promedios de los elementos categorizados en ese grupo hasta el momento.
- Repetimos el proceso para un número determinado de iteraciones y al final tenemos nuestros clústeres.
Los puntos mencionados anteriormente se denominan medias porque son los valores medios de los elementos categorizados en ellos. Para inicializar estos medios, tenemos muchas opciones. Un método intuitivo consiste en inicializar las medias en elementos aleatorios del conjunto de datos. Otro método es inicializar las medias en valores aleatorios entre los límites del conjunto de datos (si se trata de una característica X, los elementos tienen valores en [0,3], inicializaremos las medias con valores para X en [0,3]).
El algoritmo anterior en pseudocódigo es el siguiente:
Initialize k means with random values -->Para un número determinado de iteraciones: --> Iterar a través de elementos: --> Encuentre la media más cercana al elemento calculando la distancia euclidiana del elemento con cada una de las medias --> Asignar elemento a la media --> Actualizar la media por cambiándolo al promedio de los elementos en ese grupo>
Implementación de K-Means Clustering en Python
Ejemplo 1
Importar las bibliotecas necesarias
estamos importando numpy para cálculos estadísticos, Matplotlib para trazar el grafico, y make_blobs de sklearn.datasets.
Python3
10 millones
import> numpy as np> import> matplotlib.pyplot as plt> from> sklearn.datasets>import> make_blobs> |
>
>
Cree el conjunto de datos personalizado con make_blobs y trácelo
Python3
X,y>=> make_blobs(n_samples>=> 500>,n_features>=> 2>,centers>=> 3>,random_state>=> 23>)> fig>=> plt.figure(>0>)> plt.grid(>True>)> plt.scatter(X[:,>0>],X[:,>1>])> plt.show()> |
>
>
Producción :
Conjunto de datos de agrupación
Inicializar los centroides aleatorios
El código inicializa tres grupos para la agrupación de K-medias. Establece una semilla aleatoria y genera centros de clúster aleatorios dentro de un rango específico, y crea un espacio vacío. lista de puntos para cada grupo.
Python3
k>=> 3> clusters>=> {}> np.random.seed(>23>)> for> idx>in> range>(k):> >center>=> 2>*>(>2>*>np.random.random((X.shape[>1>],))>->1>)> >points>=> []> >cluster>=> {> >'center'> : center,> >'points'> : []> >}> > >clusters[idx]>=> cluster> > clusters> |
>
>
Producción:
{0: {'center': array([0.06919154, 1.78785042]), 'points': []}, 1: {'center': array([ 1.06183904, -0.87041662]), 'points': []}, 2: {'center': array([-1.11581855, 0.74488834]), 'points': []}}> Trazar el centro de inicialización aleatoria con puntos de datos
Python3
plt.scatter(X[:,>0>],X[:,>1>])> plt.grid(>True>)> for> i>in> clusters:> >center>=> clusters[i][>'center'>]> >plt.scatter(center[>0>],center[>1>],marker>=> '*'>,c>=> 'red'>)> plt.show()> |
>
>
Producción :
Python tupla ordenada
Puntos de datos con centro aleatorio.
El gráfico muestra un diagrama de dispersión de puntos de datos (X[:,0], X[:,1]) con líneas de cuadrícula. También marca los centros de cúmulos iniciales (estrellas rojas) generados para la agrupación de K-medias.
Definir la distancia euclidiana
Python3
def> distance(p1,p2):> >return> np.sqrt(np.>sum>((p1>->p2)>*>*>2>))> |
>
>
Crear la función para Asignar y Actualizar el centro del cluster
El paso E asigna puntos de datos al centro del grupo más cercano y el paso M actualiza los centros del grupo según la media de los puntos asignados en la agrupación de medias K.
Python3
#Implementing E step> def> assign_clusters(X, clusters):> >for> idx>in> range>(X.shape[>0>]):> >dist>=> []> > >curr_x>=> X[idx]> > >for> i>in> range>(k):> >dis>=> distance(curr_x,clusters[i][>'center'>])> >dist.append(dis)> >curr_cluster>=> np.argmin(dist)> >clusters[curr_cluster][>'points'>].append(curr_x)> >return> clusters> > #Implementing the M-Step> def> update_clusters(X, clusters):> >for> i>in> range>(k):> >points>=> np.array(clusters[i][>'points'>])> >if> points.shape[>0>]>>0>:> >new_center>=> points.mean(axis>=>0>)> >clusters[i][>'center'>]>=> new_center> > >clusters[i][>'points'>]>=> []> >return> clusters> |
>
>
Paso 7: cree la función para predecir el clúster para los puntos de datos
Python3
def> pred_cluster(X, clusters):> >pred>=> []> >for> i>in> range>(X.shape[>0>]):> >dist>=> []> >for> j>in> range>(k):> >dist.append(distance(X[i],clusters[j][>'center'>]))> >pred.append(np.argmin(dist))> >return> pred> |
>
>
Asignar, actualizar y predecir el centro del cluster
Python3
clusters>=> assign_clusters(X,clusters)> clusters>=> update_clusters(X,clusters)> pred>=> pred_cluster(X,clusters)> |
>
>
Trazar los puntos de datos con su centro de grupo previsto
Python3
plt.scatter(X[:,>0>],X[:,>1>],c>=> pred)> for> i>in> clusters:> >center>=> clusters[i][>'center'>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.show()> |
>
>
Producción :
K-significa agrupación
El gráfico muestra puntos de datos coloreados según sus grupos predichos. Los marcadores rojos representan los centros de agrupación actualizados después de los pasos E-M en el algoritmo de agrupación de K-medias.
Ejemplo 2
Importar las bibliotecas necesarias
Python3
genericidad en java
import> pandas as pd> import> numpy as np> import> seaborn as sns> import> matplotlib.pyplot as plt> import> matplotlib.cm as cm> from> sklearn.datasets>import> load_iris> from> sklearn.cluster>import> KMeans> |
>
>
Cargar el conjunto de datos
Python3
X, y>=> load_iris(return_X_y>=>True>)> |
prueba el bloque catch java
>
>
Método del codo
Encontrar el número ideal de grupos para dividir los datos es una etapa básica en cualquier algoritmo no supervisado. Una de las técnicas más comunes para calcular este valor ideal de k es el método del codo.
Python3
#Find optimum number of cluster> sse>=> []>#SUM OF SQUARED ERROR> for> k>in> range>(>1>,>11>):> >km>=> KMeans(n_clusters>=>k, random_state>=>2>)> >km.fit(X)> >sse.append(km.inertia_)> |
>
>
Trazar el gráfico del codo para encontrar el número óptimo de grupos
Python3
sns.set_style(>'whitegrid'>)> g>=>sns.lineplot(x>=>range>(>1>,>11>), y>=>sse)> g.>set>(xlabel>=>'Number of cluster (k)'>,> >ylabel>=> 'Sum Squared Error'>,> >title>=>'Elbow Method'>)> plt.show()> |
>
>
Producción:
Método del codo
En el gráfico anterior, podemos observar que en k = 2 y k = 3, la situación es similar a la de un codo. Entonces, estamos considerando K=3
Construya el modelo de agrupación en clústeres de Kmeans
Python3
kmeans>=> KMeans(n_clusters>=> 3>, random_state>=> 2>)> kmeans.fit(X)> |
>
>
Producción:
KMeans KMeans(n_clusters=3, random_state=2)>
Encuentra el centro del cluster
Python3
operadores javascript
kmeans.cluster_centers_> |
>
>
Producción:
array([[5.006 , 3.428 , 1.462 , 0.246 ], [5.9016129 , 2.7483871 , 4.39354839, 1.43387097], [6.85 , 3.07368421, 5.74210526, 2.07105263]])>
Predecir el grupo de clústeres:
Python3
pred>=> kmeans.fit_predict(X)> pred> |
>
>
Producción:
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 1], dtype=int32)>
Trazar el centro del clúster con puntos de datos.
Python3
plt.figure(figsize>=>(>12>,>5>))> plt.subplot(>1>,>2>,>1>)> plt.scatter(X[:,>0>],X[:,>1>],c>=> pred, cmap>=>cm.Accent)> plt.grid(>True>)> for> center>in> kmeans.cluster_centers_:> >center>=> center[:>2>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.xlabel(>'petal length (cm)'>)> plt.ylabel(>'petal width (cm)'>)> > plt.subplot(>1>,>2>,>2>)> plt.scatter(X[:,>2>],X[:,>3>],c>=> pred, cmap>=>cm.Accent)> plt.grid(>True>)> for> center>in> kmeans.cluster_centers_:> >center>=> center[>2>:>4>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.xlabel(>'sepal length (cm)'>)> plt.ylabel(>'sepal width (cm)'>)> plt.show()> |
>
>
Producción:
K-medias agrupación
La trama secundaria de la izquierda muestra la longitud de los pétalos frente al ancho de los pétalos con puntos de datos coloreados por grupos, y los marcadores rojos indican los centros de los grupos de K-medias. La trama secundaria de la derecha muestra la longitud del sépalo frente al ancho del sépalo de manera similar.
Conclusión
En conclusión, la agrupación en clústeres K-means es un potente algoritmo de aprendizaje automático no supervisado para agrupar conjuntos de datos sin etiquetar. Su objetivo es dividir los datos en grupos, haciendo que puntos de datos similares formen parte del mismo grupo. El algoritmo inicializa los centroides del grupo y asigna iterativamente puntos de datos al centroide más cercano, actualizando los centroides según la media de los puntos en cada grupo.
Preguntas frecuentes (FAQ)
1. ¿Qué es la agrupación de k-medias para el análisis de datos?
K-means es un método de partición que divide un conjunto de datos en 'k' subconjuntos (grupos) distintos y no superpuestos en función de la similitud, con el objetivo de minimizar la variación dentro de cada grupo.
2. ¿Cuál es un ejemplo de k-medias en la vida real?
Segmentación de clientes en marketing, donde k-means agrupa a los clientes según su comportamiento de compra, lo que permite a las empresas adaptar estrategias de marketing para diferentes segmentos.
3. ¿Qué tipo de datos es el modelo de agrupamiento de k-medias?
K-means funciona bien con datos numéricos, donde el concepto de distancia entre puntos de datos es significativo. Se aplica comúnmente a variables continuas.
4. ¿Se utilizan K-means para la predicción?
K-means se utiliza principalmente para agrupar y agrupar puntos de datos similares. No predice etiquetas para datos nuevos; los asigna a grupos existentes en función de la similitud.
5. ¿Cuál es el objetivo de la agrupación de k-medias?
El objetivo es dividir los datos en 'k' grupos, minimizando la variación dentro del grupo. Busca formar grupos donde los puntos de datos dentro de cada grupo sean más similares entre sí que con los de otros grupos.