python_机器学习_最临近规则分类（K-Nearest Neighbor）KNN算法

1. 概念：

https://scikit-learn.org/stable/modules/neighbors.html

　　1. Cover和Hart在1968年提出了最初的临近算法

　　2. 分类算法（classification）

　　3. 输入基于实例的学习（instance-based leaning）。懒惰学习（lazy learning）

　　开始时候不广泛建立模型，在归类的时候才分类

2. 例子：

3. 算法详述

 

 1. 步骤：

　　为了判断未知实例的类别，以所有已知类别的实例作为参照

　　选择参数K

　　计算未知实例与所有已知实例的距离

　　选择最近K个已知实例  ---》 通常是奇数，更好的选择

　　根据少数服从多数的投票法则， 让未知实例归类为K个最邻近样本肿最多数的类别

2. 细节：

　　关于K

　　关于距离的衡量方法：

　　　　1). Euclidean Distance定义

　　　　　　

 

3. 举例：

 

 

4. 算法优缺点

 1.  算法优点：

　　简单

　　易于理解

　　容易实现

　　通过对K的选择可具备丢噪音数据的健壮性

2. 算法缺点

　　

需要大量空间存储所有已知实例

算法复杂度高（需要比较所有已知实例与要分类的实例）

 

比如Y那个点属于不平衡，属于短板

当其样本分布不平衡时， 比如其中一类样本过大（实例数量过多）占主导的时候， 新的未知实例容易被分类为这个主导样本， 因为这类样本实例的数量过大，但这个新的

未知实例并没有接近目标样本

5. 改进版本

 考虑距离， 根据距离增加权重

比如1/d（d：距离）

 

6. 应用

虹膜花数据集介绍

 

 

 python3.6.3

# -*- coding:utf-8 -*-

from sklearn import neighbors
from sklearn import datasets

knn = neighbors.KNeighborsClassifier()
# 返回一个数据库 iris ---> 默认的参数
#  'filename': 'C:\\python3.6.3\\lib\\site-packages\\sklearn\\datasets\\data\\iris.csv'
iris = datasets.load_iris()

print(iris)

# 模型建立
# data为特征值
# target 为向量，每一行对应的分类，一维的模型
knn.fit(iris.data, iris.target)
# 预测
predictedLabel = knn.predict([[0.1, 0.2, 0.3, 0.4]])
print("===========================\n\n\n\n\n\n\n")
# [0] 属于第一类花的名字
#  'target_names': array(['setosa', 'versicolor', 'virginica']
print(predictedLabel)

 

模拟过程自己封装--》不是我写的，是我抄的--》代码也没测试

# -*- coding:utf-8 -*-

import csv
import random
import math
import operator

def loadDataset(filename, split, trainingSet=[], testSet=[]):
    with open(filename, 'rb') as csvfile:
        lines = csv.reader(csvfile)
        dataset = list(lines)
        for x in range(len(dataset) -1 ):
            for y  in range(4):
                dataset[x][y] = float(dataset[x][y])
            if random.random() < split:
                trainingSet.append(dataset[x])
            else:
                testSet.append(dataset[x])

def euclideanDistance(instance1, instance2, length):
    distance = 0
    for x in range(length):
        distance += pow((instance1[x] - instance2[x]), 2)
    return math.sqrt(distance)

def getNeighbors(trainingSet, testInstance, k):
    distance = []
    length = len(testInstance) -1
    for x in range(len(trainingSet)):
        dist = euclideanDistance(testInstance, trainingSet[x], length)
        distance.append((trainingSet[x], dist))
    distance.sort(key=operator.itemgetter(1))
    neighbors = []
    for x in range(k):
        neighbors.append(distance[x][0])
    return neighbors

def getResponse(neighbors):
    classVotes = {}
    for x in range(len(neighbors)):
        response = neighbors[x][-1]
        if response in classVotes:
            classVotes[response] += 1
        else:
            classVotes[response] = 1
    sortedVotes = sorted(classVotes.iteritems(), key=operator.itemgetter(1), reverse=True)
    return sortedVotes[0][0]

def getAccuracy(testSet, predictions):
    correct = 0
    for x in range(len(testSet)):
        if testSet[x][-1] == predictions[x]:
            correct += 1
    return (correct/float(len(testSet))) * 100.0

def main():
    trainingSet = []
    testSet = []

    split = 0.57
    loadDataset(r"...", split, trainingSet)

    print "Train set: " + repr(len(trainingSet))
    print "Train set: " + repr(len(testSet))

    predictions = []
    k = 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) + "%")


main()