Question

我有一个当前正在运行的模拟，但ETA大约需要40个小时 - 我正试图通过多重处理来加速它。

它基本上迭代了一个变量（L）的3个值，以及第二个变量（a）的99个值。使用这些值，它基本上运行复杂的模拟并返回9个不同的标准偏差。因此（即使我还没有这样编码）它本质上是一个函数，它将两个值作为输入（L，a）并返回9个值。

以下是我所拥有的代码的本质：

STD_1 = []
STD_2 = []
# etc.

for L in range(0,6,2):
    for a in range(1,100):
        ### simulation code ###
        STD_1.append(value_1)
        STD_2.append(value_2)
        # etc.

以下是我可以将其修改为：

master_list = []

def simulate(a,L):
    ### simulation code ###
    return (a,L,STD_1, STD_2 etc.)

for L in range(0,6,2):
    for a in range(1,100): 
        master_list.append(simulate(a,L))

由于每个模拟都是独立的，因此它似乎是实现某种多线程/处理的理想场所。

我将如何准确编码？

编辑：此外，所有内容都会按顺序返回主列表，或者如果多个进程正在运行，它们可能会出现故障吗？

编辑2：这是我的代码 - 但它无法正常运行。它问我是否想在运行后立即杀死程序。

import multiprocessing

data = []

for L in range(0,6,2):
    for a in range(1,100):
        data.append((L,a))

print (data)

def simulation(arg):
    # unpack the tuple
    a = arg[1]
    L = arg[0]
    STD_1 = a**2
    STD_2 = a**3
    STD_3 = a**4
    # simulation code #
    return((STD_1,STD_2,STD_3))

print("1")

p = multiprocessing.Pool()

print ("2")

results = p.map(simulation, data)

编辑3：多处理的局限性是什么。我听说它在OS X上不起作用。这是正确的吗？

Answer 1

将每次迭代的数据包装到元组中。
列出那些元组的列表data
编写一个函数f来处理一个元组并返回一个结果
创建p = multiprocessing.Pool()对象。
致电results = p.map(f, data)

这将运行f的多个实例，因为您的计算机在不同的进程中具有核心。

编辑1：示例：

from multiprocessing import Pool

data = [('bla', 1, 3, 7), ('spam', 12, 4, 8), ('eggs', 17, 1, 3)]

def f(t):
    name, a, b, c = t
    return (name, a + b + c)

p = Pool()
results = p.map(f, data)
print results

<强> EDIT2：

多处理应该在类似UNIX的平台（如OSX）上正常工作。只有缺少os.fork（主要是MS Windows）的平台才需要特别注意。但即便如此，它仍然有效。请参阅多处理文档。

Answer 2

以下是在并行线程中运行它的一种方法：

import threading

L_a = []

for L in range(0,6,2):
    for a in range(1,100):
        L_a.append((L,a))
        # Add the rest of your objects here

def RunParallelThreads():
    # Create an index list
    indexes = range(0,len(L_a))
    # Create the output list
    output = [None for i in indexes]
    # Create all the parallel threads
    threads = [threading.Thread(target=simulate,args=(output,i)) for i in indexes]
    # Start all the parallel threads
    for thread in threads: thread.start()
    # Wait for all the parallel threads to complete
    for thread in threads: thread.join()
    # Return the output list
    return output

def simulate(list,index):
    (L,a) = L_a[index]
    list[index] = (a,L) # Add the rest of your objects here

master_list = RunParallelThreads()

Answer 3

如果排序不重要，请使用 start chrome。它将以非阻塞方式返回结果。

使用单个函数进行Python多处理

3 个答案: