O agrupamento (clustering) é uma técnica de aprendizado não supervisionado: não há rótulos conhecidos. O algoritmo agrupa registros com características semelhantes, minimizando a distância dentro de cada grupo.

Aplicações

  • Segmentação de mercado e perfis de clientes.
  • Agrupamento de notícias e documentos por tema.
  • Identificação de padrões de consumo.

Algoritmos de clustering

AlgoritmoCaracterística
K-MeansDefine K centróides e associa cada ponto ao centro mais próximo
HierárquicoConstrói árvore de grupos aninhados
DBSCANEncontra clusters de densidade variável, identifica outliers

Este material foca no K-Means, o mais usado na prática introdutória.

K-Means: como funciona

  1. Definir K — número de grupos (centróides).
  2. Inicializar os centróides (aleatoriamente ou por heurística).
  3. Para cada ponto, calcular a distância a cada centróide e associá-lo ao mais próximo.
  4. Recalcular cada centróide como a média dos pontos do grupo.
  5. Repetir os passos 3 e 4 até os centróides não mudarem.

Distância Euclidiana

A distância entre dois pontos (x1, y1) e (x2, y2):

DE = √[(x1-x2)² + (y1-y2)²]

Exemplo: X = [6, 8, 10], Y = [6, 4, 7]

(6-6)² + (8-4)² + (10-7)² = 0 + 16 + 9 = 25  →  DE = 5

Método do cotovelo (Elbow Method)

Para escolher o valor de K, treina-se o K-Means com K = 1, 2, 3, … e plota a inércia (soma das distâncias ao centróide). O ponto em que a curva “dobra” (cotovelo) sugere o K ideal.

Padronização dos dados

Atributos em escalas muito diferentes (ex.: idade 18–55 vs salário 600–7000) distorcem o cálculo de distância. Use StandardScaler antes do K-Means.

Implementação em Python (Scikit-learn)

  • Classe: KMeans
  • Parâmetro: n_clusters — número de grupos.
  • Atributos: cluster_centers_ (centróides), labels_ (rótulo de cada ponto).
  • Método: fit_predict() — treina e retorna os rótulos.

Talk is cheap, show me the code: Base utilizada nesta aula (disponível no Google Drive): credit_card_clients.csv

Roteiro para a aula Aprendizado Não Supervisionado - Agrupamento
1. Importar as bibliotecas
#biblioteca para gerar gráficos dinâmicos
!pip install plotly --upgrade
#pandas é uma biblioteca que trabalha com a importação de arquivos .csv
import pandas as pd
#numpy é uma biblioteca para a realização de operações em arrays
import numpy as np
#seaborn é uma biblioteca para vizualização de gráficos
import seaborn as sb
#matplotlib é também uma biblioteca para a geração de gráficos
import matplotlib.pyplot as plt
import plotly.express as px


import plotly.graph_objects as go #auxilia nos gráficos do cluster
from sklearn.preprocessing import StandardScaler #padronizar

from sklearn.cluster import KMeans #para trabalhar com o K-means

2. Criar as variáveis da base teste
X = [18, 27, 21, 35, 44, 50, 55, 46, 49, 30, 40, 44, 39, 46, 48] #idade
Y = [1000, 1200, 2900, 1850, 900, 1000, 2000, 2100, 3100, 6000, 4000, 5000, 7000, 5000, 6500 ] #salario

grafico = px.scatter (x = X, y = Y)
grafico.show()

3. Colocar x e y em uma matriz
#unir as duas variáveis. Estão em vetor e precisa transformar em matriz
base_idade_salario = np.array([[18, 1000], [27, 1200], [21, 2900], [35,1850], [44, 900], [50, 1000], [55, 2000], [46,2100], [49, 3100], [30, 6000], [40, 4000], [44, 5000], [39, 7000], [46, 5000], [48, 6500]])
base_idade_salario

4. Padronização dos dados
#fazer a padronização dos dados
scaler_salario = StandardScaler()
base_padronizada = scaler_salario.fit_transform(base_idade_salario)
base padronizada

5. Treinar o algoritmo e mostrar os resultados e os centroides
kmeans_salario_idade = KMeans(n_clusters=3)
kmeans_salario_idade.fit(base_padronizada)

centros = kmeans_salario_idade.cluster_centers_ #centros ou centróides
centros

scaler_salario.inverse_transform(kmeans_salario_idade.cluster_centers_)  # reverter os dados

rotulos = kmeans_salario_idade.labels_ #visualiza os de registros de cada grupo
rótulos

6. Montar os gráficos com os centroides
grafico1 = px.scatter(x = base_padronizada[:, 0], y = base_padronizada[:, 1], color = rotulos)
grafico2 = px.scatter(x = centros[:, 0], y = centros[:, 1], size = [12, 12, 12])
grafico3 = go.Figure(data = grafico1.data + grafico2.data)
grafico3.show()
#grafico1.show()

=================================================DADOS ALEATÓRIOS=================================================================
1. Criar base aleatória a partir do datasets do sklearn
from sklearn.datasets import make_blobs #cria dados aleatórios
X_random, Y_random = make_blobs(n_samples=200, centers=5, random_state= 0)

grafico = px.scatter(x = X_random[:, 0], y = X_random[:, 1]) # gráfico de dispersão (função scatter da biblioteca plotly express)
grafico.show()

2. Treinar usando o kmeans
kmeans_blobs = KMeans(n_clusters=5)
kmeans_blobs.fit(X_random)

rotulos = kmeans_blobs.labels_
rótulos

centros = kmeans_blobs.cluster_centers_
centros

3. Gerar gráfico
grafico1 = px.scatter(x = X_random[:, 0], y = X_random[:, 1], color = rotulos)
grafico2 = px.scatter(x = centros[:, 0], y = centros[:, 1], size = [5, 5, 5, 5, 5])
grafico3 = go.Figure(data = grafico1.data + grafico2.data)
grafico3.show()



============================================Base dados de cartão de crédito 1 =====================================================
1 - Importar a base de dados credit_card_clients
base_credito = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/Cluster/credit_card_clients.csv', header = 1)
base_credito


#criando mais um atributo para ter o valor total devido pelo cliente
base_credito['BILL_TOTAL'] = base_credito['BILL_AMT1'] + base_credito['BILL_AMT2'] + base_credito['BILL_AMT3'] + base_credito['BILL_AMT4'] + base_credito['BILL_AMT5']  + base_credito['BILL_AMT6']

#variavel para pegar duas coluna (limite e total)
X_credito = base_credito.iloc[:, [1, 25]].values
X_credito


2 - Escalonar os dados (estão com valores numéricos com muita diferença)
#padronizar para deixar na mesma escala
stander_scaler = StandardScaler()
X_credito = stander_scaler.fit_transform(X_credito)
X_credito

3 - Método do cotovelo

#método do cotovelo
wmc = []
for i in range(1, 11):
 #print(i)
 kmeans_cartao = KMeans(n_clusters=i, random_state=0)
 kmeans_cartao.fit(X_credito)
 wmc.append(kmeans_cartao.inertia_)

4 - Gerar o gráfico com 4 e 5 clusters
k_means_cartao = KMeans(n_clusters=5, random_state=0)
rotulos = k_means_cartao.fit_predict(X_credito) #treinamento com 5 clusters

grafico = px.scatter(x = X_credito[:, 0], y = X_credito[:, 1], color = rotulos)
grafico

lista_clientes = np.column_stack((base_credito, rotulos))
lista_clientes = lista_clientes[lista_clientes[:, 25].argsort()]
lista_clientes