Multitraitement d'une boucle for?

J'ai un tableau (appelé data_inputs) contenant les noms de centaines d'astronomie des fichiers d'images. Ces images sont ensuite manipulées. Mon code fonctionne et ne prend que quelques secondes à chaque image. Toutefois, il ne peut le faire une image à la fois parce que je suis l'exécution du tableau par le biais d'un for boucle:

for name in data_inputs:
    sci=fits.open(name+'.fits')
    #image is manipulated

Il n'ya aucune raison pourquoi j'ai modifier une image avant toute autre, est-il donc possible d'utiliser les 4 coeurs sur ma machine avec chaque base en cours d'exécution à travers la boucle sur une autre image?

J'ai lu sur le multiprocessing module, mais je suis pas sûr de la façon de l'appliquer dans mon cas.
Je suis désireux d'obtenir multiprocessing de travailler parce que finalement je vais devoir l'exécuter sur+ de 10 000 images.

InformationsquelleAutor ChrisFro | 2013-11-25
  1. 61

    Vous pouvez simplement utiliser multiprocessing.Piscine:

    from multiprocessing import Pool

def process_image(name):
    sci=fits.open('{}.fits'.format(name))
    <process>

if __name__ == '__main__':
    pool = Pool()                         # Create a multiprocessing Pool
    pool.map(process_image, data_inputs)  # process data_inputs iterable with pool
    • Il pourrait être préférable d'utiliser: pool = Pool(os.cpu_count()) C'est une méthode générique de l'utilisation de multitraitement.
    • Remarque: os.cpu_count() a été ajouté en Python 3.4. Pour Python 2.x, utilisez multiprocessing.cpu_count().
    • Pool() est le même que Pool(os.cpu_count())
    • Pour des précisions sur @Tim commentaire - Pool() appelé sans valeur de processes est le même que Pool(processes=cpu_count()) peu importe si vous êtes à l'aide de Python 3 ou 2 - donc, la meilleure pratique dans l'une ou l'autre version est à utiliser Pool(). docs.python.org/2/library/multiprocessing.html
    • Je suis incapable de comprendre ce qu'est "data_inputs" ici. Vous n'avez pas défini. Quelle valeur dois-je lui donner?
    • sérieusement? avez-vous lu la question d'origine? tout est là
    • si je ne me trompe pas, l'utilisation de la Piscine(système d'exploitation.cpu_count ()), le se congeler jusqu'à ce que le traitement est terminé, que vous ne quittez pas le système d'exploitation libre cœurs. Pour beaucoup d'utilisateurs de la Piscine(système d'exploitation.cpu_count() - 1) pourrait être un meilleur choix
    • Vous avez absolument raison et je laisse toujours au moins un CPU seul. Je lui ai donné un exemple pour l'utilisation de multitraitement.
    • Il doit y avoir de la piscine.close() à la fin.

    InformationsquelleAutor alko
  2. 18

    Vous pouvez utiliser multiprocessing.Pool:

    from multiprocessing import Pool
class Engine(object):
    def __init__(self, parameters):
        self.parameters = parameters
    def __call__(self, filename):
        sci = fits.open(filename + '.fits')
        manipulated = manipulate_image(sci, self.parameters)
        return manipulated

try:
    pool = Pool(8) # on 8 processors
    engine = Engine(my_parameters)
    data_outputs = pool.map(engine, data_inputs)
finally: # To make sure processes are closed in the end, even if errors happen
    pool.close()
    pool.join()
    • Je suis incapable de comprendre ce qu'est "data_inputs" ici. Vous n'avez pas défini. Quelle valeur dois-je lui donner?
    • Il découle effectivement de la alko la réponse, je suis en citant son commentaire (voir le bloc de code): "proces de data_inputs itératif avec piscine". Donc data_inputs est un objet iterable (comme dans une norme map).
    InformationsquelleAutor ixxo
  3. 0

    Sinon

    with Pool() as pool: 
    pool.map(fits.open, [name + '.fits' for name in datainput])
    • TypeError: 'Pool' object is not callable
    • Désolé de mon erreur, c'est "de la piscine.la carte" et non seulement "la piscine". Je l'ai corrigé.
    InformationsquelleAutor Spas