前言：什么是KNN算法
- KNN 全称K-nearst neighbors，K近邻算法，是一种典型的监督学习算法。
- 通俗地讲，K近邻算法实际上是将待预测的样本置入到数据集中（对于这个数据集的说明详见后文），然后通过用与它最靠近的K个样本来代表待预测的样本。
- 记得看过一个论点：一个人的收入，可以通过用与他经常交往的五个人收入的平均数来确定。也就是所谓物以类聚，人以群分；近朱者赤，近墨者黑。KNN算法的思想就类似这个。
- KNN算法既可以应用于分类应用中，也可以应用在回归应用中。
- KNN在做回归和分类的主要区别在于最后做预测的时候的决策方式不同。
- KNN在分类预测时，一般采用多数表决法；而在做回归预测时，一般采用平均值法。
一、KNN算法原理
- 从训练集合中获取K个离待预测样本距离最近的样本数据；
- 根据获取得到的K个样本数据来预测当前待预测样本的目标属性值。
简单Demo说明
如上图中，绿色圆要被决定赋予哪个类，是红色三角形还是蓝色四方形？
若K=3，意思是获取3个离待测样本距离最近的数据来预测当前待预测的目标属性。
当取3个最近邻样本数据时，红色三角形所占比例为2/3，蓝色四方形占比例为1/3因此绿色圆将被赋予红色三角形那个类；
同理，若K=5，由于蓝色四方形比例为3/5，因此绿色圆被赋予蓝色四方形类。
- 由上述Demo可知，对于KNN算法来说有三个比较重要的因素要考虑,分别如下所述；
KNN 算法三要素
-
1.K值的选择：K值的确定与样本最终的判定结果有很大的关系；K 值太小会使得 KNN 算法容易过拟合。反之，太大则会欠拟合。因此，一般采用交叉验证的方式选取 K 值。
-
2.距离的度量：通过什么样的距离理论确定最近邻的样本数据。一般使用欧氏距离(欧几里得距离)；
-
3.决策规则：以什么样的决策规则来确定最终的输出结果。 如上图的决策规则是通过“多数表决法”对结果进行分类。
在分类预测时，一般采用“多数表决法”或“加权多数表决法”；
而在做回归预测时，一般采用“平均值法”或“加权平均值法”，这也是KNN做分类与回归最主要的区别。
这里所说的加权一般情况下采用权重和距离成反比的方式来计算。
二、KNN 简单编码样例
from sklearn import neighbors
from sklearn import datasets
from sklearn.model_selection import train_test_split
iris = datasets.load_iris()
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=0)
KNN = neighbors.KNeighborsClassifier(algorithm='kd_tree', n_neighbors=3)
KNN.fit(x_train, y_train)
print("训练集预测的准确率：", KNN.score(x_train, y_train))
print("测试集预测的准确率: ", KNN.score(x_test, y_test))
print("predict: ", KNN.predict([[7, 5, 2, 0.5], [7.5, 4, 7, 2]]))
代码解说：
from sklearn import neighbors
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.externals import joblib
# 加载数据集
iris = datasets.load_iris()
# random_state 随机数种子，就是为了保证程序每次运行都分割一样的训练集合测试集。
#如果没有给定种子，该函数默认为none，则每次分割的出来的数据集都不一样，
#这样模型在每次运行后的结果都不一样，难以调参。
# test_size = 0.2 切割20% 的数据做为测试集
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.20,
random_state=0)
KNN = neighbors.KNeighborsClassifier(algorithm='kd_tree', leaf_size=30,
metric='minkowski', n_neighbors=5, p=2,weights='uniform')
# 算法默认参数打印或直接查看源码如下所示
# print(KNN)
# KNeighborsClassifier(algorithm='auto', leaf_size=30,
# metric='minkowski',metric_params=None, n_jobs=1,
# n_neighbors=5, p=2, weights='uniform')
# 参数说明：
# 1.weights 样本权重，可选参数: uniform(等权重)、
# distance(权重和距离成反比，越近影响越强)；默认为uniform
# 2.n_neighbors 邻近数目，默认为5
# 3.algorithm 计算方式，默认为auto，可选参数: auto、ball_tree、kd_tree、brute；
如果设定为‘auto’，系统会根据传给fit方法的参数来选择最合适的算法，推荐选择kd_tree。
# 4.leaf_size 在使用KD_Tree的时候，叶子数量，默认为30,
#5. metric 样本之间距离度量公式，默认为minkowski（闵可夫斯基）；
# 当参数p为2的时候，其实就是欧几里得距离
# 6.p 给定minkowski距离中的p值，默认为2
# 训练模型
KNN.fit(x_train, y_train)
# 将训练模型保存至本地
joblib.dump(KNN, 'KNN_MODEL.m')
# 将保存在本地的训练模型调出用于预测
KNN = joblib.load('KNN_MODEL.m')
# 输出模型训练集预测的准确率
print("训练集预测的准确率：", KNN.score(x_train, y_train))
# 输出模型测试集预测的准确率
print("测试集预测的准确率: ", KNN.score(x_test, y_test))
print("predict: ", KNN.predict([[7, 5, 2, 0.5], [7.5, 4, 7, 2]]))
- sklearn 部分样例数据
{'data': array([[5.1, 3.5, 1.4, 0.2],
....
....
[6.3, 2.5, 5. , 1.9],
[6.5, 3. , 5.2, 2. ],
[6.2, 3.4, 5.4, 2.3],
[5.9, 3. , 5.1, 1.8]]),
'target': array([
0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2]),
'target_names': array(['setosa', 'versicolor', 'virginica'],
dtype='<U10'),
}
闵可夫斯基距离
- 闵可夫斯基距离不是一种距离，而是一类距离的定义。
- 对于 n 维空间中的两个点,假设数值点 A(x1,x2,x3,…xk), 数值点B(y1,y2,y3…yk), 则这两点的闵可夫斯基距离公式如下：
- 其中 p 是一个可变参数：
- 当 p=1 时，被称为曼哈顿距离；
- 当 p=2 时，被称为欧氏距离；
- 当 p= 无穷大时，被称为切比雪夫距离。
三、KNN算法的算法优缺点与适用场景
优点：
- 简单，易于实现，无需估计参数，无需训练；
- 既可以用来做分类也可以用来做回归；
- 训练时间复杂度为O(n)；
- 准确度高，对数据没有假设，对outlier不敏感；
缺点：
- 懒惰算法，对测试样本分类时的计算量大，内存开销大；
- 样本不平衡问题（即有些类别的样本数量很多，而其它样本的数量很少）;
- 可解释性较差，无法给出决策树那样的规则。
- 注：
懒惰算法可以如此理解：训练数据并没有形成一个“模型”，而是一个新的数据需要分类了，去和所有训练数据逐一比较，最终给出分类。也可理解成延迟计算，有点类似Spark 中的 RDD，表达式不在它被绑定到变量之后就立即求值，而是在该值被取用的时候求值。
改进算法 :
待补充
四、KNN 算法的核心：KDTree
- 通过以上的分析，我们知道 KNN 分类算法的思想非常简单，它采用的就是 K 最近邻多数投票的思想。所以，算法的关键就是在给定的距离度量下，对预测实例如何准确快速地找到它的最近的 K 个邻居？也就是说在预测实例时，怎么样可以使搜索次数减少。常用的方式以下有两种：
蛮力实现(brute)：
- 计算预测样本到所有训练集样本的距离，然后选择最小的 k个距离即可得到K个最邻近点。缺点在于当特征数比较多、样本数比较多的时候，算法的执行效率比较低;
KD树(kd_tree)：
- KD树算法中，首先是对训练数据进行建模，构建KD树，然后再根据建好的模型来获取邻近样本数据。这么做的本质是使用特殊的数据结构存储训练数据，用来减少预测时的搜索次数。
KDTree 原理说明：
- 假设数据集为 M ，样本量为m个，特征维度为n, 利用M进行构建KD Tree步骤如下：
1. 根节点的选择
- 分别计算n个特征数值所对应的方差，取方差最大那个特征(设该维特征为L)做为根节点对应的维度。将L维特征的取值进行排序，取其中位数对应的数据点作为该维的根节点。
- 注：选择方差大的维度做为根节点的原因是，该维度根节点大说明数据的分离程度大，利用它来做根节点可以更加快速将数据区分开来）
2. 构建左右子树
- 对于L维小于根节点的样本划分到左子树，对于大于等于该值的样本划分到右子树。
3. 迭代生成叶子节点
- 对左右子树按步骤1，2 进行迭代，采用同样的方式找方差最大的特征作为根节点，递归即可产生KD树。
简单demo 描述KD tree的构建：
假设二维样本: {(2,3), (5,4), (9,6), (4,7), (8,1), (7,2)}
-
- 计算 x 与 y 维度方差
arr3 = np.array([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]])
print('各维方差：%s ' % (np.std(arr3, axis=0)) ** 2)
print("对x维排序：%s, x 维中位数: %s " % (np.sort(arr3[:,0]),np.median(arr3[:,0])))
print("对y维排序：%s, y 维中位数: %s " % (np.sort(arr3[:,1]),np.median(arr3[:,1])))
打印结果如下：
各维方差：[5.80555556 4.47222222]
对x维排序：[2 4 5 7 8 9], x 维中位数: 6.0
对y维排序：[1 2 3 4 6 7], y 维中位数: 3.5
由于 x 维方差比 y 维的大，故选择 x 维做为根节点的分割维度；
由于 x 维中位数为 6.0，一般选取大的，故选择7，也就是点（7，2）被选为根节点；
切割后如上：
左子树 ：[2, 3], [5, 4], [4, 7]
右子树：[9, 6], [8, 1]
对左右子树进行重复步骤 1，2
arr4 = np.array([[2, 3], [5, 4], [4, 7]])
print('各维方差：%s ' % (np.std(arr4, axis=0)) ** 2)
print("对x维排序：%s, x 维中位数: %s " % (np.sort(arr4[:,0]),np.median(arr4[:,0])))
print("对y维排序：%s, y 维中位数: %s " % (np.sort(arr4[:,1]),np.median(arr4[:,1])))
打印结果如下：
各维方差：[1.55555556 2.88888889]
对x维排序：[2 4 5], x 维中位数: 4.0
对y维排序：[3 4 7], y 维中位数: 4.0
- 同理计算得 分割维度为 y 维，根节点为[5,4]
- 最终得到KD Tree 如下所示：
上图为二维空间的划分，如果为多维则就是将线转换成面，上图转换成树结构如下所示：
4、如何通过KDTree查找最近邻点（即如何减少搜索的计算量）
- 利用 KD 树主要是可以省去对大部分数据点的搜索，从而减少搜索的计算量。
- 下面以目标点（2，4.5）来说明其搜索过程：
- 在KD树里面找到包含目标点的叶子节点，这里找到的叶子节点分别为（7，2），（5，4），（4，7），分别计算这三个包含了目标节点的叶子节点到目标节点的距离，取其中最小的一个为半径，这里求得点（5，4）为所有叶子节点距离目标节点最小。
- 以目标点为圆心，以步骤1中的求得的最小距离为半径，得到一个超球体，最近邻的点一定在这个超球体内部。
- 待补充
五、模型的本地保存与调用
from sklearn import neighbors
from sklearn.externals import joblib #模型保存包
KNN = neighbors.KNeighborsClassifier(n_neighbors=3)
KNN.fit(x, y)
# 模型的本地保存
joblib.dump(KNN, "train_model.m")
# 模型的调用
from sklearn.externals import joblib #模型保存包
KNN = joblib.load("train_model.m")
print("predict: ", KNN.predict([[7, 5, 2, 0.5], [7.5, 4, 7, 2]]))
1343
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
