Question

我正在尝试运行一种模拟，其中有需要迭代的固定参数并找出成本最低的组合。我正在使用python多处理来实现此目的，但消耗的时间太长。是我的实施有问题吗？或者有更好的解决方案。谢谢提前

    import multiprocessing
    class Iters(object):
        #parameters for iterations
        iters['cwm']={'min':100,'max':130,'step':5}
        iters['fx']={'min':1.45,'max':1.45,'step':0.01}
        iters['lvt']={'min':106,'max':110,'step':1}
        iters['lvw']={'min':9.2,'max':10,'step':0.1}
        iters['lvk']={'min':3.3,'max':4.3,'step':0.1}
        iters['hvw']={'min':1,'max':2,'step':0.1}
        iters['lvh']={'min':6,'max':7,'step':1}

        def run_mp(self):
            mps=[]
            m=multiprocessing.Manager()
            q=m.list()
            cmain=self.iters['cwm']['min']
            while(cmain<=self.iters['cwm']['max']):
                t2=multiprocessing.Process(target=mp_main,args=(cmain,iters,q))
                mps.append(t2)
                t2.start()
                cmain=cmain+self.iters['cwm']['step']
            for mp in mps:
                mp.join()
            r1=sorted(q,key=lambda x:x['costing'])
            returning=[r1[0],r1[1],r1[2],r1[3],r1[4],r1[5],r1[6],r1[7],r1[8],r1[9],r1[10],r1[11],r1[12],r1[13],r1[14],r1[15],r1[16],r1[17],r1[18],r1[19]]
            self.counter=len(q)
            return returning

    def mp_main(cmain,iters,q):
        fmain=iters['fx']['min']
        while(fmain<=iters['fx']['max']):
            lvtmain=iters['lvt']['min']
            while (lvtmain<=iters['lvt']['max']):
                lvwmain=iters['lvw']['min']
                while (lvwmain<=iters['lvw']['max']):
                    lvkmain=iters['lvk']['min']
                    while (lvkmain<=iters['lvk']['max']):
                        hvwmain=iters['hvw']['min']
                        while (hvwmain<=iters['hvw']['max']):
                            lvhmain=iters['lvh']['min']
                            while (lvhmain<=iters['lvh']['max']):
                                test={'cmain':cmain,'fmain':fmain,'lvtmain':lvtmain,'lvwmain':lvwmain,'lvkmain':lvkmain,'hvwmain':hvwmain,'lvhmain':lvhmain}
                                y=calculations(test,q)
                                lvhmain=lvhmain+iters['lvh']['step']
                            hvwmain=hvwmain+iters['hvw']['step']
                        lvkmain=lvkmain+iters['lvk']['step']
                    lvwmain=lvwmain+iters['lvw']['step']
                lvtmain=lvtmain+iters['lvt']['step']
            fmain=fmain+iters['fx']['step']

    def calculations(test,que):
        #perform huge number of calculations here
        output={}
        output['data']=test
        output['costing']='foo'
        que.append(output)

    x=Iters()
    x.run_thread()

Answer 1

从理论的角度来看：

您正在迭代6种不同变量的每种可能组合。除非您的搜索空间非常小，或者您只想要一个非常粗略的解决方案，否则您无法在合理的时间内获得任何有意义的结果。

我需要迭代并找出成本最低的组合

这听起来像optimization problem。

根据您尝试优化的功能的属性，有许多不同的有效方法可以解决这些问题。如果它有一个直线的形状＆＃34; （它是injective），您可以使用greedy algorithm，例如hill climbing或gradient descent。如果它更复杂，您可以尝试shotgun hill climbing。

有许多更复杂的算法，但这些是基本的，在这种情况下可能对你有很大的帮助。

从更实际的编程角度来看：

你正在使用非常大的步骤 - 事实上，如此大，以至于你只会探测功能19,200。如果这是你想要的，那似乎是非常可行的。事实上，如果我评论y=calculations(test,q)，则会立即在我的计算机上返回。

正如您所指出的，有大量的计算＆＃34;那可能是你的真正的问题，而不是你要求帮助的代码。

对于多处理，我的诚实建议是在你的代码执行速度相当快之前不要使用它。除非你正在运行一个超级计算集群（你没有不在python中编程一个超级计算集群，不管你怎么做？），并行处理会让你的速度提高2-4倍。与我提到的那种算法变化所获得的收益相比，这绝对可以忽略不计。

顺便说一句，我不认为我曾经见过我生命中的许多嵌套循环（不包括代码笑话）。如果您不想切换到其他算法，可能需要考虑将itertools.product与numpy.arange一起使用

运行并行迭代

1 个答案: