有效地返回数组中第一个满足条件的值的索引

Question

我需要在满足条件的一维 NumPy 数组或 Pandas 数字系列中找到第一个值的索引。数组很大，索引可能靠近数组的开始或结束，或条件可能根本不满足。我无法提前判断哪个更有可能。如果不满足条件，则返回值应为-1。我考虑了几种方法。

尝试 1

# func(arr) returns a Boolean array
idx = next(iter(np.where(func(arr))[0]), -1)

但这通常太慢了，因为func(arr) 在 整个 数组上应用了矢量化函数，而不是在满足条件时停止。具体来说，当条件在数组的开始附近满足时，它是昂贵的。

尝试 2

np.argmax 稍微快一些，但无法识别何时从未满足条件：

np.random.seed(0)
arr = np.random.rand(10**7)

assert next(iter(np.where(arr > 0.999999)[0]), -1) == np.argmax(arr > 0.999999)

%timeit next(iter(np.where(arr > 0.999999)[0]), -1)  # 21.2 ms
%timeit np.argmax(arr > 0.999999)                    # 17.7 ms

np.argmax(arr > 1.0) 返回0，即条件不满足时的实例。

尝试 3

# func(arr) returns a Boolean scalar
idx = next((idx for idx, val in enumerate(arr) if func(arr)), -1)

但是当在数组的end附近满足条件时，这太慢了。这可能是因为生成器表达式因大量__next__ 调用而产生了昂贵的开销。

这总是是一种妥协还是有办法，对于通用func，有效地提取第一个索引？

基准测试

对于基准测试，假设func 在值大于给定常数时找到索引：

# Python 3.6.5, NumPy 1.14.3, Numba 0.38.0
import numpy as np

np.random.seed(0)
arr = np.random.rand(10**7)
m = 0.9
n = 0.999999

# Start of array benchmark
%timeit next(iter(np.where(arr > m)[0]), -1)                       # 43.5 ms
%timeit next((idx for idx, val in enumerate(arr) if val > m), -1)  # 2.5 µs

# End of array benchmark
%timeit next(iter(np.where(arr > n)[0]), -1)                       # 21.4 ms
%timeit next((idx for idx, val in enumerate(arr) if val > n), -1)  # 39.2 ms

Answer 1

numba

使用numba，可以优化两个场景。从语法上讲，您只需要使用简单的for 循环构造一个函数：

from numba import njit

@njit
def get_first_index_nb(A, k):
    for i in range(len(A)):
        if A[i] > k:
            return i
    return -1

idx = get_first_index_nb(A, 0.9)

Numba 通过 JIT（“及时”）编译代码和利用 CPU-level optimisations 来提高性能。没有@njit 装饰器的常规 for 循环通常会慢 比您已经尝试过的条件迟到的情况。 p>

对于 Pandas 数字系列 df['data']，您可以简单地将 NumPy 表示提供给 JIT 编译的函数：

idx = get_first_index_nb(df['data'].values, 0.9)

概括

由于numba 允许functions as arguments，并且假设传递的函数也可以进行 JIT 编译，您可以得出一种方法来计算满足条件的第 n 个索引任意func。

@njit
def get_nth_index_count(A, func, count):
    c = 0
    for i in range(len(A)):
        if func(A[i]):
            c += 1
            if c == count:
                return i
    return -1

@njit
def func(val):
    return val > 0.9

# get index of 3rd value where func evaluates to True
idx = get_nth_index_count(arr, func, 3)

对于第三个 last 值，您可以提供相反的值，arr[::-1]，并否定来自 len(arr) - 1 的结果，- 1 是考虑 0 索引所必需的。

性能基准测试

# Python 3.6.5, NumPy 1.14.3, Numba 0.38.0

np.random.seed(0)
arr = np.random.rand(10**7)
m = 0.9
n = 0.999999

@njit
def get_first_index_nb(A, k):
    for i in range(len(A)):
        if A[i] > k:
            return i
    return -1

def get_first_index_np(A, k):
    for i in range(len(A)):
        if A[i] > k:
            return i
    return -1

%timeit get_first_index_nb(arr, m)                                 # 375 ns
%timeit get_first_index_np(arr, m)                                 # 2.71 µs
%timeit next(iter(np.where(arr > m)[0]), -1)                       # 43.5 ms
%timeit next((idx for idx, val in enumerate(arr) if val > m), -1)  # 2.5 µs

%timeit get_first_index_nb(arr, n)                                 # 204 µs
%timeit get_first_index_np(arr, n)                                 # 44.8 ms
%timeit next(iter(np.where(arr > n)[0]), -1)                       # 21.4 ms
%timeit next((idx for idx, val in enumerate(arr) if val > n), -1)  # 39.2 ms

Answer 2

我也想做类似的事情，发现这个问题中提出的解决方案并没有真正帮助我。特别是，numba 解决方案对我来说比问题本身中提出的更传统的方法要慢得多。我有一个times_all 列表，通常大约有数万个元素，并且想要找到大于time_event 的times_all 的第一个元素的索引。我有成千上万的time_events。我的解决方案是将times_all划分为例如100个元素的块，首先确定time_event属于哪个时间段，保留该段的第一个元素的索引，然后找到该段中的哪个索引，并将两者相加指数。这是一个最小的代码。对我来说，它的运行速度比本页中的其他解决方案快几个数量级。

def event_time_2_index(time_event, times_all, STEPS=100):
    import numpy as np
    time_indices_jumps = np.arange(0, len(times_all), STEPS)
    time_list_jumps = [times_all[idx] for idx in time_indices_jumps]

    time_list_jumps_idx = next((idx for idx, val in enumerate(time_list_jumps)\
                          if val > time_event), -1)
    index_in_jumps = time_indices_jumps[time_list_jumps_idx-1]
    times_cropped = times_all[index_in_jumps:]
    event_index_rel = next((idx for idx, val in enumerate(times_cropped) \
                      if val > time_event), -1)

    event_index = event_index_rel + index_in_jumps
    return event_index