NearestNeighbors#

class sklearn.neighbors.NearestNeighbors(*, n_neighbors=5, radius=1.0, algorithm='auto', leaf_size=30, metric='minkowski', p=2, metric_params=None, n_jobs=None)#

无监督学习者，用于实现邻居搜索。

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

Added in version 0.9.

Parameters:
n_neighborsint, default=5

默认用于 kneighbors 查询的邻居数量。

radiusfloat, default=1.0

默认用于 radius_neighbors 查询的参数空间范围。

algorithm{‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, default=’auto’

用于计算最近邻居的算法：

  • ‘ball_tree’ 将使用 BallTree

  • ‘kd_tree’ 将使用 KDTree

  • ‘brute’ 将使用暴力搜索。

  • ‘auto’ 将尝试根据传递给 fit 方法的值决定最合适的算法。

注意：在稀疏输入上拟合将覆盖此参数的设置，使用暴力搜索。

leaf_sizeint, default=30

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

metricstr or callable, default=’minkowski’

用于距离计算的度量。默认是 “minkowski”，当 p = 2 时，这会产生标准的欧几里得距离。请参阅 scipy.spatial.distance 的文档和 distance_metrics 中列出的度量，以获取有效的度量值。

如果度量是 “precomputed”，则假定 X 是距离矩阵，并且在拟合时必须是方阵。X 可以是 稀疏图 ，在这种情况下，只考虑 “非零” 元素作为邻居。

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

pfloat (正数), default=2

sklearn.metrics.pairwise.pairwise_distances 中 Minkowski 度量的参数。当 p = 1 时，这相当于使用 manhattan_distance (l1)，当 p = 2 时，使用 euclidean_distance (l2)。对于任意 p，使用 minkowski_distance (l_p)。

metric_paramsdict, default=None

度量函数的额外关键字参数。

n_jobsint, default=None

用于邻居搜索的并行作业数量。 None 意味着 1，除非在 joblib.parallel_backend 上下文中。 -1 意味着使用所有处理器。有关更多详细信息，请参阅 Glossary 。

Attributes:
effective_metric_str

用于计算邻居距离的度量。

effective_metric_params_dict

用于计算邻居距离的度量参数。

n_features_in_int

在 fit 过程中看到的特征数量。

Added in version 0.24.

feature_names_in_ndarray of shape ( n_features_in_ ,)

在 fit 过程中看到的特征名称。仅当 X 的特征名称均为字符串时定义。

Added in version 1.0.

n_samples_fit_int

拟合数据中的样本数量。

See also

KNeighborsClassifier

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

RadiusNeighborsClassifier

在给定半径内实现邻居投票的分类器。

KNeighborsRegressor

基于 k-最近邻居的回归。

RadiusNeighborsRegressor

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

BallTree

用于组织多维空间中点的空间分区数据结构，用于最近邻搜索。

Notes

有关 algorithm 和 leaf_size 选择的讨论，请参阅在线文档中的 Nearest Neighbors 。

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

Examples

>>> import numpy as np
>>> from sklearn.neighbors import NearestNeighbors
>>> samples = [[0, 0, 2], [1, 0, 0], [0, 0, 1]]
>>> neigh = NearestNeighbors(n_neighbors=2, radius=0.4)
>>> neigh.fit(samples)
NearestNeighbors(...)
>>> neigh.kneighbors([[0, 0, 1.3]], 2, return_distance=False)
array([[2, 0]]...)
>>> nbrs = neigh.radius_neighbors(
...    [[0, 0, 1.3]], 0.4, return_distance=False
... )
>>> np.asarray(nbrs[0][0])
array(2)
fit(X, y=None)#

拟合从训练数据集得到的最近邻估计器。

Parameters:
X{array-like, sparse matrix}，形状为 (n_samples, n_features) 或 如果 metric=’precomputed’ 则为 (n_samples, n_samples)

训练数据。

y忽略

未使用，为了API一致性而存在。

Returns:
selfNearestNeighbors

拟合的最近邻估计器。

get_metadata_routing()#

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

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

Returns:
routingMetadataRequest

MetadataRequest 封装的 路由信息。

get_params(deep=True)#

获取此估计器的参数。

Parameters:
deepbool, 默认=True

如果为True，将返回此估计器和包含的子对象（也是估计器）的参数。

Returns:
paramsdict

参数名称映射到它们的值。

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

查找一个点的K近邻。

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

Parameters:
X{array-like, sparse matrix}, shape (n_queries, n_features), 或 (n_queries, n_indexed) 如果 metric == ‘precomputed’, default=None

查询点或点。 如果未提供，则返回每个索引点的邻居。 在这种情况下，查询点不视为其自身的邻居。

n_neighborsint, default=None

每个样本所需的邻居数量。默认值是在构造函数中传递的值。

return_distancebool, default=True

是否返回距离。

Returns:
neigh_distndarray of shape (n_queries, n_neighbors)

表示到点的长度的数组，仅在 return_distance=True 时存在。

neigh_indndarray of shape (n_queries, n_neighbors)

在总体矩阵中最接近点的索引。

Examples

在以下示例中，我们从一个表示数据集的数组构造一个 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，并且是 samples 的第三个元素（索引从 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')#

计算X中点的k-邻居的（加权）图。

Parameters:
X{array-like, sparse matrix}，形状为(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参数。

Returns:
A形状为(n_queries, n_samples_fit)的稀疏矩阵

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

See also

NearestNeighbors.radius_neighbors_graph

计算X中点的（加权）邻居图。

Examples

>>> 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.]])
radius_neighbors(X=None, radius=None, return_distance=True, sort_results=False)#

查找给定半径内的点的邻居。

返回数据集中每个点在查询数组的点周围半径为 radius 的球内的索引和距离。位于边界上的点包含在结果中。

结果点与其查询点的距离不一定按升序排序。

Parameters:
X{array-like, sparse matrix} of (n_samples, n_features), default=None

查询点或点。 如果未提供，则返回每个索引点的邻居。 在这种情况下，查询点不视为其自身的邻居。

radiusfloat, default=None

返回邻居的限制距离。默认值是在构造函数中传递的值。

return_distancebool, default=True

是否返回距离。

sort_resultsbool, default=False

如果为True，距离和索引将在返回前按升序排序。如果为False，结果可能未排序。如果 return_distance=False ，设置 sort_results=True 将导致错误。

Added in version 0.22.

Returns:
neigh_distndarray of shape (n_samples,) of arrays

表示到每个点的距离的数组，仅在 return_distance=True 时存在。距离值根据 metric 构造函数参数计算。

neigh_indndarray of shape (n_samples,) of arrays

一个数组的数组，包含来自总体矩阵的近似最近点的索引，这些点位于查询点周围半径为 radius 的球内。

Notes

因为每个点的邻居数量不一定相等，多个查询点的结果不能适应标准数据数组。 为了效率， radius_neighbors 返回对象数组，其中每个对象是索引或距离的1D数组。

Examples

在以下示例中，我们从一个表示数据集的数组构造一个NeighborsClassifier类，并询问谁是[1, 1, 1]最近的点：

>>> import numpy as np
>>> samples = [[0., 0., 0.], [0., .5, 0.], [1., 1., .5]]
>>> from sklearn.neighbors import NearestNeighbors
>>> neigh = NearestNeighbors(radius=1.6)
>>> neigh.fit(samples)
NearestNeighbors(radius=1.6)
>>> rng = neigh.radius_neighbors([[1., 1., 1.]])
>>> print(np.asarray(rng[0][0]))
[1.5 0.5]
>>> print(np.asarray(rng[1][0]))
[1 2]

第一个返回的数组包含所有距离小于1.6的点的距离，而第二个返回的数组包含它们的索引。通常，可以同时查询多个点。

radius_neighbors_graph(X=None, radius=None, mode='connectivity', sort_results=False)#

计算X中点的（加权）邻居图。

邻居限制在距离小于半径的点。

Parameters:
X{array-like, sparse matrix}，形状为 (n_samples, n_features)，默认=None

查询点或点。 如果未提供，则返回每个索引点的邻居。 在这种情况下，查询点不被视为其自身的邻居。

radiusfloat，默认=None

邻域的半径。默认值是在构造函数中传递的值。

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

返回矩阵的类型：’connectivity’ 将返回带有1和0的连通性矩阵，在’distance’中， 边是点之间的距离，距离的类型取决于NearestNeighbors类中选择的度量参数。

sort_resultsbool，默认=False

如果为True，结果中的每一行的非零条目将按增加的距离排序。如果为False，非零条目可能 不会排序。仅在mode=’distance’时使用。

Added in version 0.22.

Returns:
A形状为 (n_queries, n_samples_fit) 的稀疏矩阵

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

See also

kneighbors_graph

计算X中点的（加权）k-邻居图。

Examples

>>> X = [[0], [3], [1]]
>>> from sklearn.neighbors import NearestNeighbors
>>> neigh = NearestNeighbors(radius=1.5)
>>> neigh.fit(X)
NearestNeighbors(radius=1.5)
>>> A = neigh.radius_neighbors_graph(X)
>>> A.toarray()
array([[1., 0., 1.],
       [0., 1., 0.],
       [1., 0., 1.]])
set_params(**params)#

设置此估计器的参数。

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

Parameters:
**paramsdict

估计器参数。

Returns:
selfestimator instance

估计器实例。

On this page
Show Source