Как обойти ошибку травления многопроцессорности python, не находясь на верхнем уровне?

Question

Я исследовал этот вопрос несколько раз, но не нашел обходного пути, который либо работает в моем случае, либо тот, который я понимаю, поэтому, пожалуйста, несите меня.

В принципе, у меня есть иерархическая организация функций, и это мешает мне многопроцессорствовать на верхнем уровне. К сожалению, я не верю, что могу изменить макет программы, потому что мне нужны все переменные, которые я создаю после начальных входов.

Например, у меня есть это:

import multiprocessing 

    def calculate(x): 
    # here is where I would take this input x (and maybe a couple more inputs) 
    # and build a larger library of variables that I use further down the line 

    def domath(y): 
     return x * y 

    pool = multiprocessing.Pool(3) 
    final= pool.map(domath, range(3)) 

calculate(2) 

Это дает следующее сообщение об ошибке:

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

Я думал глобалов, но я боюсь, что я должен был бы определить слишком много, и это может замедлить мою программу совсем немного. Есть ли какое-либо обходное решение без перестройки всей программы?

Answer 1

Вы можете использовать pathos.multiprocessing, который является ответвлением multiprocessing, который использует dill сериалайзер вместо pickle. dill может сериализовать почти что угодно в python. Тогда вам не нужно редактировать код.

>>> from pathos.multiprocessing import ProcessingPool as Pool 
>>> 
>>> def calculate(x): 
... def domath(y): 
...  return x*y 
... return Pool().map(domath, range(3)) 
... 
>>> calculate(2) 
[0, 2, 4] 

Вы можете даже сходить с ума ... так как большинство вещей маринованное. Нет необходимости в нечетных непифонных решениях, которые нужно приготовить с чистым multiprocessing.

>>> class Foo(object): 
... def __init__(self, x): 
...  self.x = x 
... def doit(self, y): 
...  return ProcessingPool().map(self.squared, calculate(y+self.x)) 
... def squared(self, z): 
...  return z*z 
... 
>>> def thing(obj, y): 
... return getattr(obj, 'doit')(y) 
... 
>>> ProcessingPool().map(thing, ProcessingPool().map(Foo, range(3)), range(3)) 
[[0, 0, 0], [0, 4, 16], [0, 16, 64]] 

Получить pathos здесь: https://github.com/uqfoundation

Answer 2

Проблема, с которой вы столкнулись, на самом деле является особенностью. Источник рассола фактически предназначен для предотвращения такого поведения, чтобы предотвратить выполнение вредоносного кода. Пожалуйста, учтите, что при решении любой применимой реализации безопасности.

Прежде всего, у нас есть импорт.

import marshal 
import pickle 
import types 

Здесь мы имеем функцию, которая принимает в функции в качестве аргумента, соленья части объекта, а затем возвращает кортеж, содержащий все детали:

def pack(fn): 
    code = marshal.dumps(fn.__code__) 
    name = pickle.dumps(fn.__name__) 
    defs = pickle.dumps(fn.__defaults__) 
    clos = pickle.dumps(fn.__closure__) 
    return (code, name, defs, clos) 

Далее мы имеем функцию, которая берет четыре части нашей преобразованной функции. Он переводит эти четыре части и создает затем возвращает функцию из этих частей. Вы должны принять к сведению, что Глобал повторно вводят здесь потому, что наш процесс не обрабатывает эти:

def unpack(code, name, defs, clos): 
    code = marshal.loads(code) 
    glob = globals() 
    name = pickle.loads(name) 
    defs = pickle.loads(defs) 
    clos = pickle.loads(clos) 
    return types.FunctionType(code, glob, name, defs, clos) 

Здесь мы имеем тестовую функцию. Заметьте, что я ввожу импорт в область действия функции. Глобал не обрабатываются через наш процесс травления:

def test_function(a, b): 
    from random import randint 
    return randint(a, b) 

Наконец мы упаковываем наш тестовый объект и распечатать результат, чтобы убедиться, что все работает:

packed = pack(test_function) 
print((packed)) 

Наконец, мы распаковываем нашу функцию, присвоить его переменную, вызвать ее и распечатать ее вывод:

unpacked = unpack(*packed) 
print((unpacked(2, 20))) 

Комментарий, если у вас есть вопросы.

Answer 3

Как насчет принятия встроенной функции вне дома?

Это кажется мне ясное решение (так как вы не дали свой ожидаемый результат, я должен был догадаться):

$ cat /tmp/tmp.py 
import multiprocessing 

def calculate(x): 
    # here is where I would take this input x (and maybe a couple more inputs) 
    # and build a larger library of variables that I use further down the line 

    pool = multiprocessing.Pool(3) 
    _lst = [(x, y) for x in (x,) for y in range(3)] 
    final= pool.map(domath, _lst) 
    print(final) 

def domath(l): 
    return l[0] * l[1] 

calculate(2) 

$ python /tmp/tmp.py 
[0, 2, 4] 

$