Python 嵌套的多处理

我目前正试图从下面显示的过程中得到一个结果。然而，对于所需的步骤数量来说，这需要花费太长的时间。我想加快结果。 在这种情况下，如何实现多处理

在我正在构建的类中，我有以下定义

    def class_corr(self,Delta,xi_q,Q,counter):
        to = self.t
        npts = 512
        x0 = 12
        dx =2*x0/npts
        norm=0
        classic=0
        for n in range(0,npts+1):
            qi = -x0+n*dx
            for m in range(0,npts+1):
                pj = -x0+m*dx
                for k in range(0,npts+1):
                    xi_pk = -x0+k*dx
                    f1    += dx**3*wt(qi,pj,qo,po,to)*F(qi,xi_pk,Delta, Q)
                    fn += dx**3*wt(qi,pj,qo,po,to)*G(qi,xi_pk,xi_q,Delta,Q)
        if counter:
            return  [f1, fn/f1]
        return  fn/f1

使用多重处理是否合理

到目前为止，我已经检查了这些：

---

但是我还没有能够实现这些，也没有找到解决方案。

在我看来，这里真正存在的是一个动态编程风格的问题。你一直在重新计算相同的术语。例如，您只需要计算

dx^3

一次，但您需要计算

npts^3

次。类似地，您只需要计算每个

3*wt（qi、pj、qo、po、to）

term一次，但您需要计算

2*NPT

次

尝试以下方法：

def class_corr(self,Delta,xi_q,Q,counter):
    to = self.t
    npts = 512
    x0 = 12
    dx =2*x0/npts
    dx3 = dx**3
    norm=0
    classic=0
    for n in range(0,npts+1):
        qi = -x0+n*dx
        for m in range(0,npts+1):
            pj = -x0+m*dx
            wt_curr = wt(qi,pj,qo,po,to)
            for k in range(0,npts+1):
                xi_pk = -x0+k*dx
                f1 += dx3*wt_curr*F(qi,xi_pk,Delta, Q)
                fn += dx3*wt_curr*G(qi,xi_pk,xi_q,Delta,Q)
    if counter:
        return  [f1, fn/f1]
    return  fn/f1

此外，您计算

F

和

G

npt

的次数超过了您需要的次数。似乎每个都只随

qi

和

xi_pk

而变化（

xi_q

，

Delta

和

q

在这种方法中似乎没有变化）。如果您尝试使用某种2层defaultdict来记录您已经计算过的

F

（或

G

）的

qi

和

xiu pk

值，那么您将节省大量不必要的调用和

F

（或

G

）计算

---

（PS-我知道这不是你想要的方法，但我认为它解决了你问题的核心。你花了很多时间重新计算你已经计算过的术语。）

正如我所想，这里真正存在的是一个动态编程风格的问题。你一直在重新计算相同的术语。例如，您只需要计算

dx^3

一次，但您需要计算

npts^3

次。类似地，您只需要计算每个

3*wt（qi、pj、qo、po、to）

term一次，但您需要计算

2*NPT

次

尝试以下方法：

def class_corr(self,Delta,xi_q,Q,counter):
    to = self.t
    npts = 512
    x0 = 12
    dx =2*x0/npts
    dx3 = dx**3
    norm=0
    classic=0
    for n in range(0,npts+1):
        qi = -x0+n*dx
        for m in range(0,npts+1):
            pj = -x0+m*dx
            wt_curr = wt(qi,pj,qo,po,to)
            for k in range(0,npts+1):
                xi_pk = -x0+k*dx
                f1 += dx3*wt_curr*F(qi,xi_pk,Delta, Q)
                fn += dx3*wt_curr*G(qi,xi_pk,xi_q,Delta,Q)
    if counter:
        return  [f1, fn/f1]
    return  fn/f1

此外，您计算

F

和

G

npt

的次数超过了您需要的次数。似乎每个都只随

qi

和

xi_pk

而变化（

xi_q

，

Delta

和

q

在这种方法中似乎没有变化）。如果您尝试使用某种2层defaultdict来记录您已经计算过的

F

（或

G

）的

qi

和

xiu pk

值，那么您将节省大量不必要的调用和

F

（或

G

）计算

---

（PS-我知道这不是您想要的方法，但我认为它解决了您的问题的核心。您正在花费大量时间重新计算您已经计算过的术语。）

我不擅长python，但似乎您可以并行运行两个内部循环，您需要同步f1和fn变量的读取和更新操作（+=）。或者在java中使用类似AtomicDouble的东西。似乎您可以利用

itertools.product

这不是您真正想要的，但是为什么不将dx**3移出嵌套循环呢。看起来你只需要计算一次。类似地，为什么在k循环内部调用两个wt（qi、pj、q0、p0、t0），而不是在m循环内部调用一个。我不擅长python，但似乎可以并行运行两个内部循环，需要同步f1和fn变量的读取和更新操作（+=）。或者在java中使用类似AtomicDouble的东西。似乎您可以利用

itertools.product

这不是您真正想要的，但是为什么不将dx**3移出嵌套循环呢。看起来你只需要计算一次。类似地，为什么在k循环内部调用两个wt（qi、pj、q0、p0、t0），而不是在m循环内部调用一个。