sklearn.neighbors.BallTree

class sklearn.neighbors.BallTree(X, leaf_size=40, metric='minkowski', **kwargs)

BallTree用于快速广义N-point问题

参数 说明
X array-like of shape (n_samples, n_features)
n_samples是数据集中的点数，n_features是参数空间的维数。 注意：如果X是C连续的双精度数组，则不会复制数据。 否则，将进行内部复制。
leaf_size positive int, default=40
转换为蛮力点的点数。 更改leaf_size不会影响查询的结果，但是会显着影响查询的速度以及存储构造的树所需的内存。 存储树比例尺所需的内存量约为n_samples / leaf_size。 对于指定的leaf_size，请确保叶子节点满足leaf_size <= n_points <= 2 * leaf_size，除非n_samples <leaf_size。
metric str or DistanceMetric object
树使用的距离度量。 默认值=“ minkowski”，其中p = 2（即欧氏度量）。
有关可用度量的列表，请参见DistanceMetric类的文档。
ball_tree.valid_metrics给出了对BallTree有效的度量的列表。
其他关键字将传递到距离度量标准类。
注意：KDTree和Ball Tree 中不支持metric参数中的可调用函数。
函数调用开销将导致非常差的性能。
属性 说明
data memory view
训练数据

示例 查询k-最近邻

>>> import numpy as np
>>> rng = np.random.RandomState(0)
>>> X = rng.random_sample((10, 3))  # 10 points in 3 dimensions
>>> tree = BallTree(X, leaf_size=2)              # doctest: +SKIP
>>> dist, ind = tree.query(X[:1], k=3)                # doctest: +SKIP
>>> print(ind)  # indices of 3 closest neighbors
[0 3 1]
>>> print(dist)  # distances to 3 closest neighbors
[ 0.          0.19662693  0.29473397]

请注意，树的状态是在pickle操作中保存的：解开时不需要重建树。

>>> import numpy as np
>>> import pickle
>>> rng = np.random.RandomState(0)
>>> X = rng.random_sample((10, 3))  # 10 points in 3 dimensions
>>> tree = BallTree(X, leaf_size=2)        # doctest: +SKIP
>>> s = pickle.dumps(tree)                     # doctest: +SKIP
>>> tree_copy = pickle.loads(s)                # doctest: +SKIP
>>> dist, ind = tree_copy.query(X[:1], k=3)     # doctest: +SKIP
>>> print(ind)  # indices of 3 closest neighbors
[0 3 1]
>>> print(dist)  # distances to 3 closest neighbors
[ 0.          0.19662693  0.29473397]

查询给定半径内的临近点

>>> import numpy as np
>>> rng = np.random.RandomState(0)
>>> X = rng.random_sample((10, 3))  # 10 points in 3 dimensions
>>> tree = BallTree(X, leaf_size=2)     # doctest: +SKIP
>>> print(tree.query_radius(X[:1], r=0.3, count_only=True))
3
>>> ind = tree.query_radius(X[:1], r=0.3)  # doctest: +SKIP
>>> print(ind)  # indices of neighbors within distance 0.3
[3 0 1]

计算高斯核密度估计：

>>> import numpy as np
>>> rng = np.random.RandomState(42)
>>> X = rng.random_sample((100, 3))
>>> tree = BallTree(X)                # doctest: +SKIP
>>> tree.kernel_density(X[:3], h=0.1, kernel='gaussian')
array([ 6.94114649,  7.83281226,  7.2071716 ])

计算两点自相关函数

>>> import numpy as np
>>> rng = np.random.RandomState(0)
>>> X = rng.random_sample((30, 3))
>>> r = np.linspace(0, 1, 5)
>>> tree = BallTree(X)                # doctest: +SKIP
>>> tree.two_point_correlation(X, r)
array([ 30,  62, 278, 580, 820])

方法

方法 说明
get_arrays() 获取数据和节点数组。
get_n_calls() 获取通话数量。
get_tree_stats() 获取树状态。
kernel_density(, X, h[, kernel, atol, …]) 使用在树创建时指定的距离度量，使用给定的内核计算点X处的内核密度估计。
query(X[, k, return_distance, dualtree, …]) 查询树中最近的k个临近点
query_radius(X, r[, return_distance, …]) 查询树中半径为r的临近点
reset_n_calls() 将会话次数重置为0。
two_point_correlation(X, r[, dualtree]) 计算两点相关函数 
__init__(, /, *args, **kwargs)

初始化self， 请参阅help(type())以获得准确的说明.

get_arrays()

获取数据和节点数组。

返回值 说明
arrays: tuple of array
用于存储树数据，索引，节点数据和节点边界的数组。		 
get_tree_stats()

获取树状态

返回值 说明
tree_stats tuple of int
（修剪数量，叶子数量，分割数量）		 
kernel_density(, X, h, kernel='gaussian', atol=0, rtol=1E-8, breadth_first=True, return_log=False)

使用在树创建时指定的距离度量，使用给定的内核计算点X处的内核密度估计。

参数 说明
X array-like of shape (n_samples, n_features)
要查询的点数组。 最后维度应与训练数据的维度匹配。
h float
内核的宽度
kernel str, default=”gaussian”
指定要使用的内核。 选项为-'gaussian'-'tophat'-'epanechnikov'-'exponential'-'linear'-'cosine'默认为kernel ='gaussian'
atol, rtol float, default=0, 1e-8
指定结果的所需相对和绝对公差。 如果真实结果为K_true，则返回的结果K_ret满足abs（K_true-K_ret）<atol + rtol * K_ret两者的默认值为零（即机器精度）。
breadth_first bool, default=False
如果为True，则使用广度优先搜索。 如果为False（默认），则使用深度优先搜索。 对于紧凑的内核和/或高公差，广度优先通常更快。
return_log bool, default=False
回结果的对数。 这比返回狭窄内核的结果本身更准确。
返回值 说明
density ndarray of shape X.shape[:-1]
（对数）密度评估的数组		 
query(X, k=1, return_distance=True, dualtree=False, breadth_first=False)

查询树中最近的k个临近点

参数 说明
X array-like of shape (n_samples, n_features)
要查询的点数组
k int, default=1
要返回的最近临近点的数量
return_distance bool, default=True
如果为True，则返回距离和索引的元组（d，i）；如果为False，则返回数组i
dualtree bool, default=False
如果为True，则对查询使用双树形式：对查询点构建一棵树，并使用这对树来有效地搜索该空间。 随着点数的增加，这可以导致更好的性能。
breadth_first bool, default=False
如果为True，则以广度优先的方式查询节点。 否则，以深度优先的方式查询节点。
sort_results bool, default=True
如果为True，则在返回时对每个点的距离和索引进行排序，以便第一列包含最近的点。 否则，将以任意顺序返回临近点。
返回值 说明
i： if return_distance == False
(d,i)： if return_distance == True
d： ndarray of shape X.shape[:-1] + k, dtype=double<br> 每个条目都列出了到相应点的临近点的距离列表。
i indarray of shape X.shape[:-1] + k, dtype=int<br> 每个条目给出相应点的邻近点的索引列表。 
query_radius(X, r, return_distance=False, count_only=False, sort_results=False)

查询树中半径为r的临近点

参数 说明
X array-like of shape (n_samples, n_features)
要查询的点数组
r distance within which neighbors are returned
r可以是单个值，也可以是形状为x.shape [：-1]的值的数组，如果每个点都需要不同的半径。
return_distance bool, default=False
如果为True，则返回到每个点的临近点的距离；如果为False，则仅返回临近点的注意。请注意，与query（）方法不同，此处设置return_distance = True会增加计算时间。 对于return_distance = False，并非所有距离都需要显式计算。 默认情况下，结果未排序：请参见sort_results关键字。
count_only bool, default=False
如果为True，则仅返回距离r内的点的计数；如果为False，则返回距离r内所有点的索引。如果return_distance == True，则设置count_only = True将导致错误。
sort_results bool, default=False
如果为True，则距离和索引将在返回之前进行排序。 如果为False，则不会对结果进行排序。 如果return_distance == False，则将sort_results = True设置将导致错误。
返回值 说明
- count:if count_only == True
ind:if count_only == False and return_distance == False
(ind, dist):if count_only == False and return_distance == True
count: ndarray of shape X.shape[:-1], dtype=int
每个条目给出在对应点的距离r内的临近点数。
ind： ndarray of shape X.shape[:-1], dtype=object
每个元素都是一个numpy整数数组，列出相应点的临近点的索引。 请注意，与k临近点查询的结果不同，默认情况下，返回的邻近点不按距离排序。
dist： ndarray of shape X.shape[:-1], dtype=object
每个元素都是一个numpy双数组，列出与i中的索引相对应的距离。		 
reset_n_calls()

将会话次数重置为0。

two_point_correlation(X, r, dualtree=False)

计算两点相关函数

参数 说明
X array-like of shape (n_samples, n_features)
要查询的点数组。 最后维度应与训练数据的维度匹配。
r array-like
一维距离数组
dualtree bool, default=False
如果为True，则使用双树算法。 否则，请使用单树算法。 双树算法可以针对较大的N具有更好的缩放比例。
返回值 说明
counts ndarray
counts [i]包含距离小于或等于r [i]的点对的数量