Question

这是轨迹的连续段（xy坐标）之间的点积的函数。结果如预期的那样，但是＆＃34; for循环＆＃34;让它很慢。

In [94]:
def func1(xy, s):
    size = xy.shape[0]-2*s
    out = np.zeros(size)
    for i in range(size):
        p1, p2 = xy[i], xy[i+s]     #segment 1
        p3, p4 = xy[i+s], xy[i+2*s] #segment 2
        out[i] = np.dot(p1-p2, p4-p3)
    return out

xy = np.array([[1,2],[2,3],[3,4],[5,6],[7,8],[2,4],[5,2],[9,9],[1,1]])
func1(xy, 2)

Out[94]:
array([-16.,  15.,  32.,  31., -14.])

我找了一种方法来对上面进行矢量化，希望能让它更快。以下是我提出的建议：

In [95]:
def func2(xy, s):
    size = xy.shape[0]-2*s
    p1 = xy[0:size]
    p2 = xy[s:size+s]
    p3 = p2
    p4 = xy[2*s:size+2*s]
    return np.diagonal(np.dot((p1-p2), (p4-p3).T))

func2(xy, 2)

Out[95]:
array([-16,  15,  32,  31, -14])

不幸的是，点积产生了一个方阵，从中我必须采用对角线：

In [96]:
print np.dot((p1-p2), (p4-p3).T)
np.diagonal(np.dot((p1-p2), (p4-p3).T))

[[-16  10  16 -24  10]
 [-24  15  24 -36  15]
 [-32  20  32 -48  20]
 [ 20 -13 -18  31 -14]
 [ 32 -18 -40  44 -14]]

Out[96]:
array([-16,  15,  32,  31, -14])

我的解决方案非常糟糕。它仅以2的比例提高速度，更重要的是它现在不具有可扩展性。我的平均轨迹有几万个点，这意味着我必须处理巨大的矩阵。

你们知道更好的方法吗？谢谢

编辑：真棒！ einsum绝对是解决方案。在我的沮丧中，我自己写了点积。我知道，不是很可读，它无法使用优化库，但无论如何它都是（func4）。速度与einsum相当。

def func4(xy, s):
    size = xy.shape[0]-2*s
    tmp1 = xy[0:size] - xy[s:size+s]
    tmp2 = xy[2*s:size+2*s] - xy[s:size+s]
    return tmp1[:, 0] * tmp2[:, 0] + tmp1[:, 1] * tmp2[:, 1]

Answer 1

func2中的您的想法自然会导致使用np.einsum。

func2的好处是它只计算p1，p2，p3，p4一次较大的数组而不是func1中的小块。

func2的不好之处在于，它会做很多你不做的点积关心。

这就是einsum的用武之地。它是np.dot的更灵活的版本。无论何时计算产品总数，都要考虑使用np.einsum。它可能是最快的（如果不是最快）计算方法之一数量使用NumPy。

def func3(xy, s):
    size = xy.shape[0]-2*s
    p1 = xy[0:size]
    p2 = xy[s:size+s]
    p3 = p2
    p4 = xy[2*s:size+2*s]
    return np.einsum('ij,ij->i', p1-p2, p4-p3)

下标字符串'ij,ij->i'具有以下含义：

下标字符串'ij,ij->i'分为两部分：箭头之前（->）位于左侧，ij,ij位于箭头后i。

在左侧，逗号前的ij引用p1-p2的下标，逗号后的ij引用p4-p3的下标。

爱因斯坦求和符号总结了箭头之后没有出现的重复下标。在这种情况下，j会重复出现，并且不会出现在箭头后面。

因此，对于每个i，计算总和(p1-p2)[i,j]*(p4-p3)[i,j]，其中总和将在所有j上运行。结果是由i索引的数组。

完整性检查：

In [90]: np.allclose(func1(xy, 2), func3(xy, 2))
Out[90]: True

这是一个基准：在形状{9}的数组xy上，使用einsum显示比func1快450倍，比func2快7470倍：

In [13]: xy = np.tile(xy, (1000,1))

In [14]: %timeit func1(xy, 2)
10 loops, best of 3: 42.1 ms per loop

In [15]: %timeit func2(xy, 2)
1 loops, best of 3: 686 ms per loop

In [16]: %timeit func3(xy, 2)
10000 loops, best of 3: 91.8 µs per loop

OP func4的效果甚至超过func3！

In [92]: %timeit func4(xy, 2)
10000 loops, best of 3: 74.1 µs per loop

我认为func4在einsum击败einsum的原因是因为仅仅手动写出2次迭代时{{1}}中的循环设置成本太高了总和。

Answer 2

einsum是宣传dot产品的好工具。玩弄它，我可以用：

重现你的数字

np.einsum('ij,ij->i',p1-p2,p4-p3)

＆＃39; IJ，KJ＆＃39;产生dot(p1-p2, (p4-p3).T); ＆＃39;我...，我...-＆gt;我＆＃39;做对角线 - 一步到位。

作为我尝试的跨产品问题的衍生产品

tmp11,tmp21),tmp11[:,0]*tmp21[:,0]+tmp11[:,1]*tmp21[:,1])

对于5000行数组，它几乎是einsum计算速度的2倍。

如何在轨迹的各段之间矢量化点积

2 个答案: