K近邻（KNN）算法

K近邻算法用官方的话来说，所谓K近邻算法，即是给定一个训练数据集，对新的输入实例，在训练数据集中找到与该实例最邻近的K个实例（也就是上面所说的K个邻居）， 这K个实例的多数属于某个类，就把该输入实例分类到这个类中。

下面通过一个简单的例子说明一下：如下图，绿色圆要被决定赋予哪个类，是红色三角形还是蓝色四方形？如果K=3，由于红色三角形所占比例为2/3，绿色圆将被赋予红色三角形那个类，如果K=5，由于蓝色四方形比例为3/5，因此绿色圆被赋予蓝色四方形类。

按照《机器学习实战》的给出的代码，从最基础的部分开始,首先编写KNN.py文件，它负责生成训练样本以及实施KNN算法

'''

KNN
'''
#coding:utf-8

from numpy import *
import operator

def createDataSet():
    group = array([[1.0, 1.1], [1.0, 1.0], [0, 0], [0, 0.1]])
    lables = ['A', 'A', 'B', 'B']
    return group, lables

def  classify0(inX, dataSet, lables, k):
    dataSetSize = dataSet.shape[0] '''获取训练样本数'''
    '''开始计算测试样本和训练样本的欧式距离'''
    diffMat = tile(inX, (dataSetSize,1)) - dataSet '''将测试样本重复dataSetSize次，以生成和训练样本一样的矩阵，并与训练样本做差'''
    sqDiffMat = diffMat**2
    sqDistance = sqDiffMat.sum(axis=1)
    distance = sqDistance**0.5
    sortedDistanceIndex=distance.argsort() '''将计算出的距离从小到大排序，返回每个元素在原数组中的索引值'''
    classCount={} '''储存结果字典'''
    for i in range(k):
        voteIlabel=lables[sortedDistanceIndex[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0)+1
    sortedClassCount = sorted(classCount.iteritems(), key= operator.itemgetter(1), reverse= True)
    return sortedClassCount[0][0]

group , lables=createDataSet ()
print classify0([0,0], group, lables, 3)

运行代码后就会打印出 B

接下来的例子为使用K近邻算法改进约会网站的配对效果

假设根据每个人玩游戏所占的时间比，每年获得的飞行常客里程数，每周所消费的冰淇淋公升数这三个数据根据一定情况划分为三类人

一点也不喜欢,有一丢丢喜欢,灰常喜欢

如

玩游戏所占的时间比	每年获得的飞行常客里程数	每周所消费的冰淇淋公升数	分类
0.8	400	0.5	一点也不喜欢
12	134000	0.9	灰常喜欢

from numpy import *
import operator
import matplotlib
import matplotlib.pyplot as plt
from os import listdir

def createDataSet():
    group = array([[1.0, 1.1], [1.0, 1.0], [0, 0], [0, 0.1]])
    lables = ['A', 'A', 'B', 'B']
    return group, lables

def  classify0(inX, dataSet, lables, k):
    dataSetSize = dataSet.shape[0] ##获取训练样本数
    ##开始计算测试样本和训练样本的欧式距离'''
    diffMat = tile(inX, (dataSetSize,1)) - dataSet ##将测试样本重复dataSetSize次，以生成和训练样本一样的矩阵，并与训练样本做差'''
    sqDiffMat = diffMat**2
    sqDistance = sqDiffMat.sum(axis=1)
    distance = sqDistance**0.5
    sortedDistanceIndex=distance.argsort() ##将计算出的距离从小到大排序，返回每个元素在原数组中的索引值'''
    classCount={} ##储存结果字典'''
    for i in range(k):
        voteIlabel=lables[sortedDistanceIndex[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0)+1
    sortedClassCount = sorted(classCount.iteritems(), key= operator.itemgetter(1), reverse= True)
    return sortedClassCount[0][0]

def fileToMatrix(filename):
    fr = open(filename) ##打开文件
    arrayOLines = fr.readlines() ##读取文件 
    numberOfLines = len(arrayOLines) ##获取文件行数
    returnMat = zeros((numberOfLines,3)) ##生成numberOfLines行3列的矩阵
    classLabelVector = []  ##存放分类信息
    index = 0
    for line in arrayOLines:  ##读取文件的每一行
        line =line.strip()  ##去掉\n
        listFromLine = line.split('\t') ##数据按\t分割成数组
        returnMat[index, :] = listFromLine[0 : 3]  ##复制数据到矩阵
        classLabelVector.append(int (listFromLine[-1]))  ##添加分类信息数据
        index +=1
    return returnMat, classLabelVector

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

def datingClassTest():##使用样本测试
    hoRatio = 0.1
    datingDataMat, datingLables = fileToMatrix("datingTestSet2.txt")
    normMat ,ranges ,minVals =autoNorm(datingDataMat)
    m = normMat.shape[0]
    numTestVecs = int(m*hoRatio)
    errorCount = 0
    for i in range(numTestVecs):
        classifierResult = classify0(normMat[i, :], normMat[numTestVecs:m, :],datingLables[numTestVecs: m],3)
        print "Classifer Result  :   %d , Corret Result  :   %d"%(classifierResult, datingLables[i])
        if(classifierResult != datingLables[i]):
            errorCount +=1
    print "Error Rate :  %f"%(errorCount/float(numTestVecs))
##group , lables=createDataSet ()
##print classify0([0,0], group, lables, 3)

###预测函数
def classifyPerson():
    resultList = [u'一点也不喜欢',u'有一丢丢喜欢',u'灰常喜欢']
    percentTats = float(input(u"玩视频所占的时间比?".encode("GBK")))
    miles = float(input(u"每年获得的飞行常客里程数?".encode("GBK")))
    iceCream = float(input(u"每周所消费的冰淇淋公升数?".encode("GBK")))
    datingDataMat,datingLabels = fileToMatrix("datingTestSet2.txt")
    normMat,ranges,minVals = autoNorm(datingDataMat)
    inArr = array([miles,percentTats,iceCream])
    classifierResult = classify0((inArr-minVals)/ranges,normMat,datingLabels,3)
    print u"你对这个人的喜欢程度:".encode("GBK"),resultList[classifierResult - 1].encode("GBK")

datingClassTest()
classifyPerson()

最后一个例子为手写数字识别系统的测试系统

这个例子里首先有训练好的数据集，用这些数据集检测测试数据集

from numpy import *
import operator
import matplotlib
import matplotlib.pyplot as plt
from os import listdir

def createDataSet():
    group = array([[1.0, 1.1], [1.0, 1.0], [0, 0], [0, 0.1]])
    lables = ['A', 'A', 'B', 'B']
    return group, lables

def  classify0(inX, dataSet, lables, k):
    dataSetSize = dataSet.shape[0] ##获取训练样本数
    ##开始计算测试样本和训练样本的欧式距离'''
    diffMat = tile(inX, (dataSetSize,1)) - dataSet ##将测试样本重复dataSetSize次，以生成和训练样本一样的矩阵，并与训练样本做差'''
    sqDiffMat = diffMat**2
    sqDistance = sqDiffMat.sum(axis=1)
    distance = sqDistance**0.5
    sortedDistanceIndex=distance.argsort() ##将计算出的距离从小到大排序，返回每个元素在原数组中的索引值'''
    classCount={} ##储存结果字典'''
    for i in range(k):
        voteIlabel=lables[sortedDistanceIndex[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0)+1
    sortedClassCount = sorted(classCount.iteritems(), key= operator.itemgetter(1), reverse= True)
    return sortedClassCount[0][0]

''' 以下两个函数为手写数字识别系统的测试系统的相关代码'''

def imgToVector(filename):##将32*32文本的txt文件读入并保存为1*1024的一维矩阵
    returnVect = zeros((1,1024))
    fr = open(filename)
    for i in range(32):
         lineStr = fr.readline()
         for j in range(32):
             a= returnVect[0,32*i+j]
             b= int(lineStr[j])
             returnVect[0,32*i+j] = int(lineStr[j])
            
    return returnVect

def handwritingClassTest():
    hwLabels = []
    trainingFileList = listdir('trainingDigits')           #load the training set
    m = len(trainingFileList)
    trainingMat = zeros((m,1024))
    for i in range(m):
        fileNameStr = trainingFileList[i]
        fileStr = fileNameStr.split('.')[0]     #take off .txt
        classNumStr = int(fileStr.split('_')[0])
        hwLabels.append(classNumStr)
        trainingMat[i,:] = imgToVector('trainingDigits/%s' % fileNameStr)
    testFileList = listdir('testDigits')        #iterate through the test set
    errorCount = 0.0
    mTest = len(testFileList)
    for i in range(mTest):
        fileNameStr = testFileList[i]
        fileStr = fileNameStr.split('.')[0]     #take off .txt
        classNumStr = int(fileStr.split('_')[0])
        vectorUnderTest = imgToVector('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 "\nthe total number of errors is: %d" % errorCount
    print "\nthe total error rate is: %f" % (errorCount/float(mTest))

handwritingClassTest()

可以看到分类的结果，其中有11个分类错误