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()