Introdução ao Algoritmo de Agrupamento Kmeans

O que é agrupamento K-Means?

O agrupamento K-Means é um algoritmo de aprendizado de máquina não supervisionado usado para agrupar ou agrupar pontos de dados semelhantes em um conjunto de dados. É um algoritmo de particionamento, que divide os dados em clusters não sobrepostos, onde cada ponto de dados pertence a um único cluster. O agrupamento K-means visa minimizar a soma das distâncias ao quadrado entre cada ponto de dados e seu centróide atribuído.

Teoria – Como funciona?

Etapa 1. Primeiro, precisamos decidir o valor de K, que é o número de clusters que queremos criar. O valor de K pode ser decidido aleatoriamente ou usando algum método como Elbow, Silhouette.

Etapa 2. Em seguida, selecionamos aleatoriamente K pontos do conjunto de dados para atuar como centróides iniciais para cada cluster.

Etapa 3. Em seguida, calculamos a distância euclidiana entre cada ponto de dados e os centróides e atribuímos o ponto de dados ao centróide mais próximo, criando K clusters.

Etapa 4. Depois de atribuir todos os pontos de dados ao centroide mais próximo, atualizamos a localização de cada centroide calculando a média de todos os pontos de dados atribuídos a esse centroide.

Etapa 5. Repetimos as etapas 3 e 4 até que o algoritmo converja, o que significa que os centróides não se movem mais ou a melhoria na soma das distâncias ao quadrado entre os pontos de dados e seus centróides atribuídos torna-se insignificante.

Como funciona o código?

Importe as bibliotecas necessárias:

import numpy as np
import matplotlib.pyplot as plt

X = np.random.rand(100, 2) * 2
plt.scatter(X[:, 0], X[:, 1])
plt.show()

      
                

                    
                    
                
            

K = 7
centroids = X[np.random.choice(len(X), K, replace=False)]
plt.scatter(X[:, 0], X[:, 1])
plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', s=200, linewidths=3, color='r')
plt.show()

      
                

                    
                    
                
            
while True:
    # Assign data points to the nearest centroid
    distances = np.sqrt(((X - centroids[:, np.newaxis])**2).sum(axis=2))
    labels = np.argmin(distances, axis=0)

    # Calculate new centroids
    new_centroids = np.array([X[labels == i].mean(axis=0) for i in range(K)])

    # Check for convergence
    if np.all(centroids == new_centroids):
        break

    # Update centroids
    centroids = new_centroids
plt.scatter(X[:, 0], X[:, 1], c=labels)
plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', s=200, linewidths=3, color='r')
plt.show()

      
                

                    
                    
                
            

Limitações de K significa algoritmo

1. K significa que o agrupamento é sensível à seleção do centroide inicial. O algoritmo pode convergir para uma solução abaixo do ideal se os centróides iniciais não forem selecionados apropriadamente.
2. K significa que o agrupamento é sensível a outliers
3. K significa que o clustering é sensível ao valor de K. Se K não for escolhido corretamente, pode resultar em clusters abaixo do ideal.