美文网首页Cython
Cython基本用法

Cython基本用法

作者: yalesaleng | 来源:发表于2018-07-14 12:29 被阅读625次

    文章转自:https://zhuanlan.zhihu.com/p/24311879

    当人们提到 Python 的时候,经常会说到下面两个优点:

    1. 写起来方便
    2. 容易调用 C/C++ 的库

    然而实际上,第一点是以巨慢的执行速度为代价的,而第二点也需要库本身按照 Python 的规范使用 Python API、导出相应的符号。

    天壤实习的时候,跟 Cython 打了不少交道,觉得这个工具虽然 Bug 多多,写的时候也有些用户体验不好的地方,但已经能极大提高速度和方便调用 C/C++,还是非常不错的。这里就给大家简单介绍一下 Cython(注意区别于 CPython)。Cython 可以让我们方便地:

    • 用 Python 的语法混合编写 Python 和 C/C++ 代码,提升 Python 速度
    • 调用 C/C++ 代码

    例子:矩阵乘法

    假设我们现在正在编写一个很简单的矩阵乘法代码,其中矩阵是保存在 numpy.ndarray 中。Python 代码可以这么写:

    # dot_python.py
    import numpy as np
    
    def naive_dot(a, b):
        if a.shape[1] != b.shape[0]:
            raise ValueError('shape not matched')
        n, p, m = a.shape[0], a.shape[1], b.shape[1]
        c = np.zeros((n, m), dtype=np.float32)
        for i in xrange(n):
            for j in xrange(m):
                s = 0
                for k in xrange(p):
                    s += a[i, k] * b[k, j]
                c[i, j] = s
        return c
    
    

    不用猜也知道这比起 C/C++ 写的要慢的不少。我们感兴趣的是,怎么用 Cython 加速这个程序。我们先上 Cython 程序代码:

    # dot_cython.pyx
    import numpy as np
    cimport numpy as np
    cimport cython
    
    @cython.boundscheck(False)
    @cython.wraparound(False)
    cdef np.ndarray[np.float32_t, ndim=2] _naive_dot(np.ndarray[np.float32_t, ndim=2] a, np.ndarray[np.float32_t, ndim=2] b):
        cdef np.ndarray[np.float32_t, ndim=2] c
        cdef int n, p, m
        cdef np.float32_t s
        if a.shape[1] != b.shape[0]:
            raise ValueError('shape not matched')
        n, p, m = a.shape[0], a.shape[1], b.shape[1]
        c = np.zeros((n, m), dtype=np.float32)
        for i in xrange(n):
            for j in xrange(m):
                s = 0
                for k in xrange(p):
                    s += a[i, k] * b[k, j]
                c[i, j] = s
        return c
    
    def naive_dot(a, b):
        return _naive_dot(a, b)
    
    

    可以看到这个程序和 Python 写的几乎差不多。我们来看看不一样部分:

    • Cython 程序的扩展名是 .pyx

    • cimport 是 Cython 中用来引入 .pxd 文件的命令。有关 .pxd 文件,可以简单理解成 C/C++ 中用来写声明的头文件,更具体的我会在后面写到。这里引入的两个是 Cython 预置的。

    • @cython.boundscheck(False) 和 @cython.wraparound(False) 两个修饰符用来关闭 Cython 的边界检查

    • Cython 的函数使用 cdef 定义,并且他可以给所有参数以及返回值指定类型。比方说,我们可以这么编写整数 min 函数:

        cdef int my_min(int x, int y):
            return x if x <= y else y
      
      

      这里 np.ndarray[np.float32_t, ndim=2] 就是一个类型名就像 int 一样,只是它比较长而且信息量比较大而已。它的意思是,这是个类型为 np.float32_t 的2维 np.ndarray。

    • 在函数体内部,我们一样可以使用 cdef typename varname 这样的语法来声明变量

    • 在 Python 程序中,是看不到 cdef 的函数的,所以我们这里 def naive_dot(a, b) 来调用 cdef 过的 _naive_dot 函数。

    另外,Cython 程序需要先编译之后才能被 Python 调用,流程是:

    1. Cython 编译器把 Cython 代码编译成调用了 Python 源码的 C/C++ 代码
    2. 把生成的代码编译成动态链接库
    3. Python 解释器载入动态链接库

    要完成前两步,我们要写如下代码:

    # setup.py
    from distutils.core import setup, Extension
    from Cython.Build import cythonize
    import numpy
    setup(ext_modules = cythonize(Extension(
        'dot_cython',
        sources=['dot_cython.pyx'],
        language='c',
        include_dirs=[numpy.get_include()],
        library_dirs=[],
        libraries=[],
        extra_compile_args=[],
        extra_link_args=[]
    )))
    
    

    这段代码对于我们这个简单的例子来说有些太复杂了,不过实际上,再复杂也就这么复杂了,为了省得后面再贴一遍,所以索性就在这里把最复杂的列出来好了。这里顺带解释一下好了:

    • 'dot_cython' 是我们要生成的动态链接库的名字
    • sources 里面可以包含 .pyx 文件,以及后面如果我们要调用 C/C++ 程序的话,还可以往里面加 .c / .cpp 文件
    • language 其实默认就是 c,如果要用 C++,就改成 c++ 就好了
    • include_dirs 这个就是传给 gcc 的 -I 参数
    • library_dirs 这个就是传给 gcc 的 -L 参数
    • libraries 这个就是传给 gcc 的 -l 参数
    • extra_compile_args 就是传给 gcc 的额外的编译参数,比方说你可以传一个 -std=c++11
    • extra_link_args 就是传给 gcc 的额外的链接参数(也就是生成动态链接库的时候用的)
    • 如果你从来没见过上面几个 gcc 参数,说明你暂时还没这些需求,等你遇到了你就懂了

    然后我们只需要执行下面命令就可以把 Cython 程序编译成动态链接库了。

    python setup.py build_ext --inplace
    
    

    成功运行完上面这句话,可以看到在当前目录多出来了 dot_cython.c 和 dot_cython.so。前者是生成的 C 程序,后者是编译好了的动态链接库。

    下面让我们来试试看效果:

    $ ipython                                                                                                   15:07:43
    Python 2.7.12 (default, Oct 11 2016, 05:20:59)
    Type "copyright", "credits" or "license" for more information.
    
    IPython 4.0.1 -- An enhanced Interactive Python.
    ?         -> Introduction and overview of IPython's features.
    %quickref -> Quick reference.
    help      -> Python's own help system.
    object?   -> Details about 'object', use 'object??' for extra details.
    
    In [1]: import numpy as np
    In [2]: import dot_python
    In [3]: import dot_cython
    In [4]: a = np.random.randn(100, 200).astype(np.float32)
    In [5]: b = np.random.randn(200, 50).astype(np.float32)
    
    In [6]: %timeit -n 100 -r 3 dot_python.naive_dot(a, b)
    100 loops, best of 3: 560 ms per loop
    
    In [7]: %timeit -n 100 -r 3 dot_cython.naive_dot(a, b)
    100 loops, best of 3: 982 µs per loop
    
    In [8]: %timeit -n 100 -r 3 np.dot(a, b)
    100 loops, best of 3: 49.2 µs per loop
    
    

    所以说,提升了大概 570 倍的效率!而我们的代码基本上就没有改动过!当然啦,你要跟高度优化过的 numpy 实现比,当然还是慢了很多啦。不过掐指一算,这 0.982ms 其实跟直接写 C++ 是差不多的,能实现这个这样的效果已经很令人满意了。不信我们可以试试看手写一次 C++ 版本:

    // dot.cpp
    #include <ctime>
    #include <cstdlib>
    #include <chrono>
    #include <iostream>
    
    class Matrix {
        float *data;
    public:
        size_t n, m;
        Matrix(size_t r, size_t c): data(new float[r*c]), n(r), m(c) {}
        ~Matrix() { delete[] data; }
        float& operator() (size_t x, size_t y) { return data[x*m+y]; }
        float operator() (size_t x, size_t y) const { return data[x*m+y]; }
    };
    
    float dot(const Matrix &a, const Matrix& b) {
        Matrix c(a.n, b.m);
        for (size_t i = 0; i < a.n; ++i)
            for (size_t j = 0; j < b.m; ++j) {
                float s = 0;
                for (size_t k = 0; k < a.m; ++k)
                    s += a(i, k) * b(k, j);
                c(i, j) = s;
            }
        return c(0, 0); // to comfort -O2 optimization
    }
    
    void fill_rand(Matrix &a) {
        for (size_t i = 0; i < a.n; ++i)
            for (size_t j = 0; j < a.m; ++j)
                a(i, j) = rand() / static_cast<float>(RAND_MAX) * 2 - 1;
    }
    
    int main() {
        srand((unsigned)time(NULL));
        const int n = 100, p = 200, m = 50, T = 100;
        Matrix a(n, p), b(p, m);
        fill_rand(a);
        fill_rand(b);
        auto st = std::chrono::system_clock::now();
        float s = 0;
        for (int i = 0; i < T; ++i) {
            s += dot(a, b);
        }
        auto ed = std::chrono::system_clock::now();
        std::chrono::duration<double> diff = ed-st;
        std::cerr << s << std::endl;
        std::cout << T << " loops. average " << diff.count() * 1e6 / T << "us" << std::endl;
    }
    
    
    $ g++ -O2 -std=c++11 -o dot dot.cpp
    $ ./dot 2>/dev/null
    100 loops. average 1112.11us
    
    

    可以看到相比起随手写的 C++ 程序,Cython 甚至还更快了些,或许是因为 numpy 以及计量方式(取3次最好 vs 取平均)的缘故。

    Cython 加速 Python 代码的关键

    如果我们把刚刚 Cython 代码中的类型标注都去掉(也就是函数参数和返回值类型以及函数体内部的 cdef),再试试看运行速度:

    $ python setup.py build_ext --inplace
    $ ipython
    In [1]: import numpy as np
    In [2]: import dot_python
    In [3]: import dot_cython
    In [4]: a = np.random.randn(100, 200).astype(np.float32)
    In [5]: b = np.random.randn(200, 50).astype(np.float32)
    
    In [6]: %timeit -n 100 -r 3 dot_cython.naive_dot(a, b)
    100 loops, best of 3: 416 ms per loop
    
    In [7]: %timeit -n 100 -r 3 dot_python.naive_dot(a, b)
    100 loops, best of 3: 537 ms per loop
    
    

    可以看到,这下 Cython 实现几乎和 Python 实现一样慢了。所以说,在 Cython 中,类型标注对于提升速度是至关重要的。

    到了这里就可以吐槽动态类型的不好了。单就性能方面来看,很多编译期间就能确定下来的事情被推到了运行时;很多编译期间能检查出来的问题被推到了运行时;很多编译期间能做的优化也被推到了运行时。再加上 CPython 又没有带 JIT 编译器,这相当于有相当大的时间都浪费在了类型相关的事情上,更不用说一大堆编译器优化都用不了。

    分析 Cython 程序

    前面说到,Cython 中类型声明非常重要,但是我们不加类型标注它依然是一个合法的 Cython 程序,所以自然而然地,我们会担心漏加类型声明。不过好在 Cython 提供了一个很好的工具,可以方便地检查 Cython 程序中哪里可能可以进一步优化。下面命令既可以对 dot_cython.pyx 进行分析:

    cython -a dot_cython.pyx
    
    

    如果当前 Cython 程序用到了 C++,那么还得加上 --cplus 参数。在成功运行完 cython -a 之后,会产生同名的 .html 文件。我们可以打开看看不带类型标注的版本:

    这里用黄色部分标出了和 Python 发生交互的地方,简单地理解,就是拖累性能的地方。点击每一行可以查看相应的生成的 C/C++ 代码。可以看到我们这里几乎每一行都被标了出来(汗……)

    这里我们点开了第16行,也就是 for k in xrange(p),可以发现这么一句简单的话,却被展开成了如此复杂的语句,从这一系列 Python API 的名称来看,我们至少额外地做了:创建和销毁 Python Object、增加和减少 Python Object 的引用计数、类型检查、列表长度检查等等……然而在不知道类型的情况下,为保证运行正确,这些事情又是不得不做的。

    我们把类型标注加回来,再看看 cython -a 的结果:

    这里同样展开了 for k in xrange(p) 这一行,可以看到,它很直接地就翻译成了 C 里面的 for 循环。其他地方同样也简化了很多,剩下的只有进出函数调用、raise ValueError 和 np.zeros 这些确实是要和 Python 发生交互的地方被标了出来。一般来说,我们把一个 Cython 程序优化到这个地步就行了。

    根据 Amdahl’s Law 我们知道(其实根据直觉我们也知道),只要最核心的代码足够快就行了。所以说,我们完全可以放心地编写 Python 代码,享受 Python 带来的好处,同时把核心代码用 C/C++ 或者 Cython 重写,这样就能兼顾开发效率和执行效率了。

    以上部分的参考资料:

    作为胶水

    Python 是很好的胶水语言,但是前提是库本身要使用 Python API 来和 Python 交互。有了 Cython 之后,我们可以照常编写 C/C++ 程序,或者是直接拿来一份已有的 C/C++ 源码,然后用 Cython 简单包装一下就可以使用了。

    本来我想胶水这一部分也像前面性能提升部分一样详细地写出来。后来想想,其实这一部分主要涉及的就是 Cython 语法本身,没有什么特别值得注意的,所以看看 Cython 文档就好了。我这里把一些特性不完全地列出来:

    • 函数签名基本上可以原样从 C/C++ 复制到 Cython 中
      • C 中的 _Bool 类型和 C++ 中的 bool 类型在 Cython 中都用 bint 取代(因为 Python 没有布尔类型)
    • struct / enum / union 是支持的
    • const 限定和引用都是支持的
    • 命名空间是支持的
    • C++ 类是支持的
    • 部分操作符重载是支持的,部分操作符需要改名
    • 内嵌类是支持的
    • 模板是支持的
    • 异常是支持的
    • 构造函数、析构函数是支持的
    • 静态成员是支持的
    • libc / libcpp / STL 是支持的
    • 声明写在 .pxd 中可以在 .pyx 中 cimport 进来
    • 你可能需要注意 Python 字符串到各式各样的 C/C++ 字符串的转换

    也就是说在 Cython 里面调用 C/C++ 代码应该是没有任何问题的,你想在 Cython 里面用 Python 的语法写 C/C++ 程序基本上也是没有问题的。具体的可以查阅以下资料:

    ​首发于博客 Python 多核并行计算

    相关文章

      网友评论

        本文标题:Cython基本用法

        本文链接:https://www.haomeiwen.com/subject/vgtypftx.html