python机器学习库sklearn——K最近邻、K最近邻分类、K最近邻回归

全栈工程师开发手册 （作者：栾鹏）

python数据挖掘系列教程

KNN即K最近邻，相关的知识内容可以参考
http://blog.csdn.net/luanpeng825485697/article/details/78796773

这里只讲述sklearn中如何使用KNN算法。

无监督最近邻

NearestNeighbors （最近邻）实现了 unsupervised nearest neighbors learning（无监督的最近邻学习）。 它为三种不同的最近邻算法提供统一的接口：BallTree, KDTree, 还有基于 sklearn.metrics.pairwise 的 brute-force 算法。算法的选择可通过关键字 ‘algorithm’ 来控制， 并必须是 [‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’] 其中的一个。当默认值设置为 ‘auto’ 时，算法会尝试从训练数据中确定最佳方法。

# ========无监督查找最近邻（常在聚类中使用，例如变色龙聚类算法）==========

from sklearn.neighbors import NearestNeighbors
import numpy as np # 快速操作结构数组的工具

X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])  # 样本数据
test_x = np.array([[-3.2, -2.1], [-2.6, -1.3], [1.4, 1.0], [3.1, 2.6], [2.5, 1.0], [-1.2, -1.3]])  # 设置测试数据
# test_x=X  # 测试数据等于样本数据。这样就相当于在样本数据内部查找每个样本的邻节点了。
nbrs = NearestNeighbors(n_neighbors=2, algorithm='ball_tree').fit(X)  # 为X生成knn模型
distances, indices = nbrs.kneighbors(test_x)  # 为test_x中的数据寻找模型中的邻节点
print('邻节点：',indices)
print('邻节点距离：',distances)

# ==============================使用kd树和Ball树实现无监督查找最近邻========================

from sklearn.neighbors import KDTree,BallTree
import numpy as np # 快速操作结构数组的工具

X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
# test_x = np.array([[-3.2, -2.1], [-2.6, -1.3], [1.4, 1.0], [3.1, 2.6], [2.5, 1.0], [-1.2, -1.3]])  # 设置测试数据
test_x=X  # 测试数据等于样本数据。这样就相当于在样本数据内部查找每个样本的邻节点了。
kdt = KDTree(X, leaf_size=30, metric='euclidean')
distances,indices = kdt.query(test_x, k=2, return_distance=True)
print('邻节点：',indices)
print('邻节点距离：',distances)

最近邻分类

scikit-learn 实现了两种不同的最近邻分类器：KNeighborsClassifier 基于每个查询点的 k 个最近邻实现，其中 k 是用户指定的整数值。RadiusNeighborsClassifier 基于每个查询点的固定半径 r 内的邻居数量实现， 其中 r 是用户指定的浮点数值。

k -邻居分类是 KNeighborsClassifier 下的两种技术中比较常用的一种。k 值的最佳选择是高度依赖数据的：通常较大的 k 是会抑制噪声的影响，但是使得分类界限不明显。

如果数据是不均匀采样的，那么 RadiusNeighborsClassifier 中的基于半径的近邻分类可能是更好的选择。

RadiusNeighborsClassifier 中用户指定一个固定半径 r，使得稀疏邻居中的点使用较少的最近邻来分类。

对于高维参数空间，这个方法会由于所谓的 “维度灾难” 而变得不那么有效。

在两种k最近邻分类中，基本的最近邻分类使用统一的权重：分配给查询点的值是从最近邻的简单多数投票中计算出来的。 在某些环境下，最好对邻居进行加权，使得更近邻更有利于拟合。可以通过 weights 关键字来实现。

默认值 weights = ‘uniform’ 为每个近邻分配统一的权重。而 weights = ‘distance’ 分配权重与查询点的距离成反比。 或者，用户可以自定义一个距离函数用来计算权重。

# ==========k最近邻分类=========
import numpy as np # 快速操作结构数组的工具
from sklearn.neighbors import KNeighborsClassifier,KDTree   # 导入knn分类器


# 数据集。4种属性，3种类别
data=[
    [ 5.1,  3.5,  1.4,  0.2, 0],
    [ 4.9,  3.0,  1.4,  0.2, 0],
    [ 4.7,  3.2,  1.3,  0.2, 0],
    [ 4.6,  3.1,  1.5,  0.2, 0],
    [ 5.0,  3.6,  1.4,  0.2, 0],
    [ 7.0,  3.2,  4.7,  1.4, 1],
    [ 6.4,  3.2,  4.5,  1.5, 1],
    [ 6.9,  3.1,  4.9,  1.5, 1],
    [ 5.5,  2.3,  4.0,  1.3, 1],
    [ 6.5,  2.8,  4.6,  1.5, 1],
    [ 6.3,  3.3,  6.0,  2.5, 2],
    [ 5.8,  2.7,  5.1,  1.9, 2],
    [ 7.1,  3.0,  5.9,  2.1, 2],
    [ 6.3,  2.9,  5.6,  1.8, 2],
    [ 6.5,  3.0,  5.8,  2.2, 2],
]

# 构造数据集
dataMat = np.array(data)
X = dataMat[:,0:4]
y = dataMat[:,4]

knn = KNeighborsClassifier(n_neighbors=2,weights='distance')    # 初始化一个knn模型，设置k=2。weights='distance'样本权重等于距离的倒数。'uniform'为统一权重
knn.fit(X, y)                                          #根据样本集、结果集，对knn进行建模
result = knn.predict([[3, 2, 2, 5]])                   #使用knn对新对象进行预测
print(result)

最近邻回归

最近邻回归是用在数据标签为连续变量，而不是离散变量的情况下。分配给查询点的标签是由它的最近邻标签的均值计算而来的。

scikit-learn 实现了两种不同的最近邻回归：KNeighborsRegressor 基于每个查询点的 k 个最近邻实现， 其中 k 是用户指定的整数值。RadiusNeighborsRegressor 基于每个查询点的固定半径 r 内的邻点数量实现， 其中 r 是用户指定的浮点数值。

基本的最近邻回归使用统一的权重：即，本地邻域内的每个邻点对查询点的分类贡献一致。 在某些环境下，对邻点加权可能是有利的，使得附近点对于回归所作出的贡献多于远处点。 这可以通过 weights 关键字来实现。默认值 weights = ‘uniform’ 为所有点分配同等权重。 而 weights = ‘distance’ 分配的权重与查询点距离呈反比。 或者，用户可以自定义一个距离函数用来计算权重。

# ==============================k最近邻回归========================

import numpy as np
import matplotlib.pyplot as plt
from sklearn import neighbors

np.random.seed(0)
X = np.sort(5 * np.random.rand(40, 1), axis=0)
T = np.linspace(0, 5, 500)[:, np.newaxis]
y = np.sin(X).ravel()

# 为输出值添加噪声
y[::5] += 1 * (0.5 - np.random.rand(8))

# 训练回归模型
n_neighbors = 5

for i, weights in enumerate(['uniform', 'distance']):
    knn = neighbors.KNeighborsRegressor(n_neighbors, weights=weights)
    y_ = knn.fit(X, y).predict(T)

    plt.subplot(2, 1, i + 1)
    plt.scatter(X, y, c='k', label='data')
    plt.plot(T, y_, c='g', label='prediction')
    plt.axis('tight')
    plt.legend()
    plt.title("KNeighborsRegressor (k = %i, weights = '%s')" % (n_neighbors,weights))

plt.show()