Python multiprocessing PicklingError: Can pickle <type 'function'>

Mi dispiace non poter riprodurre l'errore con un esempio più semplice e il mio codice è troppo complicato per essere pubblicato. Se eseguo il programma nella shell IPython invece del normale Python, le cose funzionano bene.

Ho cercato alcune note precedenti su questo problema. Sono stati tutti causati dall'uso del pool per chiamare la funzione definita all'interno di una funzione di classe. Ma questo non è il caso per me.

Exception in thread Thread-3:
Traceback (most recent call last):
  File "/usr/lib64/python2.7/threading.py", line 552, in __bootstrap_inner
    self.run()
  File "/usr/lib64/python2.7/threading.py", line 505, in run
    self.__target(*self.__args, **self.__kwargs)
  File "/usr/lib64/python2.7/multiprocessing/pool.py", line 313, in _handle_tasks
    put(task)
PicklingError: Can't pickle <type 'function'>: attribute lookup __builtin__.function failed

Gradirei qualsiasi aiuto.

Aggiornamento : la funzione I pickle è definita al livello superiore del modulo. Anche se chiama una funzione che contiene una funzione nidificata. vale a dire, f()chiama le g()chiamate h()che hanno una funzione nidificata i()e io sto chiamando pool.apply_async(f). f(), g(), h()Sono tutti definiti a livello superiore. Ho provato un esempio più semplice con questo modello e funziona però.

Ecco un elenco di ciò che può essere decapato . In particolare, le funzioni sono selezionabili solo se sono definite al livello superiore di un modulo.

Questo pezzo di codice:

import multiprocessing as mp

class Foo():
    @staticmethod
    def work(self):
        pass

if __name__ == '__main__':   
    pool = mp.Pool()
    foo = Foo()
    pool.apply_async(foo.work)
    pool.close()
    pool.join()

genera un errore quasi identico a quello che hai pubblicato:

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

Il problema è che pooltutti i metodi usano a mp.SimpleQueueper passare le attività ai processi di lavoro. Tutto ciò che passa attraverso mp.SimpleQueuedeve essere selezionabile e foo.worknon è selezionabile poiché non è definito al livello superiore del modulo.

Può essere risolto definendo una funzione di livello superiore, che chiama foo.work():

def work(foo):
    foo.work()

pool.apply_async(work,args=(foo,))

Si noti che fooè selezionabile, poiché Fooè definito al livello più alto ed foo.__dict__è selezionabile.

Userei pathos.multiprocesssing, invece di multiprocessing. pathos.multiprocessingè un fork di multiprocessingciò che usa dill. dillpuoi serializzare quasi tutto in Python, così puoi inviare molto di più in parallelo. Il pathosfork ha anche la capacità di lavorare direttamente con più funzioni di argomento, come è necessario per i metodi di classe.

>>> from pathos.multiprocessing import ProcessingPool as Pool
>>> p = Pool(4)
>>> class Test(object):
...   def plus(self, x, y): 
...     return x+y
... 
>>> t = Test()
>>> p.map(t.plus, x, y)
[4, 6, 8, 10]
>>> 
>>> class Foo(object):
...   @staticmethod
...   def work(self, x):
...     return x+1
... 
>>> f = Foo()
>>> p.apipe(f.work, f, 100)
<processing.pool.ApplyResult object at 0x10504f8d0>
>>> res = _
>>> res.get()
101

Ottieni pathos(e se vuoi, dill) qui: https://github.com/uqfoundation

Come altri hanno già detto, è multiprocessingpossibile trasferire oggetti Python solo su processi di lavoro che possono essere decapati. Se non è possibile riorganizzare il codice come descritto da unutbu, è possibile utilizzare le funzionalità dillestese di decapaggio / disimballaggio per il trasferimento di dati (in particolare i dati di codice), come indicato di seguito.

Questa soluzione richiede solo l'installazione dille nessuna altra libreria come pathos:

import os
from multiprocessing import Pool

import dill


def run_dill_encoded(payload):
    fun, args = dill.loads(payload)
    return fun(*args)


def apply_async(pool, fun, args):
    payload = dill.dumps((fun, args))
    return pool.apply_async(run_dill_encoded, (payload,))


if __name__ == "__main__":

    pool = Pool(processes=5)

    # asyn execution of lambda
    jobs = []
    for i in range(10):
        job = apply_async(pool, lambda a, b: (a, b, a * b), (i, i + 1))
        jobs.append(job)

    for job in jobs:
        print job.get()
    print

    # async execution of static method

    class O(object):

        @staticmethod
        def calc():
            return os.getpid()

    jobs = []
    for i in range(10):
        job = apply_async(pool, O.calc, ())
        jobs.append(job)

    for job in jobs:
        print job.get()

Ho scoperto che posso anche generare esattamente quell'output di errore su un pezzo di codice perfettamente funzionante tentando di utilizzare il profiler su di esso.

Si noti che questo era su Windows (dove il fork è un po 'meno elegante).

Io stavo correndo:

python -m profile -o output.pstats <script> 

E ho scoperto che la rimozione della profilazione ha rimosso l'errore e il ripristino della profilazione. Mi stava facendo impazzire anche perché sapevo che il codice funzionava. Stavo controllando per vedere se qualcosa aveva aggiornato pool.py ... poi aveva una sensazione di affondamento ed eliminava la profilazione e basta.

Pubblicare qui per gli archivi nel caso in cui qualcuno lo incontri.

Quando questo problema si presenta con multiprocessinguna soluzione semplice è passare da Poola ThreadPool. Questo può essere fatto senza alcuna modifica del codice oltre all'importazione-

from multiprocessing.pool import ThreadPool as Pool

Ciò funziona perché ThreadPool condivide la memoria con il thread principale, anziché creare un nuovo processo, ciò significa che non è necessario il decapaggio.

L'aspetto negativo di questo metodo è che python non è il miglior linguaggio per la gestione dei thread, ma utilizza qualcosa chiamato Global Interpreter Lock per proteggere i thread, il che può rallentare alcuni casi d'uso qui. Tuttavia, se stai principalmente interagendo con altri sistemi (eseguendo comandi HTTP, parlando con un database, scrivendo su filesystem), probabilmente il tuo codice non è vincolato dalla CPU e non avrà molto successo. In effetti, quando ho scritto benchmark HTTP / HTTPS, ho scoperto che il modello threaded utilizzato qui ha un sovraccarico e ritardi minori, poiché l'overhead derivante dalla creazione di nuovi processi è molto più elevato dell'overhead per la creazione di nuovi thread.

Quindi, se stai elaborando un sacco di cose nello spazio utente di Python, questo potrebbe non essere il metodo migliore.

Questa soluzione richiede solo l'installazione di dill e nessuna altra libreria come pathos

def apply_packed_function_for_map((dumped_function, item, args, kwargs),):
    """
    Unpack dumped function as target function and call it with arguments.

    :param (dumped_function, item, args, kwargs):
        a tuple of dumped function and its arguments
    :return:
        result of target function
    """
    target_function = dill.loads(dumped_function)
    res = target_function(item, *args, **kwargs)
    return res


def pack_function_for_map(target_function, items, *args, **kwargs):
    """
    Pack function and arguments to object that can be sent from one
    multiprocessing.Process to another. The main problem is:
        «multiprocessing.Pool.map*» or «apply*»
        cannot use class methods or closures.
    It solves this problem with «dill».
    It works with target function as argument, dumps it («with dill»)
    and returns dumped function with arguments of target function.
    For more performance we dump only target function itself
    and don't dump its arguments.
    How to use (pseudo-code):

        ~>>> import multiprocessing
        ~>>> images = [...]
        ~>>> pool = multiprocessing.Pool(100500)
        ~>>> features = pool.map(
        ~...     *pack_function_for_map(
        ~...         super(Extractor, self).extract_features,
        ~...         images,
        ~...         type='png'
        ~...         **options,
        ~...     )
        ~... )
        ~>>>

    :param target_function:
        function, that you want to execute like  target_function(item, *args, **kwargs).
    :param items:
        list of items for map
    :param args:
        positional arguments for target_function(item, *args, **kwargs)
    :param kwargs:
        named arguments for target_function(item, *args, **kwargs)
    :return: tuple(function_wrapper, dumped_items)
        It returs a tuple with
            * function wrapper, that unpack and call target function;
            * list of packed target function and its' arguments.
    """
    dumped_function = dill.dumps(target_function)
    dumped_items = [(dumped_function, item, args, kwargs) for item in items]
    return apply_packed_function_for_map, dumped_items

Funziona anche con array intorpiditi.

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

Questo errore verrà anche se si dispone di una funzione incorporata all'interno dell'oggetto modello che è stata passata al lavoro asincrono.

Quindi assicurati di controllare che gli oggetti del modello passati non abbiano funzioni integrate. (Nel nostro caso stavamo usando la FieldTracker()funzione di django-model-utils all'interno del modello per tracciare un determinato campo). Ecco il link al problema GitHub pertinente.

Basandosi sulla soluzione @rocksportrocker, sarebbe logico aneto quando si inviano e si RECVing i risultati.

import dill
import itertools
def run_dill_encoded(payload):
    fun, args = dill.loads(payload)
    res = fun(*args)
    res = dill.dumps(res)
    return res

def dill_map_async(pool, fun, args_list,
                   as_tuple=True,
                   **kw):
    if as_tuple:
        args_list = ((x,) for x in args_list)

    it = itertools.izip(
        itertools.cycle([fun]),
        args_list)
    it = itertools.imap(dill.dumps, it)
    return pool.map_async(run_dill_encoded, it, **kw)

if __name__ == '__main__':
    import multiprocessing as mp
    import sys,os
    p = mp.Pool(4)
    res = dill_map_async(p, lambda x:[sys.stdout.write('%s\n'%os.getpid()),x][-1],
                  [lambda x:x+1]*10,)
    res = res.get(timeout=100)
    res = map(dill.loads,res)
    print(res)