OpenCV 3.1 优化

Question

我目前正在尝试在 python 2.7 上使用 OpenCV 3.1 的论文实现算法，但该过程花费的时间太长。

给我带来麻烦的代码部分如下所示：

width, height = mr.shape[:2]
Pm = []
for i in d:
    M = np.float32([[1,0,-d[i]], [0,1,1]])
    mrd = cv2.warpAffine(mr, M, (height,width))
    C = cv2.subtract(ml, mrd)
    C = cv2.pow(C,2)
    C = np.divide(C, sigma_m)
    C = p0 + (1-p0)**(-C)
    Pm.append(C)

其中ml、mr 和 mrd 是 cv2 对象，d、p0 和 sigma_m 是整数。

最后 3 行中的除法和最终方程是这里真正的麻烦制造者。这个循环的每次迭代都是独立的，所以理论上我可以通过几个处理器拆分“for循环”，但这似乎是一种懒惰的方法，我只是绕过问题而不是修复它。

有人知道更快地执行这些计算的方法吗？

Answer 1

我们可以利用numexpr module 将所有后面的算术运算作为一个评估表达式高效地执行。

因此，这些步骤：

C = cv2.subtract(ml, mrd)
C = cv2.pow(C,2)
C = np.divide(C, sigma_m)
C = p0 + (1-p0)**(-C)

可以用一个表达式代替 -

import numexpr as ne
C = ne.evaluate('p0 +(1-p0)**(-((ml-mrd)**2)/sigma_m)')

让我们验证一下。原来的方法是 func -

def original_app(ml, mrd, sigma_m, p0):
    C = cv2.subtract(ml, mrd)
    C = cv2.pow(C,2)
    C = np.divide(C, sigma_m)
    C = p0 + (1-p0)**(-C)
    return C

验证 -

In [28]: # Setup inputs
    ...: S = 1024 # Size parameter
    ...: ml = np.random.randint(0,255,(S,S))/255.0
    ...: mrd = np.random.randint(0,255,(S,S))/255.0
    ...: sigma_m = 0.45
    ...: p0 = 0.56
    ...: 

In [29]: out1 = original_app(ml, mrd, sigma_m, p0)

In [30]: out2 = ne.evaluate('p0 +(1-p0)**(-((ml-mrd)**2)/sigma_m)')

In [31]: np.allclose(out1, out2)
Out[31]: True

各种规模数据集的时间安排 -

In [19]: # Setup inputs
    ...: S = 1024 # Size parameter
    ...: ml = np.random.randint(0,255,(S,S))/255.0
    ...: mrd = np.random.randint(0,255,(S,S))/255.0
    ...: sigma_m = 0.45
    ...: p0 = 0.56
    ...: 

In [20]: %timeit original_app(ml, mrd, sigma_m, p0)
10 loops, best of 3: 67.1 ms per loop

In [21]: %timeit ne.evaluate('p0 +(1-p0)**(-((ml-mrd)**2)/sigma_m)')
100 loops, best of 3: 12.9 ms per loop

In [22]: # Setup inputs
    ...: S = 512 # Size parameter

In [23]: %timeit original_app(ml, mrd, sigma_m, p0)
100 loops, best of 3: 15.3 ms per loop

In [24]: %timeit ne.evaluate('p0 +(1-p0)**(-((ml-mrd)**2)/sigma_m)')
100 loops, best of 3: 3.39 ms per loop

In [25]: # Setup inputs
    ...: S = 256 # Size parameter

In [26]: %timeit original_app(ml, mrd, sigma_m, p0)
100 loops, best of 3: 3.65 ms per loop

In [27]: %timeit ne.evaluate('p0 +(1-p0)**(-((ml-mrd)**2)/sigma_m)')
1000 loops, best of 3: 878 µs per loop

大约 5x 可以在各种大小上加速，对于更大的阵列有更好的加速！

另外，作为旁注，我建议使用初始化数组，而不是像您在最后一步所做的那样追加。因此，我们可以在进入循环之前使用 out = np.zeros((len(d), width, height)) / np.empty 进行初始化，并在最后一步使用 out[iteration_ID] = C 分配到输出数组中。