kNN完整代码

超、凢脫俗 2023-06-13 14:26 2阅读 0赞

## 完整代码 ##

#!/usr/bin/env python
    # coding: utf-8
    from __future__ import print_function
    from numpy import *
    import operator
    from os import listdir
    from collections import Counter
    
    def file2matrix(filename):
        """
        Desc:
            导入训练数据
        :param filename:数据文件路径
        :return: 数据矩阵 returnMat 和对应的类别 classLabelVector
        """
    
        fr = open(filename)
        # 获得文件中的数据行的行数
        numberOfLines = len(fr.readlines())
        # 生成对应的空矩阵
        returnMat = zeros((numberOfLines, 3))
        classLabelVector = []
        fr = open(filename)
        index = 0
        for line in fr.readlines():
            line = line.strip()
            listFromLine = line.split('\t')
            # 每列的属性数据
            returnMat[index, :] = listFromLine[0:3]
            # 每列的类别数据，就是 label 标签数据
            classLabelVector.append(int(listFromLine[-1]))
            index += 1
        # 返回数据矩阵returnMat和对应的类别classLabelVector
        return returnMat, classLabelVector
    
    
    def autoNorm(dataSet):
        """
        归一化特征值，消除属性之间量级不同导致的影响
        :param dataSet: 数据集
        :return: 归一化后的数据集normDataSet,ranges 和 minVals即范围与最小值（没有用到）
    
        归一化公式：
            Y = (X-Xmin)/(Xmax-Xmin)
            其中的 min 和 max 分别是数据集中的最小特征值和最大特征值。该函数可以自动将数字特征值转化为0到1的区间。
        """
    
        # 计算每种属性的最大值、最小值、范围
        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 classify0(inX, dataSet, labels, k):
        """
           inX: 用于分类的输入向量
           dataSet: 输入的训练样本集
           labels: 标签向量
           k: 选择最近邻居的数目
           注意：labels元素数目和dataSet行数相同；程序使用欧式距离公式.
           预测数据所在分类可在输入下列命令
           kNN.classify0([0,0], group, labels, 3)
        """
    
        dataSetSize = dataSet.shape[0]
        # 距离度量 度量公式为欧氏距离
        diffMat = tile(inX, (dataSetSize, 1)) - dataSet
        sqDiffMat = diffMat ** 2  # 取平方
        sqDistances = sqDiffMat.sum(axis=1)  # 将矩阵的每一行相加
        distances = sqDistances ** 0.5  # 开方
        # 将距离排序：从小到大
        # argsort() 是将x中的元素从小到大排列，提取其对应的index（索引），然后输出到y。
        # 例如：y=array([3,0,2,1,4,5]) 则，x[3]=-1最小，所以y[0]=3;x[5]=9最大，所以y[5]=5。
        sortedDistIndicies = distances.argsort()
        # 选取前K个最短距离， 选取这K个中最多的分类类别
        classCount = {
        }
        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]
    
    
    def datingClassTest():
        """
        对约会网站的测试方法
        :return: 错误数
        """
    
        # 设置测试数据的的一个比例（训练数据集比例=1-hoRatio）
        hoRatio = 0.1  # 测试范围,一部分测试一部分作为样本
        # 从文件中加载数据
        datingDataMat, datingLabels = file2matrix('datingTestSet2.txt')  # load data setfrom file
        # 归一化数据
        normMat, ranges, minVals = autoNorm(datingDataMat)
        # m 表示数据的行数，即矩阵的第一维
        m = normMat.shape[0]
        # 设置测试的样本数量， numTestVecs:m表示训练样本的数量
        numTestVecs = int(m * hoRatio)
        print('numTestVecs=', numTestVecs)
        errorCount = 0.0
        for i in range(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: %0.3f" % (errorCount / float(numTestVecs)))
        print("the total number of errors is: %0.1f" % 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 filer miles earned per year?'))
        iceCream = float(input("liters of ice cream consumed per year?"))
        datingDataMat, datingLabels = file2matrix('datingTestSet2.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):
        """
        将图像文本数据转换为向量
        :param filename:数据文件路径
        :return:数据矩阵 一维矩阵
        该函数将图像转换为向量：该函数创建 1 * 1024 的NumPy数组，然后打开给定的文件，
        循环读出文件的前32行，并将每行的头32个字符值存储在NumPy数组中，最后返回数组。
        """
    
        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():
        # 导入训练数据
        hwLabels = []
        trainingFileList = listdir('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)
            trainingMat[i, :] = img2vector('trainingDigits/%s' % fileNameStr)
    
        # 导入测试数据
        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)
            classifierResult = classify0(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('\n the total number of errors is:%d' % errorCount)
        print('\n the total error rate is:%f' % (errorCount / float(mTest)))
    
    
    if __name__ == '__main__':
        #datingClassTest()
        classifyPerson()
        #handwritingClassTest()