python——KNN

实例：

电影名称	打斗次数	接吻次数	电影类型
California Man	3	104	Romance
He's Not Really into Dudes	2	100	Romance
Beautiful Woman	1	81	Romance
Kevin Longblade	101	10	Action
Robot Slayer 3000	99	5	Action
Amped II	98	2	Action
未知	18	90	Unknown

题目：根据前几个电影的数据，预测未知电影的类型。

关于衡量距离的方法：

 

未知电影到底属于哪种类型，就需要计算G点到A、B、C、D、E、F点的距离

点	X坐标	Y坐标	点类型
A点	3	104	Romance
B点	2	100	Romance
C点	1	81	Romance
D点	101	10	Action
E点	99	5	Action
F点	98	2	Action
G点	18	90	Unknown

例如计算A和G之间的距离：

import math
def ComputeEuclidearDistance(x1,y1,x2,y2):
    d = math.sqrt(math.pow((x1 - x2), 2) + math.pow((y1 - y2), 2))  #距离公式
    return d
d_ag = ComputeEuclidearDistance(3, 104, 18, 90)    #A和G之间的距离
d_bg = ComputeEuclidearDistance(2, 100, 18, 90)    #B和G之间的距离
d_cg = ComputeEuclidearDistance(1, 81, 18, 90)     #C和G之间的距离
d_dg = ComputeEuclidearDistance(101, 10, 18, 90)   #D和G之间的距离
d_eg = ComputeEuclidearDistance(99, 5, 18, 90)     #E和G之间的距离
d_fg = ComputeEuclidearDistance(98, 2, 18, 90)     #F和G之间的距离
print(d_ag, '\n', d_bg, '\n', d_cg, '\n', d_dg, '\n', d_eg, '\n', d_fg)

结果为：

20.518284528683193
18.867962264113206
19.235384061671343
115.27792503337315
117.41379816699569
118.92854997854805

此时选取3(K值)个距离最小的值，就是A、B、C，而A、B、C都是Romance，所以G属于Romance类型，若A、B、C类型不同，则按少数服从多数的原则来判别。

算法优点：简单、易于理解，容易实现、通过K的选择课具备丢噪音数据的健壮性

缺点：计算复杂度高、所需存储空间大，当样本分布不平衡时，预测结果不准

改进：距离上加权重（1/d，d为距离）

用KNN预测鸢尾花的类别：

from sklearn import  neighbors
from sklearn import datasets

knn = neighbors.KNeighborsClassifier()   #导入knn分类器

iris = datasets.load_iris()
#加载数据，数据是字典{'data':array(150,4),'target': array(150,1),'target_names': array(3,1)}
# 共3类（iris-setosa, iris-versicolour, iris-virginica）
# 150个花，每个花包含（花萼长度、花萼宽度、花瓣长度、花瓣宽度）4个属性
print(iris)

knn.fit(iris.data,iris.target)

predictedlabel = knn.predict([[0.1, 0.2, 0.3, 0.4]])   #预测参数为[0.1, 0.2, 0.3, 0.4]的花的类别

print(predictedlabel)

结果为 0，即属于第一种

自己编写KNN识别鸢尾花：

此处要用到鸢尾花的数据，将其转化为txt格式（单独的txt文件下载地址：https://download.csdn.net/download/qq_42006303/11523094）

格式如图所示：

 

 

代码：

import csv
import random
import math
import operator
# from sklearn import datasets

def LoadDataset(filename, split, trainingSet = [], testSet = []):   #加载数据
    #split将数据集分为训练集和测试集
    with open(filename,"rt", encoding="utf-8") as csvfile:
        lines = csv.reader(csvfile)   #读行
        dataset = list(lines)         #将其按行转化为列表
        # print('dataset',dataset)
        # print(len(dataset))
        for x in range(len(dataset) - 1):    #len(dataset)=150
            for y in range(4):
                dataset[x][y] = float(dataset[x][y])    # float() 函数用于将dataset中的整数和字符串转换成浮点数
            if random.random() < split:    #random.random()随机产生一个[0,1)之间的数（共产生150个），小于split的是训练集否则是测试集,此处split=0.67
                trainingSet.append(dataset[x])
                # print(random.random())
            else:
                testSet.append(dataset[x])

def euclideanDistance(instance1, instance2, length):  #计算距离，所有维度，instance1, instance2分别代表两个样本的参数
    distance = 0
    for x in range(length):
        distance += pow((instance1[x] - instance2[x]), 2)      #所有对应参数差的平方之和,共有length=4组参数
    return math.sqrt(distance)                #开二次方，计算距离

def getNeighbors(trainingSet, testInstance, k):   #返回最近的K个邻居
    distances = []
    length = len(testInstance) - 1
    # print('length',length)
    for x in range(len(trainingSet)):
        dist = euclideanDistance(testInstance, trainingSet[x], length)    #计算测试数据和所有训练数据距离
        distances.append((trainingSet[x], dist))          #将计算的距离依次写入distances
    distances.sort(key=operator.itemgetter(1))            #距离由小到大排序
    # print(distances)
    neighbors = []
    for x in range(k):
        neighbors.append(distances[x][0])          #取距离最小的前三个作为邻居
    # print(neighbors)
    return neighbors

def getResponse(neighbors):   #根据少数服从多数预测数据归于哪一类
    classVotes = {}
    for x in range(len(neighbors)):
        response = neighbors[x][-1]   #统计邻居中的标签
        # print(response)
        if response in classVotes:
            classVotes[response] += 1  #若某邻居标签在classVotes中，该标签个数加1
        else:
            classVotes[response] = 1   #若某邻居标签不在classVotes中，该标签个数为1
    sorteVotes = sorted(classVotes.items(), key=operator.itemgetter(1), reverse=True)  #对classVotes中的key按降序排列
    return sorteVotes[0][0]        #返回标签

def getAccuracy(testSet, predictions):   #计算准确率
    correct = 0
    for x in range(len(testSet)):
        if testSet[x][-1] == predictions[x]:      #若预测值和真实值相同则correct加1
            correct += 1
    return (correct/float(len(testSet))) * 100.0     #转化为百分数

def main():
    trainingSet=[]
    testSet=[]
    split = 0.67
    LoadDataset(r'./iris.txt', split, trainingSet, testSet)   #加载数据，并分为训练集和测试集
    print('Train set:' + repr(len(trainingSet)))
    print('Test set:' + repr(len(testSet)))

    predictions=[]
    k=3  #3个邻居
    for x in range(len(testSet)):
        neighbors = getNeighbors(trainingSet, testSet[x], k)
        result = getResponse(neighbors)
        predictions.append(result)
        print('>predicted='+repr(result)+', actual='+repr(testSet[x][-1]))
    accuracy = getAccuracy(testSet, predictions)
    print('Accuracy:'+repr(accuracy)+'%')

if __name__ == '__main__':
    main()

完整程序和数据集：https://download.csdn.net/download/qq_42006303/11523096