Classificar Flores Usando Medidas: KNN k-nearest neighbors (vizinhos mais

prximos)

O problema deste tutorial a classificao do arquivo ris, do sistema

weka.

O arquivo composto de observaes da ris de 150 flores a partir de trs

espcies diferentes. Existem 4 medies, colunas, de cada flor dada:
comprimento e largura das spalas, comprimento e largura da ptala,
todos na unidade de centmetro; mais o atributo da classe que a coluna
da espcie: setosa, versicolor ou virginica.

um conjunto de dados padro: a espcie conhecida por todas as

instncias. Assim pode-se dividir os dados em conjuntos de treinamento e
teste, para avaliar a implementao do algoritmo. Boa preciso da
classificao neste problema tipicamente superior a 90%.

Voc pode baixar o conjunto de dados iris.data, da web.

Como implementar k vizinhos mais prximos em Python

Este tutorial dividido nas seguintes etapas:

1. Ler dados: Abrir o conjunto de dados do CSV e dividi-lo em conjuntos

de dados de teste / treinamento.

2. Similaridade: calcular a distncia entre duas instncias de dados.

3. Vizinhos: Localizar os K mais vizinhos, no conjunto de treinamento, de

uma instancia do conjunto de teste.

4. Resposta: Gerar uma resposta de um conjunto de instncias de dados.

5. Preciso: Resumir a preciso das previses.

6. Principal: unir tudo isso.

1. Ler dados

A primeira coisa que precisa fazer carregar o nosso arquivo de dados. Os

dados esto no formato CSV, sem as linhas de cabealho ou qualquer
comentrios. Ns podemos abrir o arquivo com as funo de abrir e ler as
linhas de dados do mdulo csv.
import csv
with open('iris.data', 'r') as csvfile:
lines = csv.reader(csvfile)
for row in lines:
print ', '.join(row)

Os dados so lidos em uma tupla que pode ser convertida em uma lista,
como segue.

aTuple = (123, 'xyz', 'zara', 'abc');

aList = list(aTuple)

print "List elements : ", aList

>>>List elements : [123, 'xyz', 'zara', 'abc']

Em seguida, precisamos dividir os dados em um conjunto de dados de

treinamento. Assim depois que o KNN faz as previses, podemos avaliar a
acurcia do modelo gerado pelo KNN.

Primeiro precisamos converter as medidas de flores que foram carregados

como strings para nmeros, para que possamos trabalhar, calcular a
similaridade ou proximidade. Em seguida, precisamos dividir o conjunto
de dados em treinamento e teste. A diviso de forma aleatria. Uma
proporo de 67/33 para trein / teste uma razo padro.

Juntando tudo, definimos uma funo chamada loadDataset que carrega a

CSV com o nome fornecido e divide de forma aleatria em trein e teste o
conjuntos de dados usando a taxa de diviso fornecido.
import csv
import random
def loadDataset(filename, split, trainSet=[] , testSet=[]):
with open(filename, 'rb') as csvfile:
lines = csv.reader(csvfile)
dataset = list(lines)
for x in range(len(dataset)-1):
for y in range(4):
dataset[x][y] = float(dataset[x][y])
 if random.random() < split:
trainSet.append(dataset[x])
else:
testSet.append(dataset[x])

Exemplo de uso:

trainSet=[]
testSet=[]
loadDataset('iris.data', 0.66, trainSet, testSet)
print 'Train: ' + repr(len(trainSet))
print 'Test: ' + repr(len(testSet))

2. Similaridade

A fim de fazer previses precisamos calcular a similaridade entre duas

quaisquer instncias de dados. Isso necessrio para que possamos
localizar as k instncias mais prximas de uma dada instancia.

Como as quatro medies so numricos e tm as mesmas unidades,

podemos usar a distncia euclidiana: definida como a raiz quadrada da
soma das diferenas de quadrados entre os dois vetores de nmeros.

Alm disso, queremos definir quais campos a incluir no clculo da

distncia. Especificamente, ns s queremos incluir os primeiros quatro
atributos, ignorando a classe, o ltimo atributo, limitando o comprimento
para 4 atributos, dos cinco.

Colocando tudo isso junto:

import math
def euclideanDistance(instance1, instance2, length):
distance = 0
for x in range(length):
distance += pow((instance1[x] - instance2[x]), 2)
return math.sqrt(distance)
data1 = [2, 2, 2, 'a']
data2 = [4, 4, 4, 'b']
distance = euclideanDistance(data1, data2, 3)
print 'Distance: ' + repr(distance)
3. Vizinhos

Agora que temos uma medida de similaridade, podemos us-la para

coletar as k instncias mais prximas para uma dada instancia. um
processo de calcular a distncia de um com todos. Depois selecionar os k
menores valores de distncia.

Abaixo est a getNeighbors essa funo retorna k mais gostaria vizinhos

do conjunto de treinamento para uma instancia de teste.

import operator
def getNeighbors(trainSet, testInstance, k):
distances = []
length = len(testInstance)-1
for x in range(len(trainSet)):
dist = euclideanDistance(testInstance, trainSet[x],
length)
distances.append((trainSet[x], dist))
distances.sort(key=operator.itemgetter(1))
neighbors = []
for x in range(k):
neighbors.append(distances[x][0])
return neighbors

trainSet = [[2, 2, 2, 'a'], [4, 4, 4, 'b']]

testInstance = [5, 5, 5]
k = 1
neighbors = getNeighbors(trainSet, testInstance, 1)
print(neighbors)

4. Resposta

Uma vez que temos localizado os k mais vizinhos para uma instncia de
teste, a prxima tarefa criar uma previso com base nos vizinhos, por
exemplo a moda. A moda o voto da maioria.

Ele assume a classe o ltimo atributo para cada vizinho.

import operator
def getResponse(neighbors):
classVotes = {}
for x in range(len(neighbors)):
response = neighbors[x][-1]
 if response in classVotes:
classVotes[response] += 1
else:
classVotes[response] = 1
sortedVotes = sorted(classVotes.iteritems(),
key=operator.itemgetter(1), reverse=True)
return sortedVotes[0][0]

Ns podemos testar esta funo com alguns vizinhos, como segue:

neighbors = [[1,1,1,'a'], [2,2,2,'a'], [3,3,3,'b']]

response = getResponse(neighbors)
print(response)

Esta abordagem retorna a primeira resposta no caso de um empate, mas

voc poderia lidar com casos de uma forma especfica, por ex. uma
resposta aleatria imparcial.

5. Preciso

Ns temos todas as peas do algoritmo kNN no lugar. Uma preocupao

restante como avaliar a preciso das previses.

Uma maneira fcil de avaliar a preciso do modelo calcular uma

proporo do total de previses corretas de todas as previses feitas,
chamada de acurcia da classificao.

Abaixo est a getAccuracy funo que resume as previses corretas

geradas e retorna a preciso como um percentual de classificaes
corretas.

def getAccuracy(testSet, predictions):

correct = 0
for x in range(len(testSet)):
if testSet[x][-1] is predictions[x]:
correct += 1
return (correct/float(len(testSet))) * 100.0
Podemos testar a acurcia com os testes abaixo:
testSet = [[1,1,1,'a'], [2,2,2,'a'], [3,3,3,'b']]
predictions = ['a', 'a', 'a']
accuracy = getAccuracy(testSet, predictions)
print(accuracy)

6. Principal

Temos, agora, todos os elementos do algoritmo e podemos amarr-los

juntos com uma funo principal.

Abaixo est o exemplo completo da implementao do algoritmo kNN em

Python, a partir do zero.

Referencia: Tutorial: To Implement k-Nearest Neighbors in Python From

Scratch by Jason Brownlee on September 12, 2014 in Algorithms From
Scratch