python - 嵌套for循环慢速python计算特殊标准差

Question

我正在尝试计算大约 100 个节点的矩阵中拓扑属性的标准差。我要编写的代码如下:

如何计算标准差

(需要用方括号结束)

X在哪里

如何计算拓扑性质X

但是a应该换成g。

因此，我编写了以下代码。我用大约 85 个节点的随机图试运行了代码。因此，S 和 G 都是一个 85 x 85 矩阵，其中所有条目都是 0 和 1 之间的 float ，n 是节点数，在这种情况下为 85。输入到代码中的是M_std(type = numpy.ndarray, S in input of function)，是g_{ij}的标准差矩阵，M_p(type = numpy.ndarray，函数输入中的G)是g_{ij}的期望值矩阵。 Derivative 指的是 (delta X)/(delta g_{ij})。 Std_1 是正方形之间的所有内容。

import networkx as nx
import numpy as np
import math

def new_calc_std_1(S, G, n):
    std_1 = 0
    for e in range(n):
        for f in range(n):
            derivative = 0
            for i in range(n):
                for j in range(n):
                    for k in range(n):
                        if i == j or i == k or j == k:
                            None
                        elif (e not in [i,j,k]) or (f not in [i,j,k]):
                            None
                        else:
                            if e == i and f == j:
                                deriv += -G[j,i]*G[j,k]*(1-G[k,j])*(1-G[i,k])*(1-G[k,i])
                            elif e == j and f == i:
                                deriv += (1-G[i,j])*G[j,k]*(1-G[k,j])*(1-G[i,k])*(1-G[k,i])
                            elif e == j and f == k:
                                deriv += (1-G[i,j])*G[j,i]*(1-G[k,j])*(1-G[i,k])*(1-G[k,i])
                            elif e == k and f == j:
                                deriv += -(1-G[i,j])*G[j,i]*G[j,k]*(1-G[i,k])*(1-G[k,i])
                            elif e == i and f == k:
                                deriv += -(1-G[i,j])*G[j,i]*G[j,k]*(1-G[k,j])*(1-G[k,i])
                            elif e == k and f == i:
                                deriv += -(1-G[i,j])*G[j,i]*G[j,k]*(1-G[k,j])*(1-G[i,k])
                            else:
                                derivative += 0
            std_1 += (S[e,f]*derivative)**2
    std_1 = math.sqrt(std_1)
    return std_1

这总共花费了 21 分钟。我试着找到一个解决方案，然后我读到我必须尽量减少 for 循环的使用，尤其是在 python 中。因此我将代码重写为

def new_new_calc_std_1(S, G, n):
    blwsqrt = 0
    for e in range(n):
        for f in range(n):
            derivative = 0
            for z in range(n):
                if e == f or f == z or z == e:
                    None
                else:
                    derivative += -G[f,e]*G[f,z]*(1-G[z,f])*(1-G[e,z])*(1-G[z,e]) - (1-G[e,z])*G[z,e]*G[z,f]*(1-G[f,z])*(1-G[f,e]) + (1-G[f,e])*G[e,z]*(1-G[z,e])*(1-G[f,z])*(1-G[z,f]) - (1-G[f,z])*G[z,f]*G[z,e]*(1-G[e,z])*(1-G[f,e]) + (1-G[z,e])*G[e,z]*(1-G[f,e])*(1-G[z,f])*(1-G[f,z]) - (1-G[z,f])*G[f,z]*G[f,e]*(1-G[z,e])*(1-G[e,z])
            blwsqrt += (derivative*S[e,f])**2
    std_1 = math.sqrt(blwsqrt)
    return(std_1)

print(new_new_calc_std_1(M_std, M_p, n))

令我惊讶的是，这花费了完全相同的时间。然后我尝试对矩阵进行舍入。这也没有用。然后我读到我可能使用了太多 python，应该更多地使用 scipy，但我不知道在这个特定实例中如何使用。 你们知道如何优化此代码以使其花费的时间少于 21 分钟吗，或者这就是我必须处理的问题。这是上一篇文章的更新版本。对于最后一个，我感到非常抱歉。

附言我正在使用 2.5 GHz Intel Core 5 并在 jupyter notebook 中运行计算。

P.P.S M_std 的一个例子是

[[0.45 0.39 0.45 ... 0.41 0.43 0.39]
 [0.5  0.46 0.5  ... 0.48 0.49 0.47]
 [0.5  0.46 0.49 ... 0.47 0.49 0.46]
 ...
 [0.48 0.42 0.47 ... 0.44 0.46 0.43]
 [0.5  0.46 0.49 ... 0.47 0.49 0.46]
 [0.47 0.42 0.47 ... 0.43 0.46 0.42]]

和M_p

[[0.29 0.18 0.28 ... 0.21 0.25 0.19]
 [0.45 0.31 0.44 ... 0.35 0.4  0.32]
 [0.44 0.3  0.42 ... 0.34 0.39 0.31]
 ...
 [0.35 0.23 0.34 ... 0.26 0.31 0.24]
 [0.43 0.3  0.42 ... 0.34 0.39 0.31]
 [0.33 0.22 0.33 ... 0.25 0.29 0.23]]

Answer 1

如果您使用的是 Python2，我建议您使用 xrange 而不是 range。 xrange 效率更高，因为它不会预先生成整个序列。

我还建议使用 itertools.product 而不是嵌套的 for 循环。

尝试类似 for (e,f,z) in product(xrange(n), xrange(n), xrange(n)):

product docs link