sklearn.neighbors.KNeighborsClassifier的k-近邻算法使用介绍

class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, weights=’uniform’, algorithm=’auto’, leaf_size=30, 
p=2, metric=’minkowski’,metric_params=None, n_jobs=None, **kwargs)

Source code:https://github.com/scikit-learn/scikit-learn/blob/1495f6924/sklearn/neighbors/classification.py#L23

1,KNeighborsClassifier参数介绍

n_neighbors: int，默认值为5

　　表示k-nn算法中选取离测试数据最近的k个点，

weight: str or callable，默认值为uniform

　　表示k近邻点都分类结果的影响，一般的情况下是选取k近邻点中类别数目最多的作为分类结果，这种情况下默认k个点的权重相等，但在很多情况下，

　　k近邻点权重并不相等，可能近的点权重大，对分类结果影响大。

　　默认值为uniform，还可以是distance和自定义函数

• 'uniform'：表示所有点的权重相等
• 'distance'：表示权重是距离的倒数，意味着k个点中距离近的点对分类结果的影响大于距离远的点
• [callable]：用户自定义函数，接受一个距离数组，返回一个同维度的权重数

algorithm：{'ball_tree','kd_tree','brute','auto'}

　　计算找出k近邻点的算法

• 'ball_tree'：使用BallTree维数大于20时建议使用
• 'kd_tree'：使用KDTree，原理是数据结构的二叉树，以中值为划分，每个节点是一个超矩形，在维数小于20是效率高
• 'brute'：暴力算法，线性扫描
• 'auto'：自动选取最合适的算法

　　note：在稀疏的输入数据上拟合，将使用'brute'覆盖此参数

leaf_size：int，默认值为30

　　用于构造BallTree和KDTree

　　leaf_size参数设置会影响树构造的树构造和询问的速度，同样也会影响树存储需要的内存，这个值的设定取决于问题本身

p：int，默认值为2

• 1：使用曼哈顿距离进行度量
• 2：使用欧式距离进行度量

metric : string or callable, 默认使用'minkowski'(闵可夫斯基距离)，度量函数

 

　　其中p是一个变参数，也就是上一个介绍的参数p

　　当p=1时，就是曼哈顿距离

　　当p=2时，就是欧氏距离

　　当p→∞时，就是切比学夫距离

metric_params : dict, 默认为None

　　度量函数的其他关键参数，一般不用设置

n_jobs : int or None, 默认None

　　用于搜索k近邻点并行任务数量，-1表示任务数量设置为CPU的核心数，即CPU的所有core都并行工作，不会影响fit(拟合)函数

注意：关于如何选择algorithm 和 leaf_size参数，请查看Nearest Neighborsi的在线文档。

警告：根据Nearest Neighbors算法，如果找到两个邻居，例如邻居k+1和k，他们有着一样的距离但是不一样的标签，最后的结果会根据训练数据的顺序来决定。

https://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm

fit(self, X, y)	使用X作为训练集作为便签集，来拟合模型
get_params(self[, deep])	获得估计器的参数
kneighbors(self[, X, n_neighbors, …])	查找X数组X数组中所有点的K邻居点
kneighbors_graph(self[, X, n_neighbors, mode])	计算X中每个点的K邻居权重图
predict(self, X)	预测X数据集中每个点对应的标签
predict_proba(self, X)	返回X数据集中对应每个标签的概率估计值
score(self, X, y[, sample_weight])	返回给定数据集和标签的平均准确率
set_params(**params)	设置估计器的参数

　　

　　

__init__(self, n_neighbors=5, weights=’uniform’, algorithm=’auto’, leaf_size=30, p=2, metric=’minkowski’, metric_params=None, n_jobs=None, **kwargs)

[source]

fit(self, X, y)

使用X作为训练集，y作为标签集，拟合模型

参数

X：{类似数组，稀疏矩阵，BallTree，KDTree}

　　训练集：如果是数组或者矩阵，形状为[n_samples, n_features]，如果参数metric='precomputed'，形状为[n_samples, n_samples]

y：{类似数组，稀疏矩阵}

　　标签集：形状为[n_samples]或者[n_samples, n_outputs]

get_params(self, deep=True)

获取估计器的参数

参数

deep：boolean，可选

　　如果为True，返回估计器的参数，以及包含子估计器

返回值

Returns：mapping of string to any

　　返回Map变量，内容为[参数值:值, 参数值:值, ...]　

 

kneighbors(X=None,n_neighbors=None,return_distance=True)

查询X数组中的K邻居点，返回每个点的下标和查询点和邻居点之间的距离

参数：

X：类型数组，形状为 (n_query, n_features)，如果参数metric == ‘precomputed’形状为(n_query, n_indexed) 

　　在没有提供查询点的情况下，则返回有下标点的邻居们，这种情况下，没有考虑查询点的邻居们

n_neighbors：int

　　返回的邻居点的个数（默认使用改造器是设定的n_neighbors值）

return_distance：boolean，可选。 默认为True 

　　如果为False，距离值就不会返回

返回值：

Returns：

　　dist：数组

　　　　当return_distance=True是，返回到每个近邻点的距离

　　ind：数组

　　　　返回近邻点的下标

 例子

在下面例子中，我们从给定数据集中构建一个NeighborsClassifier类，并询问哪个点最接近[1, 1, 1]

from sklearn.neighbors import NearestNeighbors
samples = [[0., 0., 0.], [0., .5, 0.], [1., 1., .5]]
neigh = NearestNeighbors(n_neighbors=1)
neigh.fit(samples)
print(neigh.get_params())
print(neigh.kneighbors([[1., 1., 1.]]))

{'algorithm': 'auto', 'leaf_size': 30, 'metric': 'minkowski', 'metric_params': None, 'n_jobs': None, 'n_neighbors': 1, 'p': 2, 'radius': 1.0}
(array([[0.5]]), array([[2]], dtype=int64))

因为n_neighbors=1，所有只返回一个点的数据[[0.5]]意味着近邻点与查询点的距离为0.5，而[[2]]意味着这个近邻点的下标，同样你也可以查询多个点

X = [[0., 1., 0.], [1., 0., 1.]]
print(neigh.kneighbors(X, return_distance=False))

[[1],[2]]

 [[1],[2]]表示，第一个查询点的近邻点下标为1，同样第二个查询点的近邻点下标为2

kneighbors(self, X=None, n_neighbors=None, return_distance=True)

计算X数组中每个点的k邻居权重图

参数：

　　X：类似数组，形状为 (n_query, n_features)，如果参数metric == ‘precomputed’，形状为 (n_query, n_indexed)

　　　　一个或者多个查询点，如果没有提供，则返回每个有下标的邻居们

　　n_neighbors : int

　　　　每个查询的邻居数量(默认使用拟合时设置的n_neighbors)
　　mode : {‘connectivity’, ‘distance’}, 可选

　　　　返回矩阵类型：'connectivity'，返回0和1组成的矩阵，'distance'，返回点与点之间的欧几里得距离

返回值：

　　A：CSR格式的稀疏矩阵，形状为[n_samples, n_samples_fit]

　　　　n_samples是拟合过程中样例的数量，A[i, j]是i到j的权重

 关联：kneighbors_graph

from sklearn.neighbors import NearestNeighbors
X = [[0], [3], [1]]
neigh = NearestNeighbors(radius=1.5)
neigh.fit(X)
A = neigh.radius_neighbors_graph(X)
print(A.toarray())

[[1. 0. 1.]
[0. 1. 0.]
[1. 0. 1.]]

predict(self, X)

预测提供的数据对应的类别标签

参数：

　　X：类似数组，形状为(n_query, n_features)，如果参数metric == 'precomputed'，形状为(n_query, n_indexed) 

　　　　待测试数据

返回值：

　　y：形状为[n_samples]或者为[n_samples, n_outputs]

　　　　每个待测试样例的类别标签

predict_proba(self, X)

预测X中每个测试样例对应每个类别的概率估计值

参数：

　　X：类似数组，形状为(n_query, n_features)，如果参数metric == 'precomputed'，形状为(n_query, n_indexed) 

　　　　带测试样例

返回值：

　　p：形状为[n_samples, n_classes]，或者n_outputs列表

　　　　输出每个样例对于每个类别的概率估计值，类别按照字典顺序排序

from sklearn.neighbors import KNeighborsClassifier
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
neigh = KNeighborsClassifier(n_neighbors=3)
neigh.fit(X, y)
print(neigh.predict([[1.1]]))
print(neigh.predict_proba([[1.1]]))

[0]
[[0.66666667 0.33333333]]

解释：[0]表示预测[1.1]属于类型0，而[[0.66666667 0.33333333]]表示[1,1]属于类型0的概率为0.66666667，属于类型1的概率为0.33333333

score(self, X, y, sample_weight=None)

返回给定测试集和标签的平均准确度。在多标签分类中，返回各个子集的准确度

参数：

　　X：类似数组，形状为 (n_samples, n_features)

　　　　测试数据
　　y：类似数组，形状为(n_samples)或者(n_samples, n_outputs)

　　　　X对应的正确标签

　　sample_weight : 类似数组,形状为[n_samples], 可选　　　　

　　　　样例的权重

返回值：

　　score : float

　　　　self.predict(X)关于y的平均准确率

from sklearn.neighbors import KNeighborsClassifier
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
neigh = KNeighborsClassifier(n_neighbors=3)
neigh.fit(X, y)
print(neigh.predict([[1.1], [2.1], [3.1]]))
print(neigh.score([[1.1], [2.1], [3.1]], [0, 1, 0]))

[0 1 1]
0.6666666666666666

 可以看出3个测试数据，预测类别有2个正确，1个错误，所有准确率为0.6666666666666666

set_params(self, **params)

设置估计器的参数

这个方法不仅对于单个估计器，而且对于嵌套对象（类如管道）都有效，而嵌套对象有着<component>__<parameter>形式的参数，所以可以更新嵌套对象的每个参数

返回值：

　　self