Parfor pour Python

Je suis à la recherche d'une réponse définitive à MATLAB parfor pour Python (Scipy, Numpy).

Est-il une solution similaire à parfor? Si non, quelle est la complication pour la création d'une?

Mise à JOUR: Voici un exemple typique du calcul numérique de code que j'ai besoin d'accélérer

import numpy as np

N = 2000
output = np.zeros([N,N])
for i in range(N):
    for j in range(N):
        output[i,j] = HeavyComputationThatIsThreadSafe(i,j)

Un exemple d'un lourd fonction de calcul est:

import scipy.optimize

def HeavyComputationThatIsThreadSafe(i,j):
    n = i * j

    return scipy.optimize.anneal(lambda x: np.sum((x-np.arange(n)**2)), np.random.random((n,1)))[0][0,0]

InformationsquelleAutor Dat Chu | 2011-01-13

19

Il y a beaucoup de Python cadres pour le calcul parallèle. Celui que j'aime le plus est IPython, mais je ne sais pas trop sur les autres. Dans IPython, un analogue de parfor serait client.MultiEngineClient.map() ou d'autres constructions dans la documentation sur rapide et facile parallélisme.
- +1 Ne saviez pas sur le client.MultiEngineClient même si je ne l'utilisation de IPython. Merci pour le diriger!
- Il n'est pas évident pour moi de savoir si je peux exécuter un code accéléré avec IPython parallèle cadre informatique en mode script, c'est à dire pas en cours d'exécution par le biais de ipython.
- Chu: bien sûr, vous pouvez. Il suffit d'écrire les commandes que vous tapez à l'invite de commandes dans un fichier, et fonctionne avec Python. (Est-ce bien ce que vous demandez?)
- Up-to-date lien vers la documentation sur rapide et facile parallélisme.
- Merci pour la mise à jour.
- Sven, je pense que tu veux dire parfor où vous écrivez matfor.
- Bien sûr! Merci, fixe.
InformationsquelleAutor Sven Marnach
27

Celui intégré à python serait multiprocessing docs sont ici. J'ai toujours utiliser multiprocessing.Pool avec autant de travailleurs que les processeurs. Alors à chaque fois que j'ai besoin de faire une boucle for comme structure-je utiliser Pool.imap

Aussi longues que le corps de votre fonction ne dépend pas d'une itération précédente alors vous devriez avoir près de vitesse linéaire-up. Cela implique aussi que les entrées et les sorties sont pickle-mesure, mais c'est assez facile à assurer pour les types standard.

Mise à JOUR:
Un peu de code pour la mise à jour de votre fonction juste pour montrer combien il est facile:
```
from multiprocessing import Pool
from itertools import product

output = np.zeros((N,N))
pool = Pool() #defaults to number of available CPU's
chunksize = 20 #this may take some guessing ... take a look at the docs to decide
for ind, res in enumerate(pool.imap(Fun, product(xrange(N), xrange(N))), chunksize):
    output.flat[ind] = res
```
- Vous devez remplacer output[ind] par output.flat[ind] pour rendre le code du travail. (output est un tableau à deux dimensions et aurait besoin de deux indices.)
- Merci ... qui vient de commutation entre matlab et python tout le temps.
InformationsquelleAutor JudoWill
4

J'ai toujours utilisé des En Parallèle Python mais ce n'est pas un analogue complète car je crois qu'il utilise généralement des processus distincts qui peuvent être coûteux sur certains systèmes d'exploitation. Encore, si le corps de votre boucles sont chunky assez alors ce ne sera pas grave et peut avoir certains avantages.

InformationsquelleAutor David Heffernan

Jupyter Portable

Pour voir un exemple de considérer que vous voulez écrire l'équivalence de ce code Matlab en Python

matlabpool open 4
parfor n=0:9
   for i=1:10000
       for j=1:10000
           s=j*i   
       end
   end
   n
end
disp('done')

La façon dont on peut écrire cela en python en particulier dans jupyter ordinateur portable. Vous devez créer une fonction dans le répertoire de travail (je l'ai appelé FunForParFor.py) qui est la suivante

def func(n):
    for i in range(10000):
        for j in range(10000):
            s=j*i
    print(n)

Puis-je aller à mon Jupyter portable et d'écrire le code suivant

import multiprocessing  
import FunForParFor

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    pool.map(FunForParFor.func, range(10))
    pool.close()
    pool.join()   
    print('done')

Cela a fonctionné pour moi! Je voulais juste le partager ici, pour vous donner un exemple particulier.

InformationsquelleAutor rsc05

Cela peut se faire en toute élégance avec Ray, un système qui vous permet de paralléliser et distribuer votre code Python.

Pour paralléliser votre exemple, vous devez définir vos fonctions avec le @ray.remote décorateur, puis d'appeler avec .remote.

import numpy as np
import time

import ray

ray.init()

# Define the function. Each remote function will be executed 
# in a separate process.
@ray.remote
def HeavyComputationThatIsThreadSafe(i, j):
    n = i*j
    time.sleep(0.5) # Simulate some heavy computation. 
    return n

N = 10
output_ids = []
for i in range(N):
    for j in range(N):
        # Remote functions return a future, i.e, an identifier to the 
        # result, rather than the result itself. This allows invoking
        # the next remote function before the previous finished, which
        # leads to the remote functions being executed in parallel.
        output_ids.append(HeavyComputationThatIsThreadSafe.remote(i,j))

# Get results when ready.
output_list = ray.get(output_ids)
# Move results into an NxN numpy array.
outputs = np.array(output_list).reshape(N, N)

# This program should take approximately N*N*0.5s/p, where
# p is the number of cores on your machine, N*N
# is the number of times we invoke the remote function,
# and 0.5s is the time it takes to execute one instance
# of the remote function. For example, for two cores this
# program will take approximately 25sec.

Il y a un certain nombre d'avantages de l'utilisation de Rayons sur la multitraitement module. En particulier, la même code sera exécuté sur une seule machine ainsi que sur un cluster de machines. Pour plus d'avantages de Ray voir ce poste.

Remarque: Un point à garder à l'esprit est que chaque fonction est exécutée dans un processus distinct, éventuellement sur une autre machine, et donc la distance de la fonction de calcul devrait prendre plus de l'invocation d'une fonction à distance. En règle générale, une distance de la fonction de calcul devrait prendre au moins quelques 10s de ms à amortir la planification et le démarrage de surcharge d'une fonction à distance.

InformationsquelleAutor Ion Stoica

1

J'ai essayé toutes les solutions ici, mais a constaté que la façon la plus simple et la plus proche équivalent à matlabs parfor est numba de l' prange.

Essentiellement, vous de changer une seule lettre dans votre boucle, la gamme de prange:
```
from numba import autojit, prange

@autojit
def parallel_sum(A):
    sum = 0.0
    for i in prange(A.shape[0]):
        sum += A[i]

    return sum
```
InformationsquelleAutor Felix

Vous devez vous connecter pour publier un commentaire.