鹦鹉和麻木有何不同？因为我看不出有什么改进

Question

我想知道有没有人知道长尾鹦鹉和麻木鸡之间的一些关键区别？我很好奇，因为我把Numexpr与Numba和parakeet进行了比较，对于这个特殊的表达式（我希望在Numexpr上执行得非常好，因为它是在其文档中提到的那个）

所以结果是

以及我测试的函数（通过timeit-每个函数至少3次重复和10次循环）

import numpy as np
import numexpr as ne
from numba import jit as numba_jit
from parakeet import jit as para_jit


def numpy_complex_expr(A, B):
    return(A*B-4.1*A > 2.5*B)

def numexpr_complex_expr(A, B):
    return ne.evaluate('A*B-4.1*A > 2.5*B')

@numba_jit
def numba_complex_expr(A, B):
    return A*B-4.1*A > 2.5*B

@para_jit
def parakeet_complex_expr(A, B):
    return A*B-4.1*A > 2.5*B

如果你想在你的机器上复查结果，你也可以抓取IPython nb。在

如果有人想知道Numba是否安装正确。。。我认为是的，在我之前的基准测试中，它的表现与预期一致：

Answer 1

{uncufs}在当前的版本中，你使用的是一个不完整的测试。另一方面，您可以使用@vectorize，而且速度更快：

import numpy as np
from numba import jit, vectorize
import numexpr as ne

def numpy_complex_expr(A, B):
    return(A*B+4.1*A > 2.5*B)

def numexpr_complex_expr(A, B):
    return ne.evaluate('A*B+4.1*A > 2.5*B')

@jit
def numba_complex_expr(A, B):
    return A*B+4.1*A > 2.5*B

@vectorize(['u1(float64, float64)'])
def numba_vec(A,B):
    return A*B+4.1*A > 2.5*B

n = 1000
A = np.random.rand(n,n)
B = np.random.rand(n,n)

计时结果：

^{pr2}$

如果要充分利用numba，则需要展开任何矢量化操作：

@jit
def numba_unroll2(A, B):
    C = np.empty(A.shape, dtype=np.uint8)
    for i in xrange(A.shape[0]):
        for j in xrange(A.shape[1]):
            C[i,j] = A[i,j]*B[i,j] + 4.1*A[i,j] > 2.5*B[i,j]

    return C

---

%timeit numba_unroll2(A,B)
100 loops, best of 3: 5.96 ms per loop

还要注意，如果您将numexpr使用的线程数设置为1，那么您将看到它的主要速度优势是并行化：

ne.set_num_threads(1)
%timeit numexpr_complex_expr(A,B)
100 loops, best of 3: 8.87 ms per loop

默认情况下，numexpr使用ne.detect_number_of_cores()作为线程数。我在我的机器上最初的计时是用8。在