有效检测python中的符号变化

Question

我想做的正是这个人所做的：

Python - 计算符号变化

但是我需要优化它以超快运行。 简而言之，我想记录一个时间序列，并在它每次越过零（改变符号）时告诉它。 我想记录零交叉之间的时间。 由于这是真实数据（32 位浮点数），我怀疑每个人都会有一个恰好为零的数字，因此这并不重要。 我目前有一个计时计划，所以我会为你的结果计时，看看谁赢了。

我的解决方案给出（微秒）：

open data       8384
sign data       8123
zcd data        415466

如您所见，过零检测器是缓慢的部分。 这是我的代码。

import numpy, datetime

class timer():
    def __init__(self):
        self.t0 = datetime.datetime.now()
        self.t = datetime.datetime.now()
    def __call__(self,text='unknown'):
        print text,'\t',(datetime.datetime.now()-self.t).microseconds
        self.t=datetime.datetime.now()

def zcd(data,t):
    sign_array=numpy.sign(data)
    t('sign data')
    out=[]
    current = sign_array[0]
    count=0
    for i in sign_array[1:]:
        if i!=current:
            out.append(count)
            current=i
            count=0
        else: count+=1
    t('zcd data')
    return out

def main():
    t = timer()
    data = numpy.fromfile('deci.dat',dtype=numpy.float32)
    t('open data')
    zcd(data,t)

if __name__=='__main__':
    main()

Answer 1

怎么样：

import numpy
a = [1, 2, 1, 1, -3, -4, 7, 8, 9, 10, -2, 1, -3, 5, 6, 7, -10]
zero_crossings = numpy.where(numpy.diff(numpy.sign(a)))[0]

输出：

> zero_crossings
array([ 3,  5,  9, 10, 11, 12, 15])

即， zero_crossings 将包含发生过零之前元素的索引。 如果你想要的元素后，只需添加1到该阵列。

Answer 2

正如 Jay Borseth 所说，接受的答案没有正确处理包含 0 的数组。

我建议使用：

import numpy as np
a = np.array([-2, -1, 0, 1, 2])
zero_crossings = np.where(np.diff(np.signbit(a)))[0]
print(zero_crossings)
# output: [1]

因为 a) 使用 numpy.signbit() 比 numpy.sign() 快一点，因为它的实现更简单，我猜和 b) 它正确处理输入数组中的零。

但是有一个缺点，也许：如果您的输入数组以零开始和停止，它会在开始时找到零交叉，但不会在结束时找到...

import numpy as np
a = np.array([0, -2, -1, 0, 1, 2, 0])
zero_crossings = np.where(np.diff(np.signbit(a)))[0]
print(zero_crossings)
# output: [0 2]

Answer 3

另一种计算过零并从代码中多挤出几毫秒的方法是使用nonzero并直接计算符号。 假设您有一个一维data数组：

def crossings_nonzero_all(data):
    pos = data > 0
    npos = ~pos
    return ((pos[:-1] & npos[1:]) | (npos[:-1] & pos[1:])).nonzero()[0]

或者，如果您只想计算特定过零方向的过零（例如，从正到负），这甚至更快：

def crossings_nonzero_pos2neg(data):
    pos = data > 0
    return (pos[:-1] & ~pos[1:]).nonzero()[0]

在我的机器上，这些比where(diff(sign))方法（包含 20 个周期，总共 40 个交叉点的 10000 个正弦样本数组的时序where(diff(sign))要快一些：

$ python -mtimeit 'crossings_where(data)'
10000 loops, best of 3: 119 usec per loop

$ python -mtimeit 'crossings_nonzero_all(data)'
10000 loops, best of 3: 61.7 usec per loop

$ python -mtimeit 'crossings_nonzero_pos2neg(data)'
10000 loops, best of 3: 55.5 usec per loop

Answer 4

如果a包含值 0，Jim Brissom 的回答将失败：

import numpy  
a2 = [1, 2, 1, 1, 0, -3, -4, 7, 8, 9, 10, -2, 1, -3, 5, 6, 7, -10]  
zero_crossings2 = numpy.where(numpy.diff(numpy.sign(a2)))[0]  
print zero_crossings2  
print len(zero_crossings2)  # should be 7

输出：

[ 3  4  6 10 11 12 13 16]  
8  

过零的次数应该是 7，但是因为如果传递 0，sign() 返回 0，1 表示正值，-1 表示负值，diff() 将对包含零的转换计数两次。

另一种选择可能是：

a3 = [1, 2, 1, 1, 0, -3, -4, 7, 8, 9, 10, 0, -2, 0, 0, 1, 0, -3, 0, 5, 6, 7, -10]  
s3= numpy.sign(a3)  
s3[s3==0] = -1     # replace zeros with -1  
zero_crossings3 = numpy.where(numpy.diff(s3))[0]  
print s3  
print zero_crossings3  
print len(zero_crossings3)   # should be 7

这给出了正确的答案：

[ 3  6 10 14 15 18 21]
7

Answer 5

你想计时吗？ 或者你想让它尽可能快？

时间安排很容易。 运行无数次，秒表，然后除以无数次。

为了尽可能快地完成，您需要做的是找出什么需要时间以及您可以以更好的方式完成。 我使用 1) 随机暂停技术，或 2) 单步技术。

Answer 6

我看到人们在他们的解决方案中经常使用 diff，但是 xor 似乎要快得多，并且结果对于 bool 来说是一样的（一个很好的指针也可能是使用 diff 给出了一个已弃用的警告....:) ) 这是一个例子：

positive = a2 > 0
np.where(np.bitwise_xor(positive[1:], positive[:-1]))[0]

timeit测量它对我来说比差异快了大约一个半:)

如果您不关心边缘情况，最好使用

positive = np.signbit(a2)

但正 = a2 >0 似乎比符号位和检查 0 更快（更干净）（例如正 = np.bitwise_or(np.signbit(a2),np.logical_not(a2)) 更慢......）

Answer 7

另一种可能适合某些应用程序的方法是扩展表达式np.diff(np.sign(a)) 。

如果我们比较这个表达式对某些情况的反应：

1. 没有零的上升交叉： np.diff(np.sign([-10, 10]))返回array([2])
2. 与零上升交叉： np.diff(np.sign([-10, 0, 10]))返回array([1, 1])
3. 没有零的下降交叉： np.diff(np.sign([10, -10]))返回array([-2])
4. 与零相交： np.diff(np.sign([10, 0, -10]))返回array([-1, -1])

所以我们必须为 1. 和 2 中返回的模式评估np.diff(...) ：

sdiff = np.diff(np.sign(a))
rising_1 = (sdiff == 2)
rising_2 = (sdiff[:-1] == 1) & (sdiff[1:] == 1)
rising_all = rising_1
rising_all[1:] = rising_all[1:] | rising_2

对于情况 3. 和 4.：

falling_1 = (sdiff == -2) #the signs need to be the opposite
falling_2 = (sdiff[:-1] == -1) & (sdiff[1:] == -1)
falling_all = falling_1
falling_all[1:] = falling_all[1:] | falling_2

在此之后，我们可以轻松找到索引

indices_rising = np.where(rising_all)[0]
indices_falling = np.where(falling_all)[0]
indices_both = np.where(rising_all | falling_all)[0]

这种方法应该是合理的快速，因为它可以在不使用“慢”循环的情况下进行管理。

这结合了其他几个答案的方法。