K-紧邻算法

一、基本原理
k-紧邻算法（KNN）是最简单的机器学习算法之一，其基本思路与“近朱者赤，近墨者黑”的原理相似，当对未分类样本进行分类时，首先判断其与已分类样本的特征相似度，然后将其划分到大多数已分类样本所属的类别中。（K-紧邻算法采用测量不同特征值之间的距离方法进行分类）
简单点说就是存在一个样本数据集合，也称作训练样本集，并且训练样本集中每个数据的都存在标签，即我们知道样本集中每一数据与所属分类的对应关系，输入没有标签的新数据后，将数据集的每个特征与样本集中数据对应的特征进行比较，然后提取样本集中特征最相似的数据的分类标签。一般来说，只选择样本数据集中前k个最相似的数据，最后选择k个最相似数据中出现次数最多的分类，作为新数据的分类
二、优缺点
优点：精度高、对异常值不敏感、无数据输入假定。
缺点：计算复杂度高、空间复杂度高。
使用数据范围：数值型和标称型。

# -*- coding: utf-8 -*-
"""
Created on Mon Apr 20 21:11:55 2020

@author: 35187
"""

#2. KNN分类:
import numpy as np
import matplotlib.pyplot as plt
class KNN():
    #导入训练样本
    def fit(self, x_train, y_train):
        self.x_train = x_train
        self.y_train = y_train
    #使用反函数为近邻分配权重
    def inverse_weight(self,dist,num=1.0,const=0.1):
        return num/(dist+const)
     #预测1个样本的类别
    def predict_once(self, x_test, k, T=0): #T：普通/加权
            N = self.x_train.shape[0]
            x_test_ext = np.tile(x_test,[N,1])
            euclidean_distance = np.sqrt(np.sum(np.power(np.subtract(x_test_ext, self.x_train),2),1))
            inx = np.argsort(euclidean_distance)
            if T == 0: #根据K个近邻中对应样本最多的类别进行分类
                        #累计每个类别对应的样本数
                class_predict = np.zeros(2)
                for i in range(k):
                    idx = inx[i]
                    if self.y_train[idx] == 'A':
                        class_predict[0] += 1
                    else:
                        class_predict[1] += 1
                class_label = 'B' if np.argmax(class_predict) else 'A'
                return class_label
            else: #根据K个近邻中对应样本的距离权重进行分类
                distance_weight = np.zeros(2) #累加权重
                for i in range(k):
                    idx = inx[i]
                    if self.y_train[idx] == 'A':
                        distance_weight[0] += self.inverse_weight(euclidean_distance[idx])
                    else:
                        distance_weight[1] += self.inverse_weight(euclidean_distance[idx])
                class_label = 'B' if np.argmax(distance_weight) else 'A'
                return class_label
    def predict(self, x_test, k, T=0):
        class_predict = []
        for i in range(len(x_test)):
            class_predict.append(self.predict_once(x_test[i, :], k, T))
        return class_predict
#1. 构造数据:
#构建一组训练数据（训练样本），共7个样本及相应的标签。
#训练样本（前4个为A类，后3个为B类）
x_train = np.array([[4, 5], [6, 7], [4.8, 7], [5.5, 8], [7, 8], [10, 11], [9, 14]])
y_train = ["A","A","A","A","B","B","B"]
#测试样本（6个）
x_test = np.array([[3.5, 7], [9, 13], [8.7, 10], [5, 6], [7.5, 8], [9.5, 12]])
#3. 实验结果:
#KNN分类预测
knn = KNN()
knn.fit(x_train, y_train)
y_predict = knn.predict(x_test, 3, 0) #T=0/1
print(y_predict)
#显示结果
plt.xlabel("x"); plt.ylabel('Y'); plt.title('KNN')
plt.plot(x_train[0:4,0], x_train[0:4,1], color='red', marker='o', label='One Class (A)', linestyle="") #显示”A”类
plt.plot(x_train[4:7,0], x_train[4:7,1], color='blue', marker='s', label='Two Class (B)', linestyle="") #显示”B”类
for i in range(len(x_test)): #显示预测结果
    if y_predict[i] == 'A':
        plt.plot(x_test[i,0], x_test[i,1], color='green', marker='o')
        plt.text(x_test[i,0]-0.3, x_test[i,1]+0.3, str(i) + '->A')
    else:
        plt.plot(x_test[i,0], x_test[i,1], color='green', marker='s')
        plt.text(x_test[i,0]-0.3, x_test[i,1]+0.3, str(i) + '->B')
plt.legend(loc='upper left')
plt.grid(True)
plt.show()