KNN

1 Exploração dos Dados 20

Nessa fase, buscamos compreender a estrutura, as características e possíveis inconsistências do conjunto de dados. Inicialmente, realizamos a leitura do dataset e a visualização das primeiras linhas para identificar o tipo de variáveis presentes, como colunas numéricas e categóricas, além de verificar a existência de valores ausentes ou discrepantes. Essa análise inicial permite entender melhor o comportamento dos dados, orientar a seleção de features relevantes e definir os próximos passos para a preparação e modelagem dos dados.

2 Pré-processamento 10

Para iniciar o processo de análise, foi realizado o carregamento do dataset de carros Audi, disponível em formato CSV. Em seguida, foi feita uma amostragem aleatória de 10 registros para facilitar a visualização e manipulação inicial dos dados.

Na etapa de pré-processamento, valores ausentes nas colunas numéricas (tax, mpg e price) foram preenchidos com a mediana de cada coluna, garantindo que não houvesse dados faltantes que pudessem prejudicar as análises subsequentes. Após o tratamento dos dados, foram selecionadas as principais variáveis de interesse: model, year, price, transmission, mileage, fuelType, tax, mpg e engineSize.

A visualização das primeiras linhas do dataset permitiu verificar a estrutura dos dados, identificar possíveis inconsistências e compreender melhor as variáveis disponíveis para a construção dos modelos de machine learning.

2.1 Data cleaning

3 Treinamento do modelo

Com os dados devidamente preparados e divididos, foi realizado o treinamento do modelo KNN (K-Nearest Neighbors). O modelo foi ajustado utilizando o conjunto de treino, onde o algoritmo aprende a identificar padrões e relações entre as variáveis de entrada (features) e o alvo (rótulo).

Durante o treinamento, o KNN armazena os exemplos do conjunto de treino e, ao receber uma nova amostra, classifica-a com base nos vizinhos mais próximos, de acordo com a métrica de distância escolhida. O parâmetro k define o número de vizinhos considerados para a decisão. Esse processo é fundamental para que o modelo possa realizar previsões precisas em novos dados.

import numpy as np
import matplotlib.pyplot as plt
from io import StringIO
from sklearn.calibration import LabelEncoder
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
import pandas as pd
import seaborn as sns

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

# Limpar e preparar os dados
def preprocess(df):
    # Fill missing values
    df['tax'].fillna(df['tax'].median(), inplace=True)
    df['mpg'].fillna(df['mpg'].median(), inplace=True)
    df['price'].fillna(df['price'].median(), inplace=True)

    # Convert categorical variables
    label_encoder = LabelEncoder()
    df['transmission'] = label_encoder.fit_transform(df['transmission'])
    df['fuelType'] = label_encoder.fit_transform(df['fuelType'])
    return df

# Generate synthetic dataset
df = pd.read_csv('https://raw.githubusercontent.com/EnricoDiGioia/Machine-Learning/refs/heads/main/data/audi.csv')
df = preprocess(df)
X = df[['price', 'tax', 'mpg', 'engineSize', 'mileage', 'year']]
y = df['fuelType']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train KNN model
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
predictions = knn.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, predictions):.2f}")


df_plot = pd.DataFrame()
df_plot['price'] = (X['price']-X['price'].min())/(X['price'].max()-X['price'].min())
df_plot['tax'] = (X['tax']-X['tax'].min())/(X['tax'].max()-X['tax'].min())
df_plot['fuelType'] = y
sns.scatterplot(data=df_plot, x='price', y='tax', hue='fuelType')


#Ver se é necessario dps

# Visualize decision boundary
#h = 0.02  # Step size in mesh
#x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
#y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
#xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
#
#Z = knn.predict(np.c_[xx.ravel(), yy.ravel()])
#Z = Z.reshape(xx.shape)
#
#plt.contourf(xx, yy, Z, cmap=plt.cm.RdYlBu, alpha=0.3)
#sns.scatterplot(x=X[:, 0], y=X[:, 1], hue=y, style=y, palette="deep", s=100)
#plt.xlabel("Feature 1")
#plt.ylabel("Feature 2")
#plt.title("KNN Decision Boundary (k=3)")
#
## Display the plot
buffer = StringIO()
plt.savefig(buffer, format="svg", transparent=True)
print(buffer.getvalue())

4 Avaliação do Modelo 20

Após o treinamento do modelo KNN, a avaliação de desempenho foi realizada utilizando o conjunto de teste separado anteriormente. Para isso, o modelo fez previsões sobre os dados de teste e a acurácia foi calculada por meio da função accuracy_score da biblioteca scikit-learn.

A acurácia representa a proporção de previsões corretas em relação ao total de exemplos avaliados, sendo uma métrica simples e direta para problemas de classificação. Esse processo permite verificar se o modelo está generalizando bem para dados que não foram vistos durante o treinamento, fornecendo uma estimativa confiável de seu desempenho em situações reais.

Accuracy: 0.63