Métricas

Metrics and Evaluation - Algoritmo KNN e K-Means

Os algoritmos K-Nearest Neighbors (KNN) e K-Means são duas abordagens clássicas de Machine Learning que, embora diferentes em sua natureza, compartilham a ideia central de medir a proximidade entre pontos. O KNN é um método supervisionado, utilizado para tarefas de classificação, em que novas amostras são atribuídas à classe predominante entre seus vizinhos mais próximos. Já o K-Means é um método não supervisionado, aplicado para agrupar dados em clusters com base na semelhança de suas características, sem depender de rótulos previamente definidos.

Ao serem aplicados em conjunto, esses algoritmos permitem duas perspectivas complementares: de um lado, a predição direta de categorias por meio do KNN; de outro, a descoberta de padrões ocultos com o K-Means. Essa combinação ajuda tanto a entender melhor a estrutura dos dados quanto a explorar possibilidades de segmentação e análise de comportamento.

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	55	39000
Female	53	90500
Male	59	135500
Male	32	77500
Female	36	63000
Male	41	73500
Male	25	59500
Female	46	135500
Female	41	67500
Female	47	42500

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
166	Male	0.555556	0.381818	0
13	Male	0.244444	0.472727	0
288	Female	0.333333	0.752727	0
823	Female	0.311111	0.741818	1
249	Female	0.466667	0.723636	1
655	Male	0.555556	0.432727	1
286	Male	0.466667	0.778182	1
273	Male	0.6	0.08	1
970	Female	0.355556	0.403636	0
43	Female	0.733333	0.952727	1

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 KNN

Usando Scikit-Learn

A aplicação do KNN resultou em uma boa performance na tarefa de classificação, com acurácia próxima de 91%. O modelo conseguiu diferenciar de forma consistente as classes 0 (não comprou) e 1 (comprou), mostrando que a proximidade entre idade, gênero e salário anual é suficiente para prever o comportamento de compra. A matriz de confusão evidenciou poucos erros, reforçando a capacidade do algoritmo em generalizar padrões do conjunto de dados.

ResultCode

Accuracy: 0.91

Confusion Matrix: | | Pred 0 | Pred 1 | |:-------|---------:|---------:| | True 0 | 164 | 15 | | True 1 | 11 | 110 |

import numpy as np
import pandas as pd
from io import BytesIO
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, confusion_matrix


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)

    enc = LabelEncoder()
    df["Gender"] = enc.fit_transform(df["Gender"]) 

    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)
    # X / y
    X = df[["Gender", "Age", "AnnualSalary"]].to_numpy(float)
    y = df["Purchased"].to_numpy(int)
    return X, y


df = pd.read_csv("https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv")
X, y = preprocess(df)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.30, random_state=42, stratify=y
)


knn = KNeighborsClassifier(n_neighbors=5) 
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)

print(f"Accuracy: {accuracy_score(y_test, y_pred):.2f}")
cm = confusion_matrix(y_test, y_pred)
print("\nConfusion Matrix:")
print(pd.DataFrame(cm, index=["True 0","True 1"], columns=["Pred 0","Pred 1"]).to_markdown())

Implementação K-Means

A análise com o algoritmo K-Means permitiu identificar dois grupos principais no conjunto de dados, definidos a partir da combinação entre idade e salário anual. Cada cor no gráfico representa um cluster, enquanto as estrelas vermelhas marcam os centróides, ou seja, os pontos médios que caracterizam cada grupo. Essa separação evidencia padrões de comportamento entre os indivíduos, como faixas salariais e idades que tendem a se agrupar. Apesar de não utilizar os rótulos originais (como no KNN), o K-Means oferece uma visão exploratória útil para identificar tendências e estruturas ocultas nos dados.

GráficoCode

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())

As métricas de avaliação desempenham um papel essencial na validação de modelos de machine learning, pois permitem medir sua performance de forma objetiva. No caso do KNN, foram utilizadas métricas supervisionadas como acurácia, matriz de confusão, precisão, recall e F1-score, que mostraram um desempenho consistente, com acurácia em torno de 91% e boa distinção entre as classes 0 (não comprou) e 1 (comprou).

Já no K-Means, por ser um algoritmo não supervisionado, a análise foi realizada a partir da coerência entre os clusters formados e a variável real de compra, o que evidenciou padrões relevantes no comportamento dos dados. Assim, observa-se que a escolha de métricas adequadas, supervisionadas para classificação e comparativas para clustering, é indispensável para interpretar corretamente os resultados obtidos.