Python çoklu işleme kütüphanesinde, birden fazla argümanı destekleyen bir pool.map varyantı var mı?

text = "test"
def harvester(text, case):
    X = case[0]
    text+ str(X)

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=6)
    case = RAW_DATASET
    pool.map(harvester(text,case),case, 1)
    pool.close()
    pool.join()

Bunun cevabı versiyona ve duruma bağlıdır. Python'un son sürümleri (3.3'ten beri) için en genel cevap ilk olarak aşağıda JF Sebastian tarafından açıklandı . ¹Pool.starmap Bir dizi argüman tuplesini kabul eden yöntemi kullanır . Daha sonra, argümanları her bir gruptan otomatik olarak açar ve verilen işleve iletir:

import multiprocessing
from itertools import product

def merge_names(a, b):
    return '{} & {}'.format(a, b)

if __name__ == '__main__':
    names = ['Brown', 'Wilson', 'Bartlett', 'Rivera', 'Molloy', 'Opie']
    with multiprocessing.Pool(processes=3) as pool:
        results = pool.starmap(merge_names, product(names, repeat=2))
    print(results)

# Output: ['Brown & Brown', 'Brown & Wilson', 'Brown & Bartlett', ...

Python'un önceki sürümlerinde, bağımsız değişkenleri açıkça açmak için bir yardımcı işlev yazmanız gerekir. Kullanmak isterseniz with, Pooliçerik yöneticisine dönüştürmek için bir sarıcı yazmanız gerekir . ( Bunu işaret ettiği için müon için teşekkürler .)

import multiprocessing
from itertools import product
from contextlib import contextmanager

def merge_names(a, b):
    return '{} & {}'.format(a, b)

def merge_names_unpack(args):
    return merge_names(*args)

@contextmanager
def poolcontext(*args, **kwargs):
    pool = multiprocessing.Pool(*args, **kwargs)
    yield pool
    pool.terminate()

if __name__ == '__main__':
    names = ['Brown', 'Wilson', 'Bartlett', 'Rivera', 'Molloy', 'Opie']
    with poolcontext(processes=3) as pool:
        results = pool.map(merge_names_unpack, product(names, repeat=2))
    print(results)

# Output: ['Brown & Brown', 'Brown & Wilson', 'Brown & Bartlett', ...

Daha basit durumlarda, sabit bir ikinci argümanla, partialsadece Python 2.7+ ' da da kullanabilirsiniz .

import multiprocessing
from functools import partial
from contextlib import contextmanager

@contextmanager
def poolcontext(*args, **kwargs):
    pool = multiprocessing.Pool(*args, **kwargs)
    yield pool
    pool.terminate()

def merge_names(a, b):
    return '{} & {}'.format(a, b)

if __name__ == '__main__':
    names = ['Brown', 'Wilson', 'Bartlett', 'Rivera', 'Molloy', 'Opie']
    with poolcontext(processes=3) as pool:
        results = pool.map(partial(merge_names, b='Sons'), names)
    print(results)

# Output: ['Brown & Sons', 'Wilson & Sons', 'Bartlett & Sons', ...

^{1. Bunun çoğu, muhtemelen onun yerine kabul edilmesi gereken cevabından esinlenmiştir. Ancak bu en üstte kaldığından, gelecekteki okuyucular için onu iyileştirmek en iyisi gibi görünüyordu.}

birden fazla argümanı destekleyen bir pool.map varyantı var mı?

Python 3.3 pool.starmap()yöntemi içerir :

#!/usr/bin/env python3
from functools import partial
from itertools import repeat
from multiprocessing import Pool, freeze_support

def func(a, b):
    return a + b

def main():
    a_args = [1,2,3]
    second_arg = 1
    with Pool() as pool:
        L = pool.starmap(func, [(1, 1), (2, 1), (3, 1)])
        M = pool.starmap(func, zip(a_args, repeat(second_arg)))
        N = pool.map(partial(func, b=second_arg), a_args)
        assert L == M == N

if __name__=="__main__":
    freeze_support()
    main()

Eski sürümler için:

#!/usr/bin/env python2
import itertools
from multiprocessing import Pool, freeze_support

def func(a, b):
    print a, b

def func_star(a_b):
    """Convert `f([1,2])` to `f(1,2)` call."""
    return func(*a_b)

def main():
    pool = Pool()
    a_args = [1,2,3]
    second_arg = 1
    pool.map(func_star, itertools.izip(a_args, itertools.repeat(second_arg)))

if __name__=="__main__":
    freeze_support()
    main()

Çıktı

1 1
2 1
3 1

Burada nasıl itertools.izip()ve itertools.repeat()kullanıldığına dikkat edin .

@Unutbu tarafından belirtilen hata nedeniyle functools.partial(), Python 2.6'da benzer yetenekleri kullanamazsınız , bu nedenle basit sarma işlevi func_star()açıkça tanımlanmalıdır. Ayrıca önerilen geçici çözümeuptimebox bakın .

Aşağıdaki daha iyi olacağını düşünüyorum

def multi_run_wrapper(args):
   return add(*args)
def add(x,y):
    return x+y
if __name__ == "__main__":
    from multiprocessing import Pool
    pool = Pool(4)
    results = pool.map(multi_run_wrapper,[(1,2),(2,3),(3,4)])
    print results

çıktı

[3, 5, 7]

Python 3.3+ ile birlikte kullanmapool.starmap():

from multiprocessing.dummy import Pool as ThreadPool 

def write(i, x):
    print(i, "---", x)

a = ["1","2","3"]
b = ["4","5","6"] 

pool = ThreadPool(2)
pool.starmap(write, zip(a,b)) 
pool.close() 
pool.join()

Sonuç:

1 --- 4
2 --- 5
3 --- 6

İsterseniz daha fazla bağımsız değişken zip () de ekleyebilirsiniz: zip(a,b,c,d,e)

Eğer kullanmak zorunda argüman olarak iletilen sabit bir değer olmasını istediğiniz import itertoolssonra ve zip(itertools.repeat(constant), a)örneğin.

JF Sebastian cevabında itertools'u öğrendikten sonra , bir adım daha ileri gitmeye ve python-2.7 ve python-3.2 (ve daha sonra da) üzerinde çok sayıda konumsal argüman alabilen parmapparalelleştirme, teklif mapve starmapişlevlere dikkat eden bir paket yazmaya karar verdim. .

Kurulum

pip install parmap

Paralelleme nasıl yapılır:

import parmap
# If you want to do:
y = [myfunction(x, argument1, argument2) for x in mylist]
# In parallel:
y = parmap.map(myfunction, mylist, argument1, argument2)

# If you want to do:
z = [myfunction(x, y, argument1, argument2) for (x,y) in mylist]
# In parallel:
z = parmap.starmap(myfunction, mylist, argument1, argument2)

# If you want to do:
listx = [1, 2, 3, 4, 5, 6]
listy = [2, 3, 4, 5, 6, 7]
param = 3.14
param2 = 42
listz = []
for (x, y) in zip(listx, listy):
        listz.append(myfunction(x, y, param1, param2))
# In parallel:
listz = parmap.starmap(myfunction, zip(listx, listy), param1, param2)

Parmap'ı PyPI'ye ve bir github deposuna yükledim .

Örnek olarak, soru aşağıdaki gibi cevaplanabilir:

import parmap

def harvester(case, text):
    X = case[0]
    text+ str(X)

if __name__ == "__main__":
    case = RAW_DATASET  # assuming this is an iterable
    parmap.map(harvester, case, "test", chunksize=1)

# "Birden çok argüman nasıl alınır".

def f1(args):
    a, b, c = args[0] , args[1] , args[2]
    return a+b+c

if __name__ == "__main__":
    import multiprocessing
    pool = multiprocessing.Pool(4) 

    result1 = pool.map(f1, [ [1,2,3] ])
    print(result1)

Pathosmultiprocessing denilen bir çatal var ( not: github'daki sürümü kullanın ) - harita işlevleri python haritası için API'yi yansıtır, böylece harita birden fazla argüman alabilir. İle , blokta takılı kalmak yerine, genellikle yorumlayıcıda çok işlem yapabilirsiniz . Pathos, hafif bir güncellemeden sonra, çoğunlukla python 3.x'e dönüşümden sonra yayınlanacak.starmappathos__main__

  Python 2.7.5 (default, Sep 30 2013, 20:15:49) 
  [GCC 4.2.1 (Apple Inc. build 5566)] on darwin
  Type "help", "copyright", "credits" or "license" for more information.
  >>> def func(a,b):
  ...     print a,b
  ...
  >>>
  >>> from pathos.multiprocessing import ProcessingPool    
  >>> pool = ProcessingPool(nodes=4)
  >>> pool.map(func, [1,2,3], [1,1,1])
  1 1
  2 1
  3 1
  [None, None, None]
  >>>
  >>> # also can pickle stuff like lambdas 
  >>> result = pool.map(lambda x: x**2, range(10))
  >>> result
  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  >>>
  >>> # also does asynchronous map
  >>> result = pool.amap(pow, [1,2,3], [4,5,6])
  >>> result.get()
  [1, 32, 729]
  >>>
  >>> # or can return a map iterator
  >>> result = pool.imap(pow, [1,2,3], [4,5,6])
  >>> result
  <processing.pool.IMapIterator object at 0x110c2ffd0>
  >>> list(result)
  [1, 32, 729]

pathostam davranışını elde etmenin birkaç yolu vardır starmap.

>>> def add(*x):
...   return sum(x)
... 
>>> x = [[1,2,3],[4,5,6]]
>>> import pathos
>>> import numpy as np
>>> # use ProcessPool's map and transposing the inputs
>>> pp = pathos.pools.ProcessPool()
>>> pp.map(add, *np.array(x).T)
[6, 15]
>>> # use ProcessPool's map and a lambda to apply the star
>>> pp.map(lambda x: add(*x), x)
[6, 15]
>>> # use a _ProcessPool, which has starmap
>>> _pp = pathos.pools._ProcessPool()
>>> _pp.starmap(add, x)
[6, 15]
>>> 

Her yeni işlev için bir sarıcı yazmamak için aşağıdaki iki işlevi kullanabilirsiniz:

import itertools
from multiprocessing import Pool

def universal_worker(input_pair):
    function, args = input_pair
    return function(*args)

def pool_args(function, *args):
    return zip(itertools.repeat(function), zip(*args))

İşlevini kullanın functionargümanlar listeleri içeren arg_0, arg_1ve arg_2aşağıdaki gibi:

pool = Pool(n_core)
list_model = pool.map(universal_worker, pool_args(function, arg_0, arg_1, arg_2)
pool.close()
pool.join()

Python2 için daha iyi bir çözüm:

from multiprocessing import Pool
def func((i, (a, b))):
    print i, a, b
    return a + b
pool = Pool(3)
pool.map(func, [(0,(1,2)), (1,(2,3)), (2,(3, 4))])

2 3 4

1 2 3

0 1 2

dışarı[]:

[3, 5, 7]

Başka bir basit alternatif, fonksiyon parametrelerinizi bir tuple içine sarmak ve daha sonra tuples'e geçirilmesi gereken parametreleri sarmaktır. Büyük veri parçaları ile uğraşırken bu ideal olmayabilir. Her bir demet için kopyalar yapacağına inanıyorum.

from multiprocessing import Pool

def f((a,b,c,d)):
    print a,b,c,d
    return a + b + c +d

if __name__ == '__main__':
    p = Pool(10)
    data = [(i+0,i+1,i+2,i+3) for i in xrange(10)]
    print(p.map(f, data))
    p.close()
    p.join()

Çıktıyı rasgele sırada verir:

0 1 2 3
1 2 3 4
2 3 4 5
3 4 5 6
4 5 6 7
5 6 7 8
7 8 9 10
6 7 8 9
8 9 10 11
9 10 11 12
[6, 10, 14, 18, 22, 26, 30, 34, 38, 42]

Sarma işlevini elle yazmak yerine dekoratörü kullanmak daha iyi bir yoldur . Özellikle eşlemek için çok fazla fonksiyonunuz olduğunda, dekoratör her fonksiyon için sarıcı yazmaktan kaçınarak zaman kazanacaktır. Genellikle dekore edilmiş bir işlev seçilemez, ancak onu dolaşmak için kullanabiliriz. Daha fazla tartışma burada bulunabilir .functools

İşte örnek

def unpack_args(func):
    from functools import wraps
    @wraps(func)
    def wrapper(args):
        if isinstance(args, dict):
            return func(**args)
        else:
            return func(*args)
    return wrapper

@unpack_args
def func(x, y):
    return x + y

Sonra sıkıştırılmış argümanlarla eşleştirebilirsiniz

np, xlist, ylist = 2, range(10), range(10)
pool = Pool(np)
res = pool.map(func, zip(xlist, ylist))
pool.close()
pool.join()

Tabii ki, Pool.starmapPython 3'te (> = 3.3) her zaman diğer cevaplarda belirtildiği gibi kullanabilirsiniz.

Başka bir yol da liste listesini tek argümanlı bir rutine aktarmaktır:

import os
from multiprocessing import Pool

def task(args):
    print "PID =", os.getpid(), ", arg1 =", args[0], ", arg2 =", args[1]

pool = Pool()

pool.map(task, [
        [1,2],
        [3,4],
        [5,6],
        [7,8]
    ])

Kişi, en sevdiği yöntemle bir argüman listesi oluşturabilir.

IMHO'nun sağlanan diğer cevaplardan daha basit ve zarif olduğunu yapmanın başka bir yolu.

Bu programın iki parametre alan, çıktılarını alan ve toplamı yazan bir işlevi vardır:

import multiprocessing

def main():

    with multiprocessing.Pool(10) as pool:
        params = [ (2, 2), (3, 3), (4, 4) ]
        pool.starmap(printSum, params)
    # end with

# end function

def printSum(num1, num2):
    mySum = num1 + num2
    print('num1 = ' + str(num1) + ', num2 = ' + str(num2) + ', sum = ' + str(mySum))
# end function

if __name__ == '__main__':
    main()

çıktı:

num1 = 2, num2 = 2, sum = 4
num1 = 3, num2 = 3, sum = 6
num1 = 4, num2 = 4, sum = 8

Daha fazla bilgi için python belgelerine bakın:

https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing.pool

Özellikle starmapişlevi kontrol ettiğinizden emin olun .

Python 3.6 kullanıyorum, bunun eski Python sürümleriyle çalışıp çalışmayacağından emin değilim

Neden dokümanlarda böyle çok açık bir örnek yok, emin değilim.

Python 3.4.4 sürümünden, birden çok başlatma yöntemini kullanmak üzere bir bağlam nesnesi elde etmek için multiprocessing.get_context () yöntemini kullanabilirsiniz:

import multiprocessing as mp

def foo(q, h, w):
    q.put(h + ' ' + w)
    print(h + ' ' + w)

if __name__ == '__main__':
    ctx = mp.get_context('spawn')
    q = ctx.Queue()
    p = ctx.Process(target=foo, args=(q,'hello', 'world'))
    p.start()
    print(q.get())
    p.join()

Veya sadece değiştirin

pool.map(harvester(text,case),case, 1)

tarafından:

pool.apply_async(harvester(text,case),case, 1)

Burada birçok cevap var, ancak hiçbiri herhangi bir sürümde çalışacak Python 2/3 uyumlu kod sağlamıyor gibi görünüyor. Kodunuzun çalışmasını istiyorsanız , bu iki Python sürümü için de çalışır:

# For python 2/3 compatibility, define pool context manager
# to support the 'with' statement in Python 2
if sys.version_info[0] == 2:
    from contextlib import contextmanager
    @contextmanager
    def multiprocessing_context(*args, **kwargs):
        pool = multiprocessing.Pool(*args, **kwargs)
        yield pool
        pool.terminate()
else:
    multiprocessing_context = multiprocessing.Pool

Bundan sonra, istediğiniz gibi normal Python 3 yolunu çoklu işlemeyi kullanabilirsiniz. Örneğin:

def _function_to_run_for_each(x):
       return x.lower()
with multiprocessing_context(processes=3) as pool:
    results = pool.map(_function_to_run_for_each, ['Bob', 'Sue', 'Tim'])    print(results)

Python 2 veya Python 3'te çalışacaktır.

Resmi belgelerde sadece bir yinelenebilir argümanı desteklediğini belirtmektedir. Bu gibi durumlarda camera_async kullanmayı seviyorum. Senin durumunda yapardım:

from multiprocessing import Process, Pool, Manager

text = "test"
def harvester(text, case, q = None):
 X = case[0]
 res = text+ str(X)
 if q:
  q.put(res)
 return res


def block_until(q, results_queue, until_counter=0):
 i = 0
 while i < until_counter:
  results_queue.put(q.get())
  i+=1

if __name__ == '__main__':
 pool = multiprocessing.Pool(processes=6)
 case = RAW_DATASET
 m = Manager()
 q = m.Queue()
 results_queue = m.Queue() # when it completes results will reside in this queue
 blocking_process = Process(block_until, (q, results_queue, len(case)))
 blocking_process.start()
 for c in case:
  try:
   res = pool.apply_async(harvester, (text, case, q = None))
   res.get(timeout=0.1)
  except:
   pass
 blocking_process.join()

text = "test"

def unpack(args):
    return args[0](*args[1:])

def harvester(text, case):
    X = case[0]
    text+ str(X)

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=6)
    case = RAW_DATASET
    # args is a list of tuples 
    # with the function to execute as the first item in each tuple
    args = [(harvester, text, c) for c in case]
    # doing it this way, we can pass any function
    # and we don't need to define a wrapper for each different function
    # if we need to use more than one
    pool.map(unpack, args)
    pool.close()
    pool.join()

Bu, pool.imap çatalında kullanılan tek argüman işlevine birden çok argüman iletmek için kullandığım rutine bir örnektir :

from multiprocessing import Pool

# Wrapper of the function to map:
class makefun:
    def __init__(self, var2):
        self.var2 = var2
    def fun(self, i):
        var2 = self.var2
        return var1[i] + var2

# Couple of variables for the example:
var1 = [1, 2, 3, 5, 6, 7, 8]
var2 = [9, 10, 11, 12]

# Open the pool:
pool = Pool(processes=2)

# Wrapper loop
for j in range(len(var2)):
    # Obtain the function to map
    pool_fun = makefun(var2[j]).fun

    # Fork loop
    for i, value in enumerate(pool.imap(pool_fun, range(len(var1))), 0):
        print(var1[i], '+' ,var2[j], '=', value)

# Close the pool
pool.close()

python2 için bu numarayı kullanabilirsiniz

def fun(a,b):
    return a+b

pool = multiprocessing.Pool(processes=6)
b=233
pool.map(lambda x:fun(x,b),range(1000))