Implementação do algoritmo de classificação KNN usando Python

Este artigo compartilha o código específico do algoritmo de classificação KNN em Python, para referência, o conteúdo específico é o seguinte

O algoritmo de classificação KNN pode ser considerado um dos algoritmos de classificação mais simples da aprendizado de máquina, onde KNN significa K-O NearestNeighbor (K pontos mais próximos de amostra). Antes de classificar, o classificador KNN lê uma quantidade significativa de dados de amostra com rótulos de classificação como dados de referência para classificação. Quando ele classificará amostras desconhecidas de categoria, ele calculará o tamanho da diferença entre a amostra atual e todas as amostras de referência; este tamanho de diferença é medido pela distância dos pontos de dados em um espaço multidimensional das características da amostra; isso significa que quanto mais próximos dois pontos de amostra estiverem no espaço multidimensional de seus dados de características, menor será a diferença entre esses pontos de amostra, e maior será a probabilidade de que esses pontos de amostra pertençam à mesma categoria. O algoritmo de classificação KNN utiliza essa compreensão básica, calculando a distância do ponto de amostra a ser predito de todos os pontos de amostra no espaço de referência e encontrando os K pontos de referência mais próximos dessa amostra, calculando a porcentagem do número mais alto da categoria entre esses K pontos de amostra mais próximos e usando essa categoria como resultado de predição.

O modelo KNN é muito simples, não envolve treinamento do modelo, cada vez que há uma previsão, é necessário calcular a distância do ponto para todos os pontos conhecidos, portanto, à medida que o número de conjuntos de amostras de referência aumenta, o custo de cálculo do classificador KNN também aumenta proporcionalmente, e KNN não é adequado para conjuntos de amostras muito pequenos. Além disso, após a apresentação do KNN, muitas pessoas propuseram muitos algoritmos de melhoria, que visam melhorar a velocidade e a precisão do algoritmo, mas todos são baseados no princípio de "quanto mais próximo, maior a probabilidade de semelhança". Aqui foi implementado o algoritmo mais original do KNN usando Python, o conjunto de dados usado é o conjunto de dados de Iris muito usado em cursos de aprendizado de máquina, e também adicionei alguns dados de ruído ao conjunto de dados original, para testar a robustez do algoritmo KNN.

O conjunto de dados usado é o conjunto de dados de Iris,Endereço de download.

O conjunto de dados contém90 conjuntos de dados (conjunto de treinamento), divididos em2classe, cada classe45conjunto de dados, cada conjunto de dados4propriedades　

Sepal.Length (comprimento do cálice), unidade é cm;
Sepal.Width (largura do cálice), unidade é cm;
Petal.Length (comprimento da pétala), unidade é cm;
Petal.Width (largura da pétala), unidade é cm;

Tipos de classificação: Iris Setosa (Iris de Montanha), Iris Versicolour (Iris Mista)
Antes dominava C++Recentemente aprendi Python, hoje quero usar para implementar KNN para praticar, a seguir está o código:

#coding=utf-8
import math
#定义鸢尾花的数据类
class Iris:
 data=[]
 label=[]
 pass
#定义一个读取莺尾花数据集的函数
def load_dataset(filename="Iris_train.txt"):
 f=open(filename)
 line=f.readline().strip()
 propty=line.split(',')#属性名
 dataset=[]#保存每一个样本的数据信息
 label=[]#保存样本的标签
 while line:
 line=f.readline().strip()
 if(not line):
 break
 temp=line.split(',')
 content=[]
 for i in temp[0:-1]:
 content.append(float(i))
 dataset.append(content)
 label.append(temp[-1])
 total=Iris()
 total.data=dataset
 total.label=label
 return total #返回数据集
#定义一个Knn分类器类
class KnnClassifier:
 def __init__(self,k,type="Euler"): #初始化的时候定义正整数K和距离计算方式
 self.k=k
 self.type=type
 self.dataloaded=False
 def load_traindata(self,traindata): #加载数据集
 self.data=traindata.data
 self.label=traindata.label
 self.label_set=set(traindata.label)
 self.dataloaded=True #是否加载数据集的标记
 def Euler_dist(self,x,y): # 欧拉距离计算方法，x、y都是向量
 sum=0
 for i,j in zip(x,y):
 sum+=math.sqrt((i-j)**2)
 return sum
 def Manhattan_dist(self,x,y): #曼哈顿距离计算方法，x、y都是向量
 sum=0
 for i,j in zip(x,y):
 sum+=abs(i-j)
 return sum
 def predict(self,temp): #预测函数，读入一个预测样本的数据，temp是一个向量
 if(not self.dataloaded): #判断是否有训练数据
 print "No train_data load in"
 return
 distance_and_label=[]
 if(self.type=="Euler"): #判断距离计算方式，欧拉距离或者曼哈顿距离
 for i,j in zip(self.data,self.label):
 dist=self.Euler_dist(temp,i)
 distance_and_label.append([dist,j])
 else:
 if(self.type=="Manhattan"):
 for i,j in zip(self.data,self.label):
 dist=self.Manhattan_dist(temp,i)
 distance_and_label.append([dist,j])
 else:
 print "type choice error"
 #获取K个最邻近的样本的距离和类别标签
 neighborhood=sorted(distance_and_label,cmp=lambda x,y : cmp(x[0],y[0]))[0:self.k]
 neighborhood_class=[]
 for i in neighborhood:
 neighborhood_class.append(i[1])
 class_set=set(neighborhood_class)
 neighborhood_class_count=[]
 print "In k nearest neighborhoods:"
 #统计该K个最邻近点中各个类别的个数
 for i in class_set:
 a=neighborhood_class.count(i)
 neighborhood_class_count.append([i,a])
 print "class: ",i," count: ",a
 result=sorted(neighborhood_class_count,cmp=lambda x,y : cmp(x[1],y[1))[-1][0]
 print "result: ",result
 return result#返回预测的类别
if __name__ == '__main__':
 traindata=load_dataset()#training data
 testdata=load_dataset("Iris_test.txt")#testing data
 #新建一个Knn分类器的K为20，默认为欧拉距离计算方式
 kc=KnnClassifier(20)
 kc.load_traindata(traindata)
 predict_result=[]
 #预测测试集testdata中所有待预测样本的结果
 for i,j in zip(testdata.data,testdata.label):
 predict_result.append([i,kc.predict(i),j])
 correct_count=0
 #Compare os resultados de predição e os resultados corretos, calcule a taxa de precisão dessa predição
 for i in predict_result:
 if(i[1==i[2]):
 correct_count+=1
 ratio=float(correct_count)/len(predict_result)
 print "ratione predição correta",ratio

no conjunto de teste11resultados de classificação de pontos de amostra em espera:

Nos vizinhos mais próximos k:
classe: Iris-setosa count: 20
result: Iris-setosa
Nos vizinhos mais próximos k:
classe: Iris-setosa count: 20
result: Iris-setosa
Nos vizinhos mais próximos k:
classe: Iris-setosa count: 20
result: Iris-setosa
Nos vizinhos mais próximos k:
classe: Iris-setosa count: 20
result: Iris-setosa
Nos vizinhos mais próximos k:
classe: Iris-setosa count: 20
result: Iris-setosa
Nos vizinhos mais próximos k:
classe: Iris-versicolor count: 20
result: Iris-versicolor
Nos vizinhos mais próximos k:
classe: Iris-versicolor count: 20
result: Iris-versicolor
Nos vizinhos mais próximos k:
classe: Iris-versicolor count: 20
result: Iris-versicolor
Nos vizinhos mais próximos k:
classe: Iris-versicolor count: 20
result: Iris-versicolor
Nos vizinhos mais próximos k:
classe: Iris-versicolor count: 20
result: Iris-versicolor
Nos vizinhos mais próximos k:
classe: Iris-setosa count: 18
classe: Iris-versicolor count: 2
result: Iris-setosa
ratione predição correta 0.909090909091

Existem muitos métodos para calcular distância no KNN, diferentes métodos são aplicáveis a diferentes conjuntos de dados. Este código apenas implementou os métodos de distância euclidiana e Manhattan; os dados no conjunto de teste foram extraídos do conjunto de dados original, a quantidade de dados não é grande e os resultados não podem refletir bem o desempenho do KNN, então os resultados da execução do programa são apenas para referência.

Isso é tudo o que há no artigo. Esperamos que ajude na sua aprendizagem e que você apóie o tutorial Gritar.

Declaração: O conteúdo deste artigo é extraído da internet, pertencente ao respectivo proprietário. O conteúdo é contribuído e carregado voluntariamente pelos usuários da internet. Este site não possui direitos de propriedade, não foi editado manualmente e não assume responsabilidades legais relacionadas. Se você encontrar conteúdo suspeito de violação de direitos autorais, por favor, envie um e-mail para: notice#oldtoolbag.com (ao enviar e-mail, substitua # por @ para denunciar, e forneça provas relevantes. Apenas quando confirmado, o site deletará o conteúdo suspeito de infringência.)