K-means en Machine Learning

por

K-means en Machine Learning: el agrupamiento K-means es uno de los algoritmos de aprendizaje automático no supervisados ​​más simples y populares.

Típicamente, los algoritmos no supervisados ​​hacen inferencias de conjuntos de datos usando solo vectores de entrada sin referirse a resultados conocidos o etiquetados.

El objetivo de K-means es simple: agrupar datos similares y descubrir patrones subyacentes. Para lograr este objetivo, K-means busca un número fijo (k) de clusters en un conjunto de datos.

Un clúster se refiere a una colección de puntos de datos agrupados debido a ciertas similitudes. Definirá un número objetivo k que se refiere a la cantidad de centroides que necesita en el conjunto de datos. Un centroide es la ubicación real o imaginaria 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 en el grupo.

En otras palabras, el algoritmo K-medias identifica k número de centroides, y luego asigna cada punto de datos al clúster más cercano, mientras mantiene los centroides lo más pequeños posible.

‘means’  en los K-means se refiere al promedio de los datos; es decir, encontrar el centroide.

Cómo funciona el algoritmo K-means en Machine Learning

Para procesar los datos de aprendizaje, el algoritmo K-means en Machine Learning en la extracción de datos comienza con un primer grupo de centroides seleccionados al azar, que se utilizan como principio puntos 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 cambio en sus valores porque la agrupación ha sido exitoso.
  • Se ha logrado el número definido de iteraciones.

Problema de ejemplo del algoritmo K-means en Machine Learning

Veamos los pasos sobre cómo funciona el algoritmo de Machine Learning K-means usando 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-means en Machine Learning.

Paso 1: Importación de bibliotecas 

import pandas as pd
import numpy as np
import 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 visualizar 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 generaron un total de 100 puntos de datos y se dividieron en dos grupos, de 50 puntos cada uno.

Aquí se muestra cómo se muestran los datos en un espacio bidimensional:

Paso 3: use Scikit-Learn

Usaremos algunos de los disponibles funciones en el Scikit-le arn library para procesar los datos generados al azar.

Aquí está el código:

from sklearn.cluster import KMeans
Kmean = KMeans(n_clusters=2)
Kmean.fit(X)
En este caso, arbitrariamente le dimos  k  (n_clusters) un valor arbitrario de dos.

Aquí está el resultado de los parámetros de K-means que obtenemos si ejecutamos el código:

KMeans(algorithm=’auto’, copy_x=True, init=’k-means++’, max_iter=300
n_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 clusters:

Kmean.cluster_centers_

Aquí está el resultado del valor de los centroides:

array([[-0.94665068, -0.97138368],
[ 2.01559419, 2.02597093]])

 

Veamos los centroides del grupo (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á la salida:

Paso 5: Probando el algoritmo

Aquí está el código para obtener las etiquetas propiedad de los K-means conjunto de datos de ejemplo de agrupación; es decir, cómo se clasifican los puntos de datos en los dos clústeres.

Kmean.labels_

Aquí está el resultado de ejecutar el código del algoritmo 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 clúster 0 mientras que el resto pertenecen al clúster 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 en el clúster 0 (centroide verde).

Terminando

Aquí está el código del algoritmo de agrupamiento K-means completo 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)

 

K-means en Machine Learning es una técnica ampliamente utilizada para el análisis de clústeres de datos.

Sin embargo, su rendimiento generalmente no es tan competitivo como el de las otras técnicas sofisticadas de clustering, ya que pequeñas variaciones en los datos pueden conducir a una gran varianza.

Además, se supone que los clusters son esférico y de tamaño uniforme, algo que puede reducir la precisión de los resultados de Python en K-means.

¿Cuál es su experiencia con K-means en machine learning?

 

Dejá un comentario