Comment paralléliser liste-de la compréhension des calculs en Python?

Sur la parallélisation automatique de compréhension de liste

À mon humble avis, efficace automatique parallisation de compréhension de liste serait impossible sans informations supplémentaires (telles que celles fournies à l'aide de directives OpenMP), ou en la limitant à des expressions qui impliquent seulement des types intégrés/méthodes.

Sauf si il ya une garantie que le traitement effectué sur chaque élément de la liste n'a pas d'effets secondaires, il est possible que les résultats ne seront pas valides (ou au moins différents) si le fait de sortir de la commande.

# Artificial example
counter = 0

def g(x): # func with side-effect
    global counter
    counter = counter + 1
    return x + counter

vals = [g(i) for i in range(100)] # diff result when not done in order

Il y a aussi la question de la répartition des tâches. Comment le problème de l'espace être décomposé?

Si le traitement de chaque élément constitue une tâche (~ tâches de la ferme), puis, quand il y a de nombreux éléments de chaque impliquant calcul trivial, les frais généraux de gestion des tâches du marais les gains de performance de la parallélisation.

On pourrait aussi prendre les données méthode de décomposition où le problème de l'espace est divisé de manière égale entre les processus disponibles.

Le fait que la compréhension de liste fonctionne également avec des générateurs qui rend ce un peu difficile, mais ce n'est probablement pas un frein si les charges de pré-itération, il est acceptable. Bien sûr, il ya aussi une possibilité de générateurs avec des effets secondaires qui peuvent changer le résultat si les éléments suivants sont prématurément itérée. Très peu probable, mais possible.

Un plus grand souci serait déséquilibre de charge à travers le processus. Il n'y a aucune garantie que chaque élément serait de prendre la même quantité de temps pour traiter, de manière statique des données partitionnées peut résulter en un seul processus, à faire la plupart du travail alors que le ralenti de votre temps loin.

Casser la liste des plus petits morceaux et de les transmettre comme chaque processus enfant est disponible est un bon compromis, cependant, une bonne sélection de taille de bloc serait fonction de l'application n'est donc pas faisable sans plus d'informations auprès de l'utilisateur.

Alternatives

Comme mentionné dans plusieurs autres réponses, il existe de nombreuses approches et le calcul parallèle modules/cadres à choisir selon les besoins.

Avoir utilisé seulement MPI (en C) avec aucune expérience de l'utilisation de Python pour le traitement en parallèle, je ne suis pas en mesure de se porter garant pour une (quoique, après une analyse rapide à travers,
multitraitement, cruche, pp et pyro se démarquer).

Si une exigence est de s'en tenir aussi près que possible à la compréhension de liste, puis cruche semble être la plus proche. À partir de la tutoriel, la distribution des tâches entre plusieurs instances peuvent être aussi simple que:

from jug.task import Task
from yourmodule import process_data
tasks = [Task(process_data,infile) for infile in glob('*.dat')]

Alors que cela fait quelque chose de similaire à multiprocessing.Pool.map(), jug pouvez utiliser différents backends pour la synchronisation de processus et de stocker les résultats intermédiaires (redis, système de fichiers en mémoire) ce qui signifie que le processus peut s'étendre sur des nœuds dans un cluster.

De mémoire partagée parallélisme, je recommande joblib:

from joblib import delayed, Parallel

def square(x): return x*x
values = Parallel(n_jobs=NUM_CPUS)(delayed(square)(x) for x in range(1000))

Pas à l'intérieur d'une compréhension de liste autant que je sache.

Vous pourrait certainement le faire avec un traditionnel pour la boucle et le multitraitement/filetage modules.

Que les réponses ci-dessus, le point de sortir, c'est en fait assez difficile de le faire automatiquement. Alors je pense que la question est en fait la façon de le faire de la manière la plus simple possible. Idéalement, une solution ne nécessite pas de savoir des choses comme "quel est le nombre de noyaux dois-je". Une autre propriété que vous voulez est d'être en mesure de toujours faire la liste de compréhension dans une seule ligne lisible.

Certaines des réponses données semblent déjà avoir de belles propriétés de ce type, mais une autre alternative est de Rayon (docs), qui constitue un cadre pour l'écriture parallèle Python. Dans les Rayons, vous serait-il faire comme ceci:

import ray

# Start Ray. This creates some processes that can do work in parallel.
ray.init()

# Add this line to signify that the function can be run in parallel (as a
# "task"). Ray will load-balance different `square` tasks automatically.
@ray.remote
def square(x):
    return x * x

# Create some parallel work using a list comprehension, then block until the
# results are ready with `ray.get`.
ray.get([square.remote(x) for x in range(1000)])