第二章 k近邻算法（KNN）

最新推荐文章于 2022-08-13 20:13:46 发布

C.&H.

最新推荐文章于 2022-08-13 20:13:46 发布

阅读量437

点赞数

分类专栏：机器学习实战笔记

本文链接：https://blog.csdn.net/sunnnnh/article/details/98031400

版权

机器学习实战笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

KNN简介：

k近邻法(k-nearest neighbor, k-NN)是1967年由Cover T和Hart P提出的一种基本分类与回归方法。它的工作原理是：存在一个样本数据集合，也称作为训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一个数据与所属分类的对应关系。输入没有标签的新数据后，将新的数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本最相似数据(最近邻)的分类标签。一般来说，我们只选择样本数据集中前k个最相似的数据，这就是k-近邻算法中k的出处，通常k是不大于20的整数。最后，选择k个最相似数据中出现次数最多的分类，作为新数据的分类。

2.1 电影分类

2.1.1 k-近邻算法的优缺点

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

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

适用范围：数值型（例如：身高）和标称型（分类。例如：男、女）

2.1.2 电影分类的代码实现

（1）样本数据：

电影名称	打斗镜头	接吻镜头	电影类型
电影1	1	101	爱情片
电影2	5	89	爱情片
电影3	108	5	动作片
电影4	115	8	动作片

（2）使用欧式距离进行距离度量

（3）k-近邻算法的步骤：

计算已知类别数据集中的点与当前点之间的距离；
按照距离递增次序排序；
选取与当前点距离最小的k个点；
确定前k个点所在类别的出现频率；
返回前k个点所出现频率最高的类别作为当前点的预测分类。

（4）完整的代码实现：

import numpy as ny
import operator #运算符模块

#(1) 准备数据集
def createDataSet():
    #group中：[打斗镜头数，接吻镜头数]
    group =ny.array([[1,101],[5,89],[108,5],[115,8]])
    #labels对group进行分类
    labels = ['爱情片','爱情片','动作片','动作片']
    return  group,labels

#测试
# if __name__ == '__main__':
#     #创建数据集
#     group,labels = createDataSet()
#     #打印数据集
#     print(group)
#     print(labels)


#(2)根据两点距离公式，计算距离，选择距离最小的前k个点，并返回分类结果。
# Parameters:
#     inX - 用于分类的数据(测试集)
#     dataSet - 用于训练的数据(训练集)
#     labels - 分类标签
#     k - kNN算法参数,选择距离最小的k个点
def classify0(inX,dataSet,labels,k):
    # numpy函数shape[0]返回dataSet的行数
    dataSetSize = dataSet.shape[0]
    #计算训练集与测试集的坐标差(ny.tile(inX,(dataSetSize,1)):使训练集和测试集的行列数一致)
    diffMat = ny.tile(inX,(dataSetSize,1))-dataSet;
    #将获得的差进行平方
    sqDiffMat = diffMat ** 2
    #进行行相加
    sqDistances = sqDiffMat.sum(axis=1)
    #开方，计算出距离
    distances = sqDistances**0.5
    #返回distances中元素从小到大排序后的索引值（即排序后的元素在distances中的行下标）
    sortedDisIndicies = distances.argsort() #sortedDisIndicies=[2 3 1 0]
    # 定一个记录类别次数的字典
    classCount = {}
    for i in range(k): #取出数字0~k-1
        #在labels中取出对应的类别
        voteIlabel = labels[sortedDisIndicies[i]]
        #将该类别的次数加1（键：类别 ；值：该类别出现的次数）
        classCount[voteIlabel] = classCount.get(voteIlabel,0)+1
    #operator.itemgetter(1)：按照值进行排序
    #operator.itemgetter(0)：按照键进行排序
    #reverse：逆序
    #按类别出现的次数对classCount进行从大到小排序
    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)

运行结果：

2.2 改进约会网站的配对

完整代码：

from matplotlib.font_manager import FontProperties
import matplotlib.lines as mlines
import matplotlib.pyplot as plt
import numpy as ny
import operator
'''
函数说明:打开并解析文件，对数据进行分类：1代表不喜欢,2代表魅力一般,3代表极具魅力

参数:
    filename - 文件名
返回值:
    returnMat - 特征矩阵（1000*3：存储1000个人的3个特征）
    classLabelVector - 分类Label向量
'''
def classify0(inX,dataSet,labels,k):
    # numpy函数shape[0]返回dataSet的行数
    dataSetSize = dataSet.shape[0]
    #计算训练集与测试集的坐标差(ny.tile(inX,(dataSetSize,1)):使训练集和测试集的行数一致)
    diffMat = ny.tile(inX,(dataSetSize,1))-dataSet;
    #将获得的差进行平方
    sqDiffMat = diffMat ** 2
    #进行行相加
    sqDistances = sqDiffMat.sum(axis=1)
    #开方，计算出距离
    distances = sqDistances**0.5
    #返回distances中元素从小到大排序后的索引值
    sortedDisIndicies = distances.argsort()
    # 定一个记录类别次数的字典
    classCount = {}
    for i in range(k): #取出数字0~k-1
        voteIlabel = labels[sortedDisIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0)+1
    sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)
    return sortedClassCount[0][0]

#(1)准备数据
def file2matrix(filename):
    #打开文件
    fr = open(filename)
    #读取文件中的内容
    arrayOLines = fr.readlines()
    #获取文件的行数
    numberOfLines = len(arrayOLines)
    #返回的NumPy矩阵,解析完成的数据:numberOfLines行,3列(1000行3列)
    returnMat = ny.zeros((numberOfLines,3))
    # 返回的分类标签向量(一维，存储对应行的类别)
    classLabelVector = []
    #数据矩阵returnMat中行的索引值
    index = 0;
    #遍历文件中的内容（逐行遍历）
    for line in arrayOLines:
        #截取所有的回车字符
        line = line.strip()
        #将字符串根据'\t'分隔符（空格）进行切片
        listFromLine = line.split('\t')
        #将数据前三列提取出来(即3个特征)
        returnMat[index,:] = listFromLine[0:3]
        # 根据文本中标记的喜欢的程度进行分类,1代表不喜欢,2代表魅力一般,3代表极具魅力(与returnMat行一致)
        #listFromLine中最后一个元素存储的是类别
        if listFromLine[-1] == 'didntLike':
            classLabelVector.append(1)
        elif listFromLine[-1] =='smallDoses':
            classLabelVector.append(2)
        elif listFromLine[-1] =='largeDoses':
            classLabelVector.append(3)
        index+=1
        #返回数据矩阵 及 对应的类别
    return returnMat,classLabelVector
# if __name__ == '__main__':
#     filename = 'datingTestSet.txt'
#     datingDataMat,datingLabels = file2matrix(filename)
#     print(datingDataMat)
#     print(datingLabels)
#（2）分析数据
'''
函数说明:可视化数据

Parameters:
    datingDataMat - 特征矩阵
    datingLabels - 分类Label
'''
def showdatas(datingDataMat, datingLabels):
    # 设置汉字格式
    font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", 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.5
    axs[0][0].scatter(x=datingDataMat[:,0], y=datingDataMat[:,1], color=LabelsColors,s=15, alpha=.5)
    # 设置标题,x轴label,y轴label
    axs0_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.5
    axs[0][1].scatter(x=datingDataMat[:, 0], y=datingDataMat[:, 2], color=LabelsColors, s=15, alpha=.5)
    # 设置标题,x轴label,y轴label
    axs1_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.5
    axs[1][0].scatter(x=datingDataMat[:,1],y=datingDataMat[:,2],color=LabelsColors,s=15,alpha=.5)
    # 设置标题,x轴label,y轴label
    axs2_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()

# if __name__ =='__main__':
#     filename = 'datingTestSet.txt'
#     #打开并处理数据
#     datingDataMat,datingLabels = file2matrix(filename)
#     showdatas(datingDataMat,datingLabels)

#(3)准备数据，归一化特征值
'''
函数说明:对数据进行归一化

Parameters:
    dataSet - 特征矩阵
Returns:
    normDataSet - 归一化后的特征矩阵
    ranges - 数据范围
    minVals - 数据最小值
'''
def autoNorm(dataSet):
    #获取列最小最大值
    minVals = dataSet.min(0)
    maxVals = dataSet.max(0)
    #获取范围
    ranges = maxVals-minVals
    # shape(dataSet)返回dataSet的矩阵行列数，建立与dataSet形状一致的零矩阵
    normDataSet = ny.zeros(ny.shape(dataSet))
    #获取矩阵的行
    m = dataSet.shape[0]
    #原始值减去最小值
    normDataSet = dataSet-ny.tile(minVals,(m,1))
    # 除以最大和最小值的差,得到归一化数据
    normDataSet = normDataSet/ny.tile(ranges,(m,1))
    # 返回归一化数据结果,数据范围,最小值
    return normDataSet,ranges,minVals
# if __name__=='__main__':
#     filename='datingTestSet.txt'
#     datingMat,datingLabels = file2matrix(filename)
#     normDataSet,ranges,minValue = autoNorm(datingMat)
#     print(normDataSet)
#     print(ranges)
#     print(minValue)

#(4) 测试。验证分类器
'''
函数说明:分类器测试函数

Parameters:
    无
Returns:
    normDataSet - 归一化后的特征矩阵
    ranges - 数据范围
    minVals - 数据最小值
'''
def datingClassTest():
    #打开的文件名
    filename = 'datingTestSet.txt'
    #将返回的特征矩阵和分类向量分别存储到datingDataMat和datingLabels中
    datingMat,datingLabels = file2matrix(filename)
    #取所有数据的百分之十，作为测试数据
    hoRatio = 0.10
    # 数据归一化,返回归一化后的矩阵,数据范围,数据最小值
    normMat,ranges,minVaule = autoNorm(datingMat)
    #获取归一化后矩阵normMat的行数
    m = normMat.shape[0]
    #百分之十测试数据的行数
    numTest = int(m*hoRatio)
    #分类错误计数
    errorCount = 0.0

    for i in range(numTest):
        # 前numTest个数据作为测试集,后m-numTest个数据作为训练集
        #测试集、训练集、分类标签、k（选择距离最小的k个点）
        classifierResult =classify0(normMat[i,:],normMat[numTest:m,:],datingLabels[numTest:m],4)
        print("分类的结果：%d\t真实类别:%d" %(classifierResult,datingLabels[i]))
        if(classifierResult != datingLabels[i]):
            errorCount+=1.0
    print("错误率：%f%%" % (errorCount/float(numTest)*100))

# if __name__ == '__main__':
#     datingClassTest()
#(5)函数说明:通过输入一个人的三维特征,进行分类输出
def classifyPerson():
    #输出结果
    resultList = ['讨厌','有点喜欢','非常喜欢']
    #三维特征用户输入
    precentTats = float(input("玩游戏所耗时间百分比："))
    ffMiles = float(input("每年获得的飞行常客里程数:"))
    iceCream = float(input("每周消费的冰激淋公升数:"))
    #打开文件的名字
    filename = 'datingTestSet.txt'
    #打开并处理数据
    datingMat,datingLabels = file2matrix(filename)
    #将数据归一化
    normMat,ranges,minValue = autoNorm(datingMat)
    #将输入数据生成测试集
    inArr = ny.array([precentTats,ffMiles,iceCream])
    #将测试数据归一化
    norminArr = (inArr-minValue)/ranges
    #返回分类的结果
    classifyResult = classify0(norminArr,normMat,datingLabels,3)
    #打印结果
    print("你可能%s这个人" % resultList[classifyResult-1]);

if __name__ == '__main__':
    classifyPerson()

结果：

2.3 手写识别系统

实现代码：

from os import  listdir
from sklearn.neighbors import KNeighborsClassifier as KNN
import numpy as ny
import operator

#（1）将32*32的二进制图像矩阵转换为1*1024的向量
'''
参数filename：数字图像文件
返回值returnVect：转换后的1*1024的数组
'''
def img2vector(filename):
    #创建1*1024的数组
    returnVect = ny.zeros((1,1024))
    #打开文件
    fr = open(filename)
    #将32*32的图像矩阵 转换为 1*1024的数组。i：行 、j：列
    for i in range(32):
        #取出一行数据
        lineStr = fr.readline()
        for j in range(32):
            #将每一行数据依次保存在returnVect
            returnVect[0,32*i+j] = int(lineStr[j])
    #返回转换后的returnVect
    return returnVect

#(2)手写数字分类测试
def handwritingTest():
    #测试集的label
    hwLabels = []
    #返回训练目录trainingDigits下的文件名
    trainingFileList = listdir('trainingDigits')
    #返回文件夹下文件的个数
    m = len(trainingFileList)
    #初始化训练集矩阵
    trainingMat = ny.zeros((m,1024))
    #获取测试集数据及其类别，分别存储在trainingMat、hwLabels
    for i in range(m):
        #获取文件名字
        filename=trainingFileList[i]
        #获取分类的数字（每个文件名前的第一个数字表示该数字的文件）
        className = int(filename.split('_')[0])
        #将获得类别添加在hwLabels中
        hwLabels.append(className)
        #将每一个文件（都在trainingDigits目录下）的1*1924矩阵存储在trainingMat矩阵中
        trainingMat[i,:] = img2vector('trainingDigits/%s'%(filename))
    #构建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):
        #获取文件的名字
        filenameT=testFileList[i]
        #通过文件名获得分类的数字
        classNumT=int(filenameT.split('_')[0])
        #获得测试集的1*1024向量
        vectorUnderTest = img2vector('testDigits/%s'%(filenameT))
        #获得预测结果
        TestLabelResult = neigh.predict(vectorUnderTest)
        print('分类返回的结果%d,真实结果为%d'%(TestLabelResult,classNumT))
        if(TestLabelResult!=classNumT):
            errorCount+=1.0
    print('总共错了%d个数据\n错误率为：%f%%'%(errorCount,errorCount/mTest*100))

if __name__ =='__main__':
    handwritingTest()

结果：

C.&H.

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
第二章 k近邻算法（KNN）

KNN简介：k近邻法(k-nearest neighbor, k-NN)是1967年由Cover T和Hart P提出的一种基本分类与回归方法。它的工作原理是：存在一个样本数据集合，也称作为训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一个数据与所属分类的对应关系。输入没有标签的新数据后，将新的数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本最相似数据(最近...
复制链接

扫一扫

专栏目录