Como fazer clustering com K-Means em Python (scikit-learn)

João Barros 15 de July de 2026 4 min de leitura

O clustering com K-Means em Python permite agrupar automaticamente observações parecidas, sem precisares de rótulos. É uma das técnicas de aprendizagem não supervisionada mais usadas no dia a dia: serve para segmentar clientes, organizar produtos ou explorar padrões escondidos num conjunto de dados. Com a biblioteca scikit-learn, aplicá-la é rápido e simples, como vais ver a seguir.

Pré-requisitos

Python 3 instalado no teu computador.
As bibliotecas scikit-learn e numpy (instala com pip install scikit-learn numpy).
Noções básicas de Python: listas, funções e ciclos.

Passo 1: Preparar os dados

Começa por reunir os dados que queres agrupar. Cada linha é uma observação e cada coluna é uma característica (feature). Neste exemplo usamos pontos com duas características para ser fácil de visualizar, mas o K-Means funciona igualmente bem com muitas mais.

import numpy as np

# Each row is an observation, each column a feature
X = np.array([
    [1.0, 2.0],
    [1.5, 1.8],
    [5.0, 8.0],
    [8.0, 8.0],
    [1.0, 0.6],
    [9.0, 11.0],
])

Passo 2: Normalizar as variáveis

O K-Means baseia-se em distâncias entre pontos, por isso variáveis com escalas muito diferentes podem enviesar os grupos. Usa o StandardScaler para colocar todas as características na mesma escala antes de treinar o modelo.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Passo 3: Escolher o número de clusters

Tens de decidir em quantos grupos (k) queres dividir os dados. O método do cotovelo ajuda nessa escolha: treinas o modelo para vários valores de k e observas a inércia, ou seja, a soma das distâncias de cada ponto ao centro do seu cluster. O ponto onde a curva "dobra" como um cotovelo costuma indicar um bom valor de k.

from sklearn.cluster import KMeans

inertias = []
for k in range(1, 6):
    model = KMeans(n_clusters=k, random_state=42, n_init=10)
    model.fit(X_scaled)
    inertias.append(model.inertia_)

print(inertias)

Ao correr este código, obténs uma lista de inércias, uma por cada valor de k. Procura o k a partir do qual a inércia deixa de descer de forma acentuada: esse é, normalmente, o número de clusters mais adequado.

Passo 4: Treinar o modelo K-Means

O K-Means divide os dados em k grupos: coloca cada observação no cluster cujo centro está mais próximo e vai recalculando esses centros até estabilizarem. Com o valor de k escolhido (aqui, 2), cria e treina o modelo. O parâmetro n_init define quantas vezes o algoritmo corre com centros iniciais diferentes, ficando com o melhor resultado; o random_state garante que o resultado é reproduzível.

model = KMeans(n_clusters=2, random_state=42, n_init=10)
model.fit(X_scaled)

print(model.labels_)           # cluster of each observation
print(model.cluster_centers_)  # centre of each cluster

Ao imprimir model.labels_, cada número indica o cluster atribuído à observação na mesma posição; já model.cluster_centers_ mostra as coordenadas do centro de cada grupo, úteis para perceber o que cada cluster representa.

Dica: o K-Means assume clusters mais ou menos esféricos e de tamanho semelhante. Se os teus grupos têm formas alongadas ou densidades muito diferentes, algoritmos como o DBSCAN podem dar melhores resultados.

Passo 5: Prever o cluster de novos dados

Depois de treinado, o modelo consegue atribuir novos pontos a um dos clusters existentes. Não te esqueças de aplicar a mesma normalização aos dados novos antes de prever, senão o resultado não será fiável.

new_point = scaler.transform([[2.0, 2.0]])
print(model.predict(new_point))

Verificar o resultado

Para confirmar que o agrupamento faz sentido, verifica se model.labels_ tem um rótulo (0, 1, ...) para cada observação e se os pontos que esperavas ver juntos ficaram no mesmo cluster. Podes ainda comparar as inércias do Passo 3: quanto menor a inércia, mais compactos são os grupos. Atenção, porém, que aumentar sempre o número de clusters reduz a inércia de forma artificial, por isso segue o método do cotovelo em vez de escolher o k mais alto.

Conclusão

Já tens um fluxo completo para fazer clustering com K-Means em Python: preparar os dados, normalizar, escolher o número de clusters, treinar o modelo e prever novos pontos. Um bom próximo passo é visualizar os grupos num gráfico de dispersão com o matplotlib, para veres os clusters com os teus próprios olhos. E tu, que conjunto de dados vais tentar agrupar primeiro?