S19L02-KNN em Python

html
Construindo um Modelo K-Nearest Neighbors (KNN) em Python: Um Guia Abrangente



Bem-vindo a este guia abrangente sobre como construir um modelo K-Nearest Neighbors (KNN) em Python. Seja você um entusiasta de ciência de dados ou um profissional experiente, este artigo irá guiá-lo por cada etapa do desenvolvimento de um classificador KNN, desde o pré-processamento de dados até a avaliação do modelo. Ao final deste guia, você terá uma compreensão sólida de como implementar KNN utilizando as poderosas bibliotecas de Python.

Índice


    Introdução ao K-Nearest Neighbors (KNN)
    Entendendo o Conjunto de Dados
    
        Pré-processamento de Dados
        
            Tratamento de Dados Faltantes
            Codificação de Variáveis Categóricas
            Seleção de Características
            Divisão em Treino e Teste
            Normalização de Características
        
    
    Construindo o Modelo KNN
    Avaliação do Modelo
    Conclusão
    Recursos Adicionais




Introdução ao K-Nearest Neighbors (KNN) 

K-Nearest Neighbors (KNN) é um algoritmo de aprendizado de máquina supervisionado simples, mas eficaz, utilizado para tarefas de classificação e regressão. O algoritmo KNN classifica um ponto de dados com base em como seus vizinhos são classificados. É intuitivo, fácil de implementar e não requer uma fase de treinamento, tornando-o eficiente para previsões em tempo real.

Características Principais do KNN:

    Aprendizado Preguiçoso: O KNN não constrói um modelo interno; ele memoriza o conjunto de dados de treinamento.
    Baseado em Instâncias: As previsões são baseadas em instâncias (vizinhos) dos dados de treinamento.
    Não Paramétrico: O KNN não faz suposições sobre a distribuição de dados subjacente.




Entendendo o Conjunto de Dados 

Para este tutorial, usaremos o conjunto de dados WeatherAUS do Kaggle. Este conjunto de dados contém atributos climáticos registrados ao longo de vários anos em diversas localidades australianas.

Visão Geral do Conjunto de Dados:

    
        Características
        Variável Alvo
    
    
        Date, Location, MinTemp, MaxTemp, Rainfall, Evaporation, Sunshine, WindGustDir, WindGustSpeed, WindDir9am, WindDir3pm, WindSpeed9am, WindSpeed3pm, Humidity9am, Humidity3pm, Pressure9am, Pressure3pm, Cloud9am, Cloud3pm, Temp9am, Temp3pm, RainToday, RISK_MM
        RainTomorrow (Yes/No)
    




Pré-processamento de Dados 

O pré-processamento de dados é uma etapa crucial no aprendizado de máquina. Envolve transformar dados brutos em um formato compreensível. Um pré-processamento adequado pode melhorar significativamente o desempenho dos algoritmos de aprendizado de máquina.

Tratamento de Dados Faltantes 

Dados faltantes podem afetar negativamente o desempenho dos modelos de aprendizado de máquina. Iremos tratar valores ausentes para características numéricas e categóricas.

Dados Numéricos


    Identificar Colunas Numéricas:
        



		
		
			
			
Java
			
			numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
			
				
					
				
					1
				
						numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
					
				
			
		


    
    Imputar Valores Faltantes com a Média:
        



		
		
			
			
Java
			
			from sklearn.impute import SimpleImputer
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
			
				
					
				
					1
2
3
4
				
						from sklearn.impute import SimpleImputer
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
					
				
			
		


    


Dados Categóricos


    Identificar Colunas Categóricas:
        



		
		
			
			
Java
			
			string_cols = list(np.where((X.dtypes == object))[0])
			
				
					
				
					1
				
						string_cols = list(np.where((X.dtypes == object))[0])
					
				
			
		


    
    Imputar Valores Faltantes com a Moda (Mais Frequente):
        



		
		
			
			
Java
			
			imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
imp_mode.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_mode.transform(X.iloc[:, string_cols])
			
				
					
				
					1
2
3
				
						imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
imp_mode.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_mode.transform(X.iloc[:, string_cols])
					
				
			
		


    


Codificação de Variáveis Categóricas 

Os algoritmos de aprendizado de máquina exigem entradas numéricas. Portanto, precisamos converter variáveis categóricas em formatos numéricos.

Codificação de Rótulo
A Codificação de Rótulo atribui a cada categoria um número inteiro único baseado na ordem alfabética.





		
		
			
			
Java
			
			from sklearn import preprocessing

def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    return le.fit_transform(series)
			
				
					
				
					1
2
3
4
5
				
						from sklearn import preprocessing
 
def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    return le.fit_transform(series)
					
				
			
		



Codificação One-Hot
A Codificação One-Hot cria colunas binárias para cada categoria.





		
		
			
			
Java
			
			from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)],
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
 
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)],
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
					
				
			
		



Função de Seleção de Codificação
Esta função decide se deve aplicar a Codificação de Rótulo ou a Codificação One-Hot com base no número de categorias únicas.





		
		
			
			
Java
			
			def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []

    for col in string_cols:
        length = len(pd.unique(X[X.columns[col]]))
        if length == 2 ou length > threshold:
            X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
    
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
 
    for col in string_cols:
        length = len(pd.unique(X[X.columns[col]]))
        if length == 2 ou length > threshold:
            X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
    
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X
					
				
			
		



Aplicar Codificação:




		
		
			
			
Java
			
			X = EncodingSelection(X)
			
				
					
				
					1
				
						X = EncodingSelection(X)
					
				
			
		



Seleção de Características 

Selecionar características relevantes pode melhorar o desempenho do modelo.


    Aplicar SelectKBest com Teste Qui-Quadrado:
        



		
		
			
			
Java
			
			from sklearn.feature_selection import SelectKBest, chi2
from sklearn import preprocessing

kbest = SelectKBest(score_func=chi2, k=10)
MMS = preprocessing.MinMaxScaler()
x_temp = MMS.fit_transform(X)
x_temp = kbest.fit(x_temp, y)
best_features = np.argsort(x_temp.scores_)[-13:]
features_to_delete = np.argsort(x_temp.scores_)[:-13]
X = np.delete(X, features_to_delete, axis=1)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn import preprocessing
 
kbest = SelectKBest(score_func=chi2, k=10)
MMS = preprocessing.MinMaxScaler()
x_temp = MMS.fit_transform(X)
x_temp = kbest.fit(x_temp, y)
best_features = np.argsort(x_temp.scores_)[-13:]
features_to_delete = np.argsort(x_temp.scores_)[:-13]
X = np.delete(X, features_to_delete, axis=1)
					
				
			
		


    
    Forma Resultante:
        



		
		
			
			
Java
			
			print(X.shape)  # Output: (142193, 13)
			
				
					
				
					1
				
						print(X.shape)  # Output: (142193, 13)
					
				
			
		


    


Divisão em Treino e Teste 

Dividir o conjunto de dados em conjuntos de treinamento e teste garante que o modelo seja avaliado com dados não vistos.





		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
print(X_train.shape)  # Output: (113754, 13)
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn.model_selection import train_test_split
 
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
print(X_train.shape)  # Output: (113754, 13)
					
				
			
		



Normalização de Características 

A normalização de características padroniza a faixa das variáveis independentes, garantindo que cada característica contribua igualmente para o resultado.


    Padronização:
        



		
		
			
			
Java
			
			from sklearn import preprocessing
sc = preprocessing.StandardScaler(with_mean=False)
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
			
				
					
				
					1
2
3
4
5
				
						from sklearn import preprocessing
sc = preprocessing.StandardScaler(with_mean=False)
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
					
				
			
		


    
    Verificar Formas:
        



		
		
			
			
Java
			
			print(X_train.shape)  # Output: (113754, 13)
print(X_test.shape)   # Output: (28439, 13)
			
				
					
				
					1
2
				
						print(X_train.shape)  # Output: (113754, 13)
print(X_test.shape)   # Output: (28439, 13)
					
				
			
		


    




Construindo o Modelo KNN 

Com os dados pré-processados, agora estamos prontos para construir o classificador KNN.


    Importar KNeighborsClassifier:
        



		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
			
				
					
				
					1
				
						from sklearn.neighbors import KNeighborsClassifier
					
				
			
		


    
    Inicializar o Classificador:
        



		
		
			
			
Java
			
			knnClassifier = KNeighborsClassifier(n_neighbors=3)
			
				
					
				
					1
				
						knnClassifier = KNeighborsClassifier(n_neighbors=3)
					
				
			
		


    
    Treinar o Modelo:
        



		
		
			
			
Java
			
			knnClassifier.fit(X_train, y_train)
			
				
					
				
					1
				
						knnClassifier.fit(X_train, y_train)
					
				
			
		


    
    Fazer Previsões:
        



		
		
			
			
Java
			
			y_pred = knnClassifier.predict(X_test)
			
				
					
				
					1
				
						y_pred = knnClassifier.predict(X_test)
					
				
			
		


    
    Exemplo de Previsão Única:
        



		
		
			
			
Java
			
			single_prediction = knnClassifier.predict([X_test[0]])
print(single_prediction)  # Output: [1] (1 indica 'Sim' para RainTomorrow)
			
				
					
				
					1
2
				
						single_prediction = knnClassifier.predict([X_test[0]])
print(single_prediction)  # Output: [1] (1 indica 'Sim' para RainTomorrow)
					
				
			
		


    
    Probabilidades de Previsão:
        



		
		
			
			
Java
			
			prediction_prob = knnClassifier.predict_proba([X_test[0]])
print(prediction_prob)  # Output: [[0.33333333 0.66666667]]
			
				
					
				
					1
2
				
						prediction_prob = knnClassifier.predict_proba([X_test[0]])
print(prediction_prob)  # Output: [[0.33333333 0.66666667]]
					
				
			
		


    




Avaliação do Modelo 

Avaliar o desempenho do modelo é essencial para entender sua precisão e confiabilidade.


    Importar Métrica de Precisão:
        



		
		
			
			
Java
			
			from sklearn.metrics import accuracy_score
			
				
					
				
					1
				
						from sklearn.metrics import accuracy_score
					
				
			
		


    
    Calcular Precisão:
        



		
		
			
			
Java
			
			accuracy = accuracy_score(y_pred, y_test) * 100
print(f"Accuracy: {accuracy:.2f}%")  # Output: Accuracy: 90.28%
			
				
					
				
					1
2
				
						accuracy = accuracy_score(y_pred, y_test) * 100
print(f"Accuracy: {accuracy:.2f}%")  # Output: Accuracy: 90.28%
					
				
			
		


    


Interpretação:

    O modelo KNN alcançou uma precisão de 90.28%, indicando que ele prevê corretamente o status da chuva para o próximo dia em mais de 90% dos casos. Essa alta precisão sugere que o modelo é bem adequado para essa tarefa de classificação.




Conclusão 

Neste guia, percorremos todo o processo de construção de um modelo K-Nearest Neighbors (KNN) em Python:


    Importação de Dados: Utilizando o conjunto de dados WeatherAUS.
    Pré-processamento de Dados: Tratamento de valores faltantes, codificação de variáveis categóricas e seleção de características relevantes.
    Divisão em Treino e Teste & Normalização de Características: Preparando os dados para o treinamento e garantindo uniformidade entre as características.
    Construção do Modelo: Treinando o classificador KNN e realizando previsões.
    Avaliação do Modelo: Avaliando a precisão do modelo.


O algoritmo KNN se mostra uma escolha robusta para tarefas de classificação, especialmente com dados bem pré-processados. No entanto, é essencial experimentar com diferentes hiperparâmetros (como o número de vizinhos) e técnicas de validação cruzada para aprimorar ainda mais o desempenho do modelo.



Recursos Adicionais 


    Documentação do Scikit-Learn
    Algoritmo KNN Explicado
    Tratamento de Dados Faltantes em Python
    Técnicas de Normalização de Características




Feliz Modelagem! 🚀



Disclaimer: Este artigo é baseado em uma transcrição de um tutorial em vídeo e complementado com exemplos de código de Jupyter Notebook e scripts Python. Certifique-se de adaptar e modificar o código conforme seu conjunto de dados específico e requisitos.