Python đa xử lý PicklingError: Không thể chọn <type 'function'>

Tôi xin lỗi vì tôi không thể tái tạo lỗi bằng một ví dụ đơn giản hơn và mã của tôi quá phức tạp để đăng. Nếu tôi chạy chương trình trong IPython shell thay vì Python thông thường, mọi thứ sẽ hoạt động tốt.

Tôi đã tra cứu một số lưu ý trước đây về vấn đề này. Tất cả đều do sử dụng pool để gọi hàm được định nghĩa trong hàm class. Nhưng đây không phải là trường hợp của tôi.

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

Tôi sẽ đánh giá cao sự giúp đỡ nào.

Cập nhật : Hàm tôi chọn được xác định ở cấp cao nhất của mô-đun. Mặc dù nó gọi một hàm chứa hàm lồng nhau. tức là f()gọi các cuộc g()gọi h()có chức năng lồng nhau i()và tôi đang gọi pool.apply_async(f). f(), g(), h()Tất cả đều được xác định ở cấp cao nhất. Tôi đã thử ví dụ đơn giản hơn với mẫu này và nó hoạt động mặc dù.

Dưới đây là danh sách những gì có thể được ngâm . Cụ thể, các chức năng chỉ có thể chọn được nếu chúng được xác định ở cấp cao nhất của mô-đun.

Đoạn mã này:

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

mang lại một lỗi gần giống với lỗi bạn đã đăng:

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

Vấn đề là pool tất cả các phương thức đều sử dụng a mp.SimpleQueueđể truyền các tác vụ cho các tiến trình worker. Tất cả mọi thứ đi qua mp.SimpleQueueđều phải được chọn và foo.workkhông thể chọn được vì nó không được xác định ở cấp cao nhất của mô-đun.

Nó có thể được sửa bằng cách định nghĩa một hàm ở cấp cao nhất, gọi foo.work() :

def work(foo):
    foo.work()

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

Lưu ý rằng foocó thể chọn, vì Foođược xác định ở cấp cao nhất và foo.__dict__có thể chọn được.

Tôi sẽ sử dụng pathos.multiprocesssing, thay vì multiprocessing. pathos.multiprocessinglà một ngã ba multiprocessingsử dụng dill. dillcó thể tuần tự hóa hầu hết mọi thứ trong python, vì vậy bạn có thể gửi nhiều hơn xung quanh song song. Các pathosngã ba cũng có khả năng làm việc trực tiếp với nhiều chức năng lập luận, như bạn cần cho các phương pháp lớp.

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

Nhận pathos(và nếu bạn thích, dill) tại đây: https://github.com/uqfoundation

Như những người khác đã nói multiprocessingchỉ có thể chuyển các đối tượng Python sang các tiến trình worker có thể được xử lý. Nếu bạn không thể sắp xếp lại mã của mình như được mô tả bởi unutbu, bạn có thể sử dụng dillcác khả năng chọn lọc / tháo gỡ mở rộng để truyền dữ liệu (đặc biệt là dữ liệu mã) như tôi trình bày bên dưới.

Giải pháp này chỉ yêu cầu cài đặt dill và không có thư viện nào khác như 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()

Tôi đã thấy rằng tôi cũng có thể tạo chính xác đầu ra lỗi đó trên một đoạn mã hoạt động hoàn hảo bằng cách cố gắng sử dụng trình lược tả trên nó.

Lưu ý rằng đây là trên Windows (trong đó việc rèn là kém thanh lịch hơn một chút).

Tôi đã đang chạy:

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

Và thấy rằng loại bỏ hồ sơ đã loại bỏ lỗi và đặt hồ sơ khôi phục nó. Đã lái xe cho tôi quá nhiều vì tôi biết mã được sử dụng để làm việc. Tôi đang kiểm tra xem có thứ gì đã cập nhật pool.py không ... sau đó có cảm giác chìm và loại bỏ hồ sơ và đó là nó.

Đăng ở đây để lưu trữ trong trường hợp có ai khác chạy vào đó.

Khi vấn đề này xuất hiện với multiprocessingmột giải pháp đơn giản là chuyển từ Poolsang ThreadPool. Điều này có thể được thực hiện mà không thay đổi mã nào ngoài việc nhập-

from multiprocessing.pool import ThreadPool as Pool

Điều này hoạt động vì ThreadPool chia sẻ bộ nhớ với luồng chính, thay vì tạo một quy trình mới - điều này có nghĩa là không cần phải tẩy.

Nhược điểm của phương pháp này là python không phải là ngôn ngữ lớn nhất với việc xử lý các luồng - nó sử dụng một thứ gọi là Khóa phiên dịch toàn cầu để giữ an toàn cho luồng, có thể làm chậm một số trường hợp sử dụng ở đây. Tuy nhiên, nếu bạn chủ yếu tương tác với các hệ thống khác (chạy các lệnh HTTP, nói chuyện với cơ sở dữ liệu, ghi vào hệ thống tệp) thì mã của bạn có thể không bị ràng buộc bởi CPU và sẽ không bị ảnh hưởng nhiều. Trong thực tế, tôi đã tìm thấy khi viết các điểm chuẩn HTTP / HTTPS rằng mô hình luồng được sử dụng ở đây có ít chi phí và độ trễ hơn, vì chi phí từ việc tạo các quy trình mới cao hơn nhiều so với chi phí để tạo các luồng mới.

Vì vậy, nếu bạn đang xử lý một tấn công cụ trong không gian người dùng python thì đây có thể không phải là phương pháp tốt nhất.

Giải pháp này chỉ yêu cầu cài đặt thì là và không có thư viện nào khác làm 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

Nó cũng hoạt động cho các mảng numpy.

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

Lỗi này cũng sẽ xuất hiện nếu bạn có bất kỳ chức năng sẵn có nào bên trong đối tượng mô hình được truyền cho công việc không đồng bộ.

Vì vậy, hãy đảm bảo kiểm tra các đối tượng mô hình được thông qua không có chức năng sẵn có. (Trong trường hợp của chúng tôi, chúng tôi đã sử dụng FieldTracker()chức năng của django-model-utils bên trong mô hình để theo dõi một trường nhất định). Đây là liên kết đến vấn đề GitHub có liên quan.

Dựa trên giải pháp @rocksportrocker, sẽ rất hợp lý khi gửi và NHẬN kết quả.

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)