《机器学习实战》知识总结及代码解析（1）K-近邻算法_深入浅出 python 机器学习:k最近邻算法 答案

@《机器学习实战》
@K-近邻算法

1 K-近邻算法（k-Nearest Neighbor，KNN

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

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

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

1.1 工作原理

存在一个样本数据集合（训练样本集），并且样本集中每个数据都存在标签，即我们知道样本集中每一数据与所属分类的对应关系。

输入没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本集中特征最相似数据的分类标签，即最近邻的分类标签。

一般来说，我们只选取样本数据集中前K个最相似的数据，通常K是不大于20的整数。

最后，选择K个最相似数据中出现次数最多的分类，作为数据的分类。

1.2 一般流程

（1）收集数据：数据是数值型，并带有分类标签
（2）准备数据：通过python从文本文件中解析数据，并归一化特征值
（3）分析数据：使用matplotlib画二维散点图
（4）测试算法：作为对分类器的验证，计算它的错误率和错误个数
（5）使用算法：输入特征数值，来对未知类别的数据进行分类

1.3 注意事项

（1）KNN分类算法的classify0函数有4个参数，其中的inX需要注意，它是输入向量，即待测试数据。它用到了tile函数，这个我在下文的代码解析会提到。

（2）标签向量labels的元素数目和矩阵dataset的行数相同

（3）读取文件数据，必须确保txt等文档存储在当前的工作目录

（4）创建散点图，需要确保环境有matplotlib（这点针对零基础的学习者）

（5）归一化特征值是很有必要的，因为这样能避免较大的特征数据对计算的影响，使得每个特征值对计算结果的影响是一样的。

（6）可以通过改变datingClassTest函数的hoRatio和K值，使得错误率发生变化，错误率是随着它们的变化而增加。

（7）书中“2-5约会网站预测函数”的raw_input函数是python2中的，python3环境会报错，直接换成input函数即可。

（8）同样，书中“2-1 k-近邻算法”，用到的iteritems也是python2中的，在python3环境下，应该换成items。

2 代码解析

这一章节书中共有9个函数代码，下面我会逐个展示代码及注释，并做一些相关的解析。

2.1 KNN分类算法

这里，我将对classify0函数和createDataSet函数进行解析。

首先，createDataSet函数是一个很基础的函数，它用来创建数据集和标签，并能返回数据集和标签的值。

而classify0函数，则是这章的精髓。它的功能是将每组数据划分到某个类中。

函数包含4个参数，其中inX是用于分类的输入向量，dataSet是输入的训练样本集，labels是标签向量，K是用于选择最近邻居的数目。

而函数的大体思路可以概括为5个步骤：
（1）计算已知数据集的点与当前点之间的距离
（2）按照距离递增次序排序
（3）选取与当前点距离最小的K个点
（4）确定前K个点所在类别的出现频率
（5）返回前K个点出现频率最高的类别
而这些步骤的解释，我在下面的代码片里有所提及，可以详见注释。

相关代码及注释：

#KNN分类算法，inX是用于分类的输入向量，dataSet是输入的训练样本集，labels是标签向量，K是用于选择最近邻居的数目
def classify0(inX, dataSet, labels, k):
    #  以下是第一步：计算已知数据集的点与当前点之间的距离
    dataSetSize = dataSet.shape[0]   #获取数据集的宽
    diffMat = tile(inX, (dataSetSize,1)) - dataSet  #使用欧式距离度量，故将输入向量和数据集中各向量相减
    sqDiffMat = diffMat**2     #进行平方
    sqDistances = sqDiffMat.sum(axis=1)      #计算输入向量和数据集中各向量之间的差的平方和
    distances = sqDistances**0.5          #计算欧式距离
    #  以下是第二步：按照距离递增次序排序
    sortedDistIndicies = distances.argsort()     #取得输入向量和数据集中各向量欧式距离的从小到大排序的下标值，返回排序后的索引值
    #  以下是第三步：选取与当前点距离最小的K个点
    classCount={}          #定义一个空字典
    for i in range(k):     #取计算欧氏距离排序后最小的前k个值
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1   #若字典中存在label键，则对应的值+1，如果不存在，则添加这个键设置为0并+1
    #  以下是第四步：确定前K个点所在类别的出现频率
    sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)  #按照字典中的值对字典进行降序排列
    #  最后是第五步，返回前K个点出现频率最高的类别
    return sortedClassCount[0][0]

#创建数据集和标签
def createDataSet():
    group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])
    labels = ['A','A','B','B']
    return group, labels
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

补充：
因为函数里有用到tile函数，这个函数将inX向量进行相应的变换，使得它与dataSet矩阵为相似矩阵，并进行相应的操作。

而tile函数的形式是： tile(A，rep)，

• A: Array类的都可以

• rep：A沿着各个维度重复的次数（由外至内）

它的功能是：重复A的各个维度

如果对tile函数感兴趣，可以参照这个Python tile函数详细解释

2.2 准备数据

这里，我将对“准备数据”的相关代码函数进行解析，即file2matrix函数和 autoNorm函数

file2matrix函数的功能是从文本文件中解析数据，输入的参数为文件名字，返回的结果为训练样本矩阵和类标签向量。

file2matrix函数的大体思路可以概况为3个步骤：
（1）得到文件行数
（2）创建返回的Numpy矩阵
（3）解析文件数据到列表
同样，这些步骤的解释，我在下面的代码片里有所提及，可以详见注释。

autoNorm函数的功能是归一化特征值，输入的参数为数据集数据，返回的结果为归一化矩阵，取值范围以及最小值。

至于归一化特征值的作用，我在上文有所提及，可以详见“1.3 注意事项”的第5点。

相关代码及注释：

#从文本文件中解析数据，输入为文件名字，输出为训练样本矩阵和类标签向量
def file2matrix(filename):
    #  以下是第一步：得到文件行数
    fr = open(filename)     #打开文件
    numberOfLines = len(fr.readlines())         #计算该文件共有多少行（即共有多少个样本）
    #  以下是第二步：创建返回的Numpy矩阵
    returnMat = zeros((numberOfLines,3))        #创建返回的Numpy矩阵
    classLabelVector = []                       #定义下面需要返回的标签
    fr = open(filename)     #需要再次打开文件，否则会报错
    index = 0
    #  以下是第三步：解析文件数据到列表
    for line in fr.readlines():          #解析文件数据到列表
        line = line.strip()              #去掉首尾空白符
        listFromLine = line.split('\t')  #利用空格符分离字符串
        returnMat[index,:] = listFromLine[0:3]    #将每行样本数据的前3个数据输入返回样本矩阵中
        classLabelVector.append(int(listFromLine[-1]))    #将每行样本数据的最后一个数据加入类标签向量中
        index += 1
    return returnMat,classLabelVector   #返回训练样本矩阵和类标签向量

#归一化特征值，输入为数据集数据
def autoNorm(dataSet):
    minVals = dataSet.min(0)    #获得数据集中每列的最小值
    maxVals = dataSet.max(0)    #获得数据集中每列的最大值
    ranges = maxVals - minVals  #获取取值范围
    normDataSet = zeros(shape(dataSet))   #初始化归一化数据集
    m = dataSet.shape[0]      #行
    normDataSet = dataSet - tile(minVals, (m,1))
    normDataSet = normDataSet/tile(ranges, (m,1))   #特征值相除
    return normDataSet, ranges, minVals       #返回归一化矩阵，取值范围以及最小值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2.3 分析数据

这里，我将对创建散点图的相关代码进行解析。
散点图使用矩阵的第二、第三列数据，分别表示特征值。
而它的scatter函数个性化标记散点图上的点。它利用变量datingLabels存储的类标签属性，在散点图上绘制了色彩不等、尺寸不同的点。它还利用datingDatamat矩阵的第二列和第三列属性来展示数据。

相关代码：

  # 创建散点图,散点图使用矩阵的第二、第三列数据，分别表示特征值
     fig = plt.figure()
     ax = fig.add_subplot(111)
     ax.scatter(datingDatamat[:,1], datingDatamat[:,2], 15.0*array(datingLabels), 15.0*array(datingLabels))
     matplotlib.pyplot.show()
1
2
3
4
5

2.4 测试算法及使用算法

“测试算法”对应datingClassTest函数，“使用算法”对应classifyperson函数。这里我将对它们的相关代码进行解析。

datingClassTest函数的功能是计算分类器的错误率和错误个数，它输出计算得到的错误率和错误个数。

classifyperson函数的功能是实现对约会网站的对象判断，它需要用户手动输入对应的特征数值，而后输出判断约会对象的类型。

输入样例：
percentage of time spent playing video games?10
frequent flier miles earned per year?10000
liters of ice cream consumed per year?0.5

输出结果：
You will probably like this person: in small doses

同样，这些函数的解释，我在下面的代码片里有所提及，可以详见注释。

相关代码及注释：

#计算分类器的错误率和错误个数
def datingClassTest():
    hoRatio = 0.50      #取测试样本占数据集样本的10%
    datingDataMat,datingLabels = file2matrix('datingTestSet2(1).txt')       #得到样本集，样本标签
    normMat, ranges, minVals = 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)  #通过k-近邻算法进行分类，并记录结果
        print ("the classifier came back with: %d, the real answer is: %d" % (classifierResult, datingLabels[i]))
        if (classifierResult != datingLabels[i]): errorCount += 1.0           #算法结果与样本的实际分类做对比
    print("the total error rate is: %f" % (errorCount/float(numTestVecs)))   #计算错误率，并输出
    print(errorCount)         #输出错误的个数

#约会网站的对象判断
def classifyperson():
    resultList = ['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('datingTestSet2(1).txt')   # 从文本文件中解析数据
    normMat, ranges, minVals = autoNorm(datingDatamat)    #特征归一化处理
    inArr = array([ffMiles, percentTats, iceCream])       #输入的约会对象的特征
    classifierResult = classify0((inArr - minVals) / ranges, normMat, datingLabels, 3)  #判断约会对象的类型
    print("You will probably like this person: ", resultList[classifierResult - 1])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2.5 手写识别系统

手写识别系统包含2个部分，即“准备数据”和“测试算法”。
“准备数据”对应img2vector函数，“测试算法”对应handwritingClassTest函数。这里我将对它们的相关代码进行解析。

img2vector函数的功能是将图像转换为测试向量，它最后返回测试向量，这个向量本身也完全是由01构成，相当于将原来的矩阵每一行首尾相连。

handwritingClassTest函数的功能是使用K-近邻算法识别手写数字，并计算错误率和错误个数。

同样，这些函数的解释，我在下面的代码片里有所提及，可以详见注释。

相关代码及注释：

#将图像转换为测试向量
def img2vector(filename):
    returnVect = zeros((1,1024))   #返回一个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])   #这个向量本身也完全是由01构成，相当于将原来的矩阵每一行首尾相连
    return returnVect

#识别手写数字
def handwritingClassTest():
    hwLabels = []
    trainingFileList = listdir('trainingDigits')           #导入训练集，‘trainingDigits’是一个文件夹
    m = len(trainingFileList)                       #计算训练样本个数
    trainingMat = zeros((m,1024))                   #初始化数据集，将所有训练数据用一个m行，1024列的矩阵表示
    for i in range(m):
        fileNameStr = trainingFileList[i]   #获得所有文件名，文件名格式‘x_y.txt’,x表示这个手写数字实际表示的数字（label）
        fileStr = fileNameStr.split('.')[0]     #去除 .txt
        classNumStr = int(fileStr.split('_')[0])   #classnumber为每个样本的分类，用‘_’分割，取得label
        hwLabels.append(classNumStr)         #将所有标签都存进hwLables[]
        trainingMat[i,:] = img2vector('trainingDigits/%s' % fileNameStr)     #将文件转化为向量后存入trainingMat[],这里展现了灵活的文件操作
    testFileList = listdir('testDigits')        #迭代测试集
    errorCount = 0.0
    mTest = len(testFileList)
    for i in range(mTest):
        fileNameStr = testFileList[i]
        fileStr = fileNameStr.split('.')[0]     #去除 .txt
        classNumStr = int(fileStr.split('_')[0])
        vectorUnderTest = img2vector('testDigits/%s' % fileNameStr)  #这部分针对测试集的预处理和前面基本相同
        classifierResult = classify0(vectorUnderTest, trainingMat, hwLabels, 3)    #使用算法预测样本所属类别，调用了前面写的classify0()函数
        print ("the classifier came back with: %d, the real answer is: %d" % (classifierResult, classNumStr))
        if (classifierResult != classNumStr): errorCount += 1.0       #算法结果与样本的实际分类做对比
    print ("\nthe total number of errors is: %d" % errorCount)
    print ("\nthe total error rate is: %f" % (errorCount/float(mTest)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

2.6 完整代码

from numpy import *   #导入科学计算包numpy模块
import operator       #导入运算符模块
from os import listdir   #用于获取目录中的文件名
import matplotlib    #用于创建散点图
import matplotlib.pyplot as plt  #将pyplot命名为plt

#KNN分类算法，inX是用于分类的输入向量，dataSet是输入的训练样本集，labels是标签向量，K是用于选择最近邻居的数目
def classify0(inX, dataSet, labels, k):
    #  以下是第一步：计算已知数据集的点与当前点之间的距离
    dataSetSize = dataSet.shape[0]   #获取数据集的宽
    diffMat = tile(inX, (dataSetSize,1)) - dataSet  #使用欧式距离度量，故将输入向量和数据集中各向量相减
    sqDiffMat = diffMat**2     #进行平方
    sqDistances = sqDiffMat.sum(axis=1)      #计算输入向量和数据集中各向量之间的差的平方和
    distances = sqDistances**0.5          #计算欧式距离
    #  以下是第二步：按照距离递增次序排序
    sortedDistIndicies = distances.argsort()     #取得输入向量和数据集中各向量欧式距离的从小到大排序的下标值，返回排序后的索引值
    #  以下是第三步：选取与当前点距离最小的K个点
    classCount={}          #定义一个空字典
    for i in range(k):     #取计算欧氏距离排序后最小的前k个值
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1   #若字典中存在label键，则对应的值+1，如果不存在，则添加这个键设置为0并+1
    #  以下是第四步：确定前K个点所在类别的出现频率
    sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)  #按照字典中的值对字典进行降序排列
    #  最后是第五步，返回前K个点出现频率最高的类别
    return sortedClassCount[0][0]

#创建数据集和标签
def createDataSet():
    group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])
    labels = ['A','A','B','B']
    return group, labels

#从文本文件中解析数据，输入为文件名字，输出为训练样本矩阵和类标签向量
def file2matrix(filename):
    #  以下是第一步：得到文件行数
    fr = open(filename)     #打开文件
    numberOfLines = len(fr.readlines())         #计算该文件共有多少行（即共有多少个样本）
    #  以下是第二步：创建返回的Numpy矩阵
    returnMat = zeros((numberOfLines,3))        #创建返回的Numpy矩阵
    classLabelVector = []                       #定义下面需要返回的标签
    fr = open(filename)     #需要再次打开文件，否则会报错
    index = 0
    #  以下是第三步：解析文件数据到列表
    for line in fr.readlines():          #解析文件数据到列表
        line = line.strip()              #去掉首尾空白符
        listFromLine = line.split('\t')  #利用空格符分离字符串
        returnMat[index,:] = listFromLine[0:3]    #将每行样本数据的前3个数据输入返回样本矩阵中
        classLabelVector.append(int(listFromLine[-1]))    #将每行样本数据的最后一个数据加入类标签向量中
        index += 1
    return returnMat,classLabelVector   #返回训练样本矩阵和类标签向量

#归一化特征值，输入为数据集数据
def autoNorm(dataSet):
    minVals = dataSet.min(0)    #获得数据集中每列的最小值
    maxVals = dataSet.max(0)    #获得数据集中每列的最大值
    ranges = maxVals - minVals  #获取取值范围
    normDataSet = zeros(shape(dataSet))   #初始化归一化数据集
    m = dataSet.shape[0]      #行
    normDataSet = dataSet - tile(minVals, (m,1))
    normDataSet = normDataSet/tile(ranges, (m,1))   #特征值相除
    return normDataSet, ranges, minVals       #返回归一化矩阵，取值范围以及最小值

#计算分类器的错误率和错误个数
def datingClassTest():
    hoRatio = 0.50      #取测试样本占数据集样本的10%
    datingDataMat,datingLabels = file2matrix('datingTestSet2(1).txt')       #得到样本集，样本标签
    normMat, ranges, minVals = 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)  #通过k-近邻算法进行分类，并记录结果
        print ("the classifier came back with: %d, the real answer is: %d" % (classifierResult, datingLabels[i]))
        if (classifierResult != datingLabels[i]): errorCount += 1.0           #算法结果与样本的实际分类做对比
    print("the total error rate is: %f" % (errorCount/float(numTestVecs)))   #计算错误率，并输出
    print(errorCount)         #输出错误的个数

#约会网站的对象判断
def classifyperson():
    resultList = ['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('datingTestSet2(1).txt')   # 从文本文件中解析数据
    normMat, ranges, minVals = autoNorm(datingDatamat)    #特征归一化处理
    inArr = array([ffMiles, percentTats, iceCream])       #输入的约会对象的特征
    classifierResult = classify0((inArr - minVals) / ranges, normMat, datingLabels, 3)  #判断约会对象的类型
    print("You will probably like this person: ", resultList[classifierResult - 1])



#将图像转换为测试向量
def img2vector(filename):
    returnVect = zeros((1,1024))   #返回一个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])   #这个向量本身也完全是由01构成，相当于将原来的矩阵每一行首尾相连
    return returnVect

#识别手写数字
def handwritingClassTest():
    hwLabels = []
    trainingFileList = listdir('trainingDigits')           #导入训练集，‘trainingDigits’是一个文件夹
    m = len(trainingFileList)                       #计算训练样本个数
    trainingMat = zeros((m,1024))                   #初始化数据集，将所有训练数据用一个m行，1024列的矩阵表示
    for i in range(m):
        fileNameStr = trainingFileList[i]   #获得所有文件名，文件名格式‘x_y.txt’,x表示这个手写数字实际表示的数字（label）
        fileStr = fileNameStr.split('.')[0]     #去除 .txt
        classNumStr = int(fileStr.split('_')[0])   #classnumber为每个样本的分类，用‘_’分割，取得label
        hwLabels.append(classNumStr)         #将所有标签都存进hwLables[]
        trainingMat[i,:] = img2vector('trainingDigits/%s' % fileNameStr)     #将文件转化为向量后存入trainingMat[],这里展现了灵活的文件操作
    testFileList = listdir('testDigits')        #迭代测试集
    errorCount = 0.0
    mTest = len(testFileList)
    for i in range(mTest):
        fileNameStr = testFileList[i]
        fileStr = fileNameStr.split('.')[0]     #去除 .txt
        classNumStr = int(fileStr.split('_')[0])
        vectorUnderTest = img2vector('testDigits/%s' % fileNameStr)  #这部分针对测试集的预处理和前面基本相同
        classifierResult = classify0(vectorUnderTest, trainingMat, hwLabels, 3)    #使用算法预测样本所属类别，调用了前面写的classify0()函数
        print ("the classifier came back with: %d, the real answer is: %d" % (classifierResult, classNumStr))
        if (classifierResult != classNumStr): errorCount += 1.0       #算法结果与样本的实际分类做对比
    print ("\nthe total number of errors is: %d" % errorCount)
    print ("\nthe total error rate is: %f" % (errorCount/float(mTest)))

if __name__ == "__main__":  # 当程序执行时
    # 调用基础函数
     group,labels = createDataSet()
     a = classify0([0,0], group, labels, 3)
     print(a)
    # 从文件中解析数据
     f = open("datingTestSet2(1).txt", "r")
     datingDatamat,datingLabels = file2matrix('datingTestSet2(1).txt')
     print(datingDatamat)
     print(datingLabels[0:20])
    # 创建散点图,散点图使用矩阵的第二、第三列数据，分别表示特征值
     fig = plt.figure()
     ax = fig.add_subplot(111)
     ax.scatter(datingDatamat[:,1], datingDatamat[:,2], 15.0*array(datingLabels), 15.0*array(datingLabels))
     matplotlib.pyplot.show()
    # 归一化特征值
     normMat, ranges, minVals = autoNorm(datingDatamat)
     print(normMat)
     print(ranges)
     print(minVals)
    # 计算分类器的错误率和错误个数
     datingClassTest()
    # 约会网站的对象判断
     classifyperson()
    # 将图像转换为测试向量
     testVector = img2vector('testDigits/0_13.txt')
     print(testVector[0,0:31])
     print(testVector[0,32:63])
    # 计算分类器的错误率和错误个数
     handwritingClassTest()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

3 实战心得

以上是我整理的k-近邻算法的相关知识和代码解析，望对大家有用。由于初写，如有纰漏或者错误，欢迎指出。

以下是对K-近邻算法的评价：
1.算法执行效率低：算法需要为每个测试向量做大约2000次距离计算，每个距离计算包括了1024个维度浮点计算，总共要执行900次。此外，还需要为测试向量准备一定的存储空间。所以这个算法不仅耗时，而且需要不少的存储空间。

2.k-临近算法的另一个缺陷就是它无法给出任何数据的基础结构信息，因此我们无法得知平均实例样本和典型实例样本具体有什么特征。

3.k-近邻算法是分类数据最简单最有效的算法，并且精度高、对异常值不敏感、无数据输入假定。

4.K决策树就是k-近邻算法的优化版，可以节省大量的计算开销。

[1]: 《机器学习实战》[美] Peter Harrington 著 李锐 李鹏 曲亚东 王斌 译