私はPythonの簡単なプロセスベースの並列マップ、つまり関数を探しています
parmap(function,[data])
それは異なるプロセスの[データ]の各要素で機能を実行します(まあ、別のコアで、しかしAFAIK、pythonインタプリタ)、および結果のリストを返します。
このようなものはありますか?何かsimpleが欲しいので、シンプルなモジュールがいいでしょう。もちろん、そのようなものが存在しない場合、私は大きなライブラリに落ち着きます:-/
必要なのは multiprocessing.Pool()のmapメソッド :
map(func、iterable [、chunksize])
A parallel equivalent of the map() built-in function (it supports only one iterable argument though). It blocks till the result is ready. This method chops the iterable into a number of chunks which it submits to the process pool as separate tasks. The (approximate) size of these chunks can be specified by setting chunksize to a positive integ
たとえば、この関数をマップする場合:
def f(x):
return x**2
range(10)には、組み込みのmap()関数を使用して実行できます。
map(f, range(10))
または、multiprocessing.Pool()オブジェクトのメソッドmap()を使用します。
import multiprocessing
pool = multiprocessing.Pool()
print pool.map(f, range(10))
私はこれが古い投稿であることを知っていますが、念のため、私は parmapper と呼ばれるこの超簡単なツールを作成しました(私は実際にparmapと呼んでいますが、名前は使われています)。
プロセスのセットアップと分解の多くを処理し、多くの機能を追加します。大まかな順序で
わずかなコストがかかりますが、ほとんどの用途では無視できます。
役に立つと思います。
(注:Python 3+のmap
のように、反復可能を返すため、すべての結果がすぐに通過することが予想される場合は、list()
を使用します)
これは、Pythonコードを簡単に並列化および配布できるシステムである Ray を使用してエレガントに行うことができます。
例を並列化するには、マップ関数を_@ray.remote
_デコレータで定義してから、_.remote
_で呼び出す必要があります。これにより、リモート関数のすべてのインスタンスが異なるプロセスで実行されるようになります。
_import time
import ray
ray.init()
# Define the function you want to apply map on, as remote function.
@ray.remote
def f(x):
# Do some work...
time.sleep(1)
return x*x
# Define a helper parmap(f, list) function.
# This function executes a copy of f() on each element in "list".
# Each copy of f() runs in a different process.
# Note f.remote(x) returns a future of its result (i.e.,
# an identifier of the result) rather than the result itself.
def parmap(f, list):
return [f.remote(x) for x in list]
# Call parmap() on a list consisting of first 5 integers.
result_ids = parmap(f, range(1, 6))
# Get the results
results = ray.get(result_ids)
print(results)
_
これは印刷されます:
_[1, 4, 9, 16, 25]
_
約len(list)/p
(最も近い整数に切り上げ)で終了します。ここで、p
はマシンのコア数です。コアが2つのマシンを想定すると、この例は_5/2
_で切り上げて、つまり約_3
_秒で実行されます。
multiprocessing モジュールよりもRayを使用することには多くの利点があります。特に、同じコードは、単一のマシンおよびマシンのクラスターで実行されます。 Rayのその他の利点については、 関連記事 を参照してください。
Python Rのmclapply()に相当するものを探している人のために、これが私の実装です。次の2つの例の改善です。
単一または複数の引数を持つマップ関数に適用できます。
import numpy as np, pandas as pd
from scipy import sparse
import functools, multiprocessing
from multiprocessing import Pool
num_cores = multiprocessing.cpu_count()
def parallelize_dataframe(df, func, U=None, V=None):
#blockSize = 5000
num_partitions = 5 # int( np.ceil(df.shape[0]*(1.0/blockSize)) )
blocks = np.array_split(df, num_partitions)
pool = Pool(num_cores)
if V is not None and U is not None:
# apply func with multiple arguments to dataframe (i.e. involves multiple columns)
df = pd.concat(pool.map(functools.partial(func, U=U, V=V), blocks))
else:
# apply func with one argument to dataframe (i.e. involves single column)
df = pd.concat(pool.map(func, blocks))
pool.close()
pool.join()
return df
def square(x):
return x**2
def test_func(data):
print("Process working on: ", data.shape)
data["squareV"] = data["testV"].apply(square)
return data
def vecProd(row, U, V):
return np.sum( np.multiply(U[int(row["obsI"]),:], V[int(row["obsJ"]),:]) )
def mProd_func(data, U, V):
data["predV"] = data.apply( lambda row: vecProd(row, U, V), axis=1 )
return data
def generate_simulated_data():
N, D, nnz, K = [302, 184, 5000, 5]
I = np.random.choice(N, size=nnz, replace=True)
J = np.random.choice(D, size=nnz, replace=True)
vals = np.random.sample(nnz)
sparseY = sparse.csc_matrix((vals, (I, J)), shape=[N, D])
# Generate parameters U and V which could be used to reconstruct the matrix Y
U = np.random.sample(N*K).reshape([N,K])
V = np.random.sample(D*K).reshape([D,K])
return sparseY, U, V
def main():
Y, U, V = generate_simulated_data()
# find row, column indices and obvseved values for sparse matrix Y
(testI, testJ, testV) = sparse.find(Y)
colNames = ["obsI", "obsJ", "testV", "predV", "squareV"]
dtypes = {"obsI":int, "obsJ":int, "testV":float, "predV":float, "squareV": float}
obsValDF = pd.DataFrame(np.zeros((len(testV), len(colNames))), columns=colNames)
obsValDF["obsI"] = testI
obsValDF["obsJ"] = testJ
obsValDF["testV"] = testV
obsValDF = obsValDF.astype(dtype=dtypes)
print("Y.shape: {!s}, #obsVals: {}, obsValDF.shape: {!s}".format(Y.shape, len(testV), obsValDF.shape))
# calculate the square of testVals
obsValDF = parallelize_dataframe(obsValDF, test_func)
# reconstruct prediction of testVals using parameters U and V
obsValDF = parallelize_dataframe(obsValDF, mProd_func, U, V)
print("obsValDF.shape after reconstruction: {!s}".format(obsValDF.shape))
print("First 5 elements of obsValDF:\n", obsValDF.iloc[:5,:])
if __== '__main__':
main()