O K-Means é uma forma de juntar informações parecidas.
Ele pega várias coisas (pontos, dados, imagens, palavras) e as coloca em grupos, sendo que cada grupo tem um ponto no meio. Isso é repetido até que os grupos parem de mudar muito ou chegue num número máximo de vezes.
Vamos começar fazendo o algoritmo K-Means funcionar no Python com a ajuda do scikit-learn. Primeiro, trazemos as bibliotecas que precisamos:
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
Agora, vamos criar um grupo de dados de exemplo usando a função “make_blobs”, que faz pontos aleatórios em grupos claros:
# Gerar dados de exemplo
X, y = make_blobs(n_samples=300, centers=4, random_state=42)
Agora que temos os dados, podemos criar uma instância do algoritmo K-Means e ajustá-lo aos dados:
# Criar instância do K-Means com 4 clusters
kmeans = KMeans(n_clusters=4, random_state=42)
kmeans.fit(X)
Depois que o K-Means aprende com os dados, podemos descobrir onde ficam os pontos centrais dos grupos e que grupo cada ponto pertence:
# Obter centróides e rótulos
centroids = kmeans.cluster_centers_
labels = kmeans.labels_
Agora que temos os rótulos atribuídos a cada ponto de dados, podemos visualizar os clusters e os centróides:
# Plot dos clusters e centróides
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.scatter(centroids[:, 0], centroids[:, 1], marker='X', s=200, color='red')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('K-Means Clustering')
plt.show()
O resultado será um gráfico mostrando os pontos de dados coloridos de acordo com seus clusters e os centróides marcados em vermelho.
Escolhendo o Número de Clusters
Uma pergunta que muitas vezes surge ao usar o K-Means é como decidir quantos grupos são bons. Duas maneiras comuns são usar o método do cotovelo e o coeficiente de silhueta.
Método do Cotovelo
No método do cotovelo, você faz um gráfico com a soma dos quadrados dentro de cada grupo (SSE) e olha onde a curva começa a ficar mais suave. Isso é chamado de “cotovelo” e dá uma ideia de quantos grupos são bons.
from kneed import KneeLocator
sse = []
for k in range(1, 11):
kmeans = KMeans(n_clusters=k, random_state=42)
kmeans.fit(X)
sse.append(kmeans.inertia_)
plt.plot(range(1, 11), sse)
plt.xlabel('Number of Clusters')
plt.ylabel('SSE')
plt.title('Elbow Method for Optimal K')
plt.show()
kl = KneeLocator(range(1, 11), sse, curve='convex', direction='decreasing')
optimal_k = kl.elbow
print(f'Optimal number of clusters: {optimal_k}')
Coeficiente de Silhueta
O coeficiente de silhueta olha se os grupos estão juntos e separados direito. Um número maior é melhor. Ele calcula isso para cada ponto e tira a média. O número de grupos que faz a média ser a maior é o certo.
from sklearn.metrics import silhouette_score
silhouette_scores = []
for k in range(2, 11):
kmeans = KMeans(n_clusters=k, random_state=42)
kmeans.fit(X)
score = silhouette_score(X, kmeans.labels_)
silhouette_scores.append(score)
plt.plot(range(2, 11), silhouette_scores)
plt.xlabel('Number of Clusters')
plt.ylabel('Silhouette Coefficient')
plt.title('Silhouette Coefficient Method for Optimal K')
plt.show()
optimal_k_silhouette = np.argmax(silhouette_scores) + 2
print(f'Optimal number of clusters (silhouette method): {optimal_k_silhouette}')
Os dois jeitos podem te ajudar a escolher quantos grupos usar, mas é importante lembrar que a decisão final depende do que você está fazendo e do que você sabe sobre o assunto.
Conclusão
O K-Means Clustering é útil para encontrar grupos em dados. Aqui, você viu como fazer isso no Python usando a biblioteca scikit-learn. Também descobriu como escolher quantos grupos usar com o método do cotovelo e o coeficiente de silhueta. Espero que este texto tenha te mostrado como usar o K-Means e entender o mundo dos grupos de dados.
Outras Referências
Link para a documentação do K-Means: https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html