机器学习实战——K-近邻算法的应用

哈密瓜Q

已于 2023-05-31 10:39:11 修改

阅读量376

点赞数

分类专栏：机器学习文章标签：机器学习近邻算法

于 2022-01-27 20:49:27 首次发布

本文链接：https://blog.csdn.net/m0_53062159/article/details/122723460

版权

机器学习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

[原发布时间：2021-10-10 20:28:27]

文章目录

1. K-邻近算法改进约会网站

1.1 提供文本文件

存放在文本文件datingTestSet.txt中的数据（局部）如下，每个样本数据占据一行，总共1000行。

该数据集由海伦收集，包含如下三个特征标签（分别对应前三列）：

每周获得的飞行常客里程数
玩视频游戏所耗时间比例
每周消费的冰淇淋公升数

根据标签分类后的类型：

不喜欢的人（didntLike）
魅力一般的人（smallDoses）
极具魅力的人（largeDoses）

1.2 使用Matplotlib画出二维扩散图

代码如下：

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

"""
函数说明：打开并解析文件，对数据进行分类：1代表不喜欢，2代表魅力一般，3代表极具魅力
Parameters:
    filename - 文件名
Returns:
    returnMat - 特征矩阵
    classLabelVector - 分类Label向量
"""
def file2matrix(filename):
    love_dictionary = {'largeDoses':3, 'smallDoses':2, 'didntLike':1}
    fr = open(filename)

    #--------------------------------------------------------------------#
    # 逐行读取文件，readlines()方法用于读取所有行（直到结束符 EOF）并返回列表，
    # 该列表可以由 Python 的 for... in ... 结构进行处理。
    #--------------------------------------------------------------------#
    arrayOLines = fr.readlines()
    #获取文件的行数
    numberOfLines = len(arrayOLines)

    #--------------------------------------------------------------------#
    #返回 numpy 矩阵，numberOfLines 行，3 列的零元素矩阵（初始化特征矩阵）
    returnMat = np.zeros((numberOfLines, 3))
    #--------------------------------------------------------------------#

    #分类的标签向量
    classLabelVector = []
    index = 0
    for line in arrayOLines:
        # 删去（每行）字符串首尾空格
        line = line.strip()
        # 按'\t'对字符串进行分割
        listFromLine = line.split('\t')

        #-------------------------------------------------------------#
        # 将数据前三列提取出来，存放到 returnMat 的 numpy 矩阵中
        # ndnarry 可以使用a[0, :]的方式遍历第一行的数据，但是普通的list类型不行
        #------------------------------------------------------------#
        returnMat[index,:] = listFromLine[0:3]

        #---------------------------------------------------------------#
        # 如果 listFromLine 最后一个元素是数字则直接赋值给 classLabelVector
        # 如果最后一个元素不是数字，而是字符串。根据字典 love_dictionary 转化为数字
        #---------------------------------------------------------------#
        if(listFromLine[-1].isdigit()):
            classLabelVector.append(int(listFromLine[-1]))
        else:
            classLabelVector.append(love_dictionary.get(listFromLine[-1]))
        index += 1
    return returnMat, classLabelVector

"""
函数说明：可视化数据
Parameters:
    datingDataMat - 特征矩阵
    datingLabels - 分类Label
"""
def showdatas(datingDataMat, datingLabels):
    # 设置汉字格式
    font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)
    # 画布被分为四个区域，axs[0][0]表示第一行第一个区域，画布的大小为(13,8)
    fig, axs = plt.subplots(nrows=2, ncols=2, sharex=False, sharey=False, figsize=(15, 8))

    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，透明度为 1
    axs[0][0].scatter(x=datingDataMat[:, 0], y=datingDataMat[:, 1], color=LabelsColors, s=15, alpha=1)
    # 设置标题,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=13, weight='bold', color='red')
    plt.setp(axs0_xlabel_text, size=11, weight='bold', color='black')
    plt.setp(axs0_ylabel_text, size=11, weight='bold', color='black')

    # 画出散点图,以 datingDataMat 矩阵的第一列、第三列数据画散点数据，散点大小为 15，透明度为 1
    axs[0][1].scatter(x=datingDataMat[:, 0], y=datingDataMat[:, 2], color=LabelsColors, s=15, alpha=1)
    # 设置标题,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=13, weight='bold', color='red')
    plt.setp(axs1_xlabel_text, size=11, weight='bold', color='black')
    plt.setp(axs1_ylabel_text, size=11, weight='bold', color='black')

    # 画出散点图,以 datingDataMat 矩阵的第二列、第三列数据画散点数据，散点大小为 15，透明度为 1
    axs[1][0].scatter(x=datingDataMat[:, 1], y=datingDataMat[:, 2], color=LabelsColors, s=15, alpha=1)
    # 设置标题,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=13, weight='bold', color='red')
    plt.setp(axs2_xlabel_text, size=11, weight='bold', color='black')
    plt.setp(axs2_ylabel_text, size=11, 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 = "D:\\桌面\\machinelearninginaction\\Ch02\\datingTestSet.txt"
    datingDataMat, datingLabels = file2matrix(filename)
    showdatas(datingDataMat, datingLabels)

运行结果：

玩视频游戏所消耗时间占比与每周消费的冰激淋公升数：
每年获得的飞行常客里程数与每周消费的冰激淋公升数：
每年获得的飞行常客里程数与玩视频游戏所消耗时间占比

1.3 归一化数值

由于每年获取的飞行常客里程数对于计算结果的影响将远远大于其他的两个特征。而产生这种现象的唯一原因，仅仅是因为飞行常客里程数远大于其他特征值。但本例认为这三种特征是同等重要的，因此作为三个等权重的特征之一，飞行常客里程数并不应该如此严重地影响到计算结果，因此我们需对数据进行归一化处理。
在处理这种不同取值范围的特征值时，我们通常采用的方法是将数值归一化，如将取值范围处理为0-1或者-1到1之间。下面的公式可以将任意取值范围的特征值转换到0到1区间内的取值：
newValue=(oldValue-min)/(max-min)
归一化代码如下：

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.4 使用算法预测数据

完整代码如下：

import numpy as np
import operator
 
def classify0(inX, dataSet, labels, k):
    # dataSet.shape[0]返回训练样本集的行数
    dataSet_size = dataSet.shape[0]
    # 在列方向上重复inX，1次，行方向上重复inX，dataSet_size次
    diff_mat = np.tile(inX, (dataSet_size, 1)) - dataSet
    # diff_mat：输入样本与每个训练样本的差值,然后对其每个x和y的差值进行平方运算
    sq_diff_mat = diff_mat ** 2
    # 按行进行累加，axis=1表示按行。
    sq_distances = sq_diff_mat.sum(axis=1)
    # 开方运算，求出距离
    distances = sq_distances ** 0.5
    # 返回distances中元素从小到大排序后的索引值
    sorted_dist_indices = distances.argsort()
    # 定一个字典:统计类别次数
    class_count = {}
 
    for i in range(k):
        # 取出前k个元素的类别
        vote_index_label = labels[sorted_dist_indices[i]]
        # 统计类别次数
        class_count[vote_index_label] = class_count.get(vote_index_label, 0) + 1
        # 把分类结果进行降序排序，然后返回得票数最多的分类结果
        sorted_class_count = sorted(class_count.items(), key=operator.itemgetter(1), reverse=True)
        return sorted_class_count[0][0]
 
def file2matrix(filename):
    love_dictionary = {'largeDoses':3, 'smallDoses':2, 'didntLike':1}    # 三个类别
    # 打开文件
    fr = open(filename) 
    # 逐行打开,readlines()方法用于读取所有行(直到结束符 EOF)并返回列表，该列表可以由 Python 的 for... in ... 结构进行处理。
    arrayOLines = fr.readlines() 
    #得到文件的行数
    numberOfLines = len(arrayOLines) 
    #返回numpy矩阵,numberOfLines行，3列的零元素矩阵//初始化特征矩阵
    returnMat = np.zeros((numberOfLines, 3))   
    #返回分类的标签向量//初始化输出标签向量
    classLabelVector = []                     
    #行的索引值
    index = 0
    for line in arrayOLines:
        # 删去字符串首尾空格
        line = line.strip()  
        # 按'\t'对字符串进行分割，listFromLine 是列表
        listFromLine = line.split('\t')   
        #将数据前三列提取出来，存放到returnMat的numpy矩阵中，也就是不含标签变量，只有特征变量。
        # listFromLine的0,1,2元素是特征，赋值给returnMat的当前行
        #一行一行的存储
        returnMat[index, :] = listFromLine[0:3]    
        # 如果listFromLine最后一个元素是数字
        if(listFromLine[-1].isdigit()): 
            # 直接赋值给classLabelVector
            classLabelVector.append(int(listFromLine[-1]))    
        else:   
            # 如果listFromLine最后一个元素不是数字，而是字符串。根据字典love_dictionary转化为数字
            # Python 字典(Dictionary) get() 函数返回指定键的值
            classLabelVector.append(love_dictionary.get(listFromLine[-1]))    
        index += 1
    return returnMat, classLabelVector    # 返回的类别标签classLabelVector是1,2,3
 
def autoNorm(dataSet):
    #获得数据每一列的最小值和最大值
    #b.min(k)就是b.min(axis=k)，就是在他的第k个轴上投影求最小
    minVals = dataSet.min(0)
    maxVals = dataSet.max(0)
    #最大值和最小值的范围
    ranges = maxVals - minVals
    #创建numpy矩阵，里面全是零元素
    normDataSet = np.zeros(np.shape(dataSet))
    #返回dataSet的行数
    m = dataSet.shape[0]
    #原始值减去最小值。np.tile: 重复n次
    normDataSet = dataSet - np.tile(minVals, (m, 1))
    #除以最大和最小值的差，得到归一化的数据
    #normDataSet值被限定在[0,1]之间
    normDataSet = normDataSet/np.tile(ranges, (m, 1))   
    return normDataSet, ranges, minVals
 
def datingClassTest():
    #整个数据集的10%用来测试
    hoRatio = 0.10    
    #导入数据集。将返回的特征矩阵和分类向量分别存储到datingDataMat, datingLabels 
    datingDataMat, datingLabels = file2matrix('C:\\Users\\lenovo\\Desktop\\machinelearninginaction\\Ch02\\datingTestSet.txt')  
    #数据归一化,返回归一化后的矩阵,数据范围,数据最小值
    normMat, ranges, minVals = autoNorm(datingDataMat)  
    #样本个数
    m = normMat.shape[0]   
    #测试样本的个数
    numTestVecs = int(m*hoRatio)    
    #分类错误计数
    errorCount = 0.0
    for i in range(numTestVecs):
        #前numTestVecs个数据作为测试集,后m-numTestVecs个数据作为训练集
        classifierResult = classify0(normMat[i, :], normMat[numTestVecs:m, :], datingLabels[numTestVecs:m], 3)
        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)))    # 打印错误率
 

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('C:\\Users\\lenovo\\Desktop\\machinelearninginaction\\Ch02\\datingTestSet.txt')
    # 读取数据,输出样本矩阵和类标签向量
    normMat, ranges, minVals = autoNorm(datingDataMat)  # 转换成归一化特征值
    inArr = np.array([ffMiles, percentTats, iceCream, ]) # 待分类特征向量
    classifierResult = classify0((inArr -  minVals)/ranges, normMat, datingLabels, 3)
    #归一化的待分类特征向量，归一化的训练特征向量以及标签
    print('you will probably like this person: ', resultList[classifierResult - 1])
 
classifyPerson()

（样例1）运行结果如下：
在这里插入图片描述
（样例2）运行结果如下：

2. 手写体识别

2.1 训练数据和测试数据

训练数据和测试数据文件：

其中trainingDigits文件中包含了2000个训练数据（其中每个数字有200个训练模型），testDigits文件中包含了大约900个待测试数据。

2.2 实现代码

手写体识别代码实现：

import operator
from numpy import *
from os import listdir
from PIL import Image

"""
函数说明：将图像向量由 32x32 转为 1x1024
Parameters：
    filename - 文件路径
Returns：
    32*32 大小的图像
"""
def img2vector(filename):
    returnVect = zeros((1, 1024))
    fr = open(filename)
    for i in range(32):
        #---------------------------------------------------------------------#
        # 当执行 readline() 时会扫描文件中的每一个字节，直到找到一个 \n 位置，
        # 然后停止扫描并读取此前的文件内容。并且记录每次调用 readline() 后的文件读取位置，
        # 这样 readline() 下次被调用的时候就会读取下一行
        #---------------------------------------------------------------------#
        lineStr = fr.readline()
        for j in range(32):
            returnVect[0, 32 * i + j] = int(lineStr[j])
    return returnVect


"""
函数说明：数据分类
Parameters:
    inx - 待分类的数据
    dataSet - 带有标签的数据集
    labels - 数据集对应的标签
    k - 最近邻数据的数量
Returns:
    分类后的类别
"""
def classifiy0(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()
    classCount = {}
    # ----------------------------------------#
    # 遍历距离最近的前 k 个样本
    # ---------------------------------------#
    for i in range(k):
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel, 0) + 1

    sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]

"""
函数说明：将彩色图片压缩为 32*32 并转成灰度图片
Parameters：
    originPath - 彩色图片路径
Returns：
    savePath - 彩色图片对应的灰色图片的路径
"""
def transferPic2grey(originPath):
    I = Image.open(originPath)
    # 将图片大小压缩至32×32
    I = I.resize((32, 32))
    # 将图片转换为灰度图片
    L = I.convert('L')
    savePath = originPath.split('.')[-2] + '_grey.jpg'
    L.save(savePath)
    return savePath

"""
函数说明：将灰度图片转换成二进制文件，数字部分用 1 表示，空白部分用 0 表示
Parameters：
    originPath - 原始图片
Returns：
    savePath - 灰度图片对应的二进制文件（.txt）
"""
def transferGrey2binary(originPath):
    im = Image.open(originPath)
    # 修改尾缀
    savePath = originPath.split('.')[-2] + "_.txt"
    fh = open(savePath, 'w')
    # 32*32
    # 行
    for i in range(im.size[1]):
        # 列
        for j in range(im.size[0]):
            color = im.getpixel((j, i))
            if color > 100:
                color = 0
            else:
                color = 1
            fh.write(str(color))

        fh.write('\n')

    fh.close()
    return savePath

"""
函数说明：手写识别的测试代码
"""
def handwritingClassTest():
    hwLabels = []
    # 获取目录内容
    trainingFileList = listdir(path='D:\\桌面\\machinelearninginaction\\Ch02\\digits\\trainingDigits')
    m = len(trainingFileList)
    trainingMat = zeros((m, 1024))
    for i in range(m):
        fileNameStr = trainingFileList[i]
        fileStr = fileNameStr.split('.')[0]
        classNumStr = int(fileStr.split('_')[0])
        hwLabels.append(classNumStr)
        # 将图像大小由 32x32 转为 1x1024，每行存储一张 1*1024 大小的图片
        trainingMat[i, :] = img2vector('D:\\桌面\\machinelearninginaction\\Ch02\\digits\\trainingDigits\\%s' % fileNameStr)

    testFileList = listdir(path='D:\\桌面\\machinelearninginaction\\Ch02\\digits\\testDigits')
    # 错误个数计数器
    errorCount = 0.0
    mTest = len(testFileList)

    # 从测试数据中提取数据
    for i in range(mTest):
        fileNameStr = testFileList[i]
        fileStr = fileNameStr.split('.')[0]
        classNumStr = int(fileStr.split('_')[0])
        # 将图像大小由 32x32 转为 1x1024
        vectorUnderTest = img2vector('D:\\桌面\\machinelearninginaction\\Ch02\\digits\\testDigits\\%s' % fileNameStr)
        classifierResult = classifiy0(vectorUnderTest, trainingMat, hwLabels, 3)
        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)))

"""
函数说明：实际手写数字的识别测试
"""
def myHandwritingClassTest():
    hwLabels = []
    # 获取目录内容
    trainingFileList = listdir(path='D:\\桌面\\machinelearninginaction\\Ch02\\digits\\trainingDigits')
    m = len(trainingFileList)
    trainingMat = zeros((m, 1024))
    for i in range(m):
        fileNameStr = trainingFileList[i]
        fileStr = fileNameStr.split('.')[0]
        classNumStr = int(fileStr.split('_')[0])
        hwLabels.append(classNumStr)
        # 将图像大小由 32x32 转为 1x1024，每行存储一张 1*1024 大小的图片
        trainingMat[i, :] = img2vector('D:\\桌面\\machinelearninginaction\\Ch02\\digits\\trainingDigits\\%s' % fileNameStr)

    # 图像大小压缩为 32*32 并转为灰色图片
    imgPath = transferPic2grey("D:\\桌面\\6.jpg")
    # 图像转为二进制文件
    imgPath = transferGrey2binary(imgPath)
    vectorUnderTest = img2vector(imgPath)
    classifierResult = classifiy0(vectorUnderTest, trainingMat, hwLabels, 3)
    print("the recognition result is: {}".format(classifierResult))

# handwritingClassTest()
myHandwritingClassTest()

运行结果（局部）：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HJpKYfrz-1679298648933)(images/2021-10-05_7e037a9f-92b3-4145-91a2-bd8556f12bdc.png)]

2.3 代码分析

img2vector(filename)函数用于将32*32的二进制图像矩阵转换为1*1024的向量，便于后面的距离计算，函数classifiy0(inX, dataSet, labels, k)是一个分类器，用于计算测试矩阵与训练矩阵之间的欧式距离并返回待分类数据的类别，函数handwritingClassTest()用于解析文件数据并输出待测试数据的识别结果。
由运行结果可知手写体识别的错误率大概为1.06%，此概率受k值、训练样本数量、测试数据集的影响。

2.4 测试自己手写数字的识别效果

传入手写数字
利用transferPic2grey()函数将图像大小压缩为 32*32 并转为灰色图片
利用transferGrey2binary()函数将图像转为二进制文件
利用img2vector()函数将图像大小由 32x32 转为 1x1024

运行myHandwritingClassTest()后的结果：

the recognition result is: 6

结果识别正确。

3. 总结

从以上实例中可以发现KNN算法的基本思路是将测试样本通过算法在训练样本中预测其类别，其预测精度受多方面因素的影响，例如训练数据的正确性和规模、算法的实现过程、参数值k的选取等等。KNN算法的识别过程相当于蛮力识别，因为每个测试向量都要对训练集里的每一个数据进行距离运算，实际运用时可以发现其执行效率并不高。但是KNN算法的实现思路较为清晰、易于理解，对刚接触图像识别的新手提供了一个清晰直观的思路，同时也能为后续的算法提供很多实用性的方法。