机器学习实战_Python3.7_kNN算法

使用 Python3.7 编译，代码与书中类似，修改了 python2 被淘汰的语法，附详细注解。

kNN算法原理非常简单，无需赘述，缺点主要是运行速度。

这里使用的方法全都是矩阵结构，全局遍历，没有用到高级数据结构，运行效率较低，但是实现简单。

重点学习 Python 和 Numpy 的基本语法（列表、矩阵操作）以及基本的文件操作。

---

基本算法

from numpy import *
#程序中 array、shape、tile、** 等需要
import operator
#程序中 itemgetter 需要

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 classify0(inX,dataSet,labels,k):
    #获取 dataSet 的数据个数，其中 .shape[0] 用于获取二维数组第一维度的长度
    dataSetSize = dataSet.shape[0]
    #利用 tile 函数将 inX 纵向复制成与 dataSet 同样大小的矩阵，与 dataSet 做矩阵减法
    diffMat = tile(inX, (dataSetSize, 1)) - dataSet
    #矩阵内所有元素求平方
    sqDiffMat = diffMat **2
    #利用 sum 函数将矩阵每行相加，不设置参数 axis 会默认为 0 ，执行每列相加
    sqDistance = sqDiffMat.sum(axis = 1)
    #矩阵内所有元素开方，到这里就得到了全部的欧几里得距离
    distance = sqDistance **0.5
    #利用 argsort 函数获得矩阵中每个元素的排序序号
    sortedDistIndicies = distance.argsort()
    #创建一个空字典
    classCount = {}
    #选取前 k 个最近邻的 label
    for i in range(k):
        #根据前面得到的矩阵元素排序的序号，依次索引出第 i 近邻的数据的 label
        voteIlabel = labels[sortedDistIndicies[i]]
        #利用 get 函数，如果第一次添加这个 label ，get 会返回 0 ，将这个 label 与 1 构建键值对
        #如果是已经添加的 label ，get 会返回当前该 label 的个数，将这个 label 记录的次数再加 1
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
    #利用 items 函数将字典结构转化为列表
    #参数 key 指明了根据那一列元素进行排列
    #参数 reverse 设置为 True ：降序排列
    sortedClassCount = sorted(classCount.items(),key = operator.itemgetter(1),reverse = True)
    return sortedClassCount[0][0]

测试：

inX = [0.1,0.1]
group, labels = createDataSet()
res = classify0(inX, group, labels, 3)
print(res)

执行结果（加入部分中间变量，更清晰的理解程序过程）：

diffMat:
[[-0.9 -1. ]
 [-0.9 -0.9]
 [ 0.1  0.1]
 [ 0.1  0. ]]
distance:
[1.3453624  1.27279221 0.14142136 0.1       ]
sortedDistIndicies:
[3 2 1 0]
classCount:
{'B': 2, 'A': 1}
sortedClassCount:
[('B', 2), ('A', 1)]
B

Process finished with exit code 0

---

示例一：约会网站

from numpy import *
#程序中 array、shape、tile、** 等需要
import operator
#程序中 itemgetter 需要

def classify0(inX,dataSet,labels,k):
    #获取 dataSet 的数据个数，其中 .shape[0] 用于获取二维数组第一维度的长度
    dataSetSize = dataSet.shape[0]
    #利用 tile 函数将 inX 纵向复制成与 dataSet 同样大小的矩阵，与 dataSet 做矩阵减法
    diffMat = tile(inX, (dataSetSize, 1)) - dataSet
    #矩阵内所有元素求平方
    sqDiffMat = diffMat ** 2
    #利用 sum 函数将矩阵每行相加，不设置参数 axis 会默认为 0 ，执行每列相加
    sqDistance = sqDiffMat.sum(axis = 1)
    #矩阵内所有元素开方，到这里就得到了全部的欧几里得距离
    distance = sqDistance ** 0.5
    #利用 argsort 函数获得矩阵中每个元素的排序序号
    sortedDistIndicies = distance.argsort()
    #创建一个空字典
    classCount = {}
    #选取前 k 个最近邻的 label
    for i in range(k):
        #根据前面得到的矩阵元素排序的序号，依次索引出第 i 近邻的数据的 label
        voteIlabel = labels[sortedDistIndicies[i]]
        #利用 get 函数，如果第一次添加这个 label ，get 会返回 0 ，将这个 label 与 1 构建键值对
        #如果是已经添加的 label ，get 会返回当前该 label 的个数，将这个 label 记录的次数再加 1
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
    #利用 items 函数将字典结构转化为列表
    #参数 key 指明了根据那一列元素进行排列
    #参数 reverse 设置为 True ：降序排列
    sortedClassCount = sorted(classCount.items(),key = operator.itemgetter(1),reverse = True)
    return sortedClassCount[0][0]

def file2matrix(filename):
    fr = open(filename)
    #利用 readlines 函数读取文件，得到的格式是以字符串为元素的列表，每个元素对应文件中的一行
    arrayOLines = fr.readlines()
    #利用 len 函数获得列表的元素个数，即文件的行数，即样本数
    numberOfLines = len(arrayOLines)
    #创建用于返回的训练样本矩阵（大小为样本数 * 3 的二维数组）
    returnMat = zeros((numberOfLines, 3))
    #创建用于返回的类标签向量（列表形式）
    classLabelVector = []
    #初始化索引（后续循环需要使用）
    index = 0
    #逐行处理文件中读取的文本数据
    for line in arrayOLines:
        #去掉每行头尾空白，截掉回车符
        line = line.strip()
        #根据 '\t' （Tab）字符进行分割，将每行的 4 个数字以列表形式保存
        listFromLine = line.split('\t')
        #根据 index 将每行的前 3 个数字（特征）依次写入 returnMat 的相应位置
        #因为前面用 zeros 构建二维数组 returnMat，会默认为 float 型，这里写入时会隐式类型转换
        returnMat[index,:] = listFromLine[0:3]
        #将第 4 个元素（label）写入 classLabelVector 的相应位置，并强制转换为 int 型
        classLabelVector.append(int(listFromLine[-1]))
        #更新索引，用于下一次的循环
        index += 1
    return returnMat, classLabelVector

def autoNorm(dataSet):
    #得到每列的最小值（列表形式）
    minVals = dataSet.min(0)
    # 得到每列的最大值（列表形式）
    maxVals = dataSet.max(0)
    #两者相减，得到每列的数据变动范围
    ranges = maxVals - minVals
    #用 zeros 创建一个和 dataSet 大小相同的矩阵
    normDataSet = zeros(shape(dataSet))
    #利用 shape[0] 获取 dataSet 的行数
    m = dataSet.shape[0]
    #归一化处理（使用 tile 函数用于纵向复制）
    normDataSet = dataSet - tile(minVals, (m, 1))
    normDataSet = normDataSet / tile(ranges, (m, 1))
    return normDataSet

def datingClassTest():
    #设置测试集占全部数据集的比率
    hoRatio = 0.03
    #利用前面编写的 file2matrix 函数读入文件并转化数据格式
    datingDataMat, datingLabels = file2matrix('datingTestSet2.txt')
    #利用前面编写的 autoNorm 函数对特征数据进行归一化
    normMat = autoNorm(datingDataMat)
    #利用 shape[0] 得到行数（总数据量）
    m = normMat.shape[0]
    #根据指定的测试集占比计算测试集数据个数
    numTestVecs = int(m * hoRatio)
    #初始化错误率
    errorCount = 0.0
    #对测试集数据逐个进行测试
    for i in range(numTestVecs):
        #利用前面编写的 classify0 函数计算得到分类结果
        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)))

测试：

datingClassTest()

执行结果：

the classifier came back with: 3, the real answer is: 3
the classifier came back with: 2, the real answer is: 2
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 3, the real answer is: 3
the classifier came back with: 3, the real answer is: 3
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 3, the real answer is: 3
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 2, the real answer is: 2
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 2, the real answer is: 2
the classifier came back with: 3, the real answer is: 3
the classifier came back with: 2, the real answer is: 2
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 3, the real answer is: 2
the classifier came back with: 3, the real answer is: 3
the classifier came back with: 2, the real answer is: 2
the classifier came back with: 3, the real answer is: 3
the classifier came back with: 2, the real answer is: 2
the classifier came back with: 3, the real answer is: 3
the classifier came back with: 2, the real answer is: 2
the classifier came back with: 1, the real answer is: 1
the total error rate is: 0.033333

Process finished with exit code 0

---

示例二：手写数字

from numpy import *
#程序中 array、shape、tile、** 等需要
import operator
#程序中 itemgetter 需要
from os import listdir
#用于打开文件夹，并将所有文件的文件名以列表形式保存

def classify0(inX,dataSet,labels,k):
    #获取 dataSet 的数据个数，其中 .shape[0] 用于获取二维数组第一维度的长度
    dataSetSize = dataSet.shape[0]
    #利用 tile 函数将 inX 纵向复制成与 dataSet 同样大小的矩阵，与 dataSet 做矩阵减法
    diffMat = tile(inX, (dataSetSize, 1)) - dataSet
    #矩阵内所有元素求平方
    sqDiffMat = diffMat ** 2
    #利用 sum 函数将矩阵每行相加，不设置参数 axis 会默认为 0 ，执行每列相加
    sqDistance = sqDiffMat.sum(axis = 1)
    #矩阵内所有元素开方，到这里就得到了全部的欧几里得距离
    distance = sqDistance ** 0.5
    #利用 argsort 函数获得矩阵中每个元素的排序序号
    sortedDistIndicies = distance.argsort()
    #创建一个空字典
    classCount = {}
    #选取前 k 个最近邻的 label
    for i in range(k):
        #根据前面得到的矩阵元素排序的序号，依次索引出第 i 近邻的数据的 label
        voteIlabel = labels[sortedDistIndicies[i]]
        #利用 get 函数，如果第一次添加这个 label ，get 会返回 0 ，将这个 label 与 1 构建键值对
        #如果是已经添加的 label ，get 会返回当前该 label 的个数，将这个 label 记录的次数再加 1
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
    #利用 items 函数将字典结构转化为列表
    #参数 key 指明了根据那一列元素进行排列
    #参数 reverse 设置为 True ：降序排列
    sortedClassCount = sorted(classCount.items(),key = operator.itemgetter(1),reverse = True)
    return sortedClassCount[0][0]

def img2vector(filename):
    #将一个手写数字的文件（32 * 32）逐行写入一个 1 * 1024 的矩阵并返回
    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():
    #创建用于保存训练集 label 的空列表
    hwLabels = []
    #利用 listdir 打开训练集文件夹
    trainingFileList = listdir('trainingDigits')
    #获取文件数目（即训练集的样本数）
    m = len(trainingFileList)
    #创建用于保存训练集特征的零矩阵
    trainingMat = zeros((m, 1024))
    #逐个文件读取训练集样本数据
    for i in range(m):
        #获取该样本的文件名，如'0_0.txt'
        fileNameStr = trainingFileList[i]
        #截取 '.' 之前的内容，如'0_0'
        fileStr = fileNameStr.split('.')[0]
        #截取 '_' 之前的内容，如'0'
        classNumStr = int(fileStr.split('_')[0])
        #将最终截取的内容（label）保存到 hwLabels
        hwLabels.append(classNumStr)
        #使用前面编写的 img2vector 函数，将特征信息写入 trainingMat
        trainingMat[i,:] = img2vector('trainingDigits/%s' % fileNameStr)
    #利用 listdir 打开测试集文件夹
    testFileList = listdir('testDigits')
    #初始化错误率
    errorCount = 0.0
    #获取文件数目（即测试集的样本数）
    mTest = len(testFileList)
    #逐个文件读取测试集样本数据
    for i in range(mTest):
        #同上
        fileNameStr = testFileList[i]
        fileStr = fileNameStr.split('.')[0]
        classNumStr = int(fileStr.split('_')[0])
        vectorUnderTest = img2vector('testDigits/%s' % fileNameStr)
        #使用前面编写的 classify0 函数进行分类
        classifierResult = classify0(vectorUnderTest, trainingMat, hwLabels, 3)
        #与示例一相关内容相同
        print("the classifier come 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)))

测试：

handwritingClassTest()

执行结果：

……
the classifier come back with: 1, the real answer is: 1
the classifier come back with: 5, the real answer is: 5
the classifier come back with: 4, the real answer is: 4
the classifier come back with: 3, the real answer is: 3
the classifier come back with: 3, the real answer is: 3

the total number of errors is: 11

the total error rate is: 0.011628

Process finished with exit code 0