机器学习--最邻近规则分类KNN算法

理论学习：

3. 算法详述

 

     3.1 步骤：

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

     选择参数K

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

     选择最近K个已知实例

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

 

     3.2 细节:

     关于K

     关于距离的衡量方法:

         3.2.1 Euclidean Distance（欧式距离） 定义

其他距离衡量：余弦值（cos）, 相关度 （correlation）, 曼哈顿距离 （Manhattan distance）

4. 算法优缺点：

     4.1 算法优点

          简单

          易于理解

          容易实现

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

          

     4.2 算法缺点

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

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

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

5. 改进版本

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

      比如: 1/d (d: 距离）

 

应用：

1、用库来进行实现算法

 from sklearn import neighbors
 from sklearn import datasets

 knn = neighbors.KNeighborsClassifier()

 iris = datasets.load_iris()

 print(iris)

 knn.fit(iris.data, iris.target)    # 建模，两个参数：二维的特征值矩阵、一维的每一个实例所对应的对象

 predictedLabel = knn.predict([[0.1, 0.2, 0.3, 0.4]])

 print(predictedLabel)

2、不调用任何库来实现knn算法，其中使用到的数据集是sklearn自带的iris数据集

 # 不调用任何库来实现knn算法

 import csv
 import random
 import math
 import operator

 # 将数据集装载到Python里面
 # filename：数据集存放的文件
 # split：以此参数为界限将数据集分为trainingSet训练集和testSet测试集
 def loadDataset(filename, split, trainingSet=[], testSet=[]):
     with open(filename, 'r') as csvfile:   # 打开文件
         lines = csv.reader(csvfile)     # 读取文件的所有行
         dataset = list(lines)           # 文件内容转换成list结构

         # 将数据集分为两部分
         for x in range(len(dataset) - 1):
             for y in range(4):
                 dataset[x][y] = float(dataset[x][y])
             # 随机数小于split放入训练集，大于就放入测试集
             if random.random() < split:
                 trainingSet.append(dataset[x])
             else:
                 testSet.append(dataset[x])

 # 计算两个实例之间的欧式距离
 # instance1、instance2是两个实例
 # length是实例的维数
 def euclideanDistance(instance1, instance2, length):
     distance = 0    # 设置初始值为0

     # 计算所有维度的差的平方和
     for x in range(length):
         distance += pow((instance1[x] - instance2[x]), 2)
     return math.sqrt(distance)

 # 测试集中的一个实例到训练集的距离最近的k个实例
 # trainingSet：训练集
 # testInstance：测试集实例
 # k：距离最近的个数
 def getNeighbors(trainingSet, testInstance, k):
     distances = []
     length = len(testInstance) - 1
     for x in range(len(trainingSet)):
         dist = euclideanDistance(testInstance, trainingSet[x], length)
         distances.append((trainingSet[x], dist))
     distances.sort(key=operator.itemgetter(1))
     neighbors = []
     for x in range(k):
         neighbors.append(distances[x][0])
     return neighbors

 def getResponse(neighbors):
     """
     得到
     :param neighbors:附近的实例
     :return:得票最多的类别情况

     """
     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.items(), key=operator.itemgetter(1), reverse=True)  # classVotes.iteritems()
     return sortedVotes[0][0]

 def getAccuracy(testSet, predictions):
     """
     得到预测的正确率
     :param testSet:测试集
     :param predictions: 预测结果
     :return: 预测的正确率

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

     :return:
     """
     trainingSet = []
     testSet = []
     split = 0.67    # 把2/3的数据作为训练集，1/3为测试集
     loadDataset(r'irisdata.txt', split, trainingSet, testSet)
     print('Train set: ' + repr(len(trainingSet)))
     print('Test 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) + '%')

 if __name__ == '__main__':
     main()