K-Means

Algoritmo K-Means

O algoritmo K-Means é uma técnica de aprendizado não supervisionado usada para agrupar dados em k clusters distintos. Ele funciona localizando os centros (centroides) de cada grupo e atribuindo os pontos ao cluster cujo centro esteja mais próximo, geralmente usando a distância euclidiana. O processo é iterativo: os pontos são realocados conforme os centroides são recalculados, até que os grupos fiquem estáveis.

Cars Purchase Decision

Este projeto tem como objetivo aplicar técnicas de Machine Learning para compreender os fatores que influenciam a decisão de compra de automóveis. A partir de um conjunto de dados com informações sobre idade, gênero e salário anual dos clientes, foi construída uma árvore de decisão capaz de classificar se um indivíduo provavelmente realizará a compra ou não.

Exploração dos Dados

Estatísticas Descritivas

Para o projeto foi utilizado o dataset Cars - Purchase Decision Dataset e contém detalhes de clientes que consideraram comprar um automóvel, juntamente com seus salários.

O conjunto de dados contém 1000 registros e 5 variáveis. A variável alvo é Purchased (0 = não comprou, 1 = comprou). Entre as variáveis explicativas, temos Gender (categórica), Age (numérica) e AnnualSalary (numérica).

Variáveis

User ID: Código do Cliente
Gender: Gênero do Cliente
Age: Idade do Cliente em anos
AnnualSalary: Salário anual do Cliente
Purchased: Se o cliente realizou a compra

Estatísticas Descritivas e Visualizações

O gráfico mostra a relação entre idade e salário dos clientes, destacando quem realizou a compra e quem não comprou:

ResultCode

import pandas as pd
import matplotlib.pyplot as plt
from io import BytesIO

# Carregar dataset
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)

# --- ETAPA 1: Data Cleaning
df["Age"].fillna(df["Age"].median(), inplace=True)
df["Gender"].fillna(df["Gender"].mode()[0], inplace=True)
df["AnnualSalary"].fillna(df["AnnualSalary"].median(), inplace=True)

# --- ETAPA 2: Encoding
df["Gender"] = df["Gender"].map({"Male": 1, "Female": 0})

# --- ETAPA 3: Normalização
for col in ["Age", "AnnualSalary"]:
    cmin, cmax = df[col].min(), df[col].max()
    df[col] = 0.0 if cmax == cmin else (df[col] - cmin) / (cmax - cmin)


df0 = df[df["Purchased"] == 0]
df1 = df[df["Purchased"] == 1]

# --- PLOT: Dispersão Idade x Salário ---
fig, ax = plt.subplots(1, 1, figsize=(7, 5))

ax.scatter(
    df0["Age"], df0["AnnualSalary"],
    label="Não comprou (0)", alpha=0.4,
    color="lightcoral", edgecolor="darkred", linewidth=0.8
)
ax.scatter(
    df1["Age"], df1["AnnualSalary"],
    label="Comprou (1)", alpha=0.4,
    color="skyblue", edgecolor="navy", linewidth=0.8
)

ax.set_title("Idade x Salário por Decisão de Compra")
ax.set_xlabel("Idade")
ax.set_ylabel("Salário Anual")
ax.grid(linestyle="--", alpha=0.6)
ax.legend()


buffer = BytesIO()
plt.savefig(buffer, format="svg", bbox_inches="tight")
buffer.seek(0)
print(buffer.getvalue().decode("utf-8"))

Info

A visualização deixa claro que idade e salário exercem influência relevante no comportamento de compra

O próximo gráfico apresenta a distribuição de clientes por gênero:

ResultCode

import pandas as pd
import matplotlib.pyplot as plt
from io import BytesIO

# Carregar dataset
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)

# --- ETAPA 1: Data Cleaning 
df["Gender"].fillna(df["Gender"].mode()[0], inplace=True)


counts = df["Gender"].value_counts()

# --- PLOT: Distribuição por Gênero ---
fig, ax = plt.subplots(1, 1, figsize=(6, 4))

ax.bar(
    counts.index, counts.values,
    color=["pink", "skyblue"], edgecolor="lightcoral"
)

ax.set_title("Distribuição por Gênero")
ax.set_xlabel("Gênero")
ax.set_ylabel("Quantidade")
ax.grid(axis="y", linestyle="--", alpha=0.6)


buffer = BytesIO()
plt.savefig(buffer, format="svg", bbox_inches="tight")
buffer.seek(0)
print(buffer.getvalue().decode("utf-8"))

Info

Observa-se que há uma leve predominância de mulheres no dataset.

O último gráfico apresenta a distribuição do salário anual dos clientes, permitindo visualizar a mediana, a dispersão dos valores e a presença de possíveis extremos:

ResultCode

import pandas as pd
import matplotlib.pyplot as plt
from io import BytesIO

# Carregar dataset
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)

# --- ETAPA 1: Data Cleaning
df["AnnualSalary"].fillna(df["AnnualSalary"].median(), inplace=True)

# --- PLOT: Boxplot
fig, ax = plt.subplots(figsize=(7, 5))

bp = ax.boxplot(df["AnnualSalary"], patch_artist=True, widths=0.5)

for box in bp["boxes"]:
    box.set(facecolor="skyblue", edgecolor="navy", linewidth=1.2)
for whisker in bp["whiskers"]:
    whisker.set(color="navy", linewidth=1.2)
for cap in bp["caps"]:
    cap.set(color="navy", linewidth=1.2)
for median in bp["medians"]:
    median.set(color="darkred", linewidth=1.5)

ax.set_title("Distribuição do Salário Anual")
ax.set_ylabel("Salário Anual")
ax.set_xticks([])
ax.grid(axis="y", linestyle="--", alpha=0.6)


buffer = BytesIO()
plt.savefig(buffer, format="svg", bbox_inches="tight")
buffer.seek(0)
print(buffer.getvalue().decode("utf-8"))

Info

O gráfico evidencia que a maior parte dos salários está concentrada em uma faixa intermediária, entre aproximadamente 50 mil e 90 mil, com a mediana em torno de 70 mil.

Pré-processamento

Pré-processamento de dados brutos deve ser a primeira etapa ao lidar com datasets de todos tamanhos.

Data Cleaning

O processo de data cleaning garante que o conjunto utilizado seja confiável e esteja livre de falhas que possam distorcer os resultados. Consiste em identificar e corrigir problemas como valores ausentes, dados inconsistentes ou informações que não fazem sentido. Essa limpeza permite que a base seja mais fiel à realidade e forneça condições adequadas para a construção de modelos de Machine Learning.

No código, a limpeza foi feita dessa forma: possíveis valores vazios em idade, gênero e salário foram preenchidos com informações representativas, como a mediana ou o valor mais frequente.

ResultCode

Gender	Age	AnnualSalary
Male	32	77500
Female	46	135500
Female	36	63000
Female	53	90500
Female	47	42500
Male	41	73500
Male	55	39000
Male	59	135500
Female	41	67500
Male	25	59500

import pandas as pd

def preprocess(df):
    df['Age'].fillna(df['Age'].median(), inplace=True)
    df['Gender'].fillna(df['Gender'].mode()[0], inplace=True)
    df['AnnualSalary'].fillna(df['AnnualSalary'].median(), inplace=True)

    features = ['Gender', 'Age', 'AnnualSalary']
    return df[features]

df = pd.read_csv('https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv')
df = df.sample(n=10, random_state=42)
df = preprocess(df)


print(df.sample(n=10).to_markdown(index=False))

Encoding Categorical Variables

O processo de encoding de variáveis categóricas transforma informações em formato de texto em valores numéricos, permitindo que algoritmos de Machine Learning consigam utilizá-las em seus cálculos.

No código, o encoding foi aplicado à variável gênero, convertendo as categorias “Male” e “Female” em valores numéricos (1 e 0). Dessa forma, a base de dados mantém todas as colunas originais, mas agora com a variável categórica representada de maneira adequada para ser usada em algoritmos de classificação.

ResultCode

User ID	Gender	Age	AnnualSalary	Purchased
176	1	41	73500	0
448	1	59	135500	1
391	1	25	59500	0
623	0	47	42500	1
773	0	46	135500	0
413	0	53	90500	1
793	1	55	39000	1
836	0	36	63000	0
586	0	41	67500	0
651	1	32	77500	0

import pandas as pd

def preprocess(df):
    # Limpeza
    df['Age'].fillna(df['Age'].median(), inplace=True)
    df['Gender'].fillna(df['Gender'].mode()[0], inplace=True)
    df['AnnualSalary'].fillna(df['AnnualSalary'].median(), inplace=True)

    # Encoding simples para Gender
    df['Gender'] = df['Gender'].map({'Male': 1, 'Female': 0})


    return df


df = pd.read_csv('https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv')
df = df.sample(n=10, random_state=42)
df = preprocess(df)


print(df.to_markdown(index=False))

Normalização

A normalização é o processo de reescalar os valores numéricos de forma que fiquem dentro de um intervalo fixo, normalmente entre 0 e 1. Isso facilita a comparação entre variáveis que possuem unidades ou magnitudes diferentes, evitando que atributos com valores muito altos dominem a análise.

No código, a normalização foi aplicada às colunas idade e salário anual, transformando seus valores para a faixa de 0 a 1 por meio do método Min-Max Scaling. Dessa forma, ambas as variáveis passam a estar na mesma escala, tornando o conjunto de dados mais consistente e adequado para a modelagem.

ResultCode

User ID	Gender	Age	AnnualSalary	Purchased
576	Male	0.955556	0.643636	1
461	Female	0.488889	0.323636	0
896	Male	0.555556	0.454545	0
712	Female	0.244444	0.232727	0
405	Female	0.666667	0.894545	1
730	Male	0.555556	0.323636	0
581	Female	0.377778	0.0836364	0
73	Male	0.933333	0.447273	1
448	Male	0.911111	0.876364	1
436	Female	0.111111	0.24	0

import pandas as pd
from sklearn.preprocessing import MinMaxScaler

# Carregar dataset
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)

# Selecionar colunas numéricas para normalizar
features_to_normalize = ['Age', 'AnnualSalary']

# Inicializar o scaler
scaler = MinMaxScaler()

# Aplicar normalização e substituir no DataFrame
df[features_to_normalize] = scaler.fit_transform(df[features_to_normalize])

# Mostrar amostra dos dados normalizados
print(df.sample(10).to_markdown(index=False))

Divisão dos Dados

Após o pré-processamento, o conjunto de dados precisa ser separado em duas partes: uma para treinamento e outra para teste. Essa divisão é fundamental para que o modelo de Machine Learning aprenda padrões a partir de um grupo de exemplos e, depois, seja avaliado em dados que ainda não foram vistos. Dessa forma, é possível medir a capacidade de generalização do modelo e evitar que ele apenas memorize os exemplos fornecidos.

No código, os atributos escolhidos como preditores foram gênero, idade e salário anual, enquanto a variável-alvo foi Purchased, que indica se o cliente comprou ou não o produto. A divisão foi feita em 70% para treino e 30% para teste, garantindo que a proporção de clientes que compraram e não compraram fosse preservada em ambos os subconjuntos.

ResultCode

Tamanho treino: 700 Tamanho teste: 300

import pandas as pd
from sklearn.model_selection import train_test_split

# Carregar dataset
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)

# --- Data Cleaning
df["Age"].fillna(df["Age"].median(), inplace=True)
df["Gender"].fillna(df["Gender"].mode()[0], inplace=True)
df["AnnualSalary"].fillna(df["AnnualSalary"].median(), inplace=True)

# --- Encoding
df["Gender"] = df["Gender"].map({"Male": 1, "Female": 0})

# --- Normalização
for col in ["Age", "AnnualSalary"]:
    cmin, cmax = df[col].min(), df[col].max()
    df[col] = 0.0 if cmax == cmin else (df[col] - cmin) / (cmax - cmin)

# --- Separar variáveis preditoras 
X = df[["Gender", "Age", "AnnualSalary"]]
y = df["Purchased"]

# --- Divisão em treino e teste 
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

print("Tamanho treino:", X_train.shape[0])
print("Tamanho teste:", X_test.shape[0])

Implementação K-Means

O processo de clustering foi conduzido utilizando Idade e Salário Anual como variáveis principais, resultando em clusters bem definidos e centróides que representam os perfis médios de cada grupo.

Os resultados evidenciaram que a renda anual foi um fator decisivo na formação dos clusters, separando clientes em faixas de poder aquisitivo distintas. Essa segmentação pode ser útil para estratégias de marketing, definição de público-alvo e personalização de ofertas.

ResultCode

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from io import StringIO
from sklearn.cluster import KMeans

plt.figure(figsize=(12, 10))


url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)


X = df[["Age", "AnnualSalary"]].dropna().to_numpy()


kmeans = KMeans(n_clusters=2, init="k-means++", max_iter=100, random_state=42, n_init=10)
labels = kmeans.fit_predict(X)


plt.scatter(X[:, 0], X[:, 1], c=labels, cmap="viridis", s=50, alpha=0.7)
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1],
            c="red", marker="*", s=200, label="Centroides")

plt.title("Clusters com K-Means")
plt.xlabel("Idade")
plt.ylabel("Salário Anual")
plt.legend()


buffer = StringIO()
plt.savefig(buffer, format="svg", transparent=True)
print(buffer.getvalue())

O gráfico mostra os clusters formados pelo K-Means, com cada cor representando um grupo de clientes e as estrelas vermelhas indicando os centróides. É possível notar que o Salário Anual foi a variável mais determinante na separação dos grupos, criando um cluster associado a clientes com maior poder aquisitivo e outro relacionado a clientes de renda mais baixa. Assim, o modelo demonstra como o K-Means pode ser usado de forma eficaz para segmentação de mercado e análise de perfis de consumidores.

Apesar dos bons resultados, é importante destacar que o K-Means depende fortemente da escolha do número de clusters (K) e pode ser influenciado por outliers.