หลามมัลติโพรเซสซิง PicklingError: ไม่สามารถดอง <type 'function'>

ฉันขอโทษที่ฉันไม่สามารถทำซ้ำข้อผิดพลาดด้วยตัวอย่างที่ง่ายขึ้นและรหัสของฉันซับซ้อนเกินกว่าจะโพสต์ ถ้าฉันรันโปรแกรมใน IPython shell แทนที่จะเป็น Python ปกติสิ่งต่าง ๆ ก็ใช้ได้ดี

ฉันค้นหาบันทึกย่อก่อนหน้านี้เกี่ยวกับปัญหานี้ พวกเขาทั้งหมดเกิดจากการใช้พูลเพื่อเรียกใช้ฟังก์ชันที่กำหนดไว้ในฟังก์ชันคลาส แต่นี่ไม่ใช่กรณีสำหรับฉัน

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

ฉันอยากจะขอบคุณความช่วยเหลือใด ๆ.

ปรับปรุง : ฟังก์ชั่นที่ฉันดองถูกกำหนดไว้ที่ระดับบนสุดของโมดูล แม้ว่ามันจะเรียกฟังก์ชั่นที่มีฟังก์ชั่นที่ซ้อนกัน เช่นf()เรียกg()สายh()ซึ่งมีฟังก์ชั่นที่ซ้อนกันและฉันโทรi() , , ที่กำหนดไว้ทั้งหมดในระดับด้านบน ฉันลองตัวอย่างที่ง่ายขึ้นด้วยรูปแบบนี้และทำงานได้pool.apply_async(f)f()g()h()

นี่คือรายการของสิ่งที่สามารถนำมาดอง โดยเฉพาะอย่างยิ่งฟังก์ชั่นสามารถเลือกได้เฉพาะในกรณีที่กำหนดไว้ที่ระดับบนสุดของโมดูล

รหัสชิ้นนี้:

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

ให้ข้อผิดพลาดเกือบจะเหมือนกับที่คุณโพสต์:

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

ปัญหาคือpoolวิธีการทั้งหมดใช้mp.SimpleQueueเพื่อส่งผ่านงานไปยังกระบวนการของผู้ปฏิบัติงาน ทุกอย่างที่ต้องผ่านmp.SimpleQueueจะต้องเลือกได้และfoo.workไม่สามารถเลือกได้เนื่องจากไม่ได้กำหนดไว้ที่ระดับบนสุดของโมดูล

มันสามารถแก้ไขได้โดยการกำหนดฟังก์ชั่นที่ระดับบนสุดซึ่งเรียกfoo.work():

def work(foo):
    foo.work()

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

โปรดสังเกตว่าfooสามารถเลือกได้เนื่องจากFooถูกกำหนดที่ระดับบนสุดและ foo.__dict__สามารถเลือกได้

ฉันต้องการใช้แทน pathos.multiprocesssing เป็นทางแยกของใช้ที่ สามารถทำให้เป็นอนุกรมได้เกือบทุกอย่างในงูใหญ่ดังนั้นคุณจึงสามารถส่งมากขึ้นในแบบคู่ขนาน ส้อมนอกจากนี้ยังมีความสามารถในการทำงานโดยตรงกับฟังก์ชั่นการโต้แย้งหลายอย่างที่คุณต้องการสำหรับวิธีการเรียนmultiprocessingpathos.multiprocessingmultiprocessingdilldillpathos

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

รับpathos(และหากคุณต้องการdill) ที่นี่: https://github.com/uqfoundation

อย่างที่คนอื่นพูดว่าmultiprocessingสามารถถ่ายโอนวัตถุ Python ไปยังกระบวนการของผู้ปฏิบัติงานซึ่งสามารถเก็บได้ หากคุณไม่สามารถจัดระเบียบรหัสของคุณใหม่ตามที่อธิบายโดย unutbu คุณสามารถใช้ความสามารถในการdillดอง / การแยกส่วนขยายของการถ่ายโอนข้อมูล (โดยเฉพาะข้อมูลรหัส) ตามที่ฉันแสดงด้านล่าง

โซลูชันนี้ต้องการเพียงการติดตั้งdillและไม่มีไลบรารีอื่น ๆ เช่น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()

ฉันพบว่าฉันยังสามารถสร้างผลลัพธ์ข้อผิดพลาดที่แน่นอนบนชิ้นงานที่สมบูรณ์แบบของรหัสโดยพยายามใช้ profiler ในมัน

โปรดทราบว่านี่เป็นบน Windows (ซึ่งการฟอร์กมีความสวยงามน้อยกว่าเล็กน้อย)

ฉันกำลังวิ่ง:

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

และพบว่าการลบโปรไฟล์ลบข้อผิดพลาดและวางโปรไฟล์เรียกคืน กำลังขับรถฉันบ้าเหมือนกันเพราะฉันรู้รหัสที่ใช้ในการทำงาน ฉันกำลังตรวจสอบเพื่อดูว่ามีบางสิ่งบางอย่างที่อัปเดต pool.py ... แล้วมีความรู้สึกจมและตัดการทำโปรไฟล์และนั่นก็เป็นเช่นนั้น

การโพสต์ที่นี่เพื่อเก็บถาวรในกรณีที่มีคนอื่นเข้ามา

เมื่อปัญหานี้ขึ้นมาด้วยmultiprocessingวิธีง่ายๆคือการเปลี่ยนจากการPool ThreadPoolซึ่งสามารถทำได้โดยไม่ต้องเปลี่ยนรหัสอื่นนอกจากการนำเข้า -

from multiprocessing.pool import ThreadPool as Pool

ใช้งานได้เนื่องจาก ThreadPool ใช้หน่วยความจำร่วมกับเธรดหลักแทนที่จะสร้างกระบวนการใหม่ซึ่งหมายความว่าไม่จำเป็นต้องมีการดอง

ข้อเสียของวิธีนี้คือ python ไม่ใช่ภาษาที่ดีที่สุดในการจัดการกับเธรด - มันใช้สิ่งที่เรียกว่า Global Interpreter Lock เพื่อรักษาความปลอดภัยของเธรดซึ่งอาจทำให้การใช้งานช้าลงในบางกรณี อย่างไรก็ตามหากคุณมีปฏิสัมพันธ์กับระบบอื่น ๆ เป็นหลัก (การใช้คำสั่ง HTTP การพูดคุยกับฐานข้อมูลการเขียนไปยังระบบไฟล์) รหัสของคุณก็ไม่ได้ผูกกับซีพียูและจะไม่กระทบอะไรมาก ในความเป็นจริงฉันพบเมื่อเขียน HTTP / HTTPS เบนช์มาร์กที่โมเดลเธรดที่ใช้ที่นี่มีค่าใช้จ่ายและความล่าช้าน้อยลงเนื่องจากโอเวอร์เฮดจากการสร้างกระบวนการใหม่นั้นสูงกว่าโอเวอร์เฮดสำหรับสร้างเธรดใหม่

ดังนั้นหากคุณกำลังประมวลผลข้อมูลจำนวนมากในพื้นที่ผู้ใช้หลามนี่อาจไม่ใช่วิธีที่ดีที่สุด

วิธีการแก้ปัญหานี้ต้องการเพียงการติดตั้งของดิลล์และไม่มีไลบรารีอื่น ๆ ที่น่าสมเพช

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

นอกจากนี้ยังใช้งานได้กับอาร์เรย์ที่มีจำนวนมาก

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

ข้อผิดพลาดนี้จะเกิดขึ้นหากคุณมีฟังก์ชั่น inbuilt ภายในโมเดลวัตถุที่ส่งผ่านไปยังงาน async

ดังนั้นตรวจสอบให้แน่ใจว่าได้ตรวจสอบวัตถุจำลองที่ผ่านไปแล้วว่าไม่มีฟังก์ชั่น inbuilt (ในกรณีของเราเราใช้FieldTracker()ฟังก์ชั่นของdjango-model-utilsภายในโมเดลเพื่อติดตามบางฟิลด์) นี่คือลิงค์สำหรับปัญหา GitHub ที่เกี่ยวข้อง

การสร้างโซลูชัน @rocksportrocker จะทำให้รู้สึกถึงความสดชื่นเมื่อส่งและรับผลลัพธ์

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)