python numba 转灰度图_如何正确地将numpy向量化转换为numba向量化

大多数内置的NumPy函数都已经向量化了，根本不需要np.vectorize修饰符。通常，numpy.vectorize修饰符将产生非常慢的结果(与NumPy相比)！作为documentation mentions in the Notes section：The vectorize function is provided primarily for convenience, not for performance. The implementation is essentially a for loop.

通过从f、mz、和{}中删除装饰符，可以极大地提高代码效率。它将给出相同的结果，但运行得更快(您的代码10.4秒，更改代码0.014秒)。在

通过使用广播而不是vectorize，还可以改进E1m函数(就性能而言)。在

但是，由于您的问题是关于如何在这些函数上使用numba.vectorize，我有一些坏消息：在实例方法上使用numba.vectorize是不可能的，因为numba需要类型信息，而这些信息对于定制的Python类不可用。在

一般来说，numba最好从NumPy数组上的纯循环代码开始(无矢量化)，然后使用numba njit修饰符(或jit(nopython=True))。这对方法也不起作用，但是传递标量参数和只迭代所需的数组要容易得多。在

但是，如果您真的想使用vectorize方法，那么您应该如何使用f：由于self，您不能使用实例方法，因此您需要一个静态方法或一个独立的函数。因为您没有访问self的权限，所以您需要传入delta或使其全局化。我决定把它作为一个论据：def f(ro, rs, delta):

return rs / ro * np.exp((-1 / delta) * (ro - rs))然后你需要找出你的参数是什么类型(或者你想支持什么类型)，以及为签名返回什么。您的ro是一个整数数组，rs是一个浮点数组，delta是一个整数，因此签名如下(语法是return_type(argument_1_type, argument_2_type, ....))：

^{pr2}$

基本上就是这样。在

对于mz和mro，您也可以这样做(记住，您还需要delta)：@nb.vectorize('f8(i8, f8, f8)')

def mz(ro, rs, delta):

return (1 - f(ro, rs, delta)**2) / (1 + f(ro, rs, delta)**2)

@nb.vectorize('f8(i8, f8, f8)')

def mro(ro, rs, delta):

return (2 * f(ro, rs, delta) ) / (1 + f(ro, rs, delta)**2)

转换E1m函数似乎有点棘手(我没有尝试过)，我把它留给读者作为练习。在

如果您感兴趣的话，我将如何解决没有vectorize：import numpy as np

import numba as nb

@nb.njit

def f(ro, rs, delta):

return rs / ro * np.exp((-1 / delta) * (ro - rs))

@nb.njit

def mz(ro, rs, delta):

f_2 = f(ro, rs, delta) ** 2

return (1 - f_2) / (1 + f_2)

@nb.njit

def mro(ro, rs, delta):

f_ = f(ro, rs, delta)

return (2 * f_ ) / (1 + f_**2)

@nb.njit(parallel=True)

def E1m(a, b, N, rs, d):

delta = 1

r = np.linspace(a + (b - a) / (2 * N), b - (b - a) / (2 * N), N)

result = np.empty(rs.size)

for idx in nb.prange(rs.size):

rs_item = rs[idx]

sum_ = 0.

for r_item in r:

mro_ = mro(r_item, rs_item, delta)

sum_ += r_item * ((1 / delta + 1 / r_item)**2 * mro_**2

+ (1 / r_item**2 + 1) * mro_**2

+ d * (-(1 / delta + 1 / r_item) * mro_

+ 1 / r_item * mro_ * mz(r_item, rs_item, delta)))

result[idx] = sum_ * (b - a) / N

return result

可能还有一点可以通过循环提升或更聪明的计算方法来优化，但在我的电脑上，它已经相当快了：大约100微秒，比上面的14毫秒快了100倍。在