La agrupación en clústeres de K-means es uno de los algoritmos de aprendizaje automático no supervisados más simples y populares.
Normalmente, los algoritmos no supervisados hacen inferencias a partir de conjuntos de datos utilizando solo vectores de entrada sin hacer referencia a resultados conocidos o etiquetados.
El objetivo de K-means es simple: agrupar puntos de datos similares y descubrir patrones subyacentes. Para lograr este objetivo, K-means busca un número fijo ( k ) de grupos en un conjunto de datos ".
Un grupo se refiere a una colección de puntos de datos agregados debido a ciertas similitudes.
Usted debe definir un número k , que se refiere al número de centroides que necesita en el conjunto de datos. Un centroide es la ubicación imaginaria o real que representa el centro del grupo.
Cada punto de datos se asigna a cada uno de los grupos mediante la reducción de la suma de cuadrados dentro del grupo.
En otras palabras, el algoritmo de K-medias identifica un número k de centroides y luego asigna cada punto de datos al grupo más cercano, mientras mantiene los centroides lo más pequeños posible.
Los ‘medios’ en los K-means se refieren al promedio de los datos; es decir, encontrar el centroide.
Cómo funciona el algoritmo K-means
Para procesar los datos de aprendizaje, el algoritmo K-means en la minería de datos comienza con un primer grupo de centroides seleccionados al azar, que se utilizan como puntos de inicio para cada grupo, y luego realiza cálculos iterativos (repetitivos) para optimizar las posiciones de los centroides.
Detiene la creación y optimización de clústeres cuando:
Los centroides se han estabilizado; no hay cambios en sus valores porque la agrupación se ha realizado correctamente.
Se ha logrado el número definido de iteraciones.
Problema de ejemplo del algoritmo K-means
Veamos los pasos sobre cómo funciona el algoritmo de aprendizaje automático K-means utilizando el lenguaje de programación Python.
Usaremos la biblioteca Scikit-learn y algunos datos aleatorios para ilustrar una explicación simple de agrupamiento de K-medias.
Paso 1: importar bibliotecas
import pandas as pdimport numpy as npimport matplotlib.pyplot as plt
from sklearn.cluster import KMeans
%matplotlib inline
Como puede ver en el código anterior, importaremos las siguientes bibliotecas en nuestro proyecto:
Pandas para leer y escribir hojas de cálculo.
Numpy para realizar cálculos eficientes
Matplotlib para visualización de datos
Paso 2: generar datos aleatorios
Aquí está el código para generar algunos datos aleatorios en un espacio bidimensional:
X= -2 * np.random.rand(100,2)
X1 = 1 + 2 * np.random.rand(50,2)
X[50:100, :] = X1
plt.scatter(X[ : , 0], X[ :, 1], s = 50, c = ‘b’)
plt.show()
Se han generado un total de 100 puntos de datos y se han dividido en dos grupos, de 50 puntos cada uno.
Así es como se muestran los datos en un espacio bidimensional:
Paso 3: use Scikit-Learn
Usaremos algunas de las funciones disponibles en la biblioteca Scikit-learn para procesar los datos generados aleatoriamente.
Aquí está el código:
from sklearn.cluster import KMeans
Kmean = KMeans(n_clusters=2)
Kmean.fit(X)
En este caso, arbitrariamente le dimos a k (n_clusters) un valor arbitrario de dos.
Aquí está la salida de los parámetros K-means que obtenemos si ejecutamos el código:
KMeans(algorithm=’auto’,copy_x=True,init=’k-means++’,max_iter=300n_clusters=2,n_init=10,n_jobs=1,precompute_distances=’auto’,random_state=None,tol=0.0001,verbose=0)Paso 4: encontrar el centroide
Aquí está el código para encontrar el centro de los clústeres:
Kmean.cluster_centers_Aquí está el resultado del valor de los centroides:
array([[-0.94665068, -0.97138368],
[ 2.01559419, 2.02597093]])
Visualicemos los centroides del clúster (usando color verde y rojo).
plt.scatter(X[ : , 0], X[ : , 1], s =50, c=’b’)
plt.scatter(-0.94665068, -0.97138368, s=200, c=’g’, marker=’s’)
plt.scatter(2.01559419, 2.02597093, s=200, c=’r’, marker=’s’)
plt.show()
Aquí está el resultado:
Paso 5: probar el algoritmo
Aquí está el código para obtener la propiedad de etiquetas del conjunto de datos de ejemplo de agrupamiento en clústeres de K-means; es decir, cómo se clasifican los puntos de datos en los dos grupos.
Kmean.labels_Aquí está el resultado de ejecutar el código de algoritmo de K-means anterior:
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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
Como puede ver arriba, 50 puntos de datos pertenecen al grupo 0 mientras que el resto pertenecen al grupo 1 .
Por ejemplo, usemos el siguiente código para predecir el clúster de un punto de datos:
sample_test=np.array([-3.0,-3.0])
second_test=sample_test.reshape(1, -1)
Kmean.predict(second_test)
Aquí está el resultado:
array ([0])
Muestra que el punto de datos de prueba pertenece al grupo 0 (centroide verde).
Terminando
Aquí está todo el código del algoritmo de agrupación en clústeres de K-means en Python:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
%matplotlib inline
X= -2 * np.random.rand(100,2)
X1 = 1 + 2 * np.random.rand(50,2)
X[50:100, :] = X1
plt.scatter(X[ : , 0], X[ :, 1], s = 50, c = ‘b’)
plt.show()
from sklearn.cluster import KMeans
Kmean = KMeans(n_clusters=2)
Kmean.fit(X)
Kmean.cluster_centers_
plt.scatter(X[ : , 0], X[ : , 1], s =50, c=’b’)
plt.scatter(-0.94665068, -0.97138368, s=200,c=’g’,marker=’s’)
plt.scatter(2.01559419, 2.02597093, s=200,c=’r’,marker=’s’)
plt.show()
Kmean.labels_
sample_test=np.array([-3.0,-3.0])second_test=sample_test.reshape(1, -1)
Kmean.predict(second_test)
La agrupación de K-medias es una técnica ampliamente utilizada para el análisis de agrupaciones de datos.
Es fácil de entender, especialmente si acelera su aprendizaje utilizando un tutorial de agrupación en clústeres de K-means . Además, ofrece resultados de entrenamiento rápidamente.
Sin embargo, su rendimiento no suele ser tan competitivo como el de otras técnicas de agrupación sofisticadas porque ligeras variaciones en los datos podrían provocar una gran variación.
Además, se supone que los clústeres son esféricos y de tamaño uniforme, algo que puede reducir la precisión de los resultados de Python de clústeres de K-means
