Question

给定一个数组＆＃39;数组＆＃39;和一组索引＆＃39;如何找到通过以矢量化方式沿着那些索引分割数组而形成的子阵列的累积和？澄清一下，假设我有：

>>> array = np.arange(20)
>>> array
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
indices = np.arrray([3, 8, 14])

操作应输出：

array([0, 1, 3, 3, 7, 12, 18, 25, 8, 17, 27, 38, 50, 63, 14, 29, 45, 62, 80, 99])

请注意，阵列非常大（100000个元素），因此，我需要一个矢量化答案。使用任何循环会大大减慢它。另外，如果我有同样的问题，但是2D数组和相应的索引，我需要对数组中的每一行做同样的事情，我该怎么做？

对于2D版本：

>>>array = np.arange(12).reshape((3,4))
>>>array
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> indices = np.array([[2], [1, 3], [1, 2]])

输出结果为：

array([[ 0,  1,  3,  3],
       [ 4,  9,  6, 13],
       [ 8, 17, 10, 11]])

澄清：每一行都将被拆分。

Answer 1

您可以在indices位置引入原始累加求和数组的微分，以在这些位置创建类似边界的效果，这样当差分数组被累加求和时，给出 indices-stopped累积求和输出。初看起来可能会感觉有点设计，但坚持下去，试试其他样品，希望有意义！这个想法与this other MATLAB solution.中应用的想法非常相似所以，遵循这样的哲学，这里使用numpy.diff和cumulative summation的一种方法 -

# Get linear indices
n = array.shape[1]
lidx = np.hstack(([id*n+np.array(item) for id,item in enumerate(indices)]))

# Get successive differentiations
diffs = array.cumsum(1).ravel()[lidx] - array.ravel()[lidx]

# Get previous group's offsetted summations for each row at all 
# indices positions across the entire 2D array
_,idx = np.unique(lidx/n,return_index=True)
offsetted_diffs = np.diff(np.append(0,diffs))
offsetted_diffs[idx] = diffs[idx]

# Get a copy of input array and place previous group's offsetted summations 
# at indices. Then, do cumulative sum which will create a boundary like 
# effect with those offsets at indices positions.
arrayc = array.copy()
arrayc.ravel()[lidx] -= offsetted_diffs
out = arrayc.cumsum(1)

这应该是几乎矢量化解决方案，几乎是因为即使我们在循环中计算线性索引，但由于它不是计算密集型部分，所以它对总运行时间的影响将是最小的。此外，如果您不关心破坏输入以保存内存，则可以将arrayc替换为array。

示例输入，输出 -

In [75]: array
Out[75]: 
array([[ 0,  1,  2,  3,  4,  5,  6,  7],
       [ 8,  9, 10, 11, 12, 13, 14, 15],
       [16, 17, 18, 19, 20, 21, 22, 23]])

In [76]: indices
Out[76]: array([[3, 6], [4, 7], [5]], dtype=object)

In [77]: out
Out[77]: 
array([[ 0,  1,  3,  3,  7, 12,  6, 13],
       [ 8, 17, 27, 38, 12, 25, 39, 15],
       [16, 33, 51, 70, 90, 21, 43, 66]])

Answer 2

您可以使用np.split沿索引分割数组，然后使用内置函数map的python将np.cumsum()应用于子数组。最后，使用np.hstack将结果转换为集成数组：

>>> np.hstack(map(np.cumsum,np.split(array,indices)))
array([ 0,  1,  3,  3,  7, 12, 18, 25,  8, 17, 27, 38, 50, 63, 14, 29, 45,
       62, 80, 99])

注意由于map是python中的内置函数，并且implemented in C inside the Python interpreter它的性能优于常规循环。¹

以下是2D阵列的替代方案：

>>> def func(array,indices):
...     return np.hstack(map(np.cumsum,np.split(array,indices)))
... 
>>> 
>>> array
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> 
>>> indices
array([[2], [1, 3], [1, 2]], dtype=object)

>>> np.array([func(arr,ind) for arr,ind in np.array((array,indices)).T])
array([[ 0,  1,  2,  5],
       [ 4,  5, 11,  7],
       [ 8,  9, 10, 21]])

注意您的预期输出不是基于np.split的工作方式。

如果您想获得此类结果，则需要在索引中添加1：

>>> indices = np.array([[3], [2, 4], [2, 3]], dtype=object)
>>> 
>>> np.array([func(arr,ind) for arr,ind in np.array((array,indices)).T])
array([[  0.,   1.,   3.,   3.],
       [  4.,   9.,   6.,  13.],
       [  8.,  17.,  10.,  11.]])

由于评论说使用生成器表达式和map函数之间没有性能差异，我运行了一个更好地演示结果的基准测试。

# Use map
~$ python -m timeit --setup "import numpy as np;array = np.arange(20);indices = np.array([3, 8, 14])" "np.hstack(map(np.cumsum,np.split(array,indices)))"
10000 loops, best of 3: 72.1 usec per loop
# Use generator expression
~$ python -m timeit --setup "import numpy as np;array = np.arange(20);indices = np.array([3, 8, 14])" "np.hstack(np.cumsum(a) for a in np.split(array,indices))"
10000 loops, best of 3: 81.2 usec per loop

<子> 请注意，这并不意味着使用以C速度执行的映射会使该代码以C速度执行。因此，代码已在python中实现并调用函数（第一个参数）并将其应用于可迭代项目需要时间。

查找由numpy数组的索引分割的子数组的子集

2 个答案: