Question

我对Python很陌生，对C很不了解（不幸的是）所以我正在努力正确理解使用Cython的一些方面。

在剖析Python程序并发现它只是几个在大多数时间都在占用的循环之后，我决定考虑将它们转储到Cython中。最初，我让Cython按原样解释Python，结果是（非凡！）〜2倍的速度提升。酷！

从Python main，我传递函数两个二维数组（“a”和“b”）和一个浮点数“d”，它返回一个列表“newlist”。例如：

a =[[12.7, 13.5, 1.0],[23.4, 43.1, 1.0],...]
b =[[0.46,0.95,0],[4.56,0.92,0],...]
d = 0.1

这是原始代码，只为Cython添加了cdef：

def loop(a, b, d):

    cdef int i, j
    cdef double x, y

    newlist = []

    for i in range(len(a)):
        if b[i][2] != 1:
            for j in range(i+1,len(a)):
                if a[i] == a[j] and b[j][2] != 1:
                    x = b[i][0]+b[j][0]
                    y = b[i][1]+b[j][1]
                    b[i][2],b[j][2] = 1,1

                    if abs(y)/abs(x) > d:
                        if y > 0: newlist.append([a[i][0],a[i][1],y])

    return newlist

在“纯Python”中，这在~12.5秒内运行（有几万个循环）。在Cython中，它运行在~6.3秒。在接近零工作的情况下取得了巨大进步！

然而，通过一点阅读，很明显可以做更多，更多的事情，所以我开始尝试应用一些类型更改，以便更快地进行，遵循Cython文档，here（也在评论中引用）。

以下是收集的修改，旨在模仿Cython文档：

import numpy as np
cimport numpy as np

DtypeA = np.float
DtypeB = np.int

ctypedef np.float_t DtypeA_t
ctypedef np.int_t DtypeB_t

def loop(np.ndarray[DtypeA_t, ndim=2] A,
         np.ndarray[DtypeA_t, ndim=2] B,
         np.ndarray[DtypeB_t, ndim=1] C,
         float D):

    cdef Py_ssize_t i, j
    cdef float x, y

    cdef np.ndarray[DtypeA_t, ndim=2] NEW_ARRAY = np.zeros((len(C),3), dtype=DtypeA)

    for i in range(len(C)):
        if C[i] != 1:
            for j in range(i+1,len(C)):
                if A[i][0]==A[j][0] and A[i][1]==A[j][1] and C[j]!= 1:
                    x = B[i][0]+B[j][0]
                    y = B[i][1]+B[j][1]
                    C[i],C[j] = 1,1

                    if abs(y)/abs(x) > D:
                        if y > 0: NEW_ARRAY[i]=([A[i][0],A[i][1],y])

    return NEW_ARRAY

除此之外，我将前一个数组“b”分成两个不同的输入数组“B”和“C”，因为“b”的每一行包含2个浮点元素和一个仅作为标志的整数。所以我删除了标志整数并将它们放在一个单独的1-D数组中，“C”。所以，输入现在看起来像这样：

A =[[12.7, 13.5, 1.0],[23.4, 43.1, 1.0],...]
B =[[0.46,0.95],[4.56,0.92],...]
C =[0,0,...]
D = 0.1

理想情况下，现在输入的所有变量（？）都应该快得多......但显然我做的事情非常错误，因为函数现在是在35.3s时出现的...方式WORSE而不是“纯Python”!!

我怎么这么糟糕？谢谢你的阅读！

Answer 1

我相信索引符号b[j][0]的使用可能会使Cython失效，使得它无法在幕后使用快速索引操作。顺便说一句，即使在纯Python代码中，这种风格也不是惯用的，可能会导致代码变慢。

请尝试在整个过程中使用符号b[j,0]，看看它是否会提高您的效果。

Answer 2

您是否使用cython -a手动编译并检查了逐行注释？（如果是这样，如果你可以发布它的图像，或者写一些关于它告诉你什么的东西，这将有助于我们）。用黄色突出显示的行表示源到源转换器输出的行会导致大量使用CPython API。

例如，您执行cdef Py_ssize_t i, j但没有理由说这些不能是C整数。将它们视为Py_ssize_t需要花费很多时间，并且如果它们仅仅用作带有边界的简单循环中的索引，则可以轻松保证，没有必要。我没有提起Py_ssize_t试图说一般不要使用它。如果您的案例需要支持64位体系结构或索引的更高精度整数，那么当然要使用它。我只是提到它，因为像这样的小事有时会对一堆CPython API的东西被捆绑到一些您认为不含CPython API的Cython代码时会产生意想不到的影响。也许代码中更好的例子是在循环中使用Python bool值和and的构造，而不是这些的矢量化或C级版本。

Cython中的这些位置通常指的是你不会获得加速并且经常变慢的位置，特别是如果它们与NumPy代码混合在一起，由于它更加优化地使用Cython /扩展包装器，否则不得不处理CPython API开销。您可以让cython -a输出指导您添加C级类型声明以替换Python类型，或者使用C级函数（如C数学库），而不是可能需要处理参数的Python操作，即使在键入时，可能是任何类型的Python对象，也包含所涉及的所有属性查找和调度调用。

Answer 3

使用cython -a显示注释对于优化Cython代码确实非常有用。这个版本应该更快，并且使用更清晰的语法和memoryviews，

# cython: boundscheck=False
# cython: cdivision=True
# cython: wraparound=False

import numpy as np
cimport numpy as np


def loop(double [:,::1] A, double [:,::1] B, long [::1] C, float D):

    cdef Py_ssize_t i, j, N
    cdef float x, y

    N = len(C)

    cdef double[:,::1] NEW_ARRAY = np.zeros((N,3), dtype='float64')

    for i in range(N):
        if C[i] != 1:
            for j in range(i+1, N):
                if (A[i,0]==A[j,0]) & (A[i,1]==A[j,1]) & (C[j] != 1):
                    x = B[i,0] + B[j,0]
                    y = B[i,1] + B[j,1]
                    C[i] = 1
                    C[j] = 1

                    if abs(y/x) > D and y >0:
                        NEW_ARRAY[i,0] = A[i,0]
                        NEW_ARRAY[i,1] = A[i,1]
                        NEW_ARRAY[i,2] = y

    return NEW_ARRAY.base

我严重损坏了Cython，它的性能比纯Python差。为什么呢？

3 个答案: