k-nearest neighbor(kNN,k近邻算法)理论与实操及KNeighborsClassifier参数详解

1. k-NN算法简介

k近邻法是基本且简单的分类与回归方法，这里只讨论分类方法，利用数据集对特征向量空间进行划分，可以进行多分类。如下图：
三角形与矩形分别代表两类数据，标签已知。现要对新输入的为分类点(绿色)进行分类，k-NN的做法是寻找与该绿点相邻最近的k个点(k-NN算法的k的含义，图中的距离为欧式距离)，然后通过多数表决的方式把绿点划分到这k个最近点出现频数最高的类。例如如果k取3，则绿点最近的3个点中频数最高为三角形类，所以归为三角形类；若k取5，则距离绿点最近的5个点中频数最高为矩形类，所以归绿点为矩形类。

1.1 模型

输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}, 实例特征向量$x$
总共N个样本，$x_i\in \mathcal{X}\subseteq R^n$为实例的特征向量， y i ∈ Y = { c 1 , c 2 , . . . , c K } 为 实 例 的 类 别 , i = 1 , 2 , . . . , N y_i \in \mathcal{Y}=\{c_1,c_2,...,c_K\}为实例的类别, i=1,2,...,N yi​∈Y={c1​,c2​,...,cK​}为实例的类别,i=1,2,...,N
输出：实例$x$所属的类$y$
step1:根据给定的距离度量，在训练集T中找出与$x$最近的k个点，涵盖这k个点的x的邻域记为$N_k(x);$
step2:在$N_k(x)$中根据决策规则（如多数表决）决定$x$的类别$y$
$$y=\underset{c_j}{\mathrm{argmax}}\sum _{x_i\subseteq N_k(x)}I(y_i=c_j)，i=1,2,...,N,j=1,2,...,K；$$
其中I为指示函数

1.2 学习策略

$$\underset{c_j}{\max }\sum _{x_i\subseteq N_k(x)}I(y_i=c_j)，i=1,2,...,N,j=1,2,...,K；$$

1.3 学习算法

学习算法即如何求出以上的学习策略的最大值，用的是多数表决法，即将$c_1到c_K$得到的指示函数和的值排序，选择最大值对应的类别$c^{\ast }$作为输出。假设$c^{\ast }$为最大值对应的类别，那么得到的最终模型为：
$$y=c^{\ast }$$

1.4 距离度量

从以上公式可以看出，关键是确定输入实例$x$的邻域$N_k(x)$，而这个邻域又由两个方面决定，一个就是如何计算各点与输入实例$x$的距离（怎么判断离某些点近不近)？
$$L_p\left(x_i,x_j\right)={\left(\sum _{i=1}^n{\left|x_i^{(i)}-x_j^{(l)}\right|}^p\right)}^{\frac{1}{p}}$$

• $p=1$ 曼哈顿距离
• $p=2$ 欧氏距离
• $p=\infty$ 切比雪夫距离
  一般使用欧式距离。

1.5 k值选择

知道了怎么判断点之间离的近不近，那么要确定邻域还得需要知道该邻域包含多少个“最近”点,这就是k值决定的，该邻域会包含k个离输入实例最近的点。k值越小，模型越复杂，过拟合的风险越大，当k=1时成为最近邻模型。而k值越大，模型越简单，最极端情况就是k=N，这时直接把样本中出现频数最高的类当成所有输入实例的类。

距离的度量以及k值作为超参数，可以通过验证集来选择合适的超参数。

2. 实例操作

选取sklearn内置数据库的iris数据集进行实战演练。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# %matplotlib notebook
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from collections import Counter

iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target
df.columns = ['sepal_length', 'sepal_width','petal_length','petal_widthth','label']
df

总共有4个特征，且分为三类，每一类各50个样本。为了方便画散点图更利于观察，只选取前两个特征’sepal_length’以及’sepal_width’训练模型，

plt.figure()
ax = plt.subplot(1,1,1)
plt.scatter(df[:50]['sepal_length'], df[:50]['sepal_width'], label='0')
plt.scatter(df[50:100]['sepal_length'], df[50:100]['sepal_width'], label='1')
plt.scatter(df[100:150]['sepal_length'], df[100:150]['sepal_width'], label='2')
plt.xlabel('sepal_length')
plt.ylabel('sepal_width')
plt.legend()
plt.show()

如图：

data = np.array(df.iloc[:, [0, 1, -1]])  # 选取前两个特征
X, y = data[:,:-1], data[:,-1]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) # 划分训练集和测试集

2.1 手写kNN算法

class kNN:
    def __init__(self, X_train, y_train, k_neighbors, p=2):  
        """
        parameter: k_neighbors 所选取的临近点个数
        parameter: p 距离度量，默认p=2为欧式距离
        """
        self.k = k_neighbors
        self.p = p
        self.X_train = X_train
        self.y_train = y_train   # 定义每个模型的私有属性
        
        
    def predict(self,X):
        """
        X：要进行分类的某个输入实例
        """
        knn_list = []  # 取出k个点，组成一个双值子元组列表，元祖包含距离和标签
        
        for i in range(self.k):  # 首先遍历前k个样本
            distance = np.linalg.norm(X - self.X_train[i], ord=self.p) # 计算距离
            knn_list.append((distance, self.y_train[i]))  
        
        for i in range(self.k, len(self.X_train)):  # 再遍历剩下样本，选出最近的k个点
            max_index = knn_list.index(max(knn_list, key=lambda x: x[0]))  # 计算列表中每一次遍历距离最大的点的index
            distance = np.linalg.norm(X - self.X_train[i], ord=self.p)  # 计算剩下点的距离，和列表里最大距离的点相比
            if distance < knn_list[max_index][0] :  # 如果这次遍历的点比较小，那就替换那个距离更大的点
                knn_list[max_index] = (distance, self.y_train[i]) # 最终列表里是距离X最近的k个点
        
        # 下面要统计这最近的k个点中哪个标签出现的次数最多,作为实例X的输出标签
        knn = np.array([int(i[-1]) for i in knn_list]) # 标签数组
        most_lable = np.argmax(np.bincount(knn))  # 出现次数最多的lable
        return most_lable
    
    
    # 下面计算测试集的预测精度
    def score(self, X_test, y_test):
        right_count = 0
        for X, y in zip(X_test, y_test):
            label = self.predict(X)
            if label == y:
                right_count += 1
        return right_count / len(X_test)

trained_knn = kNN(X_train,y_train,5)  # 这就是定义好的模型，不需要fit，可以用来预测测试集了

trained_knn.score(X_test, y_test)  # 预测精度为0.7

用一个测试点来画图：

test_point = [5.0, 3.0]
print(f'Test Point: {trained_knn.predict(test_point)}') #  Test Point: 0

plt.figure()
ax = plt.subplot(1,1,1)
plt.scatter(df[:50]['sepal_length'], df[:50]['sepal_width'], label='0')
plt.scatter(df[50:100]['sepal_length'], df[50:100]['sepal_width'], label='1')
plt.scatter(df[100:150]['sepal_length'], df[100:150]['sepal_width'], label='2')
plt.plot(test_point[0], test_point[1], 'ko', label='test_point')
plt.xlabel('sepal_length')
plt.ylabel('sepal_width')
plt.legend()
plt.show()

可以看出测试点（5,3)明显离0类的大部分点更近，所以输出0。

kNN算法一般步骤就演示完了，可是存在一个效率问题，因为在寻找最近的k个点时，手写的模型要求计算出所有点到输入实例$x$的距离，再从中挑选k个最近的点，当样本数量非常大且实例的维度很高时，计算量都会很大，所以为了提高效率，在搜索k个最近值时会用到kd树。

2.2 k近邻法的实现：kd树

k近邻法需要考虑的问题就是如何把邻域找出来。k近邻法最简单的一种实现方法就是线性扫描，计算出输入实例与每个训练实例的距离，然后按距离排序，选择距离最近的k个样本进入邻域，将其标签作为多数表决的标签数据来源。

然而，当数据集很大或者说特征数量很多时，计算非常耗时，通常是不可行的。为了提高邻域的搜索效率，可以考虑用特殊的结构存储训练数据，以减少距离的计算次数。kd树就是一种比较高效实现k近邻法的实现方法。

• kd树是一种对k维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。
• kd树是二叉树，表示对k 维空间的一个划分（partition）。构造kd树相当于不断地用垂直于坐标轴的超平面将 𝑘 维空间切分，构成一系列的k维超矩形区域。kd树的每个结点对应于一个 𝑘维超矩形区域。
• kd树对k维特征空间划分成很多个超矩形区域，输入的实例$x$属于其中某一个子区域，然后从那里开始往外搜索最近值，可以减少对距离该区域较远的一些区域的搜索，提高了模型的效率。

2.3 scikit-learn实例

手写只是为了便于理解模型，之后一般应用可以调包。而且其中有个参数algorithm可以选择kd_tree，更加方便。

from sklearn.neighbors import KNeighborsClassifier

# 构造一个kNN分类器，用kd树实现
cnn_sk = KNeighborsClassifier(n_neighbors=5,weights='uniform',
                     algorithm='kd_tree',leaf_size=30,
                     metric='minkowski', p=2,
                     metric_params=None, n_jobs=1)
                     
 # 训练分类器，手写的时候看起来是没有训练模型的，因为用的是线性扫描，输入一个x在进行距离计算，不用训练模型。
 # 但是kd树需要通过训练集学习到一颗包含训练集的树。                    
cnn_sk.fit(X_train, y_train)   

使用训练好的分类器对测试集进行预测，返回准确率
clf_sk.score(X_test, y_test)

2.3.1 KNeighborsClassifier的一些参数

KNeighborsClassifier函数一共有8个参数:

• n_neighbors： int， default=5,就是k-NN的k的值，选取最近的k个点，默认为5。
• weights： 默认是uniform，参数可以是uniform、distance，也可以是用户自己定义的函数（直接weights=函数名就行）。uniform是均等的权重，就说所有的邻近点的权重都是相等的。distance是不均等的权重，距离近的点比距离远的点的影响大。用户自定义的函数，接收距离的数组，返回一组维数相同的权重。
• algorithm： {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, default=’auto’。快速k近邻搜索算法，默认参数为auto，可以理解为算法自己决定合适的搜索算法。除此之外，用户也可以自己指定搜索算法ball_tree、kd_tree、brute方法进行搜索，brute是蛮力搜索，也就是线性扫描，当训练集很大时，计算非常耗时。kd_tree，构造kd树存储数据以便对其进行快速检索的树形数据结构，kd树也就是数据结构中的二叉树。以中值切分构造的树，每个结点是一个超矩形，在维数小于20时效率高。ball tree是为了克服kd树高纬失效而发明的，其构造过程是以质心C和半径r分割样本空间，每个节点是一个超球体。
• leaf_size： int ，default=30。leaf_size：默认是30，这个是构造的kd树和ball树的大小。这个值的设置会影响树构建的速度和搜索速度，同样也影响着存储树所需的内存大小。需要根据问题的性质选择最优的大小。
• metric： str or callable, default=’minkowski’。用于距离度量，默认度量是minkowski（也就是闵氏距离，$L_p\left(x_i,x_j\right)={\left({\sum }_{i=1}^n{\left|x_i^{(i)}-x_j^{(l)}\right|}^p\right)}^{\frac{1}{p}}$），当p=2时为欧氏距离(欧几里德度量)。
• p： 距离度量公式。即设置metric里闵氏距离的参数p，这个参数默认为2，也就是默认使用欧式距离公式进行距离度量。也可以设置为1，使用曼哈顿距离公式进行距离度量。
• metric_params： 距离公式的其他关键参数，这个基本不用，使用默认的None即可。
• n_jobs： 并行处理设置。默认为1，临近点搜索并行的工作数。如果为-1，那么CPU的所有cores都用于并行工作。

2.4总结：

KNN（K-Nearest Neighbor）最邻近分类算法是数据挖掘分类（classification）技术中最简单的算法之一，其指导思想是”近朱者赤，近墨者黑“，即由你的邻居来推断出你的类别。KNN最邻近分类算法的实现原理：为了判断未知样本的类别，以所有已知类别的样本作为参照，计算未知样本与所有已知样本的距离，从中选取与未知样本距离最近的K个已知样本，根据少数服从多数的投票法则（majority-voting），将未知样本与K个最邻近样本中所属类别占比较多的归为一类。

2.4.1优缺点

优点：

• 简单好用，容易理解，精度高，理论成熟，既可以用来做分类也可以用来做回归；
• 对异常值不敏感

缺点：

• 最大的缺点是无法给出数据的内在含义。
• 计算复杂性高；空间复杂性高；
• 样本不平衡问题（即有些类别的样本数量很多，而其它样本的数量很少）；
• 一般数值很大的时候不用这个，计算量太大。而且k近邻算法最终只用了最近k个点的信息来做决策，而舍弃了其余点。

kNN算法的原理以及实操就演示完了，请大家多多指教。