Question

A是（（d，e））numpy数组。我计算一个（（d，e））numpy数组B，我计算条目B [i，j]如下

b=0
for k in range(i+1,d):
    for l in range(j+1,e):
        b=b+A[k,l]
B[i,j]=b

换句话说，B [i，j]是取自所有索引k> i，l> j的A [k，l]的和;这与应用于两个轴的通常的cumsum相反。我想知道是否有更优雅和更快的方法（例如使用np.cumsum）？

Answer 1

假设您正在尝试这样做：

A = np.arange(15).reshape((5, -1))

def cumsum2_reverse(arr):
    out = np.empty_like(arr)
    d, e = arr.shape
    for i in xrange(d):
        for j in xrange(e):
            b = 0
            for k in xrange(i + 1, d):
                for l in xrange(j + 1, e):
                    b += arr[k, l]
            out[i, j] = b
    return out

然后，如果你这样做，

In [1]: A_revsum = cumsum2_reverse(A)

In [2]: A_revsum
Out[2]: 
array([[72, 38,  0],
      [63, 33,  0],
      [48, 25,  0],
      [27, 14,  0],
      [ 0,  0,  0]])

您可以在反向排序的数组上使用np.cumsum来计算总和。例如，一开始你可能会尝试类似@Jaime建议的东西：

In [3]: np.cumsum(np.cumsum(A[::-1, ::-1], 0), 1)[::-1, ::-1]
Out[3]:
array([[105,  75,  40],
       [102,  72,  38],
       [ 90,  63,  33],
       [ 69,  48,  25],
       [ 39,  27,  14]])

这里我们记得np.cumsum以第一列中的值开头（在本例中是最后一列），因此为了确保那里的零，您可以移动此操作的输出。这可能看起来像：

def cumsum2_reverse_alt(arr):
    out = np.zeros_like(arr)
    out[:-1, :-1] = np.cumsum(np.cumsum(arr[:0:-1, :0:-1], 0), 1)[::-1, ::-1]
    return out

这给出了与上面相同的值。

In [4]: (cumsum2_reverse(A) == cumsum2_reverse_alt(A)).all()
Out[4]: True

请注意，对于大型数组，使用np.cumsum的速度要快得多。例如：

In [5]: A=np.arange(3000).reshape((50, -1))

In [6]: %timeit cumsum2_reverse(A)
1 loops, best of 3: 453 ms per loop

In [7]: %timeit cumsum2_reverse_alt(A)
10000 loops, best of 3: 24.7 us per loop

numpy的反cumsum

1 个答案: