Question

我在python中有numpy数组，其中包含很多（10k +）3D顶点（坐标为[x，y，z]的向量）。我需要计算这些点的所有可能对之间的距离。

使用scipy很容易：

import scipy
D = spdist.cdist(verts, verts)

但由于引入新依赖项的项目政策，我无法使用它。

所以我想出了这个幼稚的代码：

def vert_dist(self, A, B):
    return ((B[0]-A[0])**2+(B[1]-A[1])**2+(B[2]-A[2])**2)**(1.0/2)

# Pairwise distance between verts
#Use SciPy, otherwise use fallback
try:
    import scipy.spatial.distance as spdist
    D = spdist.cdist(verts, verts)
except ImportError:
    #FIXME: This is VERY SLOW:
    D = np.empty((len(verts), len(verts)), dtype=np.float64)
    for i,v in enumerate(verts):
        #self.app.setStatus(_("Calculating distance %d of %d (SciPy not installed => using SLOW AF fallback method)"%(i,len(verts))), True)
        for j in range(i,len(verts)):
            D[j][i] = D[i][j] = self.vert_dist(v,verts[j])

vert_dist（）计算两个顶点之间的3D距离，其余代码仅在1D数组中的顶点上进行迭代，并且对于每个顶点，它计算同一数组中彼此之间的距离并生成2D距离数组。

但是，与scipy的本机C代码相比，这非常慢（1000倍）。我想知道我是否可以使用纯numpy加快速度。至少在某种程度上。

更多信息：https://github.com/scipy/scipy/issues/9172

顺便说一句，我已经尝试过PyPy JIT编译器，它甚至比纯python慢（十倍）。

更新：我能够像这样加快速度：

    def vert_dist_matrix(self, verts):
            #FIXME: This is VERY SLOW:
            D = np.empty((len(verts), len(verts)), dtype=np.float64)
            for i,v in enumerate(verts):
                    D[i] = D[:,i] = np.sqrt(np.sum(np.square(verts-verts[i]), axis=1))
            return D

这可以一次计算整个行，从而消除了内部循环，这使内容变得更快，但仍然比scipy慢。所以我还是看看@Divakar的解决方案

Answer 1

有一个eucl_dist软件包（免责声明：我是它的作者），其中基本上包含两种方法来解决计算平方欧几里德距离的问题，该方法比SciPy's cdist更有效，特别是对于大型数组（到大量列）。

我们将使用其source code中的一些代码来适应我们的问题，从而为我们提供两种方法。

方法1

在wiki contents之后，我们可以将matrix-multiplication和一些NumPy specific implementations用作我们的第一种方法，就像这样-

def pdist_squareformed_numpy(a):
    a_sumrows = np.einsum('ij,ij->i',a,a)
    dist = a_sumrows[:,None] + a_sumrows -2*np.dot(a,a.T)
    np.fill_diagonal(dist,0)
    return dist

方法2

另一种方法是创建输入数组的“扩展”版本，再次在该github源代码链接中进行了详细讨论，以获取我们的第二种方法，这种方法适用于较小的列，例如此处所示-

def ext_arrs(A,B, precision="float64"):
    nA,dim = A.shape
    A_ext = np.ones((nA,dim*3),dtype=precision)
    A_ext[:,dim:2*dim] = A
    A_ext[:,2*dim:] = A**2

    nB = B.shape[0]
    B_ext = np.ones((dim*3,nB),dtype=precision)
    B_ext[:dim] = (B**2).T
    B_ext[dim:2*dim] = -2.0*B.T
    return A_ext, B_ext

def pdist_squareformed_numpy_v2(a):
    A_ext, B_ext = ext_arrs(a,a)
    dist = A_ext.dot(B_ext)
    np.fill_diagonal(dist,0)
    return dist

请注意，这些给了我们平方欧几里得距离。因此，对于实际距离，如果需要最终输出，我们想使用np.sqrt()。

样品运行-

In [380]: np.random.seed(0)
     ...: a = np.random.rand(5,3)

In [381]: from scipy.spatial.distance import cdist

In [382]: cdist(a,a)
Out[382]: 
array([[0.  , 0.29, 0.42, 0.2 , 0.57],
       [0.29, 0.  , 0.58, 0.42, 0.76],
       [0.42, 0.58, 0.  , 0.45, 0.9 ],
       [0.2 , 0.42, 0.45, 0.  , 0.51],
       [0.57, 0.76, 0.9 , 0.51, 0.  ]])

In [383]: np.sqrt(pdist_squareformed_numpy(a))
Out[383]: 
array([[0.  , 0.29, 0.42, 0.2 , 0.57],
       [0.29, 0.  , 0.58, 0.42, 0.76],
       [0.42, 0.58, 0.  , 0.45, 0.9 ],
       [0.2 , 0.42, 0.45, 0.  , 0.51],
       [0.57, 0.76, 0.9 , 0.51, 0.  ]])

In [384]: np.sqrt(pdist_squareformed_numpy_v2(a))
Out[384]: 
array([[0.  , 0.29, 0.42, 0.2 , 0.57],
       [0.29, 0.  , 0.58, 0.42, 0.76],
       [0.42, 0.58, 0.  , 0.45, 0.9 ],
       [0.2 , 0.42, 0.45, 0.  , 0.51],
       [0.57, 0.76, 0.9 , 0.51, 0.  ]])

在10k点上的计时-

In [385]: a = np.random.rand(10000,3)

In [386]: %timeit cdist(a,a)
1 loop, best of 3: 309 ms per loop

# Approach #1
In [388]: %timeit pdist_squareformed_numpy(a) # squared eucl distances
1 loop, best of 3: 668 ms per loop

In [389]: %timeit np.sqrt(pdist_squareformed_numpy(a)) # actual eucl distances
1 loop, best of 3: 812 ms per loop

# Approach #2
In [390]: %timeit pdist_squareformed_numpy_v2(a) # squared eucl distances
1 loop, best of 3: 237 ms per loop

In [391]: %timeit np.sqrt(pdist_squareformed_numpy_v2(a)) # actual eucl distances
1 loop, best of 3: 395 ms per loop

第二种方法似乎在性能上接近cdist！

Answer 2

您可以使用numpy.linalg.norm：

from numpy.linalg import norm

a = np.random.rand(10000, 3)
b = np.random.rand(10000, 3)

c = norm(a-b, axis=1)  # will return a np.array of distances

我没有进行基准测试，但是n=10K案例对我来说立即奏效。

使用numpy在python中进行向量化空间距离

2 个答案: