机器学习之k近邻算法

本文的代码基于书本《机器学习实战》

概念

k-近邻算法采用测量不同特征值之间距离的方法进行分类。工作原理是：存在一个样本数据集合，称作训练样本集，样本中每个数据都存在标签。输入没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较，算法提取样本集中特征最相似数据（最近邻）的分类标签，我们只选择样本数据集中前k个最相似的数据，使用的是欧式距离的计算公式，通常k是不大于20的整数，选择k个最相似数据中出现次数最多的分类作为新数据的分类，这就是k-近邻算法。

算法简单示例

import numpy as np                        #科学计算包
import operator                           #运算符模块def createDataSet():                       #创建四组数据#四组二维特征group = np.array([[1,101],[5,89],[108,5],[115,8]])#四组特征的标签labels = ['爱情片','爱情片','动作片','动作片']return group, labelsdef classify0(inX, dataSet, labels, k):#numpy函数shape[0]返回dataSet的行数dataSetSize = dataSet.shape[0]#在列向量方向上重复inX共1次(横向)，行向量方向上重复inX共dataSetSize次(纵向)diffMat = np.tile(inX, (dataSetSize, 1)) - dataSet#二维特征相减后平方sqDiffMat = diffMat**2#sum()所有元素相加，sum(0)列相加，sum(1)行相加sqDistances = sqDiffMat.sum(axis=1)#开方，计算出距离distances = sqDistances**0.5#返回distances中元素从小到大排序后的索引值sortedDistIndices = distances.argsort()#定一个记录类别次数的字典classCount = {}for i in range(k):#取出前k个元素的类别voteIlabel = labels[sortedDistIndices[i]]#dict.get(key,default=None),字典的get()方法,返回指定键的值,如果值不在字典中返回默认值。#计算类别次数classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1#python3中用items()替换python2中的iteritems()#key=operator.itemgetter(1)根据字典的值进行排序#key=operator.itemgetter(0)根据字典的键进行排序#reverse降序排序字典，这是一个列表，包含元组sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)#返回次数最多的类别,即所要分类的类别return sortedClassCount[0][0]if __name__ == '__main__':#创建数据集group, labels = createDataSet()#测试集test = [101,20]#kNN分类test_class = classify0(test, group, labels, 3)#打印分类结果print(test_class)

基于文件处理的算法（改进约会网站的配对效果）

文件前几行：

40920    8.326976    0.953952    largeDoses
14488   7.153469    1.673904    smallDoses
26052   1.441871    0.805124    didntLike
75136   13.147394   0.428964    didntLike
38344   1.669788    0.134296    didntLike
72993   10.141740   1.032955    didntLike
35948   6.830792    1.213192    largeDoses
42666   13.276369   0.543880    largeDoses
67497   8.631577    0.749278    didntLike
35483   12.273169   1.508053    largeDoses
50242   3.723498    0.831917    didntLike
63275   8.385879    1.669485    didntLike
5569    4.875435    0.728658    smallDoses
51052   4.680098    0.625224    didntLike
77372   15.299570   0.331351    didntLike
43673   1.889461    0.191283    didntLike
61364   7.516754    1.269164    didntLike
69673   14.239195   0.261333    didntLike
15669   0.000000    1.250185    smallDoses

导入的包：

from matplotlib.font_manager import FontProperties
import matplotlib.lines as mlines
import matplotlib.pyplot as plt
import numpy as np
import operator

文件处理：

def file2matrix(filename):#打开文件,此次应指定编码fr = open(filename,'r',encoding = 'utf-8')#读取文件所有内容arrayOLines = fr.readlines()#针对有BOM的UTF-8文本，应该去掉BOM，否则后面会引发错误。arrayOLines[0]=arrayOLines[0].lstrip('\ufeff')#得到文件行数numberOfLines = len(arrayOLines)#返回的NumPy矩阵,解析完成的数据:numberOfLines行,3列returnMat = np.zeros((numberOfLines,3))#返回的分类标签向量classLabelVector = []#行的索引值index = 0for line in arrayOLines:#s.strip(rm)，当rm空时,默认删除空白符(包括'\n','\r','\t',' ')line = line.strip()#使用s.split(str="",num=string,cout(str))将字符串根据'\t'分隔符进行切片。listFromLine = line.split('\t')#将数据前三列提取出来,存放到returnMat的NumPy矩阵中,也就是特征矩阵returnMat[index,:] = listFromLine[0:3]#根据文本中标记的喜欢的程度进行分类,1代表不喜欢,2代表魅力一般,3代表极具魅力   # 对于datingTestSet2.txt  最后的标签是已经经过处理的 标签已经改为了1, 2, 3if listFromLine[-1] == 'didntLike':classLabelVector.append(1)elif listFromLine[-1] == 'smallDoses':classLabelVector.append(2)elif listFromLine[-1] == 'largeDoses':classLabelVector.append(3)index += 1return returnMat, classLabelVector

分类函数：

"""inX - 用于分类的数据(测试集)dataSet - 用于训练的数据(训练集)labes - 分类标签k - kNN算法参数,选择距离最小的k个点sortedClassCount[0][0] - 分类结果
"""
def classify0(inX, dataSet, labels, k):#numpy函数shape[0]返回dataSet的行数dataSetSize = dataSet.shape[0]#在列向量方向上重复inX共1次(横向)，行向量方向上重复inX共dataSetSize次(纵向)diffMat = np.tile(inX, (dataSetSize, 1)) - dataSet#二维特征相减后平方sqDiffMat = diffMat**2#sum()所有元素相加，sum(0)列相加，sum(1)行相加sqDistances = sqDiffMat.sum(axis=1)#开方，计算出距离distances = sqDistances**0.5#返回distances中元素从小到大排序后的索引值sortedDistIndices = distances.argsort()#定一个记录类别次数的字典classCount = {}for i in range(k):#取出前k个元素的类别voteIlabel = labels[sortedDistIndices[i]]#dict.get(key,default=None),字典的get()方法,返回指定键的值,如果值不在字典中返回默认值。#计算类别次数classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1#python3中用items()替换python2中的iteritems()#key=operator.itemgetter(1)根据字典的值进行排序#key=operator.itemgetter(0)根据字典的键进行排序#reverse降序排序字典，这是一个列表，包含元组sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)#返回次数最多的类别,即所要分类的类别return sortedClassCount[0][0]

归一化函数，把数值限制在0到1的范围内，防止数值较大的属性对计算结果的影响大：

def autoNorm(dataSet):#获得数据的最小值minVals = dataSet.min(0)maxVals = dataSet.max(0)#最大值和最小值的范围ranges = maxVals - minVals#shape(dataSet)返回dataSet的矩阵行列数normDataSet = np.zeros(np.shape(dataSet))#返回dataSet的行数m = dataSet.shape[0]#原始值减去最小值normDataSet = dataSet - np.tile(minVals, (m, 1))#除以最大和最小值的差,得到归一化数据normDataSet = normDataSet / np.tile(ranges, (m, 1))#返回归一化数据结果,数据范围,最小值return normDataSet, ranges, minVals

分类器测试函数，取百分之十的数据作为测试数据，检测分类器的正确性

def datingClassTest():#打开的文件名filename = "datingTestSet.txt"#将返回的特征矩阵和分类向量分别存储到datingDataMat和datingLabels中datingDataMat, datingLabels = file2matrix(filename)#取所有数据的百分之十hoRatio = 0.10#数据归一化,返回归一化后的矩阵,数据范围,数据最小值normMat, ranges, minVals = autoNorm(datingDataMat)#获得normMat的行数m = normMat.shape[0]#百分之十的测试数据的个数numTestVecs = int(m * hoRatio)#分类错误计数errorCount = 0.0for i in range(numTestVecs):#前numTestVecs个数据作为测试集,后m-numTestVecs个数据作为训练集classifierResult = classify0(normMat[i,:], normMat[numTestVecs:m,:], datingLabels[numTestVecs:m], 4)print("分类结果:%s\t真实类别:%d" % (classifierResult, datingLabels[i]))if classifierResult != datingLabels[i]:errorCount += 1.0print("错误率:%f%%" %(errorCount/float(numTestVecs)*100))

分类结果：

--snip--
分类结果:3  真实类别:3
[(3, 4)]
分类结果:3  真实类别:3
[(2, 2), (3, 1), (1, 1)]
分类结果:2  真实类别:2
[(2, 2), (1, 2)]
分类结果:2  真实类别:1
[(1, 2), (3, 2)]
分类结果:1  真实类别:1
错误率:4.000000%

绘图函数，可视化数据：

def showdatas(datingDataMat, datingLabels):#设置汉字格式font = FontProperties(fname=r"c:\windows\fonts\simhei.ttf", size=14)  ##需要查看自己的电脑是否会包含该字体#将fig画布分隔成1行1列,不共享x轴和y轴,fig画布的大小为(13,8)#当nrow=2,nclos=2时,代表fig画布被分为四个区域,axs[0][0]表示第一行第一个区域fig, axs = plt.subplots(nrows=2, ncols=2,sharex=False, sharey=False, figsize=(13,8))numberOfLabels = len(datingLabels)LabelsColors = []for i in datingLabels:if i == 1:LabelsColors.append('black')if i == 2:LabelsColors.append('orange')if i == 3:LabelsColors.append('red')#画出散点图,以datingDataMat矩阵的第一(飞行常客例程)、第二列(玩游戏)数据画散点数据,散点大小为15,透明度为0.5axs[0][0].scatter(x=datingDataMat[:,0], y=datingDataMat[:,1], color=LabelsColors,s=15, alpha=.5)#设置标题,x轴label,y轴labelaxs0_title_text = axs[0][0].set_title(u'每年获得的飞行常客里程数与玩视频游戏所消耗时间占比',FontProperties=font)axs0_xlabel_text = axs[0][0].set_xlabel(u'每年获得的飞行常客里程数',FontProperties=font)axs0_ylabel_text = axs[0][0].set_ylabel(u'玩视频游戏所消耗时间占比',FontProperties=font)plt.setp(axs0_title_text, size=9, weight='bold', color='red')  plt.setp(axs0_xlabel_text, size=7, weight='bold', color='black')  plt.setp(axs0_ylabel_text, size=7, weight='bold', color='black') #画出散点图,以datingDataMat矩阵的第一(飞行常客例程)、第三列(冰激凌)数据画散点数据,散点大小为15,透明度为0.5axs[0][1].scatter(x=datingDataMat[:,0], y=datingDataMat[:,2], color=LabelsColors,s=15, alpha=.5)#设置标题,x轴label,y轴labelaxs1_title_text = axs[0][1].set_title(u'每年获得的飞行常客里程数与每周消费的冰激淋公升数',FontProperties=font)axs1_xlabel_text = axs[0][1].set_xlabel(u'每年获得的飞行常客里程数',FontProperties=font)axs1_ylabel_text = axs[0][1].set_ylabel(u'每周消费的冰激淋公升数',FontProperties=font)plt.setp(axs1_title_text, size=9, weight='bold', color='red')  plt.setp(axs1_xlabel_text, size=7, weight='bold', color='black')  plt.setp(axs1_ylabel_text, size=7, weight='bold', color='black') #画出散点图,以datingDataMat矩阵的第二(玩游戏)、第三列(冰激凌)数据画散点数据,散点大小为15,透明度为0.5axs[1][0].scatter(x=datingDataMat[:,1], y=datingDataMat[:,2], color=LabelsColors,s=15, alpha=.5)#设置标题,x轴label,y轴labelaxs2_title_text = axs[1][0].set_title(u'玩视频游戏所消耗时间占比与每周消费的冰激淋公升数',FontProperties=font)axs2_xlabel_text = axs[1][0].set_xlabel(u'玩视频游戏所消耗时间占比',FontProperties=font)axs2_ylabel_text = axs[1][0].set_ylabel(u'每周消费的冰激淋公升数',FontProperties=font)plt.setp(axs2_title_text, size=9, weight='bold', color='red')  plt.setp(axs2_xlabel_text, size=7, weight='bold', color='black')  plt.setp(axs2_ylabel_text, size=7, weight='bold', color='black') #设置图例didntLike = mlines.Line2D([], [], color='black', marker='.',markersize=6, label='didntLike')smallDoses = mlines.Line2D([], [], color='orange', marker='.',markersize=6, label='smallDoses')largeDoses = mlines.Line2D([], [], color='red', marker='.',markersize=6, label='largeDoses')#添加图例axs[0][0].legend(handles=[didntLike,smallDoses,largeDoses])axs[0][1].legend(handles=[didntLike,smallDoses,largeDoses])axs[1][0].legend(handles=[didntLike,smallDoses,largeDoses])#显示图片plt.show()

图片效果：

结果预测程序：

def classifyPerson():#输出结果resultList = ['讨厌','有些喜欢','非常喜欢']#三维特征用户输入precentTats = float(input("玩视频游戏所耗时间百分比:"))ffMiles = float(input("每年获得的飞行常客里程数:"))iceCream = float(input("每周消费的冰激淋公升数:"))#打开的文件名filename = "datingTestSet.txt"#打开并处理数据datingDataMat, datingLabels = file2matrix(filename)#训练集归一化normMat, ranges, minVals = autoNorm(datingDataMat)#生成NumPy数组,测试集inArr = np.array([ffMiles, precentTats, iceCream])#测试集归一化norminArr = (inArr - minVals) / ranges#返回分类结果classifierResult = classify0(norminArr, normMat, datingLabels, 3)#打印结果print("你可能%s这个人" % (resultList[classifierResult-1]))

输出：

玩视频游戏所耗时间百分比:11.11
每年获得的飞行常客里程数:10000
每周消费的冰激淋公升数:1
[(3, 2), (2, 1)]
你可能非常喜欢这个人

示例：手写识别系统

实际图像储存在两个文件夹中，trainingDigits文件夹有约2000个数据文件，testDigits约200个。简单起见，数字已经处理成文本格式。数据文件示例：

00000000000001111000000000000000
00000000000011111110000000000000
00000000001111111111000000000000
00000001111111111111100000000000
00000001111111011111100000000000
00000011111110000011110000000000
00000011111110000000111000000000
00000011111110000000111100000000
00000011111110000000011100000000
00000011111110000000011100000000
00000011111100000000011110000000
00000011111100000000001110000000
00000011111100000000001110000000
00000001111110000000000111000000
00000001111110000000000111000000
00000001111110000000000111000000
00000001111110000000000111000000
00000011111110000000001111000000
00000011110110000000001111000000
00000011110000000000011110000000
00000001111000000000001111000000
00000001111000000000011111000000
00000001111000000000111110000000
00000001111000000001111100000000
00000000111000000111111000000000
00000000111100011111110000000000
00000000111111111111110000000000
00000000011111111111110000000000
00000000011111111111100000000000
00000000001111111110000000000000
00000000000111110000000000000000
00000000000011000000000000000000

导入包：

import numpy as np
import operator
from os import listdir

为了使用前面的分类器，需要将这个32*32数据处理为一个1*1024向量：

def img2vector(filename):#创建1x1024零向量returnVect = np.zeros((1, 1024))#打开文件fr = open(filename)#按行读取for i in range(32):#读一行数据lineStr = fr.readline()#每一行的前32个元素依次添加到returnVect中for j in range(32):returnVect[0, 32*i+j] = int(lineStr[j])#返回转换后的1x1024向量return returnVect

同样把前面的分类函数拿过来后编写测试函数：

def handwritingClassTest():#测试集的LabelshwLabels = []#返回trainingDigits目录下的文件名trainingFileList = listdir('trainingDigits')#返回文件夹下文件的个数m = len(trainingFileList)#初始化训练的Mat矩阵,测试集trainingMat = np.zeros((m, 1024))#从文件名中解析出训练集的类别for i in range(m):#获得文件的名字fileNameStr = trainingFileList[i]#获得分类的数字classNumber = int(fileName87Str.split('_')[0])#将获得的类别添加到hwLabels中hwLabels.append(classNumber)#将每一个文件的1x1024数据存储到trainingMat矩阵中trainingMat[i,:] = img2vector('trainingDigits/%s' % (fileNameStr))#返回testDigits目录下的文件名testFileList = listdir('testDigits')#错误检测计数errorCount = 0.0#测试数据的数量mTest = len(testFileList)#从文件中解析出测试集的类别并进行分类测试for i in range(mTest):#获得文件的名字fileNameStr = testFileList[i]#获得分类的数字classNumber = int(fileNameStr.split('_')[0])#获得测试集的1x1024向量,用于训练vectorUnderTest = img2vector('testDigits/%s' % (fileNameStr))#获得预测结果classifierResult = classify0(vectorUnderTest, trainingMat, hwLabels, 3)print("分类返回结果为%d\t真实结果为%d" % (classifierResult, classNumber))if(classifierResult != classNumber):errorCount += 1.0print("总共错了%d个数据\n错误率为%f%%" % (errorCount, errorCount/mTest))

输出：

--snip--
分类返回结果为9    真实结果为9
分类返回结果为9    真实结果为9
分类返回结果为9    真实结果为9
分类返回结果为9    真实结果为9
分类返回结果为9    真实结果为9
分类返回结果为9    真实结果为9
分类返回结果为9    真实结果为9
分类返回结果为9    真实结果为9
分类返回结果为9    真实结果为9
总共错了10个数据
错误率为1.0571%

使用第三方库sklearn的代码

新导入的包：

from sklearn.neighbors import KNeighborsClassifier as kNN

测试函数代码修改：

def handwritingClassTest():#测试集的LabelshwLabels = []#返回trainingDigits目录下的文件名trainingFileList = listdir('trainingDigits')#返回文件夹下文件的个数m = len(trainingFileList)#初始化训练的Mat矩阵,测试集trainingMat = np.zeros((m, 1024))#从文件名中解析出训练集的类别for i in range(m):#获得文件的名字fileNameStr = trainingFileList[i]#获得分类的数字classNumber = int(fileNameStr.split('_')[0])#将获得的类别添加到hwLabels中hwLabels.append(classNumber)#将每一个文件的1x1024数据存储到trainingMat矩阵中trainingMat[i,:] = img2vector('trainingDigits/%s' % (fileNameStr))#构建kNN分类器neigh = kNN(n_neighbors = 3, algorithm = 'auto')#拟合模型, trainingMat为训练矩阵,hwLabels为对应的标签neigh.fit(trainingMat, hwLabels)#返回testDigits目录下的文件列表testFileList = listdir('testDigits')#错误检测计数errorCount = 0.0#测试数据的数量mTest = len(testFileList)#从文件中解析出测试集的类别并进行分类测试for i in range(mTest):#获得文件的名字fileNameStr = testFileList[i]#获得分类的数字classNumber = int(fileNameStr.split('_')[0])#获得测试集的1x1024向量,用于训练vectorUnderTest = img2vector('testDigits/%s' % (fileNameStr))#获得预测结果# classifierResult = classify0(vectorUnderTest, trainingMat, hwLabels, 3)classifierResult = neigh.predict(vectorUnderTest)print("分类返回结果为%d\t真实结果为%d" % (classifierResult, classNumber))if(classifierResult != classNumber):errorCount += 1.0print("总共错了%d个数据\n错误率为%f%%" % (errorCount, errorCount/mTest * 100))

函数说明：

class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, *, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=None, **kwargs)

n_neighbors：默认为5，就是k-NN的k的值，选取最近的k个点。
weights：默认是uniform，参数可以是uniform、distance，也可以是用户自己定义的函数。uniform是均等的权重，就说所有的邻近点的权重都是相等的。distance是不均等的权重，距离近的点比距离远的点的影响大。用户自定义的函数，接收距离的数组，返回一组维数相同的权重。
algorithm：快速k近邻搜索算法，默认参数为auto，可以理解为算法自己决定合适的搜索算法。除此之外，用户也可以自己指定搜索算法ball_tree、kd_tree、brute方法进行搜索，brute是蛮力搜索，也就是线性扫描，当训练集很大时，计算非常耗时。kd_tree，构造kd树存储数据以便对其进行快速检索的树形数据结构，kd树也就是数据结构中的二叉树。以中值切分构造的树，每个结点是一个超矩形，在维数小于20时效率高。ball tree是为了克服kd树高纬失效而发明的，其构造过程是以质心C和半径r分割样本空间，每个节点是一个超球体。
leaf_size：默认是30，这个是构造的kd树和ball树的大小。这个值的设置会影响树构建的速度和搜索速度，同样也影响着存储树所需的内存大小。需要根据问题的性质选择最优的大小。
metric：用于距离度量，默认度量是minkowski，也就是p=2的欧氏距离(欧几里德度量)。
p：距离度量公式。在上小结，我们使用欧氏距离公式进行距离度量。除此之外，还有其他的度量方法，例如曼哈顿距离。这个参数默认为2，也就是默认使用欧式距离公式进行距离度量。也可以设置为1，使用曼哈顿距离公式进行距离度量。
metric_params：距离公式的其他关键参数，这个可以不管，使用默认的None即可。
n_jobs：并行处理设置。默认为1，临近点搜索并行工作数。如果为-1，那么CPU的所有cores都用于并行工作。

`fit`（X，y）	从训练数据集中拟合k最近邻分类器。
`get_params`（[deep]）	获取此估计量的参数。
`kneighbors`（[X，n_neighbors，return_distance]）	查找点的K邻居。
`kneighbors_graph`（[X，n_neighbors，mode]）	计算X中点的k邻居的（加权）图
`predict`（X）	预测提供的数据的类标签。
`predict_proba`（X）	测试数据X的返回概率估计。
`score`（X，y [，sample_weight]）	返回给定测试数据和标签上的平均准确度。
`set_params`（**params）	设置此估算器的参数。

具体用法可查看https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html

运行结果与我们之前自己写的算法差不多，但运行速度明显快了不少。

总结

kNN算法的优缺点

优点

简单好用，容易理解，精度高，理论成熟，既可以用来做分类也可以用来做回归；
可用于数值型数据和离散型数据；
训练时间复杂度为O(n)；无数据输入假定；
对异常值不敏感。

缺点：

计算复杂性高；空间复杂性高；
样本不平衡问题（即有些类别的样本数量很多，而其它样本的数量很少）；
一般数值很大的时候不用这个，计算量太大。但是单个样本又不能太少，否则容易发生误分。
最大的缺点是无法给出数据的内在含义。