マルチプロセッシング：クラスで定義された関数でPool.mapを使用する方法
次のようなものを実行すると：
from multiprocessing import Pool
p = Pool(5)
def f(x):
return x*x
p.map(f, [1,2,3])
正常に動作します。ただし、これをクラスの関数として置くと：
class calculate(object):
def run(self):
def f(x):
return x*x
p = Pool()
return p.map(f, [1,2,3])
cl = calculate()
print cl.run()
次のエラーが表示されます。
Exception in thread Thread-1:
Traceback (most recent call last):
File "/sw/lib/python2.6/threading.py", line 532, in __bootstrap_inner
self.run()
File "/sw/lib/python2.6/threading.py", line 484, in run
self.__target(*self.__args, **self.__kwargs)
File "/sw/lib/python2.6/multiprocessing/pool.py", line 225, in _handle_tasks
put(task)
PicklingError: Can't pickle <type 'function'>: attribute lookup __builtin__.function failed
Alex Martelliが同じ種類の問題を扱っている投稿を見てきましたが、それは十分に明確ではありませんでした。
また、pool.mapが受け入れることができる機能の種類に関する制限にも悩まされました。これを回避するために、次を書きました。 parmapを再帰的に使用しても動作するようです。
from multiprocessing import Process, Pipe
from itertools import izip
def spawn(f):
def fun(pipe,x):
pipe.send(f(x))
pipe.close()
return fun
def parmap(f,X):
pipe=[Pipe() for x in X]
proc=[Process(target=spawn(f),args=(c,x)) for x,(p,c) in izip(X,pipe)]
[p.start() for p in proc]
[p.join() for p in proc]
return [p.recv() for (p,c) in pipe]
if __== '__main__':
print parmap(lambda x:x**x,range(1,5))
「multiprocessing.Pool」を使用するコードはラムダ式では機能せず、「multiprocessing.Pool」を使用しないコードは作業項目と同じ数のプロセスを生成するため、これまでに投稿したコードを使用できませんでした。
コードs.tを適合させました。事前に定義された量のワーカーが生成され、アイドル状態のワーカーが存在する場合にのみ入力リストを反復処理します。また、ワーカーs.tの「デーモン」モードを有効にしました。 ctrl-cは期待どおりに機能します。
import multiprocessing
def fun(f, q_in, q_out):
while True:
i, x = q_in.get()
if i is None:
break
q_out.put((i, f(x)))
def parmap(f, X, nprocs=multiprocessing.cpu_count()):
q_in = multiprocessing.Queue(1)
q_out = multiprocessing.Queue()
proc = [multiprocessing.Process(target=fun, args=(f, q_in, q_out))
for _ in range(nprocs)]
for p in proc:
p.daemon = True
p.start()
sent = [q_in.put((i, x)) for i, x in enumerate(X)]
[q_in.put((None, None)) for _ in range(nprocs)]
res = [q_out.get() for _ in range(len(sent))]
[p.join() for p in proc]
return [x for i, x in sorted(res)]
if __== '__main__':
print(parmap(lambda i: i * 2, [1, 2, 3, 4, 6, 7, 8]))
標準ライブラリの外部にジャンプしない限り、マルチプロセッシングと酸洗は壊れて制限されます。
multiprocessingと呼ばれるpathos.multiprocesssingのフォークを使用する場合、マルチプロセッシングのmap関数でクラスとクラスメソッドを直接使用できます。これは、dillまたはpickleの代わりにcPickleが使用され、dillがPythonのほとんどすべてをシリアル化できるためです。
pathos.multiprocessingは非同期マップ関数も提供します...そして、複数の引数を持つmap関数（例：map(math.pow, [1,2,3], [4,5,6])）
議論を参照してください： マルチプロセッシングとディルが一緒にできることは何ですか？
および： http://matthewrocklin.com/blog/work/2013/12/05/Parallelism-and-Serialization
最初に書いたコードを、修正せずに、インタープリターからも処理します。なぜもっと壊れやすく、特定のケースに特有のものをするのですか？
>>> from pathos.multiprocessing import ProcessingPool as Pool
>>> class calculate(object):
... def run(self):
... def f(x):
... return x*x
... p = Pool()
... return p.map(f, [1,2,3])
...
>>> cl = calculate()
>>> print cl.run()
[1, 4, 9]
ここでコードを取得します： https://github.com/uqfoundation/pathos
そして、それが何ができるかをもう少し見せるために：
>>> from pathos.multiprocessing import ProcessingPool as Pool
>>>
>>> p = Pool(4)
>>>
>>> def add(x,y):
... return x+y
...
>>> x = [0,1,2,3]
>>> y = [4,5,6,7]
>>>
>>> p.map(add, x, y)
[4, 6, 8, 10]
>>>
>>> class Test(object):
... def plus(self, x, y):
... return x+y
...
>>> t = Test()
>>>
>>> p.map(Test.plus, [t]*4, x, y)
[4, 6, 8, 10]
>>>
>>> res = p.amap(t.plus, x, y)
>>> res.get()
[4, 6, 8, 10]
私の知る限り、現在のところあなたの問題に対する解決策はありません：map()に与える関数は、モジュールのインポートを通じてアクセス可能でなければなりません。これが、ロバートのコードが機能する理由です。関数f()は、次のコードをインポートすることで取得できます。
def f(x):
return x*x
class Calculate(object):
def run(self):
p = Pool()
return p.map(f, [1,2,3])
if __== '__main__':
cl = Calculate()
print cl.run()
Windowsプラットフォームの推奨事項 （ "メインモジュールが新しいPythonインタープリターによって安全にインポートできることを確認してください。意図しない副作用」）。
PEP 8 に従うように、Calculateの前にも大文字を追加しました。 :)
Mruleによる解決策は正しいですが、バグがあります：子が大量のデータを送り返すと、パイプのバッファーがいっぱいになり、子のpipe.send()をブロックしますが、親は子がpipe.join()で終了するのを待っています。解決策は、子をjoin()ingする前に子のデータを読み取ることです。さらに、デッドロックを防ぐために、子はパイプの親の端を閉じる必要があります。以下のコードはそれを修正します。また、このparmapはXの要素ごとに1つのプロセスを作成することに注意してください。より高度なソリューションは、multiprocessing.cpu_count()を使用してXをいくつかのチャンクに分割し、結果をマージしてから戻ることです。 mruleによるNice回答の簡潔さを損なわないように、読者に演習として残しておきます。 ;）
from multiprocessing import Process, Pipe
from itertools import izip
def spawn(f):
def fun(ppipe, cpipe,x):
ppipe.close()
cpipe.send(f(x))
cpipe.close()
return fun
def parmap(f,X):
pipe=[Pipe() for x in X]
proc=[Process(target=spawn(f),args=(p,c,x)) for x,(p,c) in izip(X,pipe)]
[p.start() for p in proc]
ret = [p.recv() for (p,c) in pipe]
[p.join() for p in proc]
return ret
if __== '__main__':
print parmap(lambda x:x**x,range(1,5))
私もこれに苦労しました。簡単な例として、クラスのデータメンバーとして関数を使用しました。
from multiprocessing import Pool
import itertools
pool = Pool()
class Example(object):
def __init__(self, my_add):
self.f = my_add
def add_lists(self, list1, list2):
# Needed to do something like this (the following line won't work)
return pool.map(self.f,list1,list2)
同じクラス内からPool.map（）呼び出しでself.f関数を使用する必要があり、self.fは引数としてTupleを取りませんでした。この関数はクラスに埋め込まれているため、他の回答が示唆するラッパーのタイプをどのように記述するかは明確ではありませんでした。
Tuple/listを受け取る別のラッパーを使用してこの問題を解決しました。最初の要素は関数で、残りの要素はeval_func_Tuple（f_args）と呼ばれるその関数の引数です。これを使用して、問題のある行をreturn pool.map（eval_func_Tuple、itertools.izip（itertools.repeat（self.f）、list1、list2））に置き換えることができます。完全なコードは次のとおりです。
ファイル：util.py
def add(a, b): return a+b
def eval_func_Tuple(f_args):
"""Takes a Tuple of a function and args, evaluates and returns result"""
return f_args[0](*f_args[1:])
ファイル：main.py
from multiprocessing import Pool
import itertools
import util
pool = Pool()
class Example(object):
def __init__(self, my_add):
self.f = my_add
def add_lists(self, list1, list2):
# The following line will now work
return pool.map(util.eval_func_Tuple,
itertools.izip(itertools.repeat(self.f), list1, list2))
if __== '__main__':
myExample = Example(util.add)
list1 = [1, 2, 3]
list2 = [10, 20, 30]
print myExample.add_lists(list1, list2)
Main.pyを実行すると、[11、22、33]が得られます。これを自由に改善してください。たとえば、eval_func_Tupleを変更してキーワード引数を取ることもできます。
別の注意として、別の答えでは、使用可能なCPUの数よりも多くのプロセスの場合、関数「parmap」をより効率的にすることができます。以下の編集バージョンをコピーしています。これは私の最初の投稿であり、元の回答を直接編集する必要があるかどうかはわかりませんでした。また、いくつかの変数の名前を変更しました。
from multiprocessing import Process, Pipe
from itertools import izip
def spawn(f):
def fun(pipe,x):
pipe.send(f(x))
pipe.close()
return fun
def parmap(f,X):
pipe=[Pipe() for x in X]
processes=[Process(target=spawn(f),args=(c,x)) for x,(p,c) in izip(X,pipe)]
numProcesses = len(processes)
processNum = 0
outputList = []
while processNum < numProcesses:
endProcessNum = min(processNum+multiprocessing.cpu_count(), numProcesses)
for proc in processes[processNum:endProcessNum]:
proc.start()
for proc in processes[processNum:endProcessNum]:
proc.join()
for proc,c in pipe[processNum:endProcessNum]:
outputList.append(proc.recv())
processNum = endProcessNum
return outputList
if __== '__main__':
print parmap(lambda x:x**x,range(1,5))
クラスで定義された関数は（クラス内の関数内であっても）実際にはピクルスしません。ただし、これは機能します。
def f(x):
return x*x
class calculate(object):
def run(self):
p = Pool()
return p.map(f, [1,2,3])
cl = calculate()
print cl.run()
私はklaus seとaganders3の答えを取り、より読みやすく1つのファイルに収まる文書化されたモジュールを作成しました。プロジェクトに追加するだけです。オプションのプログレスバーもあります！
"""
The ``processes`` module provides some convenience functions
for using parallel processes in python.
Adapted from http://stackoverflow.com/a/16071616/287297
Example usage:
print prll_map(lambda i: i * 2, [1, 2, 3, 4, 6, 7, 8], 32, verbose=True)
Comments:
"It spawns a predefined amount of workers and only iterates through the input list
if there exists an idle worker. I also enabled the "daemon" mode for the workers so
that KeyboardInterupt works as expected."
Pitfalls: all the stdouts are sent back to the parent stdout, intertwined.
Alternatively, use this fork of multiprocessing:
https://github.com/uqfoundation/multiprocess
"""
# Modules #
import multiprocessing
from tqdm import tqdm
################################################################################
def apply_function(func_to_apply, queue_in, queue_out):
while not queue_in.empty():
num, obj = queue_in.get()
queue_out.put((num, func_to_apply(obj)))
################################################################################
def prll_map(func_to_apply, items, cpus=None, verbose=False):
# Number of processes to use #
if cpus is None: cpus = min(multiprocessing.cpu_count(), 32)
# Create queues #
q_in = multiprocessing.Queue()
q_out = multiprocessing.Queue()
# Process list #
new_proc = lambda t,a: multiprocessing.Process(target=t, args=a)
processes = [new_proc(apply_function, (func_to_apply, q_in, q_out)) for x in range(cpus)]
# Put all the items (objects) in the queue #
sent = [q_in.put((i, x)) for i, x in enumerate(items)]
# Start them all #
for proc in processes:
proc.daemon = True
proc.start()
# Display progress bar or not #
if verbose:
results = [q_out.get() for x in tqdm(range(len(sent)))]
else:
results = [q_out.get() for x in range(len(sent))]
# Wait for them to finish #
for proc in processes: proc.join()
# Return results #
return [x for i, x in sorted(results)]
################################################################################
def test():
def slow_square(x):
import time
time.sleep(2)
return x**2
objs = range(20)
squares = prll_map(slow_square, objs, 4, verbose=True)
print "Result: %s" % squares
EDIT：@ alexander-mcfarlaneの提案とテスト関数を追加
私はこれが6年以上前に尋ねられたことを知っていますが、上記の提案のいくつかは恐ろしく複雑に見えるので、私のソリューションを追加したかったのですが、私のソリューションは実際には非常に簡単でした。
Pool.map（）呼び出しをヘルパー関数にラップするだけでした。クラスオブジェクトをメソッドの引数とともにTupleとして渡すと、このように見えます。
def run_in_parallel(args):
return args[0].method(args[1])
myclass = MyClass()
method_args = [1,2,3,4,5,6]
args_map = [ (myclass, arg) for arg in method_args ]
pool = Pool()
pool.map(run_in_parallel, args_map)
Klaus seのメソッドを変更しました。小さなリストを使用して作業していたとき、アイテムの数が1000以上になるとハングするからです。 None停止条件を使用してジョブを一度に1つずつプッシュする代わりに、入力キューを一度にロードし、プロセスが空になるまでプロセスを起動させます。
from multiprocessing import cpu_count, Queue, Process
def apply_func(f, q_in, q_out):
while not q_in.empty():
i, x = q_in.get()
q_out.put((i, f(x)))
# map a function using a pool of processes
def parmap(f, X, nprocs = cpu_count()):
q_in, q_out = Queue(), Queue()
proc = [Process(target=apply_func, args=(f, q_in, q_out)) for _ in range(nprocs)]
sent = [q_in.put((i, x)) for i, x in enumerate(X)]
[p.start() for p in proc]
res = [q_out.get() for _ in sent]
[p.join() for p in proc]
return [x for i,x in sorted(res)]
編集：残念なことに今、私は自分のシステムでこのエラーに遭遇しています： Multiprocessing Queue maxsize limit is 32767 、うまくいけばそこの回避策が役立つでしょう。
この質問は8年10か月前に尋ねられたことを知っていますが、私の解決策を提示したいと思います。
from multiprocessing import Pool
class Test:
def __init__(self):
self.main()
@staticmethod
def methodForMultiprocessing(x):
print(x*x)
def main(self):
if __== "__main__":
p = Pool()
p.map(Test.methodForMultiprocessing, list(range(1, 11)))
p.close()
TestObject = Test()
クラス関数を静的関数にするだけです。ただし、クラスメソッドを使用することもできます。
from multiprocessing import Pool
class Test:
def __init__(self):
self.main()
@classmethod
def methodForMultiprocessing(cls, x):
print(x*x)
def main(self):
if __== "__main__":
p = Pool()
p.map(Test.methodForMultiprocessing, list(range(1, 11)))
p.close()
TestObject = Test()
Python 3.7.3でテスト済み
エラーが示すようにPoolableではないため、クラス内のオブジェクトのリストからpickleオブジェクトを何らかの方法で手動で無視すると、問題なくコードを実行できます。これを行うには、次のように__getstate__関数（ here も参照）を使用します。 Poolオブジェクトは、__getstate__および__setstate__関数を見つけようとし、map、map_asyncなどを実行するときに検出すると、それらを実行しようとします。
class calculate(object):
def __init__(self):
self.p = Pool()
def __getstate__(self):
self_dict = self.__dict__.copy()
del self_dict['p']
return self_dict
def __setstate__(self, state):
self.__dict__.update(state)
def f(self, x):
return x*x
def run(self):
return self.p.map(self.f, [1,2,3])
それから：
cl = calculate()
cl.run()
出力が表示されます：
[1, 4, 9]
上記のコードをPython 3.xでテストしましたが、動作します。
このアプローチが取られているかどうかはわかりませんが、私が使用している回避策は次のとおりです：
from multiprocessing import Pool
t = None
def run(n):
return t.f(n)
class Test(object):
def __init__(self, number):
self.number = number
def f(self, x):
print x * self.number
def pool(self):
pool = Pool(2)
pool.map(run, range(10))
if __== '__main__':
t = Test(9)
t.pool()
pool = Pool(2)
pool.map(run, range(10))
出力は次のとおりです。
0
9
18
27
36
45
54
63
72
81
0
9
18
27
36
45
54
63
72
81
ここに私の解決策がありますが、これは他のほとんどの人よりも少しハックが少ないと思います。 Nightowlの答えに似ています。
someclasses = [MyClass(), MyClass(), MyClass()]
def method_caller(some_object, some_method='the method'):
return getattr(some_object, some_method)()
othermethod = partial(method_caller, some_method='othermethod')
with Pool(6) as pool:
result = pool.map(othermethod, someclasses)
http://www.rueckstiess.net/research/snippets/show/ca1d7d9 および http://qingkaikong.blogspot.com/2016/12/python-parallel-method- in-class.html
外部関数を作成し、クラスselfオブジェクトでシードできます。
from joblib import Parallel, delayed
def unwrap_self(arg, **kwarg):
return square_class.square_int(*arg, **kwarg)
class square_class:
def square_int(self, i):
return i * i
def run(self, num):
results = []
results = Parallel(n_jobs= -1, backend="threading")\
(delayed(unwrap_self)(i) for i in Zip([self]*len(num), num))
print(results)
またはjoblibなし：
from multiprocessing import Pool
import time
def unwrap_self_f(arg, **kwarg):
return C.f(*arg, **kwarg)
class C:
def f(self, name):
print 'hello %s,'%name
time.sleep(5)
print 'Nice to meet you.'
def run(self):
pool = Pool(processes=2)
names = ('frank', 'justin', 'osi', 'thomas')
pool.map(unwrap_self_f, Zip([self]*len(names), names))
if __== '__main__':
c = C()
c.run()
class Calculate(object):
# Your instance method to be executed
def f(self, x, y):
return x*y
if __== '__main__':
inp_list = [1,2,3]
y = 2
cal_obj = Calculate()
pool = Pool(2)
results = pool.map(lambda x: cal_obj.f(x, y), inp_list)
クラスの異なるインスタンスごとにこの関数を適用する可能性があります。そして、ここにその解決策もあります
class Calculate(object):
# Your instance method to be executed
def __init__(self, x):
self.x = x
def f(self, y):
return self.x*y
if __== '__main__':
inp_list = [Calculate(i) for i in range(3)]
y = 2
pool = Pool(2)
results = pool.map(lambda x: x.f(y), inp_list)