【问题标题】:numpy faster than numba and cython , how to improve numba codenumpy 比 numba 和 cython 快,如何改进 numba 代码
【发布时间】:2019-11-17 03:07:24
【问题描述】:

我在这里有一个简单的例子来帮助我理解使用 numba 和 cython。我对 numba 和 cython 都是新手。我已经尽力整合所有技巧以使 numba 变得更快,并且在某种程度上,对于 cython 也是如此,但我的 numpy 代码几乎比 numba 快 2 倍(对于 float64),如果使用 float32 则快 2 倍以上。不确定我在这里缺少什么。

我在想也许问题不再是编码,而是更多关于编译器等我不太熟悉的问题。

我浏览了很多关于 numpy、numba 和 cython 的 stackoverflow 帖子,但没有找到直接的答案。

numpy 版本:

def py_expsum(x):
    return np.sum( np.exp(x) )

numba 版本:

@numba.jit( nopython=True)    
def nb_expsum(x):
    nx, ny = x.shape
    val = 0.0
    for ix in range(nx):
        for iy in range(ny):
            val += np.exp(x[ix, iy])
    return val

Cython 版本:

import numpy as np
import cython
from libc.math cimport exp

@cython.boundscheck(False) 
@cython.wraparound(False)
cpdef double cy_expsum2 ( double[:,:] x, int nx, int ny ):
    cdef: 
        double val = 0.0
        int ix, iy    
    for ix in range(nx):
        for iy in range(ny):
            val += exp(x[ix, iy])
    return val

播放大小为 2000 x 1000 的数组并循环超过 100 次。对于 numba,第一次激活不计入循环。

使用python 3(anaconda分布),window 10

               float64       /   float32
    1. numpy : 0.56 sec      /   0.23 sec
    2. numba : 0.93 sec      /   0.74 sec      
    3. cython: 0.83 sec

cython 接近 numba。所以对我来说最大的问题是为什么 numba 不能击败 numpy 的运行时?我在这里做错了什么或遗漏了什么?其他因素有何影响?我该如何找出答案?

【问题讨论】:

  • 认为你应该使用math.exp而不是np.exp。
  • 错字是什么?相同的信息是什么?
  • 已修复错字。 math.exp 没有帮助。
  • Numpy 可能正在并行执行指数。你也可以在 Cython(可能还有 Numba)中做到这一点,但你可能不会明显击败 Numpy。为什么不直接使用 Numpy?
  • 很难击败 numpy 矢量化代码。但是如果你想要一点性能提升,你可以使用numexpr,比如:ne.evaluate('sum(exp(x))')

标签: python performance numpy cython numba


【解决方案1】:

正如我们将看到的,行为取决于使用哪个 numpy-distribution。

此答案将侧重于使用英特尔 VML(矢量数学库)的 Anacoda 分发,根据其他硬件和 numpy 版本,milliage 可能会有所不同。

还将展示如何通过 Cython 或 numexpr 使用 VML,以防万一不使用 Anacoda-distribution,它在后台插入 VML 以进行一些 numpy 操作。


我可以重现您的结果,针对以下维度

N,M=2*10**4, 10**3
a=np.random.rand(N, M)

我明白了:

%timeit py_expsum(a)  #   87ms
%timeit nb_expsum(a)  #  672ms
%timeit nb_expsum2(a)  #  412ms

大部分(约 90%)的计算时间用于评估 exp- 函数,正如我们将看到的,这是一项 CPU 密集型任务。

快速浏览top-statistics 显示,numpy 的版本是并行执行的,但 numba 不是这种情况。然而,在我只有两个处理器的虚拟机上,单独的并行化无法解释因子 7 的巨大差异(如 DavidW 的版本 nb_expsum2 所示)。

通过perf 分析两个版本的代码显示如下:

nb_expsum

Overhead  Command  Shared Object                                      Symbol                                                             
  62,56%  python   libm-2.23.so                                       [.] __ieee754_exp_avx
  16,16%  python   libm-2.23.so                                       [.] __GI___exp
   5,25%  python   perf-28936.map                                     [.] 0x00007f1658d53213
   2,21%  python   mtrand.cpython-37m-x86_64-linux-gnu.so             [.] rk_random

py_expsum

  31,84%  python   libmkl_vml_avx.so                                  [.] mkl_vml_kernel_dExp_E9HAynn                                   ▒
   9,47%  python   libiomp5.so                                        [.] _INTERNAL_25_______src_kmp_barrier_cpp_38a91946::__kmp_wait_te▒
   6,21%  python   [unknown]                                          [k] 0xffffffff8140290c                                            ▒
   5,27%  python   mtrand.cpython-37m-x86_64-linux-gnu.so             [.] rk_random  

正如人们所看到的:numpy 在后台使用 Intel 的并行矢量化 mkl/vml-version,它很容易胜过 numba(或并行版本的 numba 或由 cython 处理)。使用并行化可以使地面稍微平整一点,但 mkl 的矢量化版本仍然会胜过 numba 和 cython。

但是,仅查看一种尺寸的性能并不是很有启发性,对于 exp(至于其他超越函数),需要考虑两个维度:

  • 数组中的元素数量 - 缓存效果和针对不同大小的不同算法(在 numpy 中并非闻所未闻)会导致不同的性能。
  • 取决于x-value,需要不同的时间来计算exp(x)。通常有三种不同类型的输入会导致不同的计算时间:非常小、正常和非常大(具有非有限结果)

我正在使用 perfplot 来可视化结果(参见附录中的代码)。对于“正常”范围,我们得到以下表现:

虽然 0.0 的性能相似,但我们可以看到,一旦结果变得无限,英特尔的 VML 就会受到相当大的负面影响:

但还有其他需要注意的事项:

  • 对于向量大小<= 8192 = 2^13 numpy 使用非并行化 glibc 版本的 exp(同样使用 numba 和 cython)。
  • 我使用的 Anaconda-distribution,overrides numpy's functionality and plugs Intel's VML-library 用于大小 > 8192,它是矢量化和并行化的 - 这解释了大小约为 10^4 的运行时间下降的原因。
  • 对于较小的尺寸,numba 轻松击败了通常的 glibc 版本(对于 numpy 来说开销太大),但对于较大的数组(如果 numpy 不会切换到 VML)则没有太大差异。
  • 这似乎是一个 CPU 密集型任务 - 我们无法在任何地方看到缓存边界。
  • 仅当元素超过 500 个时,并行化的 numba 版本才有意义。

那么后果是什么?

  1. 如果元素不超过 8192 个,则应使用 numba-version。
  2. 否则 numpy 版本(即使没有可用的 VML 插件也不会损失太多)。

注意:numba 无法自动使用英特尔 VML 中的 vdExp(如 cmets 中部分建议的那样),因为它单独计算 exp(x),而 VML 对整个阵列进行操作。


在写入和加载数据时可以减少缓存未命中,这是由 numpy-version 使用以下算法执行的:

  1. 对适合缓存的部分数据执行 VML 的vdExp,但也不会太小(开销)。
  2. 总结得到的工作数组。
  3. 执行 1.+2。对于下一部分数据,直到处理完整个数据。

但是,与 numpy 的版本相比,我不希望获得超过 10% 的收益(但也许我错了),因为无论如何 90% 的计算时间都花在了 MVL 中。

尽管如此,这是 Cython 中可能的快速而肮脏的实现:

%%cython -L=<path_mkl_libs> --link-args=-Wl,-rpath=<path_mkl_libs> --link-args=-Wl,--no-as-needed -l=mkl_intel_ilp64 -l=mkl_core -l=mkl_gnu_thread -l=iomp5
# path to mkl can be found via np.show_config()
# which libraries needed: https://software.intel.com/en-us/articles/intel-mkl-link-line-advisor

# another option would be to wrap mkl.h:
cdef extern from *:
    """
    // MKL_INT is 64bit integer for mkl-ilp64
    // see https://software.intel.com/en-us/mkl-developer-reference-c-c-datatypes-specific-to-intel-mkl
    #define MKL_INT long long int
    void  vdExp(MKL_INT n, const double *x, double *y);
    """
    void vdExp(long long int n, const double *x, double *y)

def cy_expsum(const double[:,:] v):
        cdef:
            double[1024] w;
            int n = v.size
            int current = 0;
            double res = 0.0
            int size = 0
            int i = 0
        while current<n:
            size = n-current
            if size>1024:
                size = 1024
            vdExp(size, &v[0,0]+current, w)
            for i in range(size):
                res+=w[i]
            current+=size
        return res

然而,这正是numexpr 会做的事情,它也使用英特尔的 vml 作为后端:

 import numexpr as ne
 def ne_expsum(x):
     return ne.evaluate("sum(exp(x))")

至于时间我们可以看到如下:

有以下值得注意的细节:

  • numpy、numexpr 和 cython 版本对于更大的数组具有几乎相同的性能 - 这并不奇怪,因为它们使用相同的 vml 功能。
  • 在这三个中,cython-version 开销最小,numexpr 最多
  • numexpr-version 可能是最容易编写的(考虑到并非每个 numpy 分发插件都包含 mvl 功能)。

列表:

情节:

import numpy as np
def py_expsum(x):
    return np.sum(np.exp(x))

import numba as nb
@nb.jit( nopython=True)    
def nb_expsum(x):
    nx, ny = x.shape
    val = 0.0
    for ix in range(nx):
        for iy in range(ny):
            val += np.exp( x[ix, iy] )
    return val

@nb.jit( nopython=True, parallel=True)    
def nb_expsum2(x):
    nx, ny = x.shape
    val = 0.0
    for ix in range(nx):
        for iy in nb.prange(ny):
            val += np.exp( x[ix, iy]   )
    return val

import perfplot
factor = 1.0 # 0.0 or 1e4
perfplot.show(
    setup=lambda n: factor*np.random.rand(1,n),
    n_range=[2**k for k in range(0,27)],
    kernels=[
        py_expsum, 
        nb_expsum,
        nb_expsum2, 
        ],
    logx=True,
    logy=True,
    xlabel='len(x)'
    )

【讨论】:

  • 非常感谢您。我不知道 numpy 正在做并行化。因此,更公平的测试是强制 numba 和 cython 也并行化。
  • 您的结果看起来像 numpy 使用 Intel SVML 而 numba 而 cython 没有。 SVML 可以轻松安装。 numba.pydata.org/numba-doc/dev/user/performance-tips.html
  • @max9111 我不认为 numba 能够使用 MVL 中的 vdExp,因为它对数组而不是单个值进行操作。
  • Numba 主要是 LLVM-IR 代码的翻译器(除了处理方式不同的 BLAS 调用 -> 对 scipy BLAS 后端的函数调用),例如 c 代码的 clang 和 fortran 代码的 flang(LLVM后端 O3,marche=native)。一个显着的区别是必要的数据类型和数组存储确定。我猜float32有一些问题(累加器很可能被确定为float64)。 vdExp 采用(128 到 512 位)长度的压缩向量,如果可用且有益则使用(非对齐内存加载指令非常昂贵)
  • 如果数组有超过 8192 个值,numpy 的结果也可能对某些值略有变化。 stackoverflow.com/q/55341055/4045774你试过安装SVML吗? (conda install -c numba icc_rt)
【解决方案2】:

添加并行化。在 Numba 中,只涉及制作外循环 prange 并将 parallel=True 添加到 jit 选项:

@numba.jit( nopython=True,parallel=True)    
def nb_expsum2(x):
    nx, ny = x.shape
    val = 0.0
    for ix in numba.prange(nx):
        for iy in range(ny):
            val += np.exp( x[ix, iy]   )
    return val

在我的 PC 上,它的速度比非并行版本快 3.2 倍。也就是说,在我的电脑上,Numba 和 Cython 都击败了 Numpy。

您也可以使用parallelization in Cython - 我还没有在这里测试过,但我希望在性能上与 Numba 相似。 (另请注意,对于 Cython,您可以从 x.shape[0] 和 x.shape[1] 获得 nx 和 ny,因此您不必关闭边界检查,然后完全依赖用户输入来保持在边界内。

【讨论】:

  • 谢谢大卫。我不知道 numpy 会自动使用并行化。我只是在 numba 中尝试了并行选项,但对我来说没有区别。至于您的 numba/cython 击败 numba 的情况。我在我较慢的笔记本电脑(也更少的核心)中看到了这种效果。这是击败 numpy 的唯一原因,由于内核较少,numpy 的并行化程度较低?
  • 确保对 Numba 并行化的代码进行了两项更改。很难知道相对速度的确切原因——它可能取决于编译器、CPU、编译时使用的选项。然而,总的来说,有两个主要的事情可能会有所不同:如果它是并行运行的,以及创建一个临时数组(Numpy 版本会这样做,但其他版本不会)
【解决方案3】:

取决于exp的实现和并行化

如果您在 Numpy 中使用英特尔 SVML,也可以在 Numba、Numexpr 或 Cython 等其他软件包中使用它。 Numba performance tips

如果 Numpy 命令被并行化,也尝试在 Numba 或 Cython 中并行化它。

代码

import os
#Have to be before importing numpy
#Test with 1 Thread against a single thread Numba/Cython Version and
#at least with number of physical cores against parallel versions
os.environ["MKL_NUM_THREADS"] = "1" 

import numpy as np

#from version 0.43 until 0.47 this has to be set before importing numba
#Bug: https://github.com/numba/numba/issues/4689
from llvmlite import binding
binding.set_option('SVML', '-vector-library=SVML')
import numba as nb

def py_expsum(x):
    return np.sum( np.exp(x) )

@nb.njit(parallel=False,fastmath=True) #set it to True for a parallel version  
def nb_expsum(x):
    val = nb.float32(0.)#change this to float64 on the float64 version
    for ix in nb.prange(x.shape[0]):
        for iy in range(x.shape[1]):
            val += np.exp(x[ix,iy])
    return val

N,M=2000, 1000
#a=np.random.rand(N*M).reshape((N,M)).astype(np.float32)
a=np.random.rand(N*M).reshape((N,M))

基准测试

#float64
%timeit py_expsum(a) #os.environ["MKL_NUM_THREADS"] = "1" 
#7.44 ms ± 86.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit py_expsum(a) #os.environ["MKL_NUM_THREADS"] = "6" 
#4.83 ms ± 139 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit nb_expsum(a) #parallel=false
#2.49 ms ± 25.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit nb_expsum(a) ##parallel=true
#568 µs ± 45.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

#float32
%timeit py_expsum(a) #os.environ["MKL_NUM_THREADS"] = "1" 
#3.44 ms ± 66.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit py_expsum(a) #os.environ["MKL_NUM_THREADS"] = "6" 
#2.59 ms ± 35.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit nb_expsum(a) #parallel=false
#1 ms ± 12.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit nb_expsum(a) #parallel=true
#252 µs ± 19.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

使用 SVML 的 Perfplot

import numpy as np

#from version 0.43 until 0.47 this has to be set before importing numba
#Bug: https://github.com/numba/numba/issues/4689
from llvmlite import binding
binding.set_option('SVML', '-vector-library=SVML')
import numba as nb

def py_expsum(x):
    return np.sum(np.exp(x))

@nb.jit( nopython=True,parallel=False,fastmath=False)    
def nb_expsum_single_thread(x):
    nx, ny = x.shape
    val = 0.0
    for ix in range(nx):
        for iy in range(ny):
            val += np.exp( x[ix, iy] )
    return val

#fastmath makes SIMD-vectorization possible 
#val+=some_value is not vectorizable (scalar depends on scalar)
#This would also prevents the usage of SVML
@nb.jit( nopython=True,parallel=False,fastmath=True)    
def nb_expsum_single_thread_vec(x):
    nx, ny = x.shape
    val = 0.0
    for ix in range(nx):
        for iy in range(ny):
            val += np.exp( x[ix, iy] )
    return val

@nb.jit(nopython=True,parallel=True,fastmath=False)    
def nb_expsum_parallel(x):
    nx, ny = x.shape
    val = 0.0
    #parallelization over the outer loop is almost every time faster
    #except for rare cases like this (x.shape -> (1,n))
    for ix in range(nx):
        for iy in nb.prange(ny):
            val += np.exp( x[ix, iy] )
    return val

#fastmath makes SIMD-vectorization possible 
#val+=some_value is not vectorizable (scalar depends on scalar)
#This would also prevents the usage of SVML
@nb.jit(nopython=True,parallel=True,fastmath=True)    
def nb_expsum_parallel_vec(x):
    nx, ny = x.shape
    val = 0.0
    #parallelization over the outer loop is almost every time faster
    #except for rare cases like this (x.shape -> (1,n))
    for ix in range(nx):
        for iy in nb.prange(ny):
            val += np.exp( x[ix, iy] )
    return val

import perfplot
factor = 1.0 # 0.0 or 1e4
perfplot.show(
    setup=lambda n: factor*np.random.rand(1,n),
    n_range=[2**k for k in range(0,27)],
    kernels=[
        py_expsum,
        nb_expsum_single_thread,
        nb_expsum_single_thread_vec,
        nb_expsum_parallel,
        nb_expsum_parallel_vec,
        cy_expsum
        ],
    logx=True,
    logy=True,
    xlabel='len(x)'
    )

检查是否使用了 SVML

有助于检查一切是否按预期工作。

def check_SVML(func):
    if 'intel_svmlcc' in func.inspect_llvm(func.signatures[0]):
        print("found")
    else:
        print("not found")

check_SVML(nb_expsum_parallel_vec)
#found

【讨论】:

  • 哇!!谢谢max9111,我需要一段时间才能吸收所有这些。非常感谢
猜你喜欢
  • 2016-05-07
  • 2019-04-09
  • 2014-11-15
  • 2017-08-18
  • 2014-02-23
  • 2018-11-12
  • 2014-03-06
  • 2021-07-21
  • 2017-06-07
相关资源
最近更新 更多