机器学习基础之最邻近规则分类算法

算法详述

步骤：

 为了判断未知实例的类别，以所有已知类别的实例作为参照
 选择参数K
 计算未知实例与所有已知实例的距离
 选择最近K个已知实例
 根据少数服从多数的投票法则(majority-voting)，让未知实例归类为K个最邻近样本中最多数的类别

细节:

 关于K
 关于距离的衡量方法:
 属于分类(classification)算法
  输入基于实例的学习(instance-based learning), 懒惰学习(lazy learning）

Euclidean Distance 定义

算法优缺点：

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

需要大量空间储存所有已知实例
算法复杂度高（需要比较所有已知实例与要分类的实例）
当其样本分布不平衡时，比如其中一类样本过大（实例数量过多）占主导的时候，新的未知实例容易被归类为这个主导样本，因为这类样本实例的数量过大，但这个新的未知实例实际并木接近目标样本。

改进版本

  考虑距离，根据距离加上权重
  比如: 1/d (d: 距离）

实例

项目

数据集介绍

150个实例

萼片长度，萼片宽度，花瓣长度，花瓣宽度
(sepal length, sepal width, petal length and petal width）

类别：
Iris setosa, Iris versicolor, Iris virginica.

利用python机器学习的库sklearn:SKLearnExample.py

（1）利用sklearn机器学习的库实现

'''
利用Python中的scikit-learn库进行KNN算法调用
'''
from sklearn import neighbors #导入邻近算法模块
from sklearn import datasets #导入一些数据集
 
knn = neighbors.KNeighborsClassifier() #定义一个KNN算法的分类器
iris = datasets.load_iris() #导入著名的数据集 iris
# print(iris)
 
knn.fit(iris.data,iris.target) #建立模型
pred_label = knn.predict([[0.1,0.2,0.3,0.4]])
print(pred_label)
————————————————
引用原文链接：https://blog.csdn.net/weixin_41790863/article/details/80984262

源代码

opterator库介绍
fopen与文件读写

import csv
import random
import math
import operator

#建立一个拥有这样功能的函数：把文件数据区分成训练集、测试集
def loadDataset(filename, split, trainingSet = [], testSet = []):
    with open(filename, 'rt') as csvfile:
         #返回的可迭代类型,此时reader返回的值是csvfile文件中每行的列表，将每行读取的值作为列表返回
         #list(lines)使得在程序运行时，控制台可以得到数据
        lines = csv.reader(csvfile)
        dataset = list(lines)
         #此时dataset已经有内容，dataset=[['5.1', '3.5', '1.4', '0.2', 'Iris-setosa'], .......]
        for x in range(len(dataset)-1):
            for y in range(4):
                dataset[x][y] = float(dataset[x][y])
                #这时dataset中的数据已改变，dataset=[[5.1, 3.5, 1.4, 0.2, 'Iris-setosa'],.......]
                #random.random() < split是为了随机已split为标尺，划分训练集、测试集
            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)

#取出训练集在k范围内、与测试实例最近的k个向量，邻近算法模块
def getNeighbors(trainingSet, testInstance, k):
    distances = []
    length = len(testInstance)-1
    for x in range(len(trainingSet)):
        # 欧氏距离是一个通常采用的距离定义，它是在m维空间中两个点之间的真实距离。就是上面的一个函数
        dist = euclideanDistance(testInstance, trainingSet[x], length)
        distances.append((trainingSet[x], dist))
        #运行到这时，distances=[([[5.1, 3.5, 1.4, 0.2, 'Iris-setosa']], dist),(....),.......]
        # sort()是Python列表的一个内置的排序方法，list.sort() 方法排序时直接修改原列表，返回None；
        #sorted()是Python内置的一个排序函数，它会从一个迭代器返回一个排好序的新列表。（注意：即使是不可变的元组也可以进行排序，最后返回排序后的列表）
        #sorted(iterable[, key][, reverse])
        #list.sort(*, key=None, reverse=None)
        #  这个网址可以详细学习接下来的这条语句：https://blog.csdn.net/u012513525/article/details/75253312
        #  operator.itemgetter(1)：https://blog.csdn.net/dongtingzhizi/article/details/12068205
        #要注意，operator.itemgetter函数获取的不是值，而是定义了一个函数，通过该函数作用到对象上才能获取值
    distances.sort(key=operator.itemgetter(1))
    #distances=[([[5.1, 3.5, 1.4, 0.2, 'Ia']], 1), ([[3.1, 0.5, 9.4, 5.2, 'I']], 3), ([[3.1, 0.5, 1.4, 5.2, 'ff']], 4), ([[5.1, 9.5, 1.4, 0.2, 'osa']], 8),(...),...]
    neighbors = []
    for x in range(k):
        neighbors.append(distances[x][0])
        return neighbors
    #neighors=[[[5.1, 3.5, 1.4, 0.2, 'a']], [[3.1, 0.5, 9.8, 5.2, 'I']], [[3.1, 7.5, 9.4, 8.2, 'Ic']]]

#统计取出的k个向量的标记,实现投票
def getResponse(neighbors):
    classVotes = {}
    #neighbors[x][-1]取出k行中元素的最后一个基元素eg:a=[[1],[34,0],[1,56],[15]]取出的是1 0 56 15
    for x in range(len(neighbors)):
        response = neighbors[x][-1]
        if response == classVotes:
            pass# classVotes[response] += 1
        else:
            classVotes[response] = 1
    sortedVotes = sorted(classVotes.items(), 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():
    #prepare data
    trainingSet = []
    testSet = []
    split = 0.67
    loadDataset('irisdata.txt', split, trainingSet, testSet)
    print('Train set: ' + repr(len(trainingSet)))
    print('Test set: ' + repr(len(testSet)))
    #generate predictions
    predictions = []
    k = 3
    for x in range(len(testSet)):
        # trainingsettrainingSet[x]
        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()