KNeighborsClassifier#

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

K 近邻查询默认使用的邻居数量。

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

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

  • ‘uniform’：均匀权重。每个邻域中的所有点权重相等。

  • ‘distance’：根据距离的倒数对点进行加权。在这种情况下，查询点附近更近的邻居将比更远的邻居具有更大的影响力。

  • [callable]：一个用户定义的函数，它接受一个距离数组，并返回一个包含相同形状权重的数组。

请参阅名为最近邻分类的示例，其中展示了 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

闵可夫斯基距离的幂参数。当 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 中列出的度量。

如果度量是“precomputed”，则假定 X 是一个距离矩阵，并且在拟合期间必须是方阵。X 可以是稀疏图，在这种情况下，只有“非零”元素才被视为邻居。

如果度量是一个可调用函数，它接受两个表示一维向量的数组作为输入，并且必须返回一个值表示这些向量之间的距离。这适用于 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。

另请参见

RadiusNeighborsClassifier

基于固定半径内邻居的分类器。

KNeighborsRegressor

基于 K 近邻的回归。

RadiusNeighborsRegressor

基于固定半径内邻居的回归。

NearestNeighbors

用于实现邻居搜索的无监督学习器。

备注

有关 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), 或 (n_queries, n_indexed)（如果 metric == ‘precomputed’）, 默认值=None

查询点或点集。如果未提供，则返回每个索引点的邻居。在这种情况下，查询点不被视为其自身的邻居。对于 metric='precomputed'，形状应为 (n_queries, n_indexed)。否则，形状应为 (n_queries, n_features)。

n_neighborsint, 默认值=None

每个样本的邻居数量。默认值是传递给构造函数的值。

mode{‘connectivity’, ‘distance’}, 默认值=’connectivity’

返回矩阵的类型：“connectivity”将返回由1和0组成的连接矩阵，“distance”中边的值是点之间的距离，距离类型取决于 NearestNeighbors 类中选择的度量参数。

返回:
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), 或 (n_queries, n_indexed)（如果 metric == ‘precomputed’）, 或 None

测试样本。如果为 None，则返回所有索引点的预测；在这种情况下，点不被视为其自身的邻居。

返回:
y形状为 (n_queries,) 或 (n_queries, n_outputs) 的 ndarray

每个数据样本的类别标签。

predict_proba(X)[source]#

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

参数:
X{类数组, 稀疏矩阵}, 形状为 (n_queries, n_features), 或 (n_queries, n_indexed)（如果 metric == ‘precomputed’）, 或 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

样本权重。

返回:
scorefloat

self.predict(X) 相对于 y 的平均准确度。

set_params(**params)[source]#

设置此估计器的参数。

该方法适用于简单的估计器以及嵌套对象（例如 Pipeline）。后者具有 <component>__<parameter> 形式的参数，以便可以更新嵌套对象的每个组件。

参数:
**paramsdict

估计器参数。

返回:
self估计器实例

估计器实例。

set_score_request(*, sample_weight: bool | None | str = '$UNCHANGED$') → KNeighborsClassifier[source]#

请求传递给 score 方法的元数据。

请注意，此方法仅在 enable_metadata_routing=True 时才相关（请参阅 sklearn.set_config）。请参阅用户指南，了解路由机制的工作原理。

每个参数的选项为：

  • True: 请求元数据，如果提供则传递给 score。如果未提供元数据，则忽略该请求。

  • False: 不请求元数据，元估计器不会将其传递给 score。

  • None: 不请求元数据，如果用户提供元数据，元估计器将引发错误。

  • str: 元数据应使用此给定的别名而不是原始名称传递给元估计器。

默认值 (sklearn.utils.metadata_routing.UNCHANGED) 保留现有请求。这允许您更改某些参数的请求，而不更改其他参数。

1.3 版本新增。

注意

此方法仅当此估计器用作元估计器的子估计器时才相关，例如在 Pipeline 内部使用时。否则，它不起作用。

参数:
sample_weightstr, True, False, 或 None, 默认值=sklearn.utils.metadata_routing.UNCHANGED

score 方法中 sample_weight 参数的元数据路由。

返回:
self对象

更新后的对象。