Правильный способ распараллеливания функций с несериализуемыми зависимостями с Python Multiprocessing (Pickle Error)?

Question

Я распараллелил некоторые Python функции с параллельной картой многопроцессорной обработки, и она работала хорошо. Однако теперь некоторые функции зависят от объектов, которые содержат собственный код, который не может быть сериализован (ошибка Pickle).

Обратите внимание, что все функции, в том числе с несериализуемыми зависимостями, легко поддаются распараллеливание (до этой проблемы я просто применял параллельное отображение), и единственная проблема заключается в том, что теперь некоторые из них должны загружать в память объекты, которые нельзя сериализовать.

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

• Вместо загрузки сразу -сериализуемые зависимости (я делаю это в методе __init__(), а затем делаю класс вызываемым), загружаю их при каждом вызове функции: неэффективно.
• Я мог бы создать процесс специально для каждой из функций с несериализуемыми зависимостями, а затем явно связываться с ними, но теряя удобство параллельной карты многопроцессорной обработки.
• В качестве альтернативы, возможно, я мог бы поддерживать эти несериализуемые объекты как глобальные переменные, используя менеджер многопроцессорной обработки ... не знаю точно, как.

Для ясности я прилагаю пример псевдокода / игрушки:

class SerializableFunction:
    def __init__(param):
        self.param = param

    def __call__(arg):
       if self.param == 'identity':
           return arg
       return 0

import library  # Python binding for a non-python application

class NonSerializableFunction:
    def __init__(param, path):
        self.param = param
        self.non_serializable_dependency = library.load(path)  # expensive operation, reads from disk and initializes the object

    def __call__(arg):
        if self.param == 'identity':
            return arg
        return self.non_serializable_dependency(arg)  # this call is also expensive

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

Что было бы правильным способом handlin г этой проблемы? Спасибо!

Примечание. Некоторые из функций, которые я использую, являются реальными функциями, а некоторые - вызываемыми объектами. Для простоты я назвал их просто функциями. В любом случае, обратите внимание, что несериализуемость возникает не из-за использования вызываемых объектов, а из-за загрузки несериализуемых зависимостей.