1

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]是A[k,l]取所有索引k>i,l>j的总和；这与应用于两个轴的通常 cumsum 有点相反。我想知道是否有更优雅和更快的方法来做到这一点（例如使用 np.cumsum）？

4

1 回答 1

2

假设您正在尝试这样做：

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
于 2015-07-29T19:30:04.920 回答