Dominando a Visualização de K-Vizinhos Mais Próximos (KNN) em Python: Um Guia Abrangente

Introdução

No âmbito do aprendizado de máquina, o algoritmo K-Vizinhos Mais Próximos (KNN) destaca-se por sua simplicidade e eficácia em tarefas de classificação. No entanto, compreender e interpretar as fronteiras de decisão do KNN pode ser desafiador, especialmente ao lidar com dados de alta dimensão. É aqui que a visualização se torna uma ferramenta poderosa. Neste guia abrangente, vamos explorar as complexidades da visualização do KNN usando Python, aproveitando pacotes como mlxtend e matplotlib. Ao final deste artigo, você estará equipado com o conhecimento para criar representações visuais perspicazes de seus modelos KNN.

Índice

Compreendendo o KNN e Sua Visualização
Configurando Seu Ambiente Python
Pré-processamento de Dados: Preparando Seu Conjunto de Dados
Construindo e Treinando o Modelo KNN
Visualizando Fronteiras de Decisão
Interpretando a Visualização
Conclusão
Recursos Adicionais

Compreendendo o K-Vizinhos Mais Próximos (KNN) e Sua Visualização

O Que é K-Vizinhos Mais Próximos (KNN)?

KNN é um algoritmo de aprendizado não paramétrico, baseado em instâncias, usado para tarefas de classificação e regressão. Ele opera com base no princípio de que pontos de dados semelhantes provavelmente estão próximos uns dos outros no espaço de características. Para classificação, o KNN atribui a classe mais comum entre seus K vizinhos mais próximos.

Por Que Visualizar o KNN?

A visualização auxilia em:

Interpretar o Comportamento do Modelo: Entender como o KNN toma decisões com base no espaço de características.
Identificar Overfitting ou Underfitting: Padrões visuais podem revelar se o modelo generaliza bem.
Comparar o Impacto das Características: Ver quais características contribuem mais para as fronteiras de decisão.

Configurando Seu Ambiente Python

Antes de mergulhar na visualização do KNN, certifique-se de que seu ambiente Python está configurado com os pacotes necessários.

Pacotes Necessários:

pandas: Manipulação e análise de dados.
numpy: Computação numérica.
scikit-learn: Algoritmos e ferramentas de aprendizado de máquina.
mlxtend: Pacotes de extensão para aprendizado de máquina.
matplotlib: Plotagem e visualização.

Comando de Instalação:

pip install pandas numpy scikit-learn mlxtend matplotlib

1	pip install pandas numpy scikit-learn mlxtend matplotlib

Pré-processamento de Dados: Preparando Seu Conjunto de Dados

Um conjunto de dados bem preparado é crucial para construir um modelo KNN eficaz. Usaremos o Conjunto de Dados Weather Australia para este exemplo.

1. Importando Bibliotecas e Carregando Dados

import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt

# Carregar conjunto de dados
data = pd.read_csv('weatherAUS.csv')

import pandas as pd

import numpy as np

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.impute import SimpleImputer

from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler

from sklearn.feature_selection import SelectKBest, chi2

from sklearn.neighbors import KNeighborsClassifier

from sklearn.metrics import accuracy_score

from mlxtend.plotting import plot_decision_regions

import matplotlib.pyplot as plt

# Carregar conjunto de dados

data = pd.read_csv('weatherAUS.csv')

2. Explorando os Dados

data.tail()

1	data.tail()

Saída:

Date Location  MinTemp  MaxTemp  Rainfall  Evaporation  ... Humidity3pm  Pressure9am  ...
142188  2017-06-20    Uluru      3.5     21.8       0.0          NaN  ...        27.0       1024.7  ...
...

Date Location MinTemp MaxTemp Rainfall Evaporation ... Humidity3pm Pressure9am ...

142188 2017-06-20 Uluru 3.5 21.8 0.0 NaN ... 27.0 1024.7 ...

...

3. Lidando com Dados Faltantes

Características Numéricas:

numerical_cols = data.select_dtypes(include=['int64', 'float64']).columns
imp_mean = SimpleImputer(strategy='mean')
data[numerical_cols] = imp_mean.fit_transform(data[numerical_cols])

numerical_cols = data.select_dtypes(include=['int64', 'float64']).columns

imp_mean = SimpleImputer(strategy='mean')

data[numerical_cols] = imp_mean.fit_transform(data[numerical_cols])

Características Categóricas:

string_cols = data.select_dtypes(include=['object']).columns
imp_freq = SimpleImputer(strategy='most_frequent')
data[string_cols] = imp_freq.fit_transform(data[string_cols])

string_cols = data.select_dtypes(include=['object']).columns

imp_freq = SimpleImputer(strategy='most_frequent')

data[string_cols] = imp_freq.fit_transform(data[string_cols])

4. Codificando Variáveis Categóricas

def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series)

# Codificar variável alvo
data['RainTomorrow'] = LabelEncoderMethod(data['RainTomorrow'])

# Codificar One-Hot para características categóricas
X = data.drop(['RainTomorrow', 'RISK_MM'], axis=1)
X = pd.get_dummies(X, drop_first=True)
y = data['RainTomorrow']

def LabelEncoderMethod(series):

le = LabelEncoder()

return le.fit_transform(series)

# Codificar variável alvo

data['RainTomorrow'] = LabelEncoderMethod(data['RainTomorrow'])

# Codificar One-Hot para características categóricas

X = data.drop(['RainTomorrow', 'RISK_MM'], axis=1)

X = pd.get_dummies(X, drop_first=True)

y = data['RainTomorrow']

5. Seleção de Características

kbest = SelectKBest(score_func=chi2, k=10)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_selected = kbest.fit_transform(X_scaled, y)

kbest = SelectKBest(score_func=chi2, k=10)

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

X_selected = kbest.fit_transform(X_scaled, y)

6. Dividindo o Conjunto de Dados

X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.20, random_state=1)

1	X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.20, random_state=1)

Construindo e Treinando o Modelo KNN

Com os dados pré-processados e divididos, é hora de construir o classificador KNN.

1. Inicializando e Treinando o Modelo

knn_classifier = KNeighborsClassifier(n_neighbors=3)
knn_classifier.fit(X_train, y_train)

1 2	knn_classifier = KNeighborsClassifier(n_neighbors=3) knn_classifier.fit(X_train, y_train)

2. Avaliando o Desempenho do Modelo

y_pred = knn_classifier.predict(X_test)
accuracy = accuracy_score(y_pred, y_test)
print(f"Precisão do Modelo: {accuracy:.2f}")

y_pred = knn_classifier.predict(X_test)

accuracy = accuracy_score(y_pred, y_test)

print(f"Precisão do Modelo: {accuracy:.2f}")

Saída:

Precisão do Modelo: 0.80

1	Precisão do Modelo: 0.80

Visualizando Fronteiras de Decisão

A visualização ajuda a entender como o modelo KNN separa diferentes classes com base nas características selecionadas.

1. Selecionando Duas Características para Visualização

Como as fronteiras de decisão são mais fáceis de visualizar em duas dimensões, limitamos nossa seleção de características às duas principais.

kbest = SelectKBest(score_func=chi2, k=2)
X_selected = kbest.fit_transform(X_scaled, y)

1 2	kbest = SelectKBest(score_func=chi2, k=2) X_selected = kbest.fit_transform(X_scaled, y)

2. Dividindo o Conjunto de Dados Novamente

X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.20, random_state=1)

1	X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.20, random_state=1)

3. Escalonamento de Características

scaler = StandardScaler(with_mean=False)
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

scaler = StandardScaler(with_mean=False)

X_train = scaler.fit_transform(X_train)

X_test = scaler.transform(X_test)

4. Retreinando o Modelo

knn_classifier.fit(X_train, y_train)

1	knn_classifier.fit(X_train, y_train)

5. Plotando Regiões de Decisão

plt.figure(figsize=(10,6))
plot_decision_regions(X_train, y_train, clf=knn_classifier, legend=2)
plt.xlabel('Característica 1')
plt.ylabel('Característica 2')
plt.title('Fronteira de Decisão KNN com k=3')
plt.show()

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

plot_decision_regions(X_train, y_train, clf=knn_classifier, legend=2)

plt.xlabel('Característica 1')

plt.ylabel('Característica 2')

plt.title('Fronteira de Decisão KNN com k=3')

plt.show()

Saída:

Fronteira de Decisão KNN

Nota: Substitua o link da imagem pelo gráfico gerado a partir do seu ambiente.

Interpretando a Visualização

O gráfico das fronteiras de decisão ilustra como o classificador KNN diferencia entre classes com base nas duas características selecionadas. Cada região representa a área onde o modelo prevê uma determinada classe. Pontos de dados próximos à fronteira indicam instâncias onde as previsões do modelo são mais sensíveis a mudanças nos valores das características.

Principais Insights:

Forma da Fronteira: As fronteiras do KNN podem ser não lineares e sensíveis ao valor de K.
Sobreposição de Classes: Áreas onde as classes se sobrepõem podem levar a classificações incorretas.
Influência de K: Um K menor leva a fronteiras mais flexíveis, enquanto um K maior as suaviza.

Conclusão

Visualizar o algoritmo K-Vizinhos Mais Próximos fornece insights inestimáveis sobre seu processo de tomada de decisão. Ao restringir o espaço de características a duas dimensões, você pode interpretar efetivamente como o modelo distingue entre classes. Embora a visualização seja uma ferramenta poderosa, é essencial complementá-la com métricas robustas de avaliação de modelo, como precisão, precisão e recall, para garantir uma compreensão abrangente e uma avaliação de desempenho completa.

Recursos Adicionais

Conjunto de Dados Weather Australia no Kaggle: Link
Documentação do Scikit-learn: Classificador KNN
Biblioteca mlxtend: Plotando Regiões de Decisão
Manual de Ciência de Dados em Python por Jake VanderPlas: Link

Meta Descrição: Desbloqueie o poder da visualização de K-Vizinhos Mais Próximos (KNN) em Python. Este guia abrangente cobre pré-processamento de dados, treinamento de modelo e plotagem de fronteiras de decisão usando bibliotecas como scikit-learn e mlxtend.

Palavras-chave: visualização KNN, K-Vizinhos Mais Próximos Python, gráfico de fronteira de decisão, visualização de aprendizado de máquina, scikit-learn KNN, mlxtend plotar regiões de decisão, pré-processamento de dados Python, seleção de características KNN, precisão do modelo KNN