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)[source]#

实现k近邻投票的分类器。

更多信息请参见用户指南。

参数：

n_neighborsint, 默认值=5

默认情况下，kneighbors 查询使用的邻居数量。

weights{'uniform', 'distance'}, 可调用对象或None，默认值='uniform'

预测中使用的权重函数。可能的值：

‘uniform’ : 均匀权重。每个邻域中的所有点权重相等。
‘distance’ : 根据距离的倒数对点进行加权。在这种情况下，查询点较近的邻居比较远的邻居影响更大。
[可调用对象] : 用户定义的函数，它接受一个距离数组，并返回一个包含权重的相同形状的数组。

请参考标题为最近邻分类的示例，该示例显示了 weights 参数对决策边界的的影响。

algorithm{'auto', 'ball_tree', 'kd_tree', 'brute'}, 默认值='auto'

用于计算最近邻的算法

‘ball_tree’ 将使用 BallTree
‘kd_tree’ 将使用 KDTree
‘brute’ 将使用蛮力搜索。
‘auto’ 将尝试根据传递给 fit 方法的值确定最合适的算法。

注意：对稀疏输入进行拟合将覆盖此参数的设置，使用蛮力方法。

leaf_sizeint, 默认值=30

传递给 BallTree 或 KDTree 的叶子大小。这会影响构建和查询的速度，以及存储树所需的内存。最佳值取决于问题的性质。

pfloat, 默认值=2

Minkowski 度量的幂参数。当 p = 1 时，这等效于使用 manhattan_distance (l1)，当 p = 2 时，等效于使用 euclidean_distance (l2)。对于任意 p，使用 minkowski_distance (l_p)。此参数应为正值。

metricstr 或可调用对象，默认值='minkowski'

用于距离计算的度量。默认为“minkowski”，当 p = 2 时，这将导致标准欧几里德距离。请参见 scipy.spatial.distance 的文档以及 distance_metrics 中列出的度量，以了解有效的度量值。

如果 metric 为“precomputed”，则假定 X 为距离矩阵，并且在拟合过程中必须为方阵。X 可以是稀疏图，在这种情况下，只有“非零”元素可能被视为邻居。

如果 metric 是一个可调用的函数，它将接受两个表示一维向量的数组作为输入，并且必须返回一个值来指示这些向量之间的距离。这适用于 Scipy 的度量，但效率低于将度量名称作为字符串传递。

metric_paramsdict, 默认值=None

度量函数的其他关键字参数。

n_jobsint, 默认值=None

为邻居搜索运行的并行作业数。None 表示 1，除非在 joblib.parallel_backend 上下文中。-1 表示使用所有处理器。有关更多详细信息，请参见词汇表。不影响 fit 方法。

属性：

classes_形状为 (n_classes,) 的数组: 分类器已知的类别标签
effective_metric_str 或可调用对象: 使用的距离度量。它将与 metric 参数相同，或者与其同义，例如，如果 metric 参数设置为 'minkowski' 且 p 参数设置为 2，则为 'euclidean'。
effective_metric_params_dict: 度量函数的其他关键字参数。对于大多数度量来说，它与metric_params参数相同，但如果effective_metric_属性设置为“minkowski”，则可能还包含p参数值。
n_features_in_int: 在拟合期间看到的特征数量。

0.24 版本中添加。
feature_names_in_形状为 (n_features_in_,) 的 ndarray: 在拟合期间看到的特征名称。仅当X的特征名称全部为字符串时才定义。

1.0 版本中添加。
n_samples_fit_int: 拟合数据中的样本数。
outputs_2d_bool: 当拟合期间y的形状为 (n_samples,) 或 (n_samples, 1) 时为 False，否则为 True。

另请参阅

半径近邻分类器: 基于固定半径内的邻居的分类器。
K 近邻回归器: 基于 k 近邻的回归。
半径近邻回归器: 基于固定半径内的邻居的回归。
最近邻: 用于实现邻居搜索的无监督学习器。

备注

有关algorithm和leaf_size的选择，请参阅在线文档中的最近邻。

警告

关于最近邻算法，如果发现两个邻居，邻居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.666... 0.333...]]

fit(X, y)[source]#

从训练数据集中拟合 k 近邻分类器。

参数：

X形状为 (n_samples, n_features) 或 (n_samples, n_samples)（如果 metric='precomputed'）的 {数组、稀疏矩阵}: 训练数据。
y形状为 (n_samples,) 或 (n_samples, n_outputs) 的 {数组、稀疏矩阵}: 目标值。

返回:

selfKNeighborsClassifier: 拟合的 k 近邻分类器。

get_metadata_routing()[source]#

获取此对象的元数据路由。

请查看用户指南，了解路由机制的工作原理。

返回:

routingMetadataRequest: 一个MetadataRequest，封装了路由信息。

get_params(deep=True)[source]#

获取此估计器的参数。

参数：

deepbool，默认为 True: 如果为 True，则将返回此估计器和包含的作为估计器的子对象的参数。

返回:

paramsdict: 参数名称映射到其值。

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

查找一个点的 K 近邻。

返回每个点的邻居的索引和距离。

参数：

X形状为 (n_queries, n_features) 或 (n_queries, n_indexed)（如果 metric == 'precomputed'）的 {数组、稀疏矩阵}，默认为 None: 查询点或点。如果不提供，则返回每个索引点的邻居。在这种情况下，查询点不被认为是它自己的邻居。
n_neighborsint，默认为 None: 每个样本所需的邻居数。默认为传递给构造函数的值。
return_distancebool，默认为 True: 是否返回距离。

返回:

neigh_dist形状为 (n_queries, n_neighbors) 的 ndarray: 表示到点的长度的数组，仅当 return_distance=True 时才存在。
neigh_ind形状为 (n_queries, n_neighbors) 的 ndarray: 总体矩阵中最近点的索引。

示例

在下面的示例中，我们从表示数据集的数组构造一个 NearestNeighbors 类，并询问谁是与 [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(n_neighbors=1)
>>> 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_queries, n_features)的{数组, 稀疏矩阵}，如果metric == ‘precomputed’，则为(n_queries, n_indexed)，默认为None: 查询点。如果未提供，则返回每个索引点的邻居。在这种情况下，查询点不被认为是其自身的邻居。对于metric='precomputed'，形状应为(n_queries, n_indexed)。否则形状应为(n_queries, n_features)。
n_neighborsint，默认为 None: 每个样本的邻居数量。默认为构造函数中传递的值。
mode{'connectivity', 'distance'}，默认为'connectivity': 返回矩阵的类型：'connectivity'将返回具有1和0的连通性矩阵，在'distance'中，边是点之间的距离，距离的类型取决于NearestNeighbors类中选择的metric参数。

返回:

A形状为(n_queries, n_samples_fit)的稀疏矩阵: n_samples_fit是拟合数据中的样本数量。A[i, j]给出连接i到j的边的权重。矩阵为CSR格式。

另请参阅

NearestNeighbors.radius_neighbors_graph: 计算X中点的邻居的（加权）图。

示例

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

predict(X)[source]#

预测所提供数据的类别标签。

参数：

X形状为(n_queries, n_features)的{数组, 稀疏矩阵}，如果metric == ‘precomputed’，则为(n_queries, n_indexed)，或者为None: 测试样本。如果为None，则返回所有索引点的预测；在这种情况下，点不被认为是其自身的邻居。

返回:

y形状为(n_queries,)或(n_queries, n_outputs)的ndarray: 每个数据样本的类别标签。

predict_proba(X)[source]#

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

参数：

X形状为(n_queries, n_features)的{数组, 稀疏矩阵}，如果metric == ‘precomputed’，则为(n_queries, n_indexed)，或者为None: 测试样本。如果为None，则返回所有索引点的预测；在这种情况下，点不被认为是其自身的邻居。

返回:

p形状为(n_queries, n_classes)的ndarray，如果n_outputs > 1，则为此类数组的n_outputs列表。: 输入样本的类别概率。类别按字典顺序排序。

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

返回给定测试数据和标签的平均准确率。

在多标签分类中，这是子集准确率，这是一个严格的指标，因为您要求每个样本的每个标签集都被正确预测。

参数：

X形状为(n_samples, n_features)的类数组，或None: 测试样本。如果为None，则使用所有索引点的预测；在这种情况下，点不被认为是其自身的邻居。这意味着knn.fit(X, y).score(None, y)隐式地执行留一法交叉验证过程，等效于cross_val_score(knn, X, y, cv=LeaveOneOut())，但通常速度快得多。
y形状为(n_samples,)或(n_samples, n_outputs)的类数组: X的真实标签。
sample_weight形状为(n_samples,)的类数组，默认为None: 样本权重。

返回: