cython memoryvi的慢速索引

Question

我有一个非常稀疏的矩阵，比如5000x3000，双精度浮点。这个矩阵的80%是零。我需要计算每行的总和。所有这些都是用python/cython实现的。我想加快进程。因为我需要计算这个和几百万次，我想如果我做非零元素的索引，只求和，速度会更快。结果变得比原来的“暴力”加零要慢得多。你知道吗

下面是一个简单的例子：

#cython: language_level=2
import  numpy as np
cimport numpy as np
import time


cdef int Ncells = 5000, KCells = 400, Ne= 350
cdef double x0=0.1, x1=20., x2=1.4, x3=2.8, p=0.2

# Setting up weight
all_weights = np.zeros( (Ncells,KCells) )
all_weights[  :Ne,   :Ne ] = x0
all_weights[  :Ne, Ne:   ] = x1  
all_weights[Ne:  ,   :Ne ] = x2
all_weights[Ne:  , Ne:   ] = x3  
all_weights = all_weights * (np.random.rand(Ncells,KCells) < p)

# Making a memory view
cdef np.float64_t[:,:] my_weights = all_weights

# make an index of non zero weights
x,y    = np.where( np.array(my_weights) > 0.)  
#np_pawid  = np.column_stack( (x   ,y   ) )
np_pawid  = np.column_stack( (x   ,y   ) ).astype(int)
cdef np.int_t[:,:] pawid = np_pawid

# Making vector for column sum
summEE = np.zeros(KCells)
# Memory view
cdef np.float64_t [:] my_summEE = summEE
cdef int cc,dd,i

# brute-force summing
ntm = time.time()
for cc in range(KCells):
    my_summEE[cc] = 0
    for dd in range(Ncells):
        my_summEE[cc] += my_weights[dd,cc]
stm = time.time()
print "BRUTE-FORCE summation        : %f s"%(stm-ntm)

my_summEE[:] = 0
# summing only non zero indices
ntm = time.time()
for dd,cc in pawid:
    my_summEE[cc] += my_weights[dd,cc]
stm = time.time()
print "INDEX summation              : %f s"%(stm-ntm)

my_summEE[:] = 0
# summing only non zero indices unpacked by zip
ntm = time.time()
for dd,cc in zip(pawid[:,0],pawid[:,1]):
    my_summEE[cc] += my_weights[dd,cc]
stm = time.time()
print "ZIPPED INDEX summation       : %f s"%(stm-ntm)

my_summEE[:] = 0
# summing only non zero indices unpacked by zip
ntm = time.time()
for i in range(pawid.shape[0]):
    dd = pawid[i,0]
    cc = pawid[i,1]
    my_summEE[cc] += my_weights[dd,cc]
stm = time.time()
print "INDEXING over INDEX summation: %f s"%(stm-ntm)

# Numpy brute-froce summing
ntm = time.time()
sumwee = np.sum(all_weights,axis=0)
stm = time.time()
print "NUMPY BRUTE-FORCE summation  : %f s"%(stm-ntm)

#>
print
print "Number of brute-froce summs  :",my_weights.shape[0]*my_weights.shape[1]
print "Number of indexing    summs  :",pawid.shape[0]
#<

我在Raspberry Pi 3上运行了它，但在PC上似乎也有相同的结果。你知道吗

BRUTE-FORCE summation        : 0.381014 s
INDEX summation              : 18.479018 s
ZIPPED INDEX summation       : 3.615952 s
INDEXING over INDEX summation: 0.450131 s
NUMPY BRUTE-FORCE summation  : 0.013017 s

Number of brute-froce summs  : 2000000
Number of indexing    summs  : 400820

NUMPY BRUTE-FORCE in Python  : 0.029143 s

有人能解释为什么cython代码比numpy慢3-4倍吗？为什么索引将求和次数从2000000减少到400820，慢了45倍？这没有任何意义。你知道吗

Answer 1

1. 你在一个函数之外，所以访问全局变量。这意味着Cython每次被访问时都必须检查它们是否存在，不像它知道不能从其他地方访问的函数局部变量那样。

2. 默认情况下，Cython处理负索引并执行边界检查。你可以turn these off in a number of ways。一个明显的方法是将@cython.wraparound(False)和@cython.boundscheck(False)作为修饰符添加到函数定义中。请注意这些功能的实际用途-唯一的方法是在cdefed numpy数组或类型化memoryview上关闭这些功能，而不适用于其他很多功能（因此不要将它们作为一种货物崇拜类型应用到任何地方）。

查看问题所在的好方法是运行cython -a <filename>并查看带注释的html文件。带有黄色的区域可能没有优化，您可以展开行以查看底层的C代码。显然，在这方面只需要担心频繁调用的函数和循环—设置Numpy数组的代码包含Python调用这一事实是意料之中的，而不是问题。你知道吗

---

一些测量：

就像你写的那样

BRUTE-FORCE summation        : 0.008625 s
INDEX summation              : 0.713661 s
ZIPPED INDEX summation       : 0.127343 s
INDEXING over INDEX summation: 0.002154 s
NUMPY BRUTE-FORCE summation  : 0.001461 s

在函数中

BRUTE-FORCE summation        : 0.007706 s
INDEX summation              : 0.681892 s
ZIPPED INDEX summation       : 0.123176 s
INDEXING over INDEX summation: 0.002069 s
NUMPY BRUTE-FORCE summation  : 0.001429 s

在禁用了boundscheck和wrapparound的函数中：

BRUTE-FORCE summation        : 0.005208 s
INDEX summation              : 0.672948 s
ZIPPED INDEX summation       : 0.124641 s
INDEXING over INDEX summation: 0.002006 s
NUMPY BRUTE-FORCE summation  : 0.001467 s

我的建议确实有帮助，但不会太引人注目。我的差异并不像你看到的那么显著（即使对于你的代码没有改变）。Numpy还是赢了-猜猜看：

1. 我怀疑这是多线程的。你知道吗
2. 整个数组上的直接和将具有可预测的内存访问模式，这可能使它比具有不可预测内存访问的少量操作更有效