翻译原文地址：http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html
本文为博主原创文章，如果翻译有所欠妥，非常欢迎留言帮助博主改进，谢谢大家。

sklearn.neighbors.KNeighborsClassifier

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

实现了K最近邻居投票算法的分类器。想要了解更多，请看使用手册（英文）。

参数:
        n_neighbors: int, 可选参数(默认为 5)

                用于[kneighbors](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier.kneighbors)查询的默认邻居的数量

        weights（权重）: str or callable(自定义类型), 可选参数(默认为 ‘uniform’)

                用于预测的权重函数。可选参数如下:

                       - ‘uniform’ : 统一的权重. 在每一个邻居区域里的点的权重都是一样的。

                       - ‘distance’ : 权重点等于他们距离的倒数。使用此函数，更近的邻居对于所预测的点的影响更大。

                       - [callable] : 一个用户自定义的方法，此方法接收一个距离的数组，然后返回一个相同形状并且包含权重的数组。

        algorithm（算法）: {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, 可选参数（默认为 'auto'）

                计算最近邻居用的算法：

                       - ‘ball_tree’ 使用算法[BallTree](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.BallTree.html#sklearn.neighbors.BallTree)

                       - ‘kd_tree’ 使用算法[KDTree](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KDTree.html#sklearn.neighbors.KDTree)

                       - ‘brute’ 使用暴力搜索.

                       - ‘auto’ 会基于传入[fit](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier.fit)方法的内容，选择最合适的算法。

                注意 : 如果传入fit方法的输入是稀疏的，将会重载参数设置，直接使用暴力搜索。

         leaf_size（叶子数量）: int, 可选参数(默认为 30)

                传入BallTree或者KDTree算法的叶子数量。此参数会影响构建、查询BallTree或者KDTree的速度，以及存储BallTree或者KDTree所需要的内存大小。 此可选参数根据是否是问题所需选择性使用。

         p: integer, 可选参数(默认为 2)

                用于Minkowski metric（[闵可夫斯基空间](https://zh.wikipedia.org/wiki/%E9%96%94%E8%80%83%E6%96%AF%E5%9F%BA%E6%99%82%E7%A9%BA)）的超参数。p = 1, 相当于使用[曼哈顿距离](https://zh.wikipedia.org/wiki/%E6%9B%BC%E5%93%88%E9%A0%93%E8%B7%9D%E9%9B%A2) (l1)，p = 2, 相当于使用[欧几里得距离](https://zh.wikipedia.org/wiki/%E6%AC%A7%E5%87%A0%E9%87%8C%E5%BE%97%E8%B7%9D%E7%A6%BB)(l2)  对于任何 p ，使用的是[闵可夫斯基空间](https://zh.wikipedia.org/wiki/%E9%96%94%E8%80%83%E6%96%AF%E5%9F%BA%E6%99%82%E7%A9%BA)(l_p)

         metric（矩阵）: string or callable, 默认为 ‘minkowski’

                用于树的距离矩阵。默认为[闵可夫斯基空间](https://zh.wikipedia.org/wiki/%E9%96%94%E8%80%83%E6%96%AF%E5%9F%BA%E6%99%82%E7%A9%BA)，如果和p=2一块使用相当于使用标准欧几里得矩阵. 所有可用的矩阵列表请查询 DistanceMetric 的文档。

         metric_params（矩阵参数）: dict, 可选参数(默认为 None)

                给矩阵方法使用的其他的关键词参数。

         n_jobs: int, 可选参数(默认为 1)

                用于搜索邻居的，可并行运行的任务数量。如果为-1, 任务数量设置为CPU核的数量。不会影响[fit](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier.fit)方法。

关联:

RadiusNeighborsClassifier,KNeighborsRegressor,RadiusNeighborsRegressor,NearestNeighbors

注意:

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

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

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

例子：

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

方法：

init(n_neighbors=5,weights=’uniform’,algorithm=’auto’,leaf_size=30,p=2,metric=’minkowski’,metric_params=None,n_jobs=1,kwargs)[source]

fit(X,y): [source]

使用X作为训练数据，y作为目标值（标签）拟合模型

参数:
              X: {类似数组, 稀疏矩阵, BallTree, KDTree}
                 
                  待训练数据。如果是数组或者矩阵，形状为 [n_samples, n_features]，如果矩阵为’precomputed', 则形状为[n_samples, n_samples]。

              y: {类似数组, 稀疏矩阵}

                  形状为[n_samples] 或者 [n_samples, n_outputs]的目标值。

get_params(deep=True)[source]

获取估值器的参数.

参数:
              deep: boolean, 可选参数

                    如果为 True, 则返回估值器的参数，以及包含子目标的估值器。

返回值:
              params: Mapping string to any
                     
                    返回Map变量，内容为[参数值: 值, 参数值: 值, ........]。

kneighbors(X=None,n_neighbors=None,return_distance=True)[source]

查询一个或几个点的K个邻居, 返回每个点的下标和到邻居的距离。

参数:
              X: 类似数组, 形状(n_query, n_features)或者(n_query, n_indexed) 。如果矩阵是‘precomputed’，形状为(n_query, n_indexed)

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

              n_neighbors: int

                邻居数量 (默认为调用构造器时设定的n_neighboes的值).

              return_distance: boolean, 可选参数. 默认为 True.

                  如果为 False，则不会返回距离

返回值:
              dist: array

                  当return_distance =True时，返回到每个点的长度。

              ind: array

                  邻居区域里最近的几个点的下标。

例子：

在此案例中, 我们构建了一个NeighborsClassifier类。 此类从数组中获取数据，并查询哪个点最接近于[1, 1, 1]

>>> samples = [[0., 0., 0.], [0., .5, 0.], [1., 1., .5]]
>>> from sklearn.neighbors import NearestNeighbors
>>> neigh = NearestNeighbors(n_neighbors=1)
>>> neigh.fit(samples)
NearestNeighbors(algorithm='auto', leaf_size=30, ...)
>>> print(neigh.kneighbors([[1., 1., 1.]]))
(array([[ 0.5]]), array([[2]]...))

如你所见返回值为[[0.5]] 和 [[2]]。意思是此点是距离为0.5并且是样本中的第三个元素 (下标从0开始)。你可以尝试查询多个点：

>>> X = [[0., 1., 0.], [1., 0., 1.]]
>>> neigh.kneighbors(X, return_distance=False)
array([[1],     
       [2]]...)

kneighbors_graph(X=None,n_neighbors=None,mode=’connectivity’)[source]

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

参数:
              X: 类似数组, 形状(n_query, n_features)。如果矩阵是‘precomputed’，形状为(n_query, n_indexed)

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

              n_neighbors: int

                  邻居数量。(默认为调用构造器时设定的n_neighboes的值)。

              mode: {‘connectivity’, ‘distance’}, 可选参数

                  返回矩阵数据类型： ‘connectivity’ 会返回1和0组成的矩阵。 in ‘distance’ 会返回点之间的欧几里得距离。

返回值:
              A: CSR格式的稀疏矩阵，形状为 [n_samples, n_samples_fit]

                  n_samples_fit 是拟合过的数据中样例的数量，其中 A[i, j] 代表i到j的边的权重。

关联：
NearestNeighbors.radius_neighbors_graph

例子：

>>> X=[[0], [3], [1]]
>>> from sklearn.neighbors import NearestNeighbors
>>> neigh=NearestNeighbors(n_neighbors=2)
>>> neigh.fit(X)
NearestNeighbors(algorithm='auto', leaf_size=30, ...)
>>> A=neigh.kneighbors_graph(X)
>>> A.toarray()array([[ 1.,  0.,  1.],
                      [ 0.,  1.,  1.],
                      [ 1.,  0.,  1.]])

predict(X)[source]

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

参数:
              X: 类似数组, 形状(n_query, n_features)。 如果矩阵是‘precomputed’，形状为(n_query, n_indexed) 

                  待测试样例。

返回值:
              y: 形状为 [n_samples] 或者 [n_samples, n_outputs]的数组

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

predict_proba(X)[source]

返回测试数据X的概率估值。

参数:
              X: 类似数组, 形状(n_query, n_features)。 如果矩阵是‘precomputed’，形状为(n_query, n_indexed) 

                  待测试样例。

返回值:
              p: 形状为[n_samples, n_classes]的数组，或者是n_outputs列表

                  输入样例的类别概率估值。其中类别根据词典顺序排序。

score(X, y, sample_weight=None)[source]

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

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

                  待测试样例

              y: 类似数组，形状为 (n_samples) 或者 (n_samples, n_outputs)

                  X对于的正确标签

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

                  待测试的权重

返回值:
              score : float

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

set_params(**params)[source]

设置估值器的参数。

此方法在单个估值器和嵌套对象（例如管道）中有效。而嵌套对象有着__形式的参数，方便更新各个参数。

返回值:
              self

使用到sklearn.neighbors.KNeighborsClassifier的案例

• Classifier comparison:
  

• Plot the decision boundaries of a VotingClassifier:
  

• Digits Classification Exercise:
  

• Nearest Neighbors Classification:
  

• Classification of text documents using sparse features: