给定距离内的点分组算法

Question

我目前正在寻找一种高效算法，该算法从三维空间中获取一组点并将它们分组为类（可能由列表表示）。如果一个点与该类中的一个或多个其他点接近，则它应该属于一个类。如果它们共享任何点，则两个类是相同的。 因为我正在处理大型数据集，所以我不想使用递归方法。此外，我尽量避免使用诸如具有 O(n^2) 性能的距离矩阵之类的东西。

我尝试在网上检查一些算法，但其中大多数并不适用于这个特定目的（例如 k-d 树或其他集群算法）。我曾想过将空间分成更小的部分，但这（可能）会导致结果不准确。

我试图自己写一些东西，但结果证明是有缺陷的。我会在距离之后对我的点进行排序并将距离附加为第四个坐标，然后重复以下代码段：

def grouping_presorted(lst, distance):
    positions = [0]
    x = []
    while positions:
        curr_el = lst[ positions[-1] ]
        nn_i = HasNeighbor(lst, distance, positions[-1])

        if nn_i is None:
            x.append(lst.pop(positions[-1]) )
            positions.pop(-1)
        else:
            positions.append(nn_i)
    return x

def HasNeighbor(lst,distance,index):
    i =  index+1
    while lst[i][3]- lst[index][3] < distance:
        dist = (lst[i][0]-lst[index][0])**2 + (lst[i][1]-lst[index][1])**2 + (lst[i][2]-lst[index][2])**2
        if dist < distance:
            return i
        i+=1
    return None

除了（可能很容易修复）溢出错误之外，链接点的逻辑还有一个更大的缺陷。如果您认为我的观点描述了空间中的线，那么该算法仅适用于严格指向原点外部的线，而不适用于圆形或类似结构。

是否有人知道为此预先编写的代码或知道我可以尝试什么？

提前致谢。

编辑：似乎我的拼写以及某些术语的混淆引发了一些误解。我希望这个（糟糕的）草图有所帮助。在这个例子中，我将我的参考距离标记为 d，并用红色圈出了我不希望最终得到的两个容器。

Answer 1

你可以试试https://en.wikipedia.org/wiki/OPTICS_algorithm。当您首先索引点时（例如，使用 R-Tree），这应该可以在 O(n log n) 中实现。

编辑：

如果您已经知道您的 epsilon 以及集群中最少有多少点 (minpoints)，那么 DBSCAN 可能是更好的选择。

Answer 2

我最终做了什么

在听取了您的 cmets 的所有建议、来自 cs.stackexchange 的帮助并进行了一些研究之后，我能够写下两种不同的方法来解决这个问题。如果有人可能感兴趣，我决定在这里分享。同样，问题是编写一个程序，接收一组坐标元组并将它们分组到集群中。如果存在元素序列 x=x_1,..,y=x_N 使得 d(x_i,x_i+1) ，则两个点 x,y 属于同一个簇

---

DBSCAN： 通过固定欧几里得度量，minPts = 2 和分组距离 epsilon = r。 scikit-learn 提供了这个算法的一个很好的实现。该任务的最小代码 sn-p 将是：

from sklearn.cluster import DBSCAN
from sklearn.datasets.samples_generator import make_blobs
import networkx as nx
import scipy.spatial as sp

def cluster(data, epsilon,N): #DBSCAN, euclidean distance
    db     = DBSCAN(eps=epsilon, min_samples=N).fit(data)
    labels = db.labels_ #labels of the found clusters
    n_clusters = len(set(labels)) - (1 if -1 in labels else 0) #number of clusters
    clusters   = [data[labels == i] for i in range(n_clusters)] #list of clusters
    return clusters, n_clusters

centers = [[1, 1,1], [-1, -1,1], [1, -1,1]]
X,_ = make_blobs(n_samples=N, centers=centers, cluster_std=0.4,
                            random_state=0)
cluster(X,epsilon,N)

在我的机器上，N=20000 对于这种具有 epsilon = 0.1 的 epsilon 的集群变化只需要 290ms，所以这看起来确实快给我。

---

图组件： 可以把这个问题想象成：坐标定义了一个图的节点，如果两个节点的距离小于epsilon/r，则两个节点是相邻的。然后给出一个集群作为该图的连接组件。起初我在实现这个图时遇到了问题，但是有很多方法可以编写线性时间算法来做到这一点。然而，对我来说，最简单和最快的方法是使用 scipy.spatial 的 cKDTree 数据结构和相应的 query_pairs() 方法，它返回给定距离内的点的索引元组列表。例如，可以这样写：

class IGraph:
    def __init__(self, nodelst=[], radius = 1):
        self.igraph = nx.Graph()
        self.radii  = radius
        self.nodelst = nodelst #nodelst is array of coordinate tuples, graph contains indices as nodes
        self.__make_edges__()

    def __make_edges__(self):
        self.igraph.add_edges_from( sp.cKDTree(self.nodelst).query_pairs(r=self.radii) )

    def get_conn_comp(self):
        ind = [list(x) for x in nx.connected_components(self.igraph) if len(x)>1]
        return [self.nodelst[indlist] for indlist in ind]


def graph_cluster(data, epsilon):
    graph = IGraph(nodelst = data, radius = epsilon)
    clusters = graph.get_conn_comp() 
    return clusters, len(clusters)

对于上面提到的同一个数据集，这个方法需要 420ms 来找到连接的组件。但是，对于较小的集群，例如N=700，这个sn-p跑得更快。它似乎在寻找更小的集群（即被赋予更小的 epsilon 值）方面也有优势，而在另一个方向上则有很大的劣势（当然，所有这些都在这个特定的数据集上）。我认为，根据给定的情况，这两种方法都值得考虑。

希望这对某人有用。

编辑： 从理论上讲，DBSCAN 在正确实现时具有 O(n log n) 的计算复杂度（根据维基百科...），同时构建图以及查找其连接的组件以线性方式运行时间。不过，我不确定这些语句对于给定的实现有多好。

Answer 3

采用路径查找算法，例如 Dijkstra 或 A*，或者采用图的广度优先或深度优先搜索。从一组未访问点中的任何点开始，然后继续执行您选择的任何算法，但需要注意的是，一个点被认为只连接到其距离小于阈值的所有点。当你完成一个类时（即当你无法发现更多新节点时），从一组未访问的节点中选择任何一个节点并重复。