最近邻#

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

实现近邻搜索的无监督学习器。

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

0.9版本中添加。

参数：
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，默认值=30

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

metricstr 或 callable，默认值='minkowski'

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

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

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

pfloat（正数），默认值=2

来自 sklearn.metrics.pairwise.pairwise_distances 的 Minkowski 度量的参数。当 p = 1 时，这等效于使用 manhattan_distance (l1)，而 p = 2 时则为 euclidean_distance (l2)。对于任意 p，使用 minkowski_distance (l_p)。

metric_paramsdict，默认值=None

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

n_jobsint，默认值=None

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

属性：
effective_metric_str

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

effective_metric_params_dict

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

n_features_in_int

在 拟合期间看到的特征数量。

在 0.24 版本中添加。

feature_names_in_ndarray，形状为（n_features_in_，）

在 拟合期间看到的特征名称。仅当 X 的特征名称全部为字符串时才定义。

在 1.0 版本中添加。

n_samples_fit_int

拟合数据中的样本数。

另请参阅

K近邻分类器

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

半径近邻分类器

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

K近邻回归器

基于 k 近邻的回归。

半径近邻回归器

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

球树

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

备注

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

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

示例

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

从训练数据集中拟合最近邻估计器。

参数：
X形状为 (n_samples, n_features) 或 (n_samples, n_samples)（如果 metric='precomputed'）的 {array-like，稀疏矩阵}

训练数据。

y忽略

未使用，出于惯例，为了 API 一致性而存在。

返回：
selfNearestNeighbors

拟合的最近邻估计器。

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{array-like，稀疏矩阵}，形状为 (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.]])
radius_neighbors(X=None, radius=None, return_distance=True, sort_results=False)[source]#

查找给定半径内某点或多个点的邻居。

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

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

参数：
X形状为 (n_samples, n_features) 的 {数组、稀疏矩阵}，默认为 None

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

radius浮点数，默认为 None

返回邻居的限制距离。默认为传递给构造函数的值。

return_distancebool，默认值=True

是否返回距离。

sort_results布尔值，默认为 False

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

在 0.22 版本中添加。

返回：
neigh_dist形状为 (n_samples,) 的数组的 ndarray

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

neigh_ind形状为 (n_samples,) 的数组的 ndarray

一个数组，包含总体矩阵中位于查询点周围大小为 radius 的球体内的近似最近邻点的索引数组。

备注

由于每个点的邻居数量不一定是相等的，因此多个查询点的结果无法放入标准数据数组中。为了提高效率，radius_neighbors 返回对象数组，其中每个对象都是一个包含索引或距离的一维数组。

示例

在下面的例子中，我们从一个表示数据集的数组构造一个 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)[source]#

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

邻域限制在距离小于 radius 的点。

参数：
X形状为 (n_samples, n_features) 的 {数组、稀疏矩阵}，默认为 None

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

radius浮点数，默认为 None

邻域半径。默认为传递给构造函数的值。

mode{'connectivity', 'distance'}，默认为 'connectivity'

返回矩阵的类型：'connectivity' 将返回包含 1 和 0 的连接矩阵，在 'distance' 中，边是点之间的距离，距离的类型取决于 NearestNeighbors 类中选择的 metric 参数。

sort_results布尔值，默认为 False

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

在 0.22 版本中添加。

返回：
A形状为 (n_queries, n_samples_fit) 的稀疏矩阵

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

另请参阅

k近邻图

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

示例

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

设置此估计器的参数。

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

参数：
**params**dict

估计器参数。

返回：
selfestimator instance

估计器实例。