多处理：如何在类中定义的函数上使用Pool.map？

Question

当我运行类似的东西时：

from multiprocessing import Pool

p = Pool(5)
def f(x):
     return x*x

p.map(f, [1,2,3])

它工作正常。但是，将此作为类的函数：

class calculate(object):
    def run(self):
        def f(x):
            return x*x

        p = Pool()
        return p.map(f, [1,2,3])

cl = calculate()
print cl.run()

给我以下错误：

Exception in thread Thread-1:
Traceback (most recent call last):
  File "/sw/lib/python2.6/threading.py", line 532, in __bootstrap_inner
    self.run()
  File "/sw/lib/python2.6/threading.py", line 484, in run
    self.__target(*self.__args, **self.__kwargs)
  File "/sw/lib/python2.6/multiprocessing/pool.py", line 225, in _handle_tasks
    put(task)
PicklingError: Can't pickle <type 'function'>: attribute lookup __builtin__.function failed

我看过Alex Martelli的一篇文章处理同样的问题，但是不够明确。

Answer 1

我无法使用到目前为止发布的代码，因为使用“multiprocessing.Pool”的代码不能与lambda表达式一起使用，而不使用“multiprocessing.Pool”的代码会产生与工作项一样多的进程。

我改编了代码s.t.它产生预定义数量的工作者，并且只有在存在空闲工作者时才迭代输入列表。我还为工人s.t启用了“守护进程”模式。 ctrl-c按预期工作。

import multiprocessing


def fun(f, q_in, q_out):
    while True:
        i, x = q_in.get()
        if i is None:
            break
        q_out.put((i, f(x)))


def parmap(f, X, nprocs=multiprocessing.cpu_count()):
    q_in = multiprocessing.Queue(1)
    q_out = multiprocessing.Queue()

    proc = [multiprocessing.Process(target=fun, args=(f, q_in, q_out))
            for _ in range(nprocs)]
    for p in proc:
        p.daemon = True
        p.start()

    sent = [q_in.put((i, x)) for i, x in enumerate(X)]
    [q_in.put((None, None)) for _ in range(nprocs)]
    res = [q_out.get() for _ in range(len(sent))]

    [p.join() for p in proc]

    return [x for i, x in sorted(res)]


if __name__ == '__main__':
    print(parmap(lambda i: i * 2, [1, 2, 3, 4, 6, 7, 8]))

Answer 2

我也对pool.map可以接受的函数限制感到恼火。我写了以下内容以规避这一点。它似乎有效，即使是递归使用parmap。

from multiprocessing import Process, Pipe
from itertools import izip

def spawn(f):
    def fun(pipe,x):
        pipe.send(f(x))
        pipe.close()
    return fun

def parmap(f,X):
    pipe=[Pipe() for x in X]
    proc=[Process(target=spawn(f),args=(c,x)) for x,(p,c) in izip(X,pipe)]
    [p.start() for p in proc]
    [p.join() for p in proc]
    return [p.recv() for (p,c) in pipe]

if __name__ == '__main__':
    print parmap(lambda x:x**x,range(1,5))

Answer 3

除非跳到标准库之外，否则多处理和酸洗会被破坏和限制。

如果使用名为multiprocessing的{​​{1}}的分支，则可以在多处理的pathos.multiprocesssing函数中直接使用类和类方法。这是因为map代替dill或pickle，而cPickle可以在python中序列化几乎所有内容。

dill还提供异步映射函数......它可以pathos.multiprocessing具有多个参数的函数（例如map）

见讨论： What can multiprocessing and dill do together?

和： http://matthewrocklin.com/blog/work/2013/12/05/Parallelism-and-Serialization

它甚至可以处理您最初编写的代码，无需修改，也可以处理解释器。为什么还要做一些更脆弱和特定于单个案例的其他内容？

map(math.pow, [1,2,3], [4,5,6])

在此处获取代码：  https://github.com/uqfoundation/pathos

而且，只是为了展示它能做些什么：

>>> from pathos.multiprocessing import ProcessingPool as Pool
>>> class calculate(object):
...  def run(self):
...   def f(x):
...    return x*x
...   p = Pool()
...   return p.map(f, [1,2,3])
... 
>>> cl = calculate()
>>> print cl.run()
[1, 4, 9]

Answer 4

Answer 5

mrule的解决方案是正确的，但有一个错误：如果孩子发回大量数据，它可以填充管道的缓冲区，阻塞孩子的pipe.send()，而父母正在等待孩子退出pipe.join()。解决方案是在join()孩子之前阅读孩子的数据。此外，孩子应该关闭父管的末端以防止死锁。下面的代码修复了这个问题。另请注意，此parmap会在X中为每个元素创建一个进程。更高级的解决方案是使用multiprocessing.cpu_count()将X划分为多个块，然后在返回之前合并结果。我把它作为练习留给读者，以免破坏了mrule的好回答的简洁性。 ;）

from multiprocessing import Process, Pipe
from itertools import izip

def spawn(f):
    def fun(ppipe, cpipe,x):
        ppipe.close()
        cpipe.send(f(x))
        cpipe.close()
    return fun

def parmap(f,X):
    pipe=[Pipe() for x in X]
    proc=[Process(target=spawn(f),args=(p,c,x)) for x,(p,c) in izip(X,pipe)]
    [p.start() for p in proc]
    ret = [p.recv() for (p,c) in pipe]
    [p.join() for p in proc]
    return ret

if __name__ == '__main__':
    print parmap(lambda x:x**x,range(1,5))

Answer 6

我也在努力解决这个问题。我将函数作为类的数据成员，作为简化示例：

from multiprocessing import Pool
import itertools
pool = Pool()
class Example(object):
    def __init__(self, my_add): 
        self.f = my_add  
    def add_lists(self, list1, list2):
        # Needed to do something like this (the following line won't work)
        return pool.map(self.f,list1,list2)  

我需要在同一个类中的Pool.map（）调用中使用self.f函数，self.f没有将元组作为参数。由于此函数嵌入在类中，因此我不清楚如何编写其他答案建议的包装类型。

我通过使用带有元组/列表的不同包装器解决了这个问题，其中第一个元素是函数，其余元素是该函数的参数，称为eval_func_tuple（f_args）。使用它，有问题的行可以被return pool.map替换（eval_func_tuple，itertools.izip（itertools.repeat（self.f），list1，list2））。这是完整的代码：

文件：util.py

def add(a, b): return a+b

def eval_func_tuple(f_args):
    """Takes a tuple of a function and args, evaluates and returns result"""
    return f_args[0](*f_args[1:])  

档案：main.py

from multiprocessing import Pool
import itertools
import util  

pool = Pool()
class Example(object):
    def __init__(self, my_add): 
        self.f = my_add  
    def add_lists(self, list1, list2):
        # The following line will now work
        return pool.map(util.eval_func_tuple, 
            itertools.izip(itertools.repeat(self.f), list1, list2)) 

if __name__ == '__main__':
    myExample = Example(util.add)
    list1 = [1, 2, 3]
    list2 = [10, 20, 30]
    print myExample.add_lists(list1, list2)  

运行main.py将给出[11,22,33]。随意改进这一点，例如，也可以修改eval_func_tuple以获取关键字参数。

另一方面，在另一个答案中，对于更多进程而不是可用CPU数量的情况，可以使函数“parmap”更有效。我正在复制下面的编辑版本。这是我的第一篇文章，我不确定是否应该直接编辑原始答案。我还重命名了一些变量。

from multiprocessing import Process, Pipe  
from itertools import izip  

def spawn(f):  
    def fun(pipe,x):  
        pipe.send(f(x))  
        pipe.close()  
    return fun  

def parmap(f,X):  
    pipe=[Pipe() for x in X]  
    processes=[Process(target=spawn(f),args=(c,x)) for x,(p,c) in izip(X,pipe)]  
    numProcesses = len(processes)  
    processNum = 0  
    outputList = []  
    while processNum < numProcesses:  
        endProcessNum = min(processNum+multiprocessing.cpu_count(), numProcesses)  
        for proc in processes[processNum:endProcessNum]:  
            proc.start()  
        for proc in processes[processNum:endProcessNum]:  
            proc.join()  
        for proc,c in pipe[processNum:endProcessNum]:  
            outputList.append(proc.recv())  
        processNum = endProcessNum  
    return outputList    

if __name__ == '__main__':  
    print parmap(lambda x:x**x,range(1,5))         

Answer 7

我接受了klaus se和aganders3的回答，并制作了一个更具可读性的文档模块并保存在一个文件中。您只需将其添加到项目中即可。它甚至还有一个可选的进度条！

"""
The ``processes`` module provides some convenience functions
for using parallel processes in python.

Adapted from http://stackoverflow.com/a/16071616/287297

Example usage:

    print prll_map(lambda i: i * 2, [1, 2, 3, 4, 6, 7, 8], 32, verbose=True)

Comments:

"It spawns a predefined amount of workers and only iterates through the input list
 if there exists an idle worker. I also enabled the "daemon" mode for the workers so
 that KeyboardInterupt works as expected."

Pitfalls: all the stdouts are sent back to the parent stdout, intertwined.

Alternatively, use this fork of multiprocessing: 
https://github.com/uqfoundation/multiprocess
"""

# Modules #
import multiprocessing
from tqdm import tqdm

################################################################################
def apply_function(func_to_apply, queue_in, queue_out):
    while not queue_in.empty():
        num, obj = queue_in.get()
        queue_out.put((num, func_to_apply(obj)))

################################################################################
def prll_map(func_to_apply, items, cpus=None, verbose=False):
    # Number of processes to use #
    if cpus is None: cpus = min(multiprocessing.cpu_count(), 32)
    # Create queues #
    q_in  = multiprocessing.Queue()
    q_out = multiprocessing.Queue()
    # Process list #
    new_proc  = lambda t,a: multiprocessing.Process(target=t, args=a)
    processes = [new_proc(apply_function, (func_to_apply, q_in, q_out)) for x in range(cpus)]
    # Put all the items (objects) in the queue #
    sent = [q_in.put((i, x)) for i, x in enumerate(items)]
    # Start them all #
    for proc in processes:
        proc.daemon = True
        proc.start()
    # Display progress bar or not #
    if verbose:
        results = [q_out.get() for x in tqdm(range(len(sent)))]
    else:
        results = [q_out.get() for x in range(len(sent))]
    # Wait for them to finish #
    for proc in processes: proc.join()
    # Return results #
    return [x for i, x in sorted(results)]

################################################################################
def test():
    def slow_square(x):
        import time
        time.sleep(2)
        return x**2
    objs    = range(20)
    squares = prll_map(slow_square, objs, 4, verbose=True)
    print "Result: %s" % squares

编辑：添加了@ alexander-mcfarlane建议和测试功能

Answer 8

在类中定义的函数（甚至在类中的函数内）并不是真正的pickle。但是，这有效：

def f(x):
    return x*x

class calculate(object):
    def run(self):
        p = Pool()
    return p.map(f, [1,2,3])

cl = calculate()
print cl.run()

Answer 9

我知道这是6年前的问题，但我只是想添加我的解决方案，因为上面的一些建议似乎非常复杂，但我的解决方案实际上非常简单。

我所要做的就是将pool.map（）调用包装到辅助函数中。将类对象和方法的args作为元组传递，看起来有点像这样。

def run_in_parallel(args):
    return args[0].method(args[1])

myclass = MyClass()
method_args = [1,2,3,4,5,6]
args_map = [ (myclass, arg) for arg in method_args ]
pool = Pool()
pool.map(run_in_parallel, args_map)

Answer 10

我修改了klaus se的方法，因为虽然它适用于小型列表，但当项目数量大约为1000或更大时它会挂起。我没有在None停止条件下一次推送一个作业，而是一次性加载输入队列，让进程咀嚼它直到它为空。

from multiprocessing import cpu_count, Queue, Process

def apply_func(f, q_in, q_out):
    while not q_in.empty():
        i, x = q_in.get()
        q_out.put((i, f(x)))

# map a function using a pool of processes
def parmap(f, X, nprocs = cpu_count()):
    q_in, q_out   = Queue(), Queue()
    proc = [Process(target=apply_func, args=(f, q_in, q_out)) for _ in range(nprocs)]
    sent = [q_in.put((i, x)) for i, x in enumerate(X)]
    [p.start() for p in proc]
    res = [q_out.get() for _ in sent]
    [p.join() for p in proc]

    return [x for i,x in sorted(res)]

编辑：不幸的是现在我在我的系统上遇到了这个错误：contentMode，希望那里的解决方法会有所帮助。

Answer 11

我知道这个问题是在8年零10个月前提出的，但我想向您介绍我的解决方案：

from multiprocessing import Pool

class Test:

    def __init__(self):
        self.main()

    @staticmethod
    def methodForMultiprocessing(x):
        print(x*x)

    def main(self):
        if __name__ == "__main__":
            p = Pool()
            p.map(Test.methodForMultiprocessing, list(range(1, 11)))
            p.close()

TestObject = Test()

您只需要使您的类函数成为静态函数即可。但也可以使用类方法：

from multiprocessing import Pool

class Test:

    def __init__(self):
        self.main()

    @classmethod
    def methodForMultiprocessing(cls, x):
        print(x*x)

    def main(self):
        if __name__ == "__main__":
            p = Pool()
            p.map(Test.methodForMultiprocessing, list(range(1, 11)))
            p.close()

TestObject = Test()

在Python 3.7.3中进行了测试

Answer 12

这是我为在python3中使用多处理池而编写的样板，特别是使用python3.7.7来运行测试。我使用imap_unordered运行得最快。只需插入您的方案并尝试一下即可。您可以使用timeit或仅使用time.time()来确定哪种最适合您。

import multiprocessing
import time

NUMBER_OF_PROCESSES = multiprocessing.cpu_count()
MP_FUNCTION = 'starmap'  # 'imap_unordered' or 'starmap' or 'apply_async'

def process_chunk(a_chunk):
    print(f"processig mp chunk {a_chunk}")
    return a_chunk


map_jobs = [1, 2, 3, 4]

result_sum = 0

s = time.time()
if MP_FUNCTION == 'imap_unordered':
    pool = multiprocessing.Pool(processes=NUMBER_OF_PROCESSES)
    for i in pool.imap_unordered(process_chunk, map_jobs):
        result_sum += i
elif MP_FUNCTION == 'starmap':
    pool = multiprocessing.Pool(processes=NUMBER_OF_PROCESSES)
    try:
        map_jobs = [(i, ) for i in map_jobs]
        result_sum = pool.starmap(process_chunk, map_jobs)
        result_sum = sum(result_sum)
    finally:
        pool.close()
        pool.join()
elif MP_FUNCTION == 'apply_async':
    with multiprocessing.Pool(processes=NUMBER_OF_PROCESSES) as pool:
        result_sum = [pool.apply_async(process_chunk, [i, ]).get() for i in map_jobs]
    result_sum = sum(result_sum)
print(f"result_sum is {result_sum}, took {time.time() - s}s")

在上述情况下，imap_unordered实际上对我而言表现最差。试用您的案例，并在打算运行它的机器上对其进行基准测试。另请阅读Process Pools。干杯！

Answer 13

我不确定是否采用了这种方法，但我正在使用的是：

from multiprocessing import Pool

t = None

def run(n):
    return t.f(n)

class Test(object):
    def __init__(self, number):
        self.number = number

    def f(self, x):
        print x * self.number

    def pool(self):
        pool = Pool(2)
        pool.map(run, range(10))

if __name__ == '__main__':
    t = Test(9)
    t.pool()
    pool = Pool(2)
    pool.map(run, range(10))

输出应为：

0
9
18
27
36
45
54
63
72
81
0
9
18
27
36
45
54
63
72
81

Answer 14

这是我的解决方案，我认为这比其他大多数人都要少一些。它类似于nightowl的答案。

someclasses = [MyClass(), MyClass(), MyClass()]

def method_caller(some_object, some_method='the method'):
    return getattr(some_object, some_method)()

othermethod = partial(method_caller, some_method='othermethod')

with Pool(6) as pool:
    result = pool.map(othermethod, someclasses)

Answer 15

来自http://www.rueckstiess.net/research/snippets/show/ca1d7d90和http://qingkaikong.blogspot.com/2016/12/python-parallel-method-in-class.html

我们可以创建一个外部函数，并使用类self对象将其作为种子：

from joblib import Parallel, delayed
def unwrap_self(arg, **kwarg):
    return square_class.square_int(*arg, **kwarg)

class square_class:
    def square_int(self, i):
        return i * i

    def run(self, num):
        results = []
        results = Parallel(n_jobs= -1, backend="threading")\
            (delayed(unwrap_self)(i) for i in zip([self]*len(num), num))
        print(results)

没有作业库的情况：

from multiprocessing import Pool
import time

def unwrap_self_f(arg, **kwarg):
    return C.f(*arg, **kwarg)

class C:
    def f(self, name):
        print 'hello %s,'%name
        time.sleep(5)
        print 'nice to meet you.'

    def run(self):
        pool = Pool(processes=2)
        names = ('frank', 'justin', 'osi', 'thomas')
        pool.map(unwrap_self_f, zip([self]*len(names), names))

if __name__ == '__main__':
    c = C()
    c.run()

Answer 16

如果您以某种方式手动忽略了类中对象列表中的Pool对象，那么您就可以毫无问题地运行代码，因为错误提示说pickle是不可行的。您可以使用__getstate__函数（也可以查看here），如下所示。 Pool对象将尝试找到__getstate__和__setstate__函数，并在运行map，map_async等时找到它们，并执行它们：

class calculate(object):
    def __init__(self):
        self.p = Pool()
    def __getstate__(self):
        self_dict = self.__dict__.copy()
        del self_dict['p']
        return self_dict
    def __setstate__(self, state):
        self.__dict__.update(state)

    def f(self, x):
        return x*x
    def run(self):
        return self.p.map(self.f, [1,2,3])

然后做：

cl = calculate()
cl.run()

将为您提供输出：

[1, 4, 9]

我已经在Python 3.x中测试了上面的代码，并且可以正常工作。

Answer 17

这可能不是一个很好的解决方案，但就我而言，我是这样解决的。

python3 ./run_classifier.py \
--task_name=${TASK_NAME} \
--do_train=true \
--do_eval=true \
--data_dir=$GLUE_DIR/${TASK_NAME} \
--vocab_file=$BERT_BASE_DIR/vocab.txt \
--bert_config_file=$BERT_BASE_DIR/bert_config.json \
--init_checkpoint=$BERT_BASE_DIR/bert_model.ckpt \
--max_seq_length=128 \
--train_batch_size=32 \
--learning_rate=2e-5 \
--num_train_epochs=3.0 \
--output_dir=${STORAGE_BUCKET}/${TASK_NAME}-output/ \
--use_tpu=True \
--tpu_name=$TPU_NAME \
--model=bert_base \
--dataset=PeerRead \
--frequency=1

我必须将from multiprocessing import Pool def foo1(data): self = data.get('slf') lst = data.get('lst') return sum(lst) + self.foo2() class Foo(object): def __init__(self, a, b): self.a = a self.b = b def foo2(self): return self.a**self.b def foo(self): p = Pool(5) lst = [1, 2, 3] result = p.map(foo1, (dict(slf=self, lst=lst),)) return result if __name__ == '__main__': print(Foo(2, 4).foo()) 传递给函数，因为我必须通过该函数访问类的属性和函数。这对我有用。始终欢迎提出纠正和建议。