K-nearest neighbors (K-esimo Vizinho mais próximo) em Python

O k-nearest neighbors é um algoritmo de Aprendizado de Maquina (Machine Learning) usado para problemas tanto de regressão assim como para problemas de classificação.

Mais sobre como knn funciona pode ser encontrado neste artigo.

Hoje usaremos este algoritmo para a resolução de um problema de classificação.

Para este tutorial usaremos o dataset de carros pertencente a repositório de aprendizado de maquina da UCI. Os dados podem ser encontrados aqui.

O código inteiro pode ser encontrado através deste link do meu GitHub em forma de Jupyter Notebook.

Depois a criação do modelo, este deveram ser capaz de determinar em que estado um determinado carro se encontra com base em características especificas do carro pode este ser, ‘inaceitável’, ‘bom’ ou ‘muito bom’.

Este tipo de classificação pode responder questões como por exemplo “Qual é o real valor de um carro A?”.

Para começar, vamos importar todas as bibliotecas que usaremos para os processos de importação dos dados, extração das features e construção do modelo preditivo.

Importando as bibliotecas

Em seguida, vamos importar os dados usando a função pd.read_csv() e depois inspecionar os nossos dados usando a função head() para ver as primeiras 5 colunas dos nossos dados. Ambas funções pertencem a biblioteca Pandas.

Importando os Dados

buying  maint door persons lug_boot safety  class
0  vhigh  vhigh    2       2    small    low  unacc
1  vhigh  vhigh    2       2    small    med  unacc
2  vhigh  vhigh    2       2    small   high  unacc
3  vhigh  vhigh    2       2      med    low  unacc
4  vhigh  vhigh    2       2      med    med  unacc

O próximo passo é a identificação e definição das nossas features e labels (rótulos). As features são os nossos inputs e as labels são os outputs, essencialmente o que pretendemos prever, usando as inputs/features.

Para este problema em particular, usaremos 3 features dos nossos dados que são: ‘buying’, ‘maint’, ‘safety’. Para tal, iremos criar uma lista usando estes elementos do dataset.

Para a label, usaremos a coluna ‘class’ do nosso dataset.

Considerando que um computador não compreende linguagem humana, devemos fazer uma conversão das features e labels durando o processo de criação destas para uma notação numérica, de forma que o computador possa compreender.

Identificação e definição das features e labels

E finalmente, a pois preparar os dados, fazer a extração das features chegou a hora de construir o modelo preditivo e testar o seu nível de precisão. Usaremos a função neighbors.KNeighborsClassifier() da biblioteca SciKit-Learn e daremos 2 parâmetros.

O primeiro parâmetro será o n_neighbors= 25 que representa a constante ‘K’ (exatamente, é o mesmo K do nome do modelo) que representa a distancia entre os vizinhos, o segundo parâmetro será o peso (weights), que será a forma como os pontos de dados serão tratados. O weights pode ser ‘uniform’ ou ‘distance’. O ‘uniform’ dará importância uniforme para todos os pontos de dados enquanto que ‘distance’ dará uma importância maior para pontos de dados mais próximos.

Em seguida, devemos separar os dados em duas categorias, dados de treino e dados de teste, tanto para as features assim como para os rótulos. Os dados de treino são usados para fazer o modelo aprender com as features e saber em que categoria de rotulo cada conjunto input se enquadra e, os dados de teste são usados para descobrir ate que ponto o modelo ‘aprendeu’ e determinar o seu nível de precisão preditiva.

O nível de precisão é determinado fazendo a comparação entre os dados reais ( dados de teste) com os resultados obtidos pelo modelo preditivo.

Os dados de treino são criados fazendo-se uma seleção aleatória de uma pequena percentagem dos dados, para este exemplo usaremos 20% dos dados para teste e, os restantes 80% serão usados para o processo de treino.

Construção do modelo preditivo e teste de precisão

Imprimir as previsoes: 
 [0 0 0 0 3 1 1 0 1 0 0 1 1 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0
 0 1 0 0 1 0 1 0 0 0 0 0 1 3 1 1 0 0 1 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0
 1 0 0 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0
 0 0 0 1 0 1 0 0 0 1 0 0 0 0 3 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0
 0 0 0 0 0 1 0 1 0 0 0 1 1 1 1 0 0 0 0 0 0 1 1 0 0 0 0 1 3 0 0 0 0 0 0 1 0
 0 1 0 0 1 0 0 1 0 0 1 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 3 0 0
 3 0 0 0 0 0 0 0 0 0 1 0 0 0 0 3 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
 1 1 0 1 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 1 1 0 1 0 0 0 1 0 0 1 0 0 1 1 1 0
 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 1
 0 0 0 3 0 0 0 0 0 1 1 0 1]
O modelo tem um nivel de precisao de  0.7254335260115607

Podemos ver que obtivemos um nível de precisão de 0.7254335260115607, ou seja, precisão = 72%, o que é um bom resultado. Mas este valor pode ser melhorado otimizando e melhorando o modelo preditivo.

Outra coisa que pode ser feita seria imprimir os 20% dos dados para fazer uma comparação visual entre os resultados previstos (a cima) e com os reais dados.

Espero que tenha gostado, o post poderá alterações com o tempo e tentarei manter também o código no GitHub updated a medida que for actualizar o post…Ate o próximo post!