Неможливо вибрати <type 'instancemethod'> під час використання багатопроцесорного Pool.map ()

Я намагаюся використовувати функцію multiprocessing's, Pool.map()щоб розділити роботу одночасно. Коли я використовую такий код, він працює добре:

import multiprocessing

def f(x):
    return x*x

def go():
    pool = multiprocessing.Pool(processes=4)        
    print pool.map(f, range(10))


if __name__== '__main__' :
    go()

Однак, коли я використовую його в більш об'єктно-орієнтованому підході, він не працює. Повідомлення про помилку, яке воно дає:

PicklingError: Can't pickle <type 'instancemethod'>: attribute lookup
__builtin__.instancemethod failed

Це відбувається, коли моя основна програма:

import someClass

if __name__== '__main__' :
    sc = someClass.someClass()
    sc.go()

і наступний мій someClassклас:

import multiprocessing

class someClass(object):
    def __init__(self):
        pass

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

    def go(self):
        pool = multiprocessing.Pool(processes=4)       
        print pool.map(self.f, range(10))

Хтось знає, яка може бути проблема чи простий спосіб її вирішити?

Проблема полягає в тому, що мультипроцесори повинні підбирати речі, щоб перетягувати їх між процесами, а пов'язані методи не підбираються. Вирішення проблеми (вважаєте ви це "легким" чи ні ;-) - додати інфраструктуру до вашої програми, щоб дозволити макіяж таких методів, зареєструвавши її за допомогою стандартного методу бібліотеки copy_reg .

Наприклад, внесок Стівена Бетхарда в цю нитку (до кінця потоку) показує один ідеально працездатний підхід, що дозволяє вибирати / відбирати метод через copy_reg.

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

Якщо ви використовуєте вилку 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/

>>> import pathos.pools as pp
>>> p = pp.ProcessPool(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]
>>> 
>>> p.map(t.plus, x, y)
[4, 6, 8, 10]

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

>>> import pathos.pools as pp
>>> class someClass(object):
...   def __init__(self):
...     pass
...   def f(self, x):
...     return x*x
...   def go(self):
...     pool = pp.ProcessPool(4)
...     print pool.map(self.f, range(10))
... 
>>> sc = someClass()
>>> sc.go()
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> 

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

Ви також можете визначити __call__()метод всередині вашого someClass(), який викликає someClass.go()та передає екземпляр someClass()до пулу. Цей об'єкт є вибірковим і він чудово працює (для мене) ...

Деякі обмеження, що стосуються рішення Стівена Бетхарда:

Коли ви реєструєте метод класу як функцію, деструктор вашого класу дивно викликається щоразу, коли обробка вашого методу закінчується. Отже, якщо у вас є 1 екземпляр вашого класу, який викликає n разів більше його методу, члени можуть зникати між двома запусками, і ви можете отримати повідомлення malloc: *** error for object 0x...: pointer being freed was not allocated(наприклад, відкритий файл-член) або pure virtual method called, terminate called without an active exception(що означає, що термін експлуатації об'єкта-члена, який я використав, був коротшим, ніж що я думав). Це я отримав, коли маю справу з n більшим, ніж розмір пулу. Ось короткий приклад:

from multiprocessing import Pool, cpu_count
from multiprocessing.pool import ApplyResult

# --------- see Stenven's solution above -------------
from copy_reg import pickle
from types import MethodType

def _pickle_method(method):
    func_name = method.im_func.__name__
    obj = method.im_self
    cls = method.im_class
    return _unpickle_method, (func_name, obj, cls)

def _unpickle_method(func_name, obj, cls):
    for cls in cls.mro():
        try:
            func = cls.__dict__[func_name]
        except KeyError:
            pass
        else:
            break
    return func.__get__(obj, cls)


class Myclass(object):

    def __init__(self, nobj, workers=cpu_count()):

        print "Constructor ..."
        # multi-processing
        pool = Pool(processes=workers)
        async_results = [ pool.apply_async(self.process_obj, (i,)) for i in range(nobj) ]
        pool.close()
        # waiting for all results
        map(ApplyResult.wait, async_results)
        lst_results=[r.get() for r in async_results]
        print lst_results

    def __del__(self):
        print "... Destructor"

    def process_obj(self, index):
        print "object %d" % index
        return "results"

pickle(MethodType, _pickle_method, _unpickle_method)
Myclass(nobj=8, workers=3)
# problem !!! the destructor is called nobj times (instead of once)

Вихід:

Constructor ...
object 0
object 1
object 2
... Destructor
object 3
... Destructor
object 4
... Destructor
object 5
... Destructor
object 6
... Destructor
object 7
... Destructor
... Destructor
... Destructor
['results', 'results', 'results', 'results', 'results', 'results', 'results', 'results']
... Destructor

__call__Метод не такий еквівалент, тому що [Ні, ...] НЕ зчитуються з результатів:

from multiprocessing import Pool, cpu_count
from multiprocessing.pool import ApplyResult

class Myclass(object):

    def __init__(self, nobj, workers=cpu_count()):

        print "Constructor ..."
        # multiprocessing
        pool = Pool(processes=workers)
        async_results = [ pool.apply_async(self, (i,)) for i in range(nobj) ]
        pool.close()
        # waiting for all results
        map(ApplyResult.wait, async_results)
        lst_results=[r.get() for r in async_results]
        print lst_results

    def __call__(self, i):
        self.process_obj(i)

    def __del__(self):
        print "... Destructor"

    def process_obj(self, i):
        print "obj %d" % i
        return "result"

Myclass(nobj=8, workers=3)
# problem !!! the destructor is called nobj times (instead of once), 
# **and** results are empty !

Тож жоден з обох методів не задовольняє ...

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

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

Однак замість того, щоб надіслати метод-примірник, ви можете надіслати фактичний екземпляр класу плюс ім'я функції для виклику звичайній функції, яка потім використовує getattrдля виклику методу-примірника, створюючи таким чином зв'язаний метод у Poolпідпроцесі. Це схоже на визначення __call__методу, за винятком того, що ви можете викликати кілька функцій-членів.

Викрасти код @ EricH. з його відповіді та трохи анотувати його (я повторно вписав його, отже, всі зміни назви, і таке, чомусь, здавалося, простіше, ніж вирізати і вставити :-)) для ілюстрації всієї магії:

import multiprocessing
import os

def call_it(instance, name, args=(), kwargs=None):
    "indirect caller for instance methods and multiprocessing"
    if kwargs is None:
        kwargs = {}
    return getattr(instance, name)(*args, **kwargs)

class Klass(object):
    def __init__(self, nobj, workers=multiprocessing.cpu_count()):
        print "Constructor (in pid=%d)..." % os.getpid()
        self.count = 1
        pool = multiprocessing.Pool(processes = workers)
        async_results = [pool.apply_async(call_it,
            args = (self, 'process_obj', (i,))) for i in range(nobj)]
        pool.close()
        map(multiprocessing.pool.ApplyResult.wait, async_results)
        lst_results = [r.get() for r in async_results]
        print lst_results

    def __del__(self):
        self.count -= 1
        print "... Destructor (in pid=%d) count=%d" % (os.getpid(), self.count)

    def process_obj(self, index):
        print "object %d" % index
        return "results"

Klass(nobj=8, workers=3)

Вихід показує, що, дійсно, конструктор викликається один раз (у оригінальному підручнику), а деструктор викликається 9 разів (один раз за кожну зроблену копію = 2 або 3 рази на процедуру пулу-працівника, якщо потрібно, плюс один раз в оригіналі процес). Це часто нормально, як і в цьому випадку, оскільки інструмент вибору за замовчуванням робить копію всього екземпляра і (напів-) таємно повторно заповнює його - у цьому випадку, роблячи:

obj = object.__new__(Klass)
obj.__dict__.update({'count':1})

- тому, хоча деструктор викликається вісім разів у трьох робочих процесах, він щоразу відлічує від 1 до 0, але, звичайно, ви все одно можете потрапити в цю проблему. При необхідності ви можете надати своє __setstate__:

    def __setstate__(self, adict):
        self.count = adict['count']

наприклад, у цьому випадку.

Ви також можете визначити __call__()метод всередині вашого someClass(), який викликає someClass.go()та передає екземпляр someClass()до пулу. Цей об'єкт є вибірковим і він чудово працює (для мене) ...

class someClass(object):
   def __init__(self):
       pass
   def f(self, x):
       return x*x

   def go(self):
      p = Pool(4)
      sc = p.map(self, range(4))
      print sc

   def __call__(self, x):   
     return self.f(x)

sc = someClass()
sc.go()

Розчин з паришона вище працює добре зі мною. Плюс код виглядає чисто і легко зрозуміти. У моєму випадку є кілька функцій для виклику за допомогою Pool, тому я трохи змінив код parisjohn трохи нижче. Я здійснив виклик, щоб мати можливість викликати декілька функцій, а назви функцій передаються у диктаті аргументів від go():

from multiprocessing import Pool
class someClass(object):
    def __init__(self):
        pass

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

    def g(self, x):
        return x*x+1    

    def go(self):
        p = Pool(4)
        sc = p.map(self, [{"func": "f", "v": 1}, {"func": "g", "v": 2}])
        print sc

    def __call__(self, x):
        if x["func"]=="f":
            return self.f(x["v"])
        if x["func"]=="g":
            return self.g(x["v"])        

sc = someClass()
sc.go()

Потенційно тривіальним рішенням цього є перехід на використання multiprocessing.dummy. Це потокова реалізація багатопроцесорного інтерфейсу, який, схоже, не має цієї проблеми в Python 2.7. Тут у мене немає великого досвіду, але ця швидка зміна імпорту дозволила мені зателефонувати apply_async за методом класу.

Кілька хороших ресурсів на тему multiprocessing.dummy:

https://docs.python.org/2/library/multiprocessing.html#module-multiprocessing.dummy

http://chriskiehl.com/article/parallelism-in-one-line/

У цьому простому випадку, коли someClass.fне успадковувати жодних даних із класу і не приєднувати нічого до класу, можливим рішенням було б відокремити f, тож його можна вибрати:

import multiprocessing


def f(x):
    return x*x


class someClass(object):
    def __init__(self):
        pass

    def go(self):
        pool = multiprocessing.Pool(processes=4)       
        print pool.map(f, range(10))

Чому б не використовувати окремий func?

def func(*args, **kwargs):
    return inst.method(args, kwargs)

print pool.map(func, arr)

Я зіткнувся з цим самим питанням, але виявив, що є кодер JSON, який можна використовувати для переміщення цих об'єктів між процесами.

from pyVmomi.VmomiSupport import VmomiJSONEncoder

Використовуйте це для створення свого списку:

jsonSerialized = json.dumps(pfVmomiObj, cls=VmomiJSONEncoder)

Потім у картографічній функції використовуйте це для відновлення об'єкта:

pfVmomiObj = json.loads(jsonSerialized)

Оновлення: станом на день написання цього тексту, назване назвамиTuples (починаючи з python 2.7)

Проблема тут полягає в тому, що дочірні процеси не в змозі імпортувати клас об'єкта - у цьому випадку клас P-, у випадку мультимодельного проекту клас P повинен бути імпортним у будь-якому місці, до якого використовується звичний дочірній процес.

швидке вирішення - зробити його вагомим, впливаючи на глобалістів ()

globals()["P"] = P