KNN的理解和实现

一、KNN算法的思想

通过一定的方法度量其他样本到目标样本的距离，选取距离最近的k个样本，当这k个样本大多数分类的结果都属于某一个类别时，则判断目标样本也是属于这个类别的。

常用的衡量距离的方式主要有两种：曼哈顿距离和欧式距离

样本的特征空间：两个样本集都是含有n为特征的数据集，

（1）曼哈顿距离：

（2）欧氏距离：

这里我们使用欧式距离L2作为衡量的尺度，实现简单数据的分类

import numpy as np
import operator
'''
parameters:
    test_X-用于分类的数据（测试集）
    dataSet-用于训练的数据（训练集）
    labels - 分类标签
    k - KNN算法的参数，选择距离最小的K个点
return：
    sortedClass[0][0]分类结果
'''
def createDataSet():
    #group表示数据集,使用矩阵表示
    dataSet = np.array([[1,101],[5,89],[108,5],[115,8]])
    #labels表示标签
    labels = ['喜欢','厌恶','难过','中立']
    return dataSet,labels
def classify(testX,dataSet,labels,k):
    #numpy函数shape[0]返回dataSet训练集的行数
    dataSetSize = dataSet.shape[0]
    #纵向重复输入集testX（需要测试的样本）dataSetSize次，横向重复inX 1次
    #将待测试的数据（重复了dataSetSize个相同的数字的） 分别与 训练的数据集 进行求差，再进行平方
    diffMat = np.tile(testX,(dataSetSize,1)) - dataSet
    sqDiffMat = diffMat**2
    #使用sum()函数，将所有的元素相加，sum(0)列相加，sum(1)行相加
    sqDistances = sqDiffMat.sum(axis=1)
    #开方计算欧式距离
    distances = sqDistances**0.5
    #列表返回distances中元素从小到大排序后的索引值
    sortedDist = distances.argsort()

    #给定一个记录类别次数的字典
    classCount = {}
    for i in range(k):
        #依次取出前k个元素的类别，原来前k个元素在训练集中的label（原标签值）值，k个元素与待测试点的距离近
        label_list = labels[sortedDist[i]]
        #计算该类别出现的次数
        #使用字典的get()方法，dict.get(key,default=None)
        #get方法，返回指定键的值，即该类别出现的次数，再进行加1
        # 如果值不在字典中，则返回默认值0，再进行加1
        #使用字典记录对于前k个键值，所属的各个类别出现的次数
        classCount[label_list]=classCount.get(label_list,0)+1

        #reverse降序对字典classcount(记录了前k个数据中，所属类别出现的次数)进行排序,其中operator.itemgetter(1)表示按照字典的值进行排序
        #最终得到的结果，是按照所属类别数值由大到小的顺序进行排列的，sortedClass[key][value]
        sortedClass = sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)
        #返回次数最多的类别和出现的次数，，即为测试数据所属的类别
        return sortedClass[0][0]

if __name__ == '__main__':
    #创建数据集
    dataSet,labels = createDataSet()
    #测试样本
    test = [120,10]
    #KNN分类
    test_class = classify(test,dataSet,labels,3)
    print(test_class)

二、使用KNN处理较大的数据集：海伦约会问题

问题描述：训练数据集中会给出3种特征属性（对象每年乘坐飞机的里程数、玩游戏消耗的百分比、每周吃掉的冰激凌公斤数）

最后一列为分类标签（海伦是否对该对象满意，有三种类型的取值：lageDoses、smallDoses、didntlike）

数据集共有1000行，将其保存为datingTestSet.txt,如下图所示：

1、数据预处理

（1）读取txt文档，转换生成特征矩阵dataSet、标签分类矩阵classLabel（将类目型变量数字化为1、2、3）

def file2mat(filename):
    """
    函数说明: 打开并解析文件，将文件的特征和标签都转化为矩阵,分类标签
    1代表不喜欢
    2代表魅力一般
    3代表极具魅力
    Parameters:
        filename - 文件名
    returns:
        dataSet - 特征矩阵
        classLabelVector - 分类Label向量
    """
    #打开文件
    with open(filename,'r') as fr:
        arrayLines = fr.readlines()
    #得到文件行数
    numbers = len(arrayLines)
    #returnMat特征矩阵：[numberOfLines,3]
    dataSet = np.zeros((numbers,3))
    #返回的分类标签向量
    classLabel = []
    #行的索引值
    index = 0
    for line in arrayLines:
        #s.strip(rm)，当rm空时,默认删除空白符(包括'\n','\r','\t',' ')
        line = line.strip()
        #使用s.split(str="",num=string,cout(str))将字符串根据'\t'分隔符进行切片
        lists = line.split('\t')
        #将数据前三列提取出来,存放到returnMat的NumPy矩阵中,也就是特征矩阵
        dataSet[index,:] = lists[0:3]
        #根据文本中标记的喜欢的程度进行分类,1代表不喜欢,2代表魅力一般,3代表极具魅力
        if lists[-1] == 'didntLike':
            classLabel.append(1)
        elif lists[-1] == 'smallDoses':
            classLabel.append(2)
        elif lists[-1] == 'largeDoses':
            classLabel.append(3)
        index += 1
    return dataSet, classLabel

（2）使用散点图的形式显示数据集的分布，数据可视化，使用子图显示特征与特征之间的关系

def showdatas(dataSet, classLabels):
    """
    函数说明: 可视化数据
    Parameters:
        dataSet - 特征矩阵
        classLabels - 分类Label
    """
    
    #当nrow=2,nclos=2时,代表fig画布被分为四个区域,axs[0][0]表示第一行第一个区域,不共享x轴和y轴,fig画布的大小为(13,8)
    fig, axs = plt.subplots(nrows=2, ncols=2,sharex=False, sharey=False, figsize=(13,8))

    numbers = len(classLabels)
    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.5
    axs[0][0].scatter(x=dataSet[:,0], y=dataSet[:,1], color=LabelsColors,s=15, alpha=.5)
    #设置标题,x轴label,y轴label
    axs0_title_text = axs[0][0].set_title(u'每年获得的飞行常客里程数与玩视频游戏所消耗时间占比')
    axs0_xlabel_text = axs[0][0].set_xlabel(u'每年获得的飞行常客里程数')
    axs0_ylabel_text = axs[0][0].set_ylabel(u'玩视频游戏所消耗时间占')
    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.5
    axs[0][1].scatter(x=dataSet[:,0], y=dataSet[:,2], color=LabelsColors,s=15, alpha=.5)
    #设置标题,x轴label,y轴label
    axs1_title_text = axs[0][1].set_title(u'每年获得的飞行常客里程数与每周消费的冰激淋公升数')
    axs1_xlabel_text = axs[0][1].set_xlabel(u'每年获得的飞行常客里程数')
    axs1_ylabel_text = axs[0][1].set_ylabel(u'每周消费的冰激淋公升数')
    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.5
    axs[1][0].scatter(x=dataSet[:,1], y=dataSet[:,2], color=LabelsColors,s=15, alpha=.5)
    #设置标题,x轴label,y轴label
    axs2_title_text = axs[1][0].set_title(u'玩视频游戏所消耗时间占比与每周消费的冰激淋公升数',)
    axs2_xlabel_text = axs[1][0].set_xlabel(u'玩视频游戏所消耗时间占比')
    axs2_ylabel_text = axs[1][0].set_ylabel(u'每周消费的冰激淋公升数')
    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()

显示特征与特征之间的关系图：

(3) 由于飞行里程数比其它两个特征 的值要大很多，所以最终的分类结果会主要受飞行里程数影响，为了保证三种因素影响效果相当，所以我们需要对每个特征进行归一化：newValue=(oldValue - min) / (max-min)，将数值限定在0-1之间

def autoNorm(dataSet):
    """
    函数说明：对数据进行归一化
    Parameters:
        dataSet-特征矩阵
    returns:
        normData - 归一化后的特征矩阵
        ranges - 数据范围
        minVals - 数据最小值
    """
    #获取数据的最小值
    minVals = dataSet.min(0)
    maxVals = dataSet.max(0)
    #最大值和最小值的范围
    ranges = maxVals - minVals
    #使用shape函数获取特征矩阵的行列数，维度，用来初始化normDataSet矩阵
    normData = np.zeros(np.shape(dataSet))
    #使用m记录数据集的样本数
    m = dataSet.shape[0]
    #将原矩阵的值减去最小值,,构造最小值的矩阵，重复m行1列，使得原矩阵的每一行元素都减去最小值
    normData = dataSet - np.tile(minVals,(m,1))
    #再除以最大值和最小值的差，得到归一化数据
    normData = normData / np.tile(ranges,(m,1))
    #返回归一化的数据结果，数据范围，最小值
    return normData,ranges,minVals

2、实现分类函数：

计算出训练集中每个样本和测试输入的数据之间的欧氏距离，再按照距离由小到大进行排序，取前k个样本的标签分类值。最终返回所属最多的分类的类别，即为测试输入数据的所属类别

def classify0(testX,dataSet,labels,k):
    """
    函数说明：KNN算法，分类器
    Parameters:
        testX-用于分类的数据（测试集输入的数据）
        dataSet-用于训练的数据（训练集）
        labels - 分类标签
        k - KNN算法，选择距离最小的K个点
    returns:
        sortedClassCount[0][0] - 分类结果    
    """
    #使用numpy函数shape[0]返回dataSet 训练集样本 的行数
    dataSetSize = dataSet.shape[0]
    #将待测试的样本，在行方向上重复dataSetSize次，在列方向重复1次，并进行距离的度量
    #二维特征相减后平方
    diffMat = np.tile(testX,(dataSetSize,1)) - dataSet
    #二维特征相减后再平方
    sqDiffMat = diffMat**2
    #使用sum函数将所有结果相加，sum(0)代表列相加，sum(1)代表行相加
    sqDistances = sqDiffMat.sum(axis=1)
    #开方，计算出距离
    distances = sqDistances**0.5
    #返回distances中元素从小到大排序后的索引值
    sortedDistances = distances.argsort()

    #记录分类的类别次数的字典
    classCount = {}
    for i in range(k):
        #取出前k个元素的类别
        kLabels = labels[sortedDistances[i]]
        #计算类别的次数
        #使用字典的get方法，如果不存在，默认返回0，加1，否则在原值的基础上加1
        classCount[kLabels] = classCount.get(kLabels,0)+1
        #对classCount字典，按照值的降序进行排列
        #使用items方法，同时遍历键和值,参与排序的是字典的键值
        sortedClass = sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)
        #返回次数最多的类别，即所要分类的类别
        return sortedClass[0][0]

3、计算测试集下分类的错误率

测试集选取所有数据集中后百分之十的作为测试集，如果预测值与之前的标签值不一样，则错误数增加1，最终计算错误率

def TestPerform():
    """函数说明：分类器测试函数
    Returns:
        normData - 归一化后的特征矩阵
        ranges - 数据范围
        minVals - 数据最小值
"""
    #打开数据集
    filename = "datingTestSet.txt"
    #将文件解析为特征矩阵、标签向量
    dataSet,classLabels = file2mat(filename)
    #取所有数据的百分之十作为验证集
    Ratio = 0.10
    #进行数据归一化，返回归一化后的矩阵、数据范围、和数据的最小值
    normMat,ranges,minVals = autoNorm(datingDataMat)
    #获得normMat的行数
    m = normMat.shape[0]
    # 取所有数据的百分之十作为验证集
    Ratio = 0.10
    #得到10%的测试数据个数
    TestMat = int(m * Ratio)
    #记录分类错误的数目
    errorCount = 0.0

    #对于每个测试样本
    for i in range(TestMat):
        #前numTestVecs个数据作为测试集，后m-numTestVecs个数据作为训练集
        #numpy中的用法，X[：,0]表示一个二维数组，取二维数组中第一维的所有数据，第二维中取第0个数据，即取所有行的第0个数据
        #X[:,m:n]取所有数据的第m到n-1列数据，含左不含右
        #normMat[TestMat:m,:]训练集：取 第一维从testMat行到第m行 的样本数据
        #classLabels[TestMat:m]分类标签：即训练样本所对应的标签，从第TestMat到第m行，
        #k的值设为4，代表最终返回离测试点最近的4个点，其中所属分类最多的类别
        classifierResult = classify0(normMat[i,:],normMat[TestMat:m,:],classLabels[TestMat:m],4)
        print("分类结果：%d\t真实类别：%d" % (classifierResult,classLabels[i]))
        #如果分类结果和真实结果不一样，则错误数加1
        if classifierResult != datingLabels[i]:
            errorCount += 1.0
        #最终计算总的错误率
        print("错误率：%f%%" % (errorCount/float(TestMat)*100))

4、最终的预测结果