python3 KNN代码详细注释
KNN注释：该算法思路简单，准确度也还不错；就是维度高，样本量大的时候计算量很大。
'''
Created on 2018 09 30
kNN: k Nearest Neighbors
Input: inX: vector to compare to existing dataset (1xN)
dataSet: size m data set of known vectors (NxM)
labels: data set labels (1xM vector)
k: number of neighbors to use for comparison (should be an odd number)
Output: the most popular class label
@author: cocoleYY
'''
#导入包
import numpy as np
import operator
from os import listdir
def classify0(inX, dataSet, labels, k):
'用已知数据集dataSet&labels预测未知数据集inX分类，投票数量为k'
dataSetSize = dataSet.shape[0] #取行数
diffMat = np.tile(inX, (dataSetSize, 1)) - dataSet #构造和dataSet形状相同的数组，并求两者间差值；即待测点与所有已知点的向量差。
sqDiffMat = diffMat**2 #上面向量差的平方
sqDistances = sqDiffMat.sum(axis=1) #上面平方值，在行的方向的求和，即L2距离的平方
distances = sqDistances**0.5 #上面结果的开方，即L2 欧氏距离
sortedDistIndicies = distances.argsort() #对上面所求距离，顺序排列，返回索引值
classCount = {} #创建空字典
for i in range(k):
'统计出前k个最小距离所覆盖的点，所对应的类别标签数量'
voteIlabel = labels[sortedDistIndicies[i]] #当前距离点，所对应的标签
classCount[voteIlabel] = classCount.get(voteIlabel, 0) + 1 #将该标签数量写入字典，注：get函数中的0为初始值
sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True) #指定key为字典的值，并以此逆向排序；
return sortedClassCount[0][0] #第一行第一列，即数量最多的标签
def createDataSet():
'创建数据组合标签，并返回'
group = np.array([[1.0, 1.1], [1.0, 1.0], [0, 0], [0, 0.1]])
labels = ['A', 'A', 'B', 'B']
return group, labels
def file2matrix(filename):
'文本数据转变成数据矩阵'
love_dictionary = {'largeDoses':3, 'smallDoses':2, 'didntLike':1} #声明喜欢程度的数值
fr = open(filename) #打开文件
arrayOLines = fr.readlines() #按行读取
numberOfLines = len(arrayOLines) #获取该文件行数
returnMat = np.zeros((numberOfLines, 3)) #初始化全0矩阵，形状同样本数据
classLabelVector = [] #初始化列表，用来存储类别标签
index = 0
for line in arrayOLines:
line = line.strip() #去掉每行数据的两端空格
listFromLine = line.split('\t') #分隔每一行数据，即将三个变量返回到一个列表中
returnMat[index, :] = listFromLine[0:3] #将上述列表中的值，填充到上文所初始化的全0数组矩阵中
if(listFromLine[-1].isdigit()): #判定条件为，上述所得列表最后一个元素，是否为数值型
classLabelVector.append(int(listFromLine[-1])) #将上述所得列表最后一个元素转化为整型，追加到上文所初始化的类别标签列表
else:
classLabelVector.append(love_dictionary.get(listFromLine[-1])) #不然的话，我们去love_dictionary寻找listFromLine所对应的喜好程度数值标签
index += 1
return returnMat, classLabelVector 返回数据矩阵，类别标签列表
def autoNorm(dataSet):
'该函数为数据标准化处理函数'
minVals = dataSet.min(0) #获取每一列最小值
maxVals = dataSet.max(0) #获取每一列最大值
ranges = maxVals - minVals #求极差
normDataSet = np.zeros(np.shape(dataSet)) #初始化一个dataSet形状相同的全0数组
m = dataSet.shape[0] #获取dataSet行数
normDataSet = dataSet - np.tile(minVals, (m, 1)) #将dataSet每个元素减去所对应列的最小值
normDataSet = normDataSet/np.tile(ranges, (m, 1)) #将上述求得的数组中每个元素除以所对应列的极差，即完成标准化处理过程
return normDataSet, ranges, minVals #返回标准化数据，极差，最小值
def datingClassTest():
'用约会网站数据，验证分类模型错误率'
hoRatio = 0.50 #hold out 10%
datingDataMat, datingLabels = file2matrix('datingTestSet2.txt') #加载数据
normMat, ranges, minVals = autoNorm(datingDataMat) #标准化数据
m = normMat.shape[0] #获取行数
numTestVecs = int(m*hoRatio) #声明测试数据的行数
errorCount = 0.0
for i in range(numTestVecs):
classifierResult = classify0(normMat[i, :], normMat[numTestVecs:m, :], datingLabels[numTestVecs:m], 3) #用normMat的后50%预测前50%的类别标签
print("the classifier came back with: %d, the real answer is: %d" % (classifierResult, datingLabels[i]))
if (classifierResult != datingLabels[i]): errorCount += 1.0 #若预测和实际值不同，累计errorCount，即分类错误的数量
print("the total error rate is: %f" % (errorCount / float(numTestVecs))) #打印测试数据，错误率
print(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 flier 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 = np.array([ffMiles, percentTats, iceCream, ])
classifierResult = classify0((inArr - \
minVals)/ranges, normMat, datingLabels, 3) #分类训练
print("You will probably like this person: %s" % resultList[classifierResult - 1]) #打印结果
def img2vector(filename):
returnVect = np.zeros((1, 1024)) #初始化1X1024的全0数组，用来存储图片数据
fr = open(filename) #打开文件
for i in range(32):
lineStr = fr.readline() #逐行读取文件
for j in range(32):
returnVect[0, 32*i+j] = int(lineStr[j]) #将32X32的图片数据，铺平填充到上述初始化的1X1024数组中
return returnVect #返回转化后的图片数据
def handwritingClassTest():
hwLabels = [] #初始化手写数据标签
trainingFileList = listdir('trainingDigits') #列举文件夹中所有训练数据的文件名，返回到列表
m = len(trainingFileList) #获取训练数据的数量
trainingMat = np.zeros((m, 1024)) #初始化训练数据的数组矩阵
for i in range(m):
fileNameStr = trainingFileList[i] #第i个图片名字
fileStr = fileNameStr.split('.')[0] #.分隔，取第一个
classNumStr = int(fileStr.split('_')[0]) #_分隔，去第一个，即该数据文件对应的数字
hwLabels.append(classNumStr) #追加到类别标签列表
trainingMat[i, :] = img2vector('trainingDigits/%s' % fileNameStr) #将第i个图片数据填充到训练数据矩阵
testFileList = listdir('testDigits') #列举测试数据，将测试图片数据的文件名称返回到列表
errorCount = 0.0
mTest = len(testFileList) #测试图片数据的个数
for i in range(mTest):
fileNameStr = testFileList[i] #以下三行是获取第i个测试图片数据的实际数字
fileStr = fileNameStr.split('.')[0]
classNumStr = int(fileStr.split('_')[0])
vectorUnderTest = img2vector('testDigits/%s' % fileNameStr) #加载测试图片数据，格式1X1024
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))) #打印测试图片的分类错误率