Python 如何求和的平方和的和？

我有一个总数，我想加快。有一种情况是：

S{x，y，k，l}Fu{ku}Fv{lv}Fx{kx}Fy{ly}

另一种情况是：

S{x，y}（S{k，l}Fu{ku}Fv{lv}Fx{kx}Fy{ly}）2

注：S_{index}：是这些索引的和

我发现的第一个案例是如何使用numpy的

einsum

，它带来了惊人的加速效果~x160

还有，我想尝试扩大平方，但这不是一个杀手，因为我需要求x，y，k，l，k，l的和，而不是x，y，k，l

下面是一个实现，它演示了我与

einsum

的区别和解决方案

Nx = 3
Ny = 4
Nk = 5
Nl = 6
Nu = 7
Nv = 8
Fx = np.random.rand(Nx, Nk)
Fy = np.random.rand(Ny, Nl)
Fu = np.random.rand(Nu, Nk)
Fv = np.random.rand(Nv, Nl)
P = np.random.rand(Nx, Ny)
B = np.random.rand(Nk, Nl)
I1 = np.zeros([Nu, Nv])
I2 = np.zeros([Nu, Nv])
t = time.time()
for iu in range(Nu):
    for iv in range(Nv):
        for ix in range(Nx):
            for iy in range(Ny):
                S = 0.
                for ik in range(Nk):
                    for il in range(Nl):
                        S += Fu[iu,ik]*Fv[iv,il]*Fx[ix,ik]*Fy[iy,il]*P[ix,iy]*B[ik,il]
                I1[iu, iv] += S
                I2[iu, iv] += S**2.
print time.time() - t; t = time.time()
# 0.0787379741669
I1_ = np.einsum('uk, vl, xk, yl, xy, kl->uv', Fu, Fv, Fx, Fy, P, B)
print time.time() - t
# 0.00049090385437
print np.allclose(I1_, I1)
# True
# Solution by expanding the square (not ideal)
t = time.time()
I2_ = np.einsum('uk,vl,xk,yl,um,vn,xm,yn,kl,mn,xy->uv', Fu,Fv,Fx,Fy,Fu,Fv,Fx,Fy,B,B,P**2)
print time.time() - t
# 0.0226809978485 <- faster than for loop but still much slower than I1_ einsum
print np.allclose(I2_, I2)
# True

Nx=3
Ny=4
Nk=5
Nl=6
Nu=7
Nv=8
Fx=np.rand.rand（Nx，Nk）
Fy=np.random.rand（纽约州，北爱尔兰州）
Fu=np.random.rand（Nu，Nk）
Fv=np.random.rand（Nv，Nl）
P=np.random.rand（Nx，Ny）
B=np.random.rand（Nk，Nl）
I1=np.零（[Nu，Nv]）
I2=np.零（[Nu，Nv]）
t=time.time（）
对于范围内的iu（Nu）：
对于范围内的iv（Nv）：
对于范围内的ix（Nx）：
对于范围内的iy（纽约）：
S=0。
对于范围内的ik（Nk）：
对于范围内的il（Nl）：
S+=Fu[iu，ik]*Fv[iv，il]*Fx[ix，ik]*Fy[iy，il]*P[ix，iy]*B[ik，il]
I1[iu，iv]+=S
I2[iu，iv]+=S**2。
打印时间。时间（）-t；t=time.time（）
# 0.0787379741669
I1=np.einsum（'uk，vl，xk，yl，xy，kl->uv'，Fu，Fv，Fx，Fy，P，B）
打印时间。时间（）-t
# 0.00049090385437
打印np.ALLCOSE（I1，I1）
#真的
#通过展开正方形解决方案（不理想）
t=time.time（）
I2=np.einsum（'uk，vl，xk，yl，um，vn，xm，yn，kl，mn，xy->uv'，Fu，Fv，Fx，Fy，Fu，Fv，Fx，Fy，B，B，P**2）
打印时间。时间（）-t
#0.0226809978485（更新：跳到末尾查看表示为两个矩阵乘法的结果。）

我认为通过使用恒等式，您可以大大简化计算：


比如说,

S_{k,l} Fu_{ku} Fv_{lv} Fx_{kx} Fy_{ly}
  = S_{k,l} Fu_{ku} Fx_{kx} Fv_{lv} Fy_{ly}            -- rearrange the factors
            \___ A ____/    \___ B ____/
  = ( S_k Fu_{ku} Fx_{kx} ) * ( S_l Fv_{lv} Fy_{ly} )  -- from the identity
  =   A_{ux}                * B_{vy}

其中
A{ux}
仅取决于
u
和
x
和
B{vy}
仅取决于
v
和
y

对于平方和，我们有：

S_k [ S_l Fu_{ku} Fv_{lv} Fx_{kx} Fy_{ly} ]^2
  = S_k Fu_{ku} Fx_{kx} * [ S_l Fv_{lv} Fy_{ly} ]^2
  = S_k Fu_{ku} Fx_{kx} * B_{vy}^2                 -- B is from the above calc.
  = B_{vy}^2 * S_k Fu_{ku} Fx_{kx}                 -- B_vy is free of k
  = B_{vy}^2 * A_{ux}                              -- A is from the above calc.

在
x
和
y
上继续求和时，会出现类似的减少：

S_{xy} A_{ux} * B_{vy}
  = S_x A_{ux} * S_y B_{vy}                        -- from the identity
  =  C_u       *    D_v

然后最后将
u
和
v
相加：

S_{uv} C_u D_v = (S_u C_u) * (S_v D_v)             -- from the identity

希望这有帮助

更新：我刚刚意识到也许对于你想要计算的平方和
[S_k S_l…]^2
在这种情况下，您可以像这样继续：

[ S_k  S_l Fu_{ku} Fv_{lv} Fx_{kx} Fy_{ly} ]^2
  =  [ A_{ux}                * B_{vy} ]^2
  =  A_{ux}^2 * B_{vy}^2

所以当我们对这些变量求和时，我们得到：

S_{uvxy} A_{ux}^2 B_{vy}^2
  = S_{uv} ( S_{xy}  A_{ux}^2 B_{vy}^2 )
  = S_{uv} ( S_x A_{ux}^2 ) * ( S_y B_{vy}^2 )     -- from the identity
  = S_{uv}     C_u          *      D_v
  = (S_u C_u) * (S_v D_v)                          -- from the identity

更新2：这可以归结为几个矩阵乘法

A和B的定义：

A_{uv} = S_k Fu_{ku} Fx_{kx}
B_{vy} = S_l Fv_{lv} Fy_{ly}

也可采用矩阵形式编写，如下所示：

A = (transpose Fu) . Fx             -- . = matrix multiplication
B = (transpose Fv) . Fy

以及C和D的定义：

C_u = S_x A_{ux}
D_v = S_y B_{vy}

我们看到向量C只是A的行和，向量D只是B的行和。因为整个总和（不是平方）的答案是：

我们可以看到，总和就是A的所有矩阵元素之和乘以B的所有矩阵元素之和

以下是numpy代码：

from numpy import *
# ... set up Fx, Fv, Fu, Fy as above...

A = Fx.dot(Fu.transpose())
B = Fv.dot(Fy.transpose())
sum1 = sum(A) * sum(B)

A2 = square(A)
B2 = square(B)
sum2 = sum(A2) * sum(B2)

print "sum of terms:", sum1
print "sum of squares of terms:", sum2

既然问题变了，我将开始一个新的答案

试试这个：

E = np.einsum('uk, vl, xk, yl, xy, kl->uvxy', Fu, Fv, Fx, Fy, P, B)
E1 = np.einsum('uvxy->uv', E)
E2 = np.einsum('uvxy->uv', np.square(E))

我发现它的运行速度和I1的时间一样快

这是我的测试代码：
在C语言中有一些开销。。。使用更大的阵列进行尝试。。。我想你会看到速度与物体的大小成正比dataset@SlaterTyranus哪一部分？这是一个JIT编译器，对吗？我会用它来做一个函数，这个函数做for循环？@JoranBeasley你指的是I2_u2;表达式？我希望有一种方法可以避免扩展，因为这会增加我的维度…我编辑了这个问题，所以这是不可能的，我曾试图简化我的问题以便于发布，但后来它允许了这个答案。很抱歉，因为我被淘汰了！陛下是的，这会有用的。谢谢你，我有一个跟进，但会在一个新的问题张贴。谢谢你的帮助！期待它；-）所以有点想通了，但是如果你有更好的回答，请评论/回答！
E = np.einsum('uk, vl, xk, yl, xy, kl->uvxy', Fu, Fv, Fx, Fy, P, B)
E1 = np.einsum('uvxy->uv', E)
E2 = np.einsum('uvxy->uv', np.square(E))