k-近邻算法

关注

转载最新推荐文章于 2026-06-05 15:17:35 发布 1.7k 阅读 AI 写同款· GEO 优化 ›

GeaFlow图计算快速上手之K-hop算法 K-hop算法是一种基于图论的算法，用于寻找一个起点通过K次以内跳跃能够到达的节点，也就是从起点出发，找出K层内与之关联的节点。K-hop算法广泛应用于好友推荐、影响力预测和关系发现等场景。K-hop算法本质上是一种广度优先搜索（BFS）算法，通过从起点开始不断向外扩散的方式来计算每一个节点到起点的跳跃数。阅读详情

1. 算法概述：是一种基本分类和回归的算法。k近邻法的输入为实例的特征向量，对应于特征空间的点；输出为实例的类别，可以取多类。k近邻法假设给定一个训练数据集，其中的实例类别已定。分类时，对新的实例，根据其k个最近邻的训练实例的类别，通过多数表决等方式进行预测。因此，k近邻不具有显示的学习过程。k近邻实际上是利用训练数据集对特征向量空间进行划分，并作为其分类的“模型”。k值的选择、距离度量及分类决策规则是k近邻法的三个基本要素。k-近邻法于1968年由Cover和Hart提出。（简单的说就是：给定一个训练数据集，对新的输入实例，在训练数据集中找到与该实例最邻近的k个实例，在这k个实例的多数都属于某个类，就把这个新的输入实例分为这个类。）

k近邻算法

输入：训练数据集

$T=\left\{(x_1,y_1),(x_2,y_2),...(x_N,y_N) \right \}$

其中， $x_i\in X\subseteq R^{n}$ 为实例的特征向量， $y_{i}\in Y=\left \{ c_1,c_2,..., c_K\right \}$ 为实例的类别，i=1,2,...,N；实例特征向量 $x$ ；

输出：实例 $x$ 所属的类y。

（1）根据给定的距离度量，在训练数据集 $T$ 中找到与 $x$ 最近邻的k个点，涵盖这 $k$ 个点的 $x$ 的邻域记作 $N_k(x)$ ；

（2）在 $N_k(x)$ 中根据分类决策规则（如多数表决）决定 $x$ 的类别y：

$y=arg \max_{c_{j}} \sum_{x_{i}\in N_k(x)}I(y_{i}=c_{j}),\quad i=1,2,...,K (1.1)$

式（1.1）中， $I$ 为指示函数，即当 $y_i=c_j$ 时 $I$ 为1，否则 $I$ 为0。

k近邻法的情况是k=1的情况，称为最近邻算法。对于输入的实例点（特征向量） $x$ ，最近邻法将训练数据集中与 $x$ 最近邻点的类作为 $x$ 的类。

$\Rightarrow$ k近邻没有显示学习的过程

2 k近邻模型

k近邻模型对应于对特征空间的划分。模型由三个基本要素组成：距离度量、k值选择和分类决策规则

2.1 模型

k近邻算法中，当训练集、距离度量（如欧式距离）、k值及分类决策规则（如多数表决）确定后，对于任何一个新的输入实例，它所属的类唯一地确定。这相当于根据上述要素将特征空间划分为一些子空间，确定子空间里的每个点所属的类。

特征空间中，对每个训练实例点 $x_{i}$ ，距离该点比其他点更近的所有点组成一个区域，叫做单元。每个训练实例点都拥有一个单元，所有训练实例点的单元构成对特征空间的一个划分。最近邻法将实例 $x_{i}$ 的类 $y_{i}$ 作为其单元中所有点的类标记。这样，每个单元的实例点的类别是确实的。

2.2 距离度量

特征空间中两个实例点的距离是两个实例点相似程度的反映。k近邻模型的特征一般是n维实数向量空间 $R^{n}$ 。使用的距离是欧式距离，但也可以是其他距离，如更一般的 $L_{p}$ 距离或Minkowski距离。

设特征空间 $X$ 是n维实例向量空间 $R^{n}$ ， $x_{i},x_{j}\in X,x_{i}=(x_{i}^{(1)},x_{i}^{(2)},...,x_{i}^{(n)})^{T},x_{j}=(x_{j}^{(1)},x_{j}^{(2)},...,x_{j}^{(n)})^{T}$ ， $x_{i},x_{j}$ 的 $L_{p}$ 距离定义为

$L_{p}(x_{i},x_{j})=\left (\sum_{l=1}^{n}\left | x_{i}^{(l)}-x_{j}^{(l)} \right |^{p} \right )^{\frac{1}{p}} \quad \quad (2.1)$

这里 $p\geq 1$ ，当 $p=2$ 时，称为欧式距离，即

$L_{2}(x_{i},x_{j})=\left (\sum_{l=1}^{n}\left | x_{i}^{(l)}-x_{j}^{(l)} \right |^{2} \right )^{\frac{1}{2}} \quad \quad (2.2)$

当 $p=1$ 时，称为曼哈顿距离，即

$L_{1}(x_{i},x_{j})=\sum_{l=1}^{n}\left | x_{i}^{(l)}-x_{j}^{(l)} \right | \quad \quad (2.3)$

当 $p=\infty$ 时，它是各个坐标距离的最大值，即

$L_{\infty}(x_{i},x_{j})=\max_{l}\left | x_{i}^{(l)}-x_{j}^{(l)} \right | \quad \quad (2.4)$

如图所示，给出了二维空间中p取不同值时，与原点的 $L_{p}$ 距离为1 $(L_{p}=1)$ 的点图形。

例1：已知二维空间的3个点 $x_1=(1,1)^{T},x_2=(5,1)^{T},...,x_3=(4,4)^{T}$ ，试求在 $p$ 取不同值时， $L_{p}$ 距离下的 $x_{1}$ 的最近邻点。

解答过程如下：

2.3 k值的选择

k值的选择会对k近邻法的结果产生重大影响

如果选择较小的k值，就相当于用较小的领域的训练实例进行选择，“学习”的近似误差会减小，只有与输入实例较近的（相似的）训练实例才会对预测结果起作用。但缺点是“学习”的估计误差会增大，预测结果会对近邻的实例点非常敏感。如果邻近的实例点恰巧是噪声，预测就会出错。换句话说，k值的减小就意味着整体模型变得复杂，容易发生过拟合。

如果选择较大的K值，就相当于用较大领域中的训练实例进行预测。其优点是可以减少学习的估计误差，但缺点是近似误差会增大。这时与输入实例较远的训练实例也会对预测作用，使预测发生错误。k值的增大意味着整体模型变得简单。

在应用中，k值一般取一个比较小的数值，通常采用交叉验证法来选取最优的k值。

2.4 分类决策规则

k近邻法中的分类决策规则往往是多数表决，即由输入实例的k个邻近的训练实例中的多数类决定输入实例的类。

多数表决规则有如下解释：如果分类的损失函数为0-1损失函数，分类函数为

$f:R^{n}\rightarrow \left \{ c_1,c_2,...c_k \right \}$

那么误分类的概率是：

$p(Y\neq f(x))=1-p(Y=f(x))$

对给定的实例 $x\in X$ ，其最近邻的k个训练实例点构成集合 $N_k(x)$ 。如果涵盖 $N_k(x)$ 的区域的类别是 $c_{j}$ ，那么误分类率是

$\frac{1}{k}\sum _{x_{i}\in N_{k}(x)}I(y_{i}\neq c_{j})=1-\frac{1}{k}\sum _{x_{i}\in N_{k}(x)}I(y_{i}= c_{j})$

要使误分类率最小即经验风险最小，就要使 $\sum_{x_{i}\in N_{k}(x)}I(y_{i}=c_{j})$ 最大，所以采取多数表决规则等价于经验风险最小化。

3. k近邻的实现：kd树

实现k近邻法时，主要考虑的是如何对训练数据进行快速k-近邻搜索。k近邻算法最简单的实现方法是线性扫描。这时要计算输入实例与每个训练实例的距离。当训练集很大时，计算非常耗时，这种方法是不可行的。

为了提高k近邻搜索的效率，可以考虑使用特殊的结构存储训练数据，以减少计算距离的次数。

3.1构造kd树

kd树是一种对k维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。kd树是二叉树，表示对k维空间的一个划分。构造kd树相当于不断地用垂直于坐标轴的超平面将k维空间切分，构成一系列的k维超矩形区域。kd树的每个结点对应一个k维超平面区域。

构造kd树的方法如下：构造根结点，使得根结点对应于k维空间中包含所有实例点的超矩形曲区域；通过下面的递归方法，不断地对k维空间进行切分，生成子结点。在超矩形区域（结点）上选择一个坐标轴和在此坐标上的一个切分点，确定一个超平面，这个超平面通过选定的切分点并垂直于选定的坐标轴，将当前超矩形区域切分为左右两个子区域（子结点）；这时，实例被分为两个子区域。这个过程直到子区域内没有实例时终止。在此过程中，将实例保存在相应的结点上。

通常，依次选择坐标轴对空间切分，选择训练实例点在选定坐标轴上的中位数为切分点，这样得到的kd树是平衡的。注意，平衡的kd树搜索时的效率未必是最优的。

构建kd树的算法：

输入：k维空间数据集 $T=\left \{ x_1,x_2,...,x_N \right \}$ ,

其中 $x_i=(x_i^{(1)},x_i^{(2)},...,x_i^{(k)})^{T},i=1,2,...N;$

输出：kd树

（1）开始：构造根结点，根结点对应于包含于T的k维空间的超矩形区域。

选择 $x^{(1)}$ 为坐标轴，以T中所有实例的 $x^{(1)}$ 坐标的中位数为切分点，将根结点对应的超矩形区域切分为两个子区域，切分由通过切分点并与坐标轴 $x^{(1)}$ 垂直的超平面实现。由根结点的生成深度为1的左、右子结点，左子结点对应坐标 $x^{(1)}$ 小于切分点的子区域，右子结点对应于坐标 $x^{(1)}$ 大于切分点的子区域。

将落在切分超平面上的实例点保存在跟结点。

（2）重复：对深度为j的结点，选择 $x^{(l)}$ 为切分的坐标轴， $l=j(mod \quad k)+1$ ，以该结点的区域中所有实例的 $x^{(l)}$ 坐标的中位数为切分点，将该结点对应的超平面矩形区域切分为两个子区域，切分由通过切分点并与坐标轴 $x^{(l)}$ 垂直的超平面实现。

由该结点生成深度为 $j+1$ 的左、右子结点：左子结点对应坐标 $x^{(l)}$ 小于切分点的子区域，右子结点对应坐标 $x^{(l)}$ 大于切分点的子区域。

将落在切分超平面上的实例点保存在该结点。

（3）直到两个子区域没有实例存在时停止，从而形成kd树的区域划分。

例2. 给定一个二维空间的数据集：

$T=\left \{ (2,3)^{T},(5,4)^{T},(9,6) ^{T},(4,7)^{T},(8,1)^{T},(7,2)^{T}\right \}$

构造一个平衡kd树。

3.2 搜索kd树

可以看到，利用kd可以省去对大部分数据点的搜索，从而减少搜索的计算量，这里以最近邻为例加以叙述。同样的方法可以应用到k近邻中。

给定一个目标点，搜索其最近邻。首先找到包含目标点的叶结点；然后从该叶结点出发，依次回退到父结点；不断查找与目标点最邻近的结点，当确定不可能存在更接近的结点时停止。这样搜索就限制在空间的局部区域上，效率大大提高。

包含目标点的叶结点对应包含目标点的最小超矩形区域。以此叶结点的实例点作为当前的最近点。目标点的最近邻一定在以目标点为中点并通过当前最近点的超球体的内部。然后返回当前结点的父结点，如果父结点的另一子结点的超矩形区域与超球体相交，那么在相交的区域内寻找与目标点更近的实例点。如果存在这样的点，将此点作为新的当前最近点。算法转到更上一级的父结点，继续上述过程。如果父结点的另一子结点的超矩形区域与超球体不相交，或不存在比当前最近点更近的点，则停止搜索。

最近邻搜索算法

输入：已构造的kd树；目标点 $x$ ；

输出： $x$ 的最近邻。

（1）在kd树中找到包含目标点的 $x$ 的叶结点：从根结点出发，递归地向下访问kd树。若目标点 $x$ 当前维的坐标小于切分点的坐标，则移动到左子结点，否则移动到右子结点。直到子结点为叶结点为止。

（2）以此叶结点为“当前最近点”；

（3）递归地向上回退，在每个结点进行以下操作：

（a）如果该结点保存的实例点比当前最近点距离目标点更近，则以该实例点为“当前最近点”；

（b）当前最近点一定存在于该结点一个子结点对应的区域。检查该子结点的父结点的另一个子结点对应的区域是否有更近的点。具体地，检查另一个子结点对应的区域是否与以目标点为球心、以目标点与“当前最近点”间的距离为半径的超球体相交。

如果相交，可能在另一个子结点对应的区域内存在距目标点更近的点，移动到另一个子结点。接着，递归地进行最近邻搜索；

如果不相交，向上回退。

（4）当回退到根结点时，搜索结束，最后的“当前最近点”即为 $x$ 的最近邻点。

注：如果实例点的随机分布的，kd树搜索的平均计算复杂度是 $O(logN)$ ，这里N是训练实例数。kd数更适用于训练实例数远大于空间维数时的k近邻搜索。当空间维数接近训练实例数时，它的效率会迅速下降，几乎接近线性扫描。

例3 给定一个如图所示的kd树，根结点为A，其子结点为B，C等。树上共存储7个实例点；另有一个输入目标实例点S，求S的最近邻。

解：

①在kd树中找到包含点S的叶结点D，以D作为暂时的近似最近邻，真正最近邻一定要在以点S为中心通过D的圆内部。

②然后返回D的父结点B，在点B的另一子结点F的区域内搜索最近邻。结点F的区域与圆不相交，故而不可能有最近邻点。

③继续返回上一级父结点A，在结点A的另一个子结点C区域内搜索最近邻。结点C区域与圆相交；该区域在圆内有实例点E，且点E离S的距离比点D更近，成为新的最近邻近似；

④最后得到点E是点S的最近邻点。

4. 特点介绍

优点：精度高、对异常值不敏感、无数据输入假定；

缺点：计算复杂度高、空间复杂度高；

适用数据范围：数值型和标称型。

（1）数值型：数值型目标变量可以从无限的数值集合中取，比如2,4,10,20,40……,主要用在回归分析中；

（2）标称型：标称型目标变量的结果只从有限数值集合中获取，比如0,1，主要用在分类中。

5. 算法的一般流程：

（1）收集数据：可以使用任何方法；

（2）准备数据：距离计算所需要的数值，最好是结构化的数据格式；

（3）分析数据：可以使用任何方法；

（4）训练算法：此步骤不适用于K-近邻算法；

（5）测试算法：计算错误率；

（6）使用算法：首先需要输入样本数据和结构化的输入结果，然后运行K-近邻算法判定输入数据分别属于哪个分类，最后应用对计算出的分类执行后续的处理。

案例一：约会网站分类系统

第一步：实践KNN分类算法代码如下

def classify0(intX,dataSet,labels,k):
    dataSetSize=dataSet.shape[0] #表示数据集的大小
    '''距离计算'''
    diffMat=tile(intX,(dataSetSize,1))-dataSet #当前点和训练集中的对应元素相减
    sqDiffMat=diffMat**2 #当前点和训练集中的对应元素相减的值上面添加平方
    sqDistance=sqDiffMat.sum(axis=1) #将相减的值的平方累加
    distances=sqDistance**0.5 #求出当前点与数据集中每个点的距离
    sortedDistIndices=distances.argsort() #将distances的值从小到大排列，提取其对应的索引
    classCount={}
    for i in range(k):
        voteIlabel=labels[sortedDistIndices[i]] #确定前k个距离最小的元素所在的类别
        classCount[voteIlabel]=classCount.get(voteIlabel,0)+1 #通过字典的形式，统计前k个距离最小的元素所在的类别出现的频率
    '''classCount.items()将字典classCount分解为元组列表
       operator.itemgetter(1)按照第二个元素的次序对元组进行排序
       reverse=True表示降序，即从大到小排列'''
    sortedclasscount=sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)
    return sortedclasscount[0][0]

第二步：从文本文件中解析数据

def file2matrix(filename):
    fr=open(filename)
    #readlines()用于读取所有行(直到结束符 EOF)并返回列表，该列表可以由Python 的 for... in ... 结构进行处理
    arrayOLines=fr.readlines()
    numberOfLines=len(arrayOLines) #文件行数
    returnMat=zeros((numberOfLines,3)) #创建返回的numpy矩阵
    classLabel=[]
    index=0
    for line in arrayOLines:
        line=line.strip() #清楚所有的回车字符
        listFromLine=line.split('\t') #使用'\t'将每行分割成元素列表
        returnMat[index,:]=listFromLine[0:3] #选取前三个文件存储到特征矩阵中
        classLabel.append(int(listFromLine[-1])) #将标签存储到列表classLabel
        index+=1
    return returnMat,classLabel

第三步：使用matlotlib创建散点图

import matplotlib.pyplot as plt

print(array(datingDataLabels))
plt.style.use('ggplot')
fig=plt.figure()
ax=fig.add_subplot(111)
#ax.scatter(datingDataMat[:,1],datingDataMat[:,2],15.0*array(datingDataLabels),15.0*array(datingDataLabels))
ax.scatter(datingDataMat[:,0],datingDataMat[:,1],15.0*array(datingDataLabels),0.2*array(datingDataLabels))
#plt.xlabel('玩视频游戏所耗时间百分比')
#plt.ylabel('每周所消费的冰淇淋公升数')
plt.xlabel('每年获取的飞行常客里程数')
plt.ylabel('玩视频游戏所耗时间百分比')
plt.legend(loc='best')
plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号
plt.show()

第四步，对数据进行归一化

'''考虑到每年获取的飞行常客里程数远大于其他特征数，在这里使用数值归一化进行处理'''
def autoNorm(dataSet):
    minvalue=dataSet.min(0) #获取列中的最小值
    maxvalue=dataSet.max(0) #获取列中的最大值
    ranges=maxvalue-minvalue #最大值与最小值的差
    m=dataSet.shape[0] #表示行数
    HandleDataSet=dataSet-tile(minvalue,(m,1)) #表示归一化的分母
    normDataSet=HandleDataSet/tile(ranges,(m,1)) #归一化的结果
    return normDataSet,ranges,minvalue

第五步：分类器针对约会网站进行测试

def datingClassTest():
    hoRatio=0.10
    datingDataMat,datingLabels=file2matrix(r'F:\python\machinelearninginaction\Ch02\datingTestSet2.txt')
    normMat,ranges,minvalues=autoNorm(datingDataMat)
    m=normMat.shape[0]
    numTestVecs=int(m*hoRatio)
    errorCount=0.0
    for i in range(numTestVecs):
        classifierResult=classify0(normMat[i,:],normMat[numTestVecs:m,:],datingLabels[numTestVecs:m],3)   #classify0()中的第一个元素表示测试数据，第二个元素表示分类器的训练数据
        print('the classifier came back with:{0}, the real answer is:{1}'.format(classifierResult,datingLabels[i]))
        if (classifierResult!=datingLabels[i]):
            errorCount+=1.0
    print('the total error rate is:{0}'.format(errorCount/float(numTestVecs)))

第六步：对人进行分类

def classifyperson():
    result_list=['not at all','in small doses','in large doses']
    percentTats=float(input("percentage of time spent playing video games?"))
    ffMiles=float(input("frequent flier miles earned per year?"))
    iceCream=float(input("liters of ice cream consumed per year?"))
    datingDataMat,datingLabels=file2matrix(r'F:\python\machinelearninginaction\Ch02\datingTestSet2.txt')
    normMat,ranges,minvalues=autoNorm(datingDataMat)
    inArr=array([ffMiles,percentTats,iceCream])
    classifierResult=classify0((inArr-minvalues)/ranges,normMat,datingLabels,3)
    print("You will probably like this personL: {}".format(result_list[classifierResult-1]))

构建完整的可用系统：

#!/usr/bin/env python3
#coding=utf-8
import pandas as pd
from numpy import *
import operator
import matplotlib.pyplot as plt
import os

'''（1）计算已知类别数据集中的点与当前点之间的距离
   （2）按照距离递增次序排列
   （3）选取与当前点距离最小的K个点
   （4）确定前K个点所在类别的出现频率
   （5）返回前K个点出现频率最高的类别作为当前点的预测分类'''
#使用k-近邻构建分类器
def classify0(intX,dataSet,labels,k):
    dataSetSize=dataSet.shape[0] #表示数据集的大小
    '''距离计算'''
    diffMat=tile(intX,(dataSetSize,1))-dataSet #当前点和训练集中的对应元素相减
    sqDiffMat=diffMat**2 #当前点和训练集中的对应元素相减的值上面添加平方
    sqDistance=sqDiffMat.sum(axis=1) #将相减的值的平方累加
    distances=sqDistance**0.5 #求出当前点与数据集中每个点的距离
    sortedDistIndices=distances.argsort() #将distances的值从小到大排列，提取其对应的索引
    classCount={}
    for i in range(k):
        voteIlabel=labels[sortedDistIndices[i]] #确定前k个距离最小的元素所在的类别
        classCount[voteIlabel]=classCount.get(voteIlabel,0)+1 #通过字典的形式，统计前k个距离最小的元素所在的类别出现的频率
    '''classCount.items()将字典classCount分解为元组列表
       operator.itemgetter(1)按照第二个元素的次序对元组进行排序
       reverse=True表示降序，即从大到小排列'''
    sortedclasscount=sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)
    return sortedclasscount[0][0]

'''将文本记录转换为Numpy的解析程序'''
def file2matrix(filename):
    fr=open(filename)
    #readlines()用于读取所有行(直到结束符 EOF)并返回列表，该列表可以由Python 的 for... in ... 结构进行处理
    arrayOLines=fr.readlines()
    numberOfLines=len(arrayOLines) #文件行数
    returnMat=zeros((numberOfLines,3)) #创建返回的numpy矩阵
    classLabel=[]
    index=0
    for line in arrayOLines:
        line=line.strip() #清楚所有的回车字符
        listFromLine=line.split('\t') #使用'\t'将每行分割成元素列表
        returnMat[index,:]=listFromLine[0:3] #选取前三个文件存储到特征矩阵中
        classLabel.append(int(listFromLine[-1])) #将标签存储到列表classLabel
        index+=1
    return returnMat,classLabel

#datingDataMat,datingDataLabels=file2matrix(r'F:\python\machinelearninginaction\Ch02\datingTestSet2.txt')
"""
print(array(datingDataLabels))
plt.style.use('ggplot')
fig=plt.figure()
ax=fig.add_subplot(111)
#ax.scatter(datingDataMat[:,1],datingDataMat[:,2],15.0*array(datingDataLabels),15.0*array(datingDataLabels))
ax.scatter(datingDataMat[:,0],datingDataMat[:,1],15.0*array(datingDataLabels),0.2*array(datingDataLabels))
#plt.xlabel('玩视频游戏所耗时间百分比')
#plt.ylabel('每周所消费的冰淇淋公升数')
plt.xlabel('每年获取的飞行常客里程数')
plt.ylabel('玩视频游戏所耗时间百分比')
plt.legend(loc='best')
plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号
plt.show()
"""

'''考虑到每年获取的飞行常客里程数远大于其他特征数，在这里使用数值归一化进行处理'''
def autoNorm(dataSet):
    minvalue=dataSet.min(0) #获取列中的最小值
    maxvalue=dataSet.max(0) #获取列中的最大值
    ranges=maxvalue-minvalue #最大值与最小值的差
    m=dataSet.shape[0] #表示行数
    HandleDataSet=dataSet-tile(minvalue,(m,1)) #表示归一化的分母
    normDataSet=HandleDataSet/tile(ranges,(m,1)) #归一化的结果
    return normDataSet,ranges,minvalue

'''用分类器针对约会网站进行测试'''
def datingClassTest():
    hoRatio=0.10
    datingDataMat,datingLabels=file2matrix(r'F:\python\machinelearninginaction\Ch02\datingTestSet2.txt')
    normMat,ranges,minvalues=autoNorm(datingDataMat)
    m=normMat.shape[0]
    numTestVecs=int(m*hoRatio)
    errorCount=0.0
    for i in range(numTestVecs):
        classifierResult=classify0(normMat[i,:],normMat[numTestVecs:m,:],datingLabels[numTestVecs:m],3)   #classify0()中的第一个元素表示测试数据，第二个元素表示分类器的训练数据
        print('the classifier came back with:{0}, the real answer is:{1}'.format(classifierResult,datingLabels[i]))
        if (classifierResult!=datingLabels[i]):
            errorCount+=1.0
    print('the total error rate is:{0}'.format(errorCount/float(numTestVecs)))

'''对人进行分类'''
def classifyperson():
    result_list=['not at all','in small doses','in large doses']
    percentTats=float(input("percentage of time spent playing video games?"))
    ffMiles=float(input("frequent flier miles earned per year?"))
    iceCream=float(input("liters of ice cream consumed per year?"))
    datingDataMat,datingLabels=file2matrix(r'F:\python\machinelearninginaction\Ch02\datingTestSet2.txt')
    normMat,ranges,minvalues=autoNorm(datingDataMat)
    inArr=array([ffMiles,percentTats,iceCream])
    classifierResult=classify0((inArr-minvalues)/ranges,normMat,datingLabels,3)
    print("You will probably like this personL: {}".format(result_list[classifierResult-1]))

案例二：手写识别系统

第一步：将图像转化成测试向量

def img2vetor(filename):
    returnVect=zeros((1,1024))
    fr=open(filename)
    for i in range(32):
        lineStr=fr.readline()  #每次读取文件的一行
        for j in range(32):
            returnVect[0,32*i+j]=int(lineStr[j])
    return returnVect

第二步：使用K-近邻算法识别手写数字

def handwritingClassTest():
    hwLabels=[]
    trainingFileList=os.listdir(r'F:\python\machinelearninginaction\Ch02\trainingDigits') #返回指定的文件夹包含的文件或文件夹的名字的列表
    m=len(trainingFileList)
    trainingMat=zeros((m,1024))
    for i in range(m):
        fileNameStr1=trainingFileList[i]
        fileStr1=fileNameStr1.split('.')[0]
        classNumStr1=int(fileStr1.split('_')[0])
        hwLabels.append(classNumStr1)
        trainingMat[i,:]=img2vetor(r'F:\python\machinelearninginaction\Ch02\trainingDigits\%s'%fileNameStr1)
    testFileList=os.listdir(r'F:\python\machinelearninginaction\Ch02\testDigits')
    errorCount=0.0
    mtest=len(testFileList)
    for i in range(mtest):
        fileNameStr2=testFileList[i]
        fileStr2=fileNameStr2.split('.')[0]
        classNumStr2=int(fileStr2.split('_')[0])
        vectorUnderTest=img2vetor(r'F:\python\machinelearninginaction\Ch02\testDigits\%s'%fileNameStr2)
        classifierResult=classify0(vectorUnderTest,trainingMat,hwLabels,3)
        print("the classifierResult came back with: {0}, the real answer is: {1}".format(classifierResult,classNumStr2))
        if (classifierResult!=classNumStr2):
            errorCount+=1.0
    print("\nthe total number of errors is:{}".format(int(errorCount)))
    print("\nthe total rate is:{}".format(errorCount/float(mtest)))

完整代码：

#!/usr/bin/env python3
#coding=utf-8
import pandas as pd
from numpy import *
import operator
import matplotlib.pyplot as plt
import os
'''（1）计算已知类别数据集中的点与当前点之间的距离
（2）按照距离递增次序排列
（3）选取与当前点距离最小的K个点
（4）确定前K个点所在类别的出现频率
（5）返回前K个点出现频率最高的类别作为当前点的预测分类'''
#使用k-近邻构建分类器
def classify0(intX,dataSet,labels,k):
dataSetSize=dataSet.shape[0] #表示数据集的大小
'''距离计算'''
diffMat=tile(intX,(dataSetSize,1))-dataSet #当前点和训练集中的对应元素相减
sqDiffMat=diffMat**2 #当前点和训练集中的对应元素相减的值上面添加平方
sqDistance=sqDiffMat.sum(axis=1) #将相减的值的平方累加
distances=sqDistance**0.5 #求出当前点与数据集中每个点的距离
sortedDistIndices=distances.argsort() #将distances的值从小到大排列，提取其对应的索引
classCount={}
for i in range(k):
voteIlabel=labels[sortedDistIndices[i]] #确定前k个距离最小的元素所在的类别
classCount[voteIlabel]=classCount.get(voteIlabel,0)+1 #通过字典的形式，统计前k个距离最小的元素所在的类别出现的频率
'''classCount.items()将字典classCount分解为元组列表
operator.itemgetter(1)按照第二个元素的次序对元组进行排序
reverse=True表示降序，即从大到小排列'''
sortedclasscount=sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)
return sortedclasscount[0][0]
'''将图像转换为测试向量'''
def img2vetor(filename):
returnVect=zeros((1,1024))
fr=open(filename)
for i in range(32):
lineStr=fr.readline() #每次读取文件的一行
for j in range(32):
returnVect[0,32*i+j]=int(lineStr[j])
return returnVect
def handwritingClassTest():
hwLabels=[]
trainingFileList=os.listdir(r'F:\python\machinelearninginaction\Ch02\trainingDigits') #返回指定的文件夹包含的文件或文件夹的名字的列表
m=len(trainingFileList)
trainingMat=zeros((m,1024))
for i in range(m):
fileNameStr1=trainingFileList[i]
fileStr1=fileNameStr1.split('.')[0]
classNumStr1=int(fileStr1.split('_')[0])
hwLabels.append(classNumStr1)
trainingMat[i,:]=img2vetor(r'F:\python\machinelearninginaction\Ch02\trainingDigits\%s'%fileNameStr1)
testFileList=os.listdir(r'F:\python\machinelearninginaction\Ch02\testDigits')
errorCount=0.0
mtest=len(testFileList)
for i in range(mtest):
fileNameStr2=testFileList[i]
fileStr2=fileNameStr2.split('.')[0]
classNumStr2=int(fileStr2.split('_')[0])
vectorUnderTest=img2vetor(r'F:\python\machinelearninginaction\Ch02\testDigits\%s'%fileNameStr2)
classifierResult=classify0(vectorUnderTest,trainingMat,hwLabels,3)
print("the classifierResult came back with: {0}, the real answer is: {1}".format(classifierResult,classNumStr2))
if (classifierResult!=classNumStr2):
errorCount+=1.0
print("\nthe total number of errors is:{}".format(int(errorCount)))
print("\nthe total rate is:{}".format(errorCount/float(mtest)))
handwritingClassTest()