Багатопроцесорна робота: Як використовувати Pool.map для функції, визначеної у класі?

Коли я запускаю щось на кшталт:

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

Я бачив повідомлення від Алекса Мартеллі, що займається тим же видом проблеми, але це було недостатньо явно.

Мене також дратували обмеження щодо того, які функції 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))

Я не міг використовувати коди, опубліковані поки що, оскільки коди, що використовують "multiprocessing.Pool", не працюють з лямбда-виразами, а коди, що не використовують "multiprocessing.Pool", породжують стільки процесів, скільки є робочих елементів.

Я адаптував код, коли він породжує заздалегідь задану кількість працівників і лише повторюється через список вводу, якщо існує непрацюючий працівник. Я також включив режим "демон" для робітників st 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]))

Багатопроцесорна та маринована робота порушена і обмежена, якщо ви не переходите за межі стандартної бібліотеки.

Якщо ви використовуєте вилку multiprocessingвиклику pathos.multiprocesssing, ви можете безпосередньо використовувати класи та методи класів у багатопроцесорнихmap функціях . Це тому dill, що використовується замість pickleабо cPickle, і dillможе серіалізувати майже що завгодно в python.

pathos.multiprocessingтакож надає функцію асинхронної карти ... і вона може mapфункціонувати з декількома аргументами (наприклад map(math.pow, [1,2,3], [4,5,6]))

Дивіться дискусії: Що може робити багатопроцесорний і кроповий разом?

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

Він навіть обробляє код, який ви написали спочатку, без змін та від перекладача. Навіщо робити щось інше, що є більш крихким і характерним для одного випадку?

>>> 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]

Отримати код тут: https://github.com/uqfoundation/pathos

І, просто показати трохи більше того, що він може зробити:

>>> from pathos.multiprocessing import ProcessingPool as Pool
>>> 
>>> p = Pool(4)
>>> 
>>> def add(x,y):
...   return x+y
... 
>>> x = [0,1,2,3]
>>> y = [4,5,6,7]
>>> 
>>> p.map(add, x, y)
[4, 6, 8, 10]
>>> 
>>> class Test(object):
...   def plus(self, x, y): 
...     return x+y
... 
>>> t = Test()
>>> 
>>> p.map(Test.plus, [t]*4, x, y)
[4, 6, 8, 10]
>>> 
>>> res = p.amap(t.plus, x, y)
>>> res.get()
[4, 6, 8, 10]

Наразі не існує рішення вашої проблеми, наскільки я знаю: функція, яку ви надаєте, map()повинна бути доступною через імпорт вашого модуля. Ось чому працює код Роберта: функцію f()можна отримати, імпортуючи такий код:

def f(x):
    return x*x

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

if __name__ == '__main__':
    cl = Calculate()
    print cl.run()

Я фактично додав "основний" розділ, тому що це відповідає рекомендаціям для платформи Windows ("Переконайтеся, що новий модуль може бути безпечно імпортований новим інтерпретатором Python, не викликаючи небажаних побічних ефектів").

Я також додав великі літери перед Calculate, щоб слідувати PEP 8 . :)

Рішення за допомогою mrule правильне, але має помилку: якщо дитина надсилає назад велику кількість даних, вона може заповнити буфер труби, блокуючи дитину pipe.send(), тоді як батько чекає, поки дитина вийде pipe.join(). Рішення полягає в тому, щоб прочитати дані дитини перед тим, як провести join()дитину. Крім того, дитина повинна закрити батьківський кінець труби, щоб запобігти тупику. Нижче наведений код виправляє це. Також пам’ятайте, що це parmapстворює один процес на елемент в X. Більш вдосконалене рішення - використовувати, multiprocessing.cpu_count()щоб розділити Xїх на кілька фрагментів, а потім об'єднати результати перед поверненням. Я залишаю це як вправу для читача, щоб не зіпсувати лаконічність приємної відповіді. ;)

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))

Я також боровся з цим. У мене були функції членів даних класу, як спрощений приклад:

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)  

Мені потрібно було використовувати функцію self.f у виклику Pool.map () з одного класу, а 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 також можна змінити, щоб прийняти аргументи ключових слів.

З іншого зауваження, в інших відповідях функція "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))         

Я взяв відповідь 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

EDIT : Додано пропозицію @ alexander-mcfarlane та тестову функцію

Я знаю, що це було запропоновано понад 6 років тому, але я просто хотів додати своє рішення, оскільки деякі пропозиції вище виглядають жахливо складними, але моє рішення насправді було дуже простим.

Все, що мені потрібно було зробити - це запустити виклик pool.map () до функції помічника. Передача об’єкта класу разом із аргументами для методу як кортеж, який виглядав приблизно так.

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)

Функції, визначені в класах (навіть у межах функцій в межах класів), насправді не підбираються. Однак це працює:

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()

Я знаю, що це питання було задано 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

Я змінив метод 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)]

Редагувати: на жаль, зараз я стикаюся з цією помилкою в моїй системі: Максимальний розмір черги багатопроцесорної черги - 32767 , сподіваємось, вирішення проблем допоможе.

Ви можете запустити свій код без будь-яких проблем, якщо ви якось вручну проігноруєте Poolоб'єкт зі списку об’єктів у класі, оскільки він не в pickleзмозі, як говорить помилка. Це можна зробити за допомогою __getstate__функції (дивіться також тут ), як слідує. 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, і він працює.

Я не впевнений, чи був застосований такий підхід, але робота, яку я використовую:

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

class Calculate(object):
  # Your instance method to be executed
  def f(self, x, y):
    return x*y

if __name__ == '__main__':
  inp_list = [1,2,3]
  y = 2
  cal_obj = Calculate()
  pool = Pool(2)
  results = pool.map(lambda x: cal_obj.f(x, y), inp_list)

Існує можливість, що ви хочете застосувати цю функцію для кожного різного екземпляра класу. Тоді ось і рішення для цього

class Calculate(object):
  # Your instance method to be executed
  def __init__(self, x):
    self.x = x

  def f(self, y):
    return self.x*y

if __name__ == '__main__':
  inp_list = [Calculate(i) for i in range(3)]
  y = 2
  pool = Pool(2)
  results = pool.map(lambda x: x.f(y), inp_list)

Ось моє рішення, яке, на мою думку, трохи менше хакітське, ніж більшість інших тут. Це схоже на відповідь 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)

З 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()

Це може бути не дуже вдалим рішенням, але в моєму випадку я вирішую це так.

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())

Мені довелося перейти selfдо своєї функції, оскільки я маю доступ до атрибутів та функцій свого класу через цю функцію. Це працює для мене. Виправлення та пропозиції завжди вітаються.

Ось котла, яку я написав для використання багатопроцесорного пулу в 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насправді здається найгіршим для мене. Спробуйте свій корпус і порівняйте його на машині, на якій ви плануєте його запустити. Читайте також у пулах процесів . Ура!