Skip to main content
 首页 » 编程设计

python之如何向量化多级递归

2024年11月01日13zfyouxi

我是 python 和 numpy(以及一般编程)的新手。我正在尝试尽可能加快我的代码。数学涉及对几个数组的多个轴的多个求和。我已经达到了一个矢量化级别,但我似乎无法比这更深入并且不得不求助于 for 循环(我相信有三个级别的递归,M,N 和 I,其中一个我已经淘汰,我)。这是相关部分的代码(此代码有效,但我想加快速度):

def B1(n, i): 
    return np.pi * n * dmaxi * (-1)**(n+1) * np.sin(qi[i]*dmaxi) * ((np.pi*n)**2 - (qi[i]*dmaxi)**2)**(-1) 
 
for n in N: 
    B[n, :] = B1(n, I) 
 
for m in M: 
    for n in N: 
        C[m, n] = np.dot((1/np.square(qi*Iq[0, :, 2]))*B[m, :], B[n, :]) 
 
    Y[m] = np.dot((1/np.square(qi*Iq[0, :, 2]))*U[0, :, 1], B[m, :]) 
 
A = np.linalg.solve(C[1:, 1:], (0.25)*Y[1:]) 

dmaxi 只是一个 float ,m、n 和 i 是整数。阵列具有以下形状:

>>> qi.shape 
(551,) 
>>> N.shape 
(18,) 
>>> M.shape 
(18,) 
>>> I.shape 
(551,) 
>>> Iq.shape 
(1, 551, 3) 
>>> U.shape 
(1, 551, 3) 

如您所见,我已经矢量化了 B 的第二个轴的计算,但我似乎无法对第一个轴、C 和 Y 执行此计算,它们仍然需要 for 循环。似乎当我尝试对 B 的第一个轴执行相同形式的矢量化时(定义一个函数,然后将数组作为参数),我收到一个广播错误,因为它似乎正在尝试计算两者轴,而不是第一个,然后第二个,这就是为什么我不得不强制它进入 for 循环的原因。 C 和 Y 都会出现同样的问题,这就是为什么它们也都在 for 循环中的原因。如果这令人困惑,基本上我尝试的是:

>>> B[:, :] = B1(N, I) 
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
  File "sasrec_v6.py", line 155, in B1 
    return np.pi * n * dmaxi * (-1)**(n+1) * np.sin(qi[i]*dmaxi) * ((np.pi*n)**2 - (qi[i]*dmaxi)**2)**(-1) 
ValueError: operands could not be broadcast together with shapes (18) (551)  

向量化 B 的第 2 轴显着提高了我的代码速度,因此我假设同样适用于进一步向量化(我希望我正确使用该术语)。

请您参考如下方法:

您可以使用 broadcasting从您的一维索引向量制作二维数组。我还没有测试过这些,但它们应该可以工作:

如果将 N reshape 为列向量,则 B1 将返回一个二维数组:

B[N] = B1(N[:, None], I) 

对于 Y 和 C,我会使用 np.einsum 来更好地控制哪些轴被多重化(可能这可能是也用 np.dot 完成了,但我不确定怎么做。

C[M[:, None], N] = np.einsum('ij,kj->ik', 
        B[M]/np.square(qi*Iq[0, :, 2]), 
        B[N]) 
 
Y[M] = np.einsum('i, ki->k', 
        U[0, :, 1]/np.square(qi*Iq[0, :, 2]), 
        B[M]) 

要查看索引技巧的作用:

In [1]: a = np.arange(3) 
 
In [2]: a 
Out[2]: array([0, 1, 2]) 
 
In [3]: a[:, None] 
Out[3]:  
array([[0], 
       [1], 
       [2]]) 
 
In [4]: b = np.arange(4,1,-1) 
 
In [5]: b 
Out[5]: array([4, 3, 2]) 
 
In [6]: a[:, None] * b 
Out[6]:  
array([[0, 0, 0], 
       [4, 3, 2], 
       [8, 6, 4]]) 

它节省了两个数量级的时间:

In [92]: %%timeit 
   ....: B = np.zeros((18, 551)) 
   ....: C = np.zeros((18, 18)) 
   ....: Y = np.zeros((18)) 
   ....: for n in N: 
   ....:     B[n, :] = B1(n, I) 
   ....: for m in M: 
   ....:     for n in N: 
   ....:         C[m, n] = np.dot((1/np.square(qi*Iq[0, :, 2]))*B[m, :], B[n, :]) 
   ....:     Y[m] = np.dot((1/np.square(qi*Iq[0, :, 2]))*U[0, :, 1], B[m, :]) 
   ....:  
100 loops, best of 3: 15.8 ms per loop 
 
In [93]: %%timeit 
   ....: Bv = np.zeros((18, 551)) 
   ....: Cv = np.zeros((18, 18)) 
   ....: Yv = np.zeros((18)) 
   ....: Bv[N] = B1(N[:, None], I) 
   ....: Cv[M[:, None], N] = np.einsum('ij,kj->ik', B[M]/np.square(qi*Iq[0, :, 2]), B[N]) 
   ....: Yv[M] = np.einsum('i, ki->k', U[0, :, 1]/np.square(qi*Iq[0, :, 2]), B[M]) 
   ....:  
1000 loops, best of 3: 1.34 ms per loop 

这是我的测试:

import numpy as np 
 
# make fake data: 
np.random.seed(5) 
 
qi = np.random.rand(551) 
N = np.random.randint(0,18,18)#np.arange(18) 
M = np.random.randint(0,18,18)#np.arange(18) 
I = np.arange(551) 
Iq = np.random.rand(1, 551, 3) 
U = np.random.rand(1, 551, 3) 
 
B = np.zeros((18, 551)) 
C = np.zeros((18, 18)) 
Y = np.zeros((18)) 
Bv = np.zeros((18, 551)) 
Cv = np.zeros((18, 18)) 
Yv = np.zeros((18)) 
 
dmaxi = 1. 
 
def B1(n, i): 
    return np.pi * n * dmaxi * (-1)**(n+1) * np.sin(qi[i]*dmaxi) * ((np.pi*n)**2 - (qi[i]*dmaxi)**2)**(-1) 
 
for n in N: 
    B[n, :] = B1(n, I) 
 
for m in M: 
    for n in N: 
        C[m, n] = np.dot((1/np.square(qi*Iq[0, :, 2]))*B[m, :], B[n, :]) 
    Y[m] = np.dot((1/np.square(qi*Iq[0, :, 2]))*U[0, :, 1], B[m, :]) 
 
Bv[N] = B1(N[:, None], I) 
print "B correct?", np.allclose(Bv, B) 
 
# np.einsum test case: 
n, m = 2, 3 
a = np.arange(n*m).reshape(n,m)*8 + 2 
b = np.arange(n*m)[::-1].reshape(n,m) 
c = np.empty((n,n)) 
for i in range(n): 
    for j in range(n): 
        c[i,j] = np.dot(a[i],b[j]) 
cv = np.einsum('ij,kj->ik', a, b) 
print "einsum test successful?", np.allclose(c,cv) 
 
Cv[M[:, None], N] = np.einsum('ij,kj->ik', 
        B[M]/np.square(qi*Iq[0, :, 2]), 
        B[N]) 
print "C correct?", np.allclose(Cv, C) 
 
Yv[M] = np.einsum('i, ki->k', 
        U[0, :, 1]/np.square(qi*Iq[0, :, 2]), 
        B[M]) 
print "Y correct?", np.allclose(Yv, Y) 

输出:D

B correct? True 
einsum test successful? True 
C correct? True 
Y correct? True