嵌套for循环缓慢python以计算特殊标准偏差

Question

我试图计算大约100个节点的矩阵中的拓扑属性的标准偏差.我想要编写的代码如下:

如何计算标准差

(这需要一个方括号关闭)

X是哪里

如何计算拓扑属性X.

但是应该用g代替.

结果我编写了以下内容.我尝试使用大约85个节点的随机图运行代码.为此,S并且G都是85由85矩阵,其中所有输入项为0和1之间的浮纱和n在这种情况下节点85的数量,.输入代码的是M_std(type = numpy.ndarray,S在函数的输入中),它是g_ {ij}的标准差的矩阵,并且M_p(type = numpy.ndarray,G in function of function)是一个矩阵的期望值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分钟,或者这就是我必须处理的问题.这是上一篇文章的更新版本.我很抱歉最后一个.

PS我正在使用2.5 GHz Intel Core 5并在jupyter笔记本中运行计算.

PPS的一个例子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文档链接