python - 对不同大小的顺序数组切片进行操作

Question

假设我有以下 signal 数组，其中每个值对应于 time 数组中的一个时间:

np.random.seed(123)
time = np.array([0,2,4,7,10,11,12,17,21,25,29,30,31,40])  # in seconds
signal = np.random.randint(1,5,len(time))

我想要做的是将signal数组分割成更小的数组，这样每个切片的时间跨度至少 10秒长。然后对每个切片的信号求和。视觉上:

         |-----sum------||-----sum------||---sum----||--X--
time   = 0,  2,  4,  7, 10, 11, 12, 17, 21, 25, 29, 31, 40
signal = 3,  2,  3,  3,  1,  3,  3,  2,  4,  3,  4,  3,  2

我想要的输出是一个列表，其中包含每 10 秒切片的信号总和:

[12,  # 3+2+3+3+1
 13,  # 1+3+3+2+4
 14]  # 4+3+4+3

请注意，最后 2 个 signal 元素不会被求和，因为时间差不到 10 秒

我编写了以下函数:

def count(x, time, epoch=60):
    # calculate time diff
    time = time - time[0]

    # get indices at time boundaries
    num_bins = int(max(time) / epoch)
    inds = [0]

    for i in range(num_bins):
        upper_ind = np.argmax(time >= time[inds[-1]] + epoch)

        if time[upper_ind] - time[inds[-1]] >= epoch:
            inds.append(upper_ind)

    # calculate sums between each boundary
    counts = []
    for i in range(len(inds) - 1):
        lower = inds[i]
        upper = inds[i+1] + 1

        cur_signal = x[lower:upper]

        counts.append(sum(cur_signal))

    return counts

调用者:

counts = count(signal, time, epoch=10)

它可以工作，但是对于大型数组来说它很慢而且很老套。有没有更有效的方法来做到这一点，也许使用一些 numpy 魔法，我不必经历确定边界，然后再次经历以获得总和？

如果有一种方法可以通过估计 signal 的值在 2 个时间点之间进行线性插值(即，如果前一个时间略短于 10 秒，而下一个时间略长于 10 秒)，则可获得奖励积分> 以精确的 10 秒间隔

编辑:

只是从评论中添加一些附加信息...

至少 10 秒长意味着切片不能短于 10 秒，但可以更长。我将取第一个大于 10 秒的时间点。请参阅上面示例中的第二个切片

边界处的信号值将被计算两次。换句话说，一个切片的结束值是下一个切片的起始值

Answer 1

编辑

经过一番思考后，我意识到最好的选择可能不是优雅的 numpy 代码，特别是如果您关心性能的话。即使 @PaulPanzer 的代码，尽管很漂亮，也依赖于在循环中调用 searchsorted (它基于相对昂贵的二分搜索)。

相反，您可以在一次循环中执行整个算法，无需搜索:

signal = np.array([3,  2,  3,  3,  1,  3,  3,  2,  4,  3,  4,  3,  2])
time = np.array([0,  2,  4,  7, 10, 11, 12, 17, 21, 25, 29, 31, 40])

def count(signal, time, epoch=10):
    counts = []
    total = 0
    timestart = times[0]

    for x,t in zip(signal, time):
        total += x

        if t - timestart >= epoch:
            counts.append(total)
            total = x
            timestart = t

    return counts

count(signal, time)

输出:

[12, 13, 14]

时间

看起来简单循环确实比 numpy/searchsorted/where 方法快一点。

我的代码:

%%timeit        
count(signal, time)

5.88 µs ± 165 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

@PaulPanzer 的代码:

%%timeit
idx = np.fromiter(iter(accumulate(chain((0,), repeat(10)), lambda now, delta: time.searchsorted(time[now] + delta)).__next__, len(time)), int)
np.add.reduceat(signal[:idx[-1]], idx[:-1]) + signal[idx[1:]]

9.63 µs ± 182 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

@Brenlla 的代码:

%%timeit
out=[]
prev=0
# need to reinitialize the time array since the loop eats it
time = np.array([0,  2,  4,  7, 10, 11, 12, 17, 21, 25, 29, 31, 40])
while True:
    try:
        idx10 = np.where(time >=10)[0][0]
        time-=time[idx10]
        out.append(np.sum(signal[prev:idx10+1]))
        prev=idx10
    except:
        break

30.1 µs ± 502 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)