Python 加速cython代码

我有一些用python编写的代码，希望使用cython来加速计算。我复制的函数位于.pyx文件中，并从python代码中调用。五、 C，train，I_k是二维numpy数组，lambda_，user，hidden是int。 我没有任何使用C或cython的经验。什么是高效的 使代码更快的方法。 使用

cython-a

进行编译表明代码有缺陷，但如何改进它。在prange中为i使用

（用户大小，nogil=True）：

如果没有gil，则不允许

构造Python切片对象

如何修改代码以获得cython的威力

 @cython.boundscheck(False)
 @cython.wraparound(False)
 def u_update(V, C, train, I_k, lambda_u, user, hidden):
    cdef int user_size = user
    cdef int hidden_dim = hidden
    cdef np.ndarray U = np.empty((hidden_dim,user_size), float)
    cdef int m = C.shape[1]

    for i in range(user_size):
        C_i = np.zeros((m, m), dtype=float)
        for j in range(m):
            C_i[j,j]=C[i,j]

        U[:,i] = np.dot(np.linalg.inv(np.dot(V, np.dot(C_i,V.T)) + lambda_u*I_k), np.dot(V, np.dot(C_i,train[i,:].T)))

    return U

首先想到的是，您没有键入函数参数并指定数据类型和维度数，如下所示：

def u_update(np.ndarray[np.float64, ndim=2]V, np.ndarray[np.float64, ndim=2]\
C, np.ndarray[np.float64, ndim=2] train, np.ndarray[np.float64, ndim=2] \
I_k, int lambda_u, int user, int hidden) :

这将大大加快使用2个索引进行索引的速度，就像您在内部循环中所做的那样

最好也对数组
U
执行此操作，尽管您正在使用切片：

cdef np.ndarray[np.float64, ndim=2] U = np.empty((hidden_dim,user_size), np.float64)

接下来，您将重新定义
C_i
，一个大的2-D数组，每次外部循环迭代一次。此外，您还没有为它提供任何类型信息，如果Cython要提供任何加速，这是必须的。要解决此问题，请执行以下操作：

cdef np.ndarray[np.float64, ndim=2] C_i = np.zeros((m, m), dtype=np.float64)
    for i in range(user_size):
        C_i.fill(0)

在这里，我们定义了它一次（使用类型信息），并通过填充零来重用内存，而不是每次调用
np.zeros（）
来创建一个新数组

此外，您可能希望仅在完成调试后关闭边界检查

如果在U[[，i]＝…/Cux>步骤中需要加速，可以考虑用Cython编写另一个函数来使用循环执行这些操作。< /P>
一定要阅读这篇文章，它会让你知道在Cython中使用Numpy数组时应该做什么，不应该做什么，同时也会让你了解通过这些简单的更改可以获得多大的加速。
你正试图通过潜入池底来使用
Cython
。你应该从一些小的东西开始，比如一些numpy的例子。甚至尝试改进
np.diag

    i = 0
    C_i = np.zeros((m, m), dtype=float)
    for j in range(m):
        C_i[j,j]=C[i,j]

五,

你能提高这个简单表达式的速度吗<代码>诊断

未编译，但它确实执行有效的索引赋值

 res[:n-k].flat[i::n+1] = v

但是，

cython

的真正问题是这个表达式：

U[:,i] = np.dot(np.linalg.inv(np.dot(V, np.dot(C_i,V.T)) + lambda_u*I_k), np.dot(V, np.dot(C_i,train[i,:].T)))

np.dot

已编译

cython

不会将其转换为

c

code，也不会将所有5个

dots

合并为一个表达式。它也不会触及

inv

。因此，在最好的情况下，

cython

将加快迭代包装器的速度，但它仍然会调用这个Python表达式

m

次

我的猜测是这个表达式可以被清除。用

einsum

替换内部

dots

可能会消除

C_i

的需要。

inv

可能会使整个事情难以“矢量化”。但我还得进一步研究

但是如果您想坚持使用

cython

路线，则需要将

U

表达式转换为简单的迭代代码，而不需要调用诸如

dot

和

inv

之类的numpy函数

===================

我相信以下几点是相当的：

np.dot(C_i,V.T)
C[i,:,None]*V.T

在：

如果

train

是2d，那么

train[i，：]

是1d，

.T

什么也不做

In [289]: np.dot(np.diag([1,2,3]),np.arange(3))
Out[289]: array([0, 2, 6])
In [290]: np.array([1,2,3])*np.arange(3)
Out[290]: array([0, 2, 6])

如果我没弄错，你就不需要

ci

======================

此外，这些计算可以移动到循环之外，表达式如下（未测试）

下一步是将两个

np.dot（V，CV…

移出循环。可能需要

np.matmul

（@）或

np.einsum

。那我们就有

for i...
    I = np.linalg.inv(VCV1[i,...])  
    U[:,i] = np.dot(I+ lambda_u), VCV2[i,])

甚至

for i...
     I[...i] = np.linalg.inv(...) # if inv can't be vectorized
U = np.einsum(..., I+lambda_u, VCV2)

---

这是一个粗略的草图，细节需要解决。

用户大小的典型值是什么？我认为，不确定您是否可以提高执行速度，因为您主要在已编译/优化的代码中使用

numpy

。你分析过你的代码吗？

U

表达式太复杂了，

cython

无法加速。

C_i

可以通过

diagonal

功能完成。

user_size

约为1000。不，我还没有分析代码。我第一次使用

np.diag

函数来计算

C_I

，但我希望使用并行循环会更快。因此，为了加快计算速度，我必须重写

U

的计算？这可以通过广义的ufunc

numpy.linalg.solve

来加速<代码>点（inv（A），B）可以通过

求解（A，B）

来计算。并且对角矩阵的点可以被多次广播所代替。如果你提供一些测试数据，我可以告诉你怎么做。是的，你是对的。我不需要计算

ci

。这样，程序的速度已经提高了3-4倍。将计算（

CV1

和

CV2=C*列车

）移到外部尚未导致改进。你的上一个建议我还没有测试过。你关于数据类型的建议当然是正确的，但在我的例子中没有明显的收获，因为大部分时间都花在计算

U[：，I]

上。这是可以理解的。然而，我的回答并不是为了优化这段特定的代码，而（正确地）接受的答案已经涵盖了这段代码。这些都是很好的实践，我强烈建议您在将来使用Cython时遵循这些实践。由于我不能对另一个答案发表评论，我也建议使用

np.linalg.solve（A，b）

而不是

dot（inv（A，b）

，因为这将得到比求逆和乘法少得多的结果。祝你快乐！

CV1 = C[:,:,None]*V.T   # a 3d array
CV2 = C * train.T  

for i in range(user_size):
    U[:,i] = np.dot(np.linalg.inv(np.dot(V, CV1[i,...]) + lambda_u*I_k), np.dot(V, CV2[i,...]))

for i...
    I = np.linalg.inv(VCV1[i,...])  
    U[:,i] = np.dot(I+ lambda_u), VCV2[i,])

for i...
     I[...i] = np.linalg.inv(...) # if inv can't be vectorized
U = np.einsum(..., I+lambda_u, VCV2)