Tampilkan kemajuan panggilan imap_unordered pool multiprosesing Python?

Saya memiliki skrip yang berhasil melakukan kumpulan tugas multiprosesing dengan imap_unordered()panggilan:

p = multiprocessing.Pool()
rs = p.imap_unordered(do_work, xrange(num_tasks))
p.close() # No more work
p.join() # Wait for completion

Namun, saya num_taskssekitar 250.000, jadi join()utas utama terkunci selama 10 detik atau lebih, dan saya ingin dapat menggema ke baris perintah secara bertahap untuk menunjukkan bahwa proses utama tidak terkunci. Sesuatu seperti:

p = multiprocessing.Pool()
rs = p.imap_unordered(do_work, xrange(num_tasks))
p.close() # No more work
while (True):
  remaining = rs.tasks_remaining() # How many of the map call haven't been done yet?
  if (remaining == 0): break # Jump out of while loop
  print "Waiting for", remaining, "tasks to complete..."
  time.sleep(2)

Apakah ada metode untuk objek hasil atau kumpulan itu sendiri yang menunjukkan jumlah tugas yang tersisa? Saya mencoba menggunakan multiprocessing.Valueobjek sebagai penghitung ( do_workmemanggil counter.value += 1tindakan setelah melakukan tugasnya), tetapi penghitung hanya mencapai ~ 85% dari total nilai sebelum berhenti menambah.

Tidak perlu mengakses atribut pribadi dari kumpulan hasil:

from __future__ import division
import sys

for i, _ in enumerate(p.imap_unordered(do_work, xrange(num_tasks)), 1):
    sys.stderr.write('\rdone {0:%}'.format(i/num_tasks))

Favorit pribadi saya - memberi Anda bilah kemajuan kecil yang bagus dan penyelesaian ETA sementara semuanya berjalan dan berjalan secara paralel.

from multiprocessing import Pool
import tqdm

pool = Pool(processes=8)
for _ in tqdm.tqdm(pool.imap_unordered(do_work, tasks), total=len(tasks)):
    pass

Saya menemukan bahwa pekerjaan tersebut sudah selesai pada saat saya mencoba untuk memeriksa kemajuannya. Inilah yang berhasil untuk saya menggunakan tqdm .

pip install tqdm

from multiprocessing import Pool
from tqdm import tqdm

tasks = range(5)
pool = Pool()
pbar = tqdm(total=len(tasks))

def do_work(x):
    # do something with x
    pbar.update(1)

pool.imap_unordered(do_work, tasks)
pool.close()
pool.join()
pbar.close()

Ini harus bekerja dengan semua rasa multiprosesing, apakah mereka memblokir atau tidak.

Menemukan jawaban sendiri dengan beberapa lebih menggali: Mengambil melihat pada __dict__satu imap_unorderedobjek hasil, saya menemukan ia memiliki _indexatribut yang bertahap dengan masing-masing penyelesaian tugas. Jadi ini berfungsi untuk logging, dibungkus dalam whileloop:

p = multiprocessing.Pool()
rs = p.imap_unordered(do_work, xrange(num_tasks))
p.close() # No more work
while (True):
  completed = rs._index
  if (completed == num_tasks): break
  print "Waiting for", num_tasks-completed, "tasks to complete..."
  time.sleep(2)

Namun, saya menemukan bahwa menukar imap_unordereduntuk map_asyncmenghasilkan eksekusi yang jauh lebih cepat, meskipun objek hasilnya sedikit berbeda. Sebagai gantinya, objek hasil dari map_asyncmemiliki _number_leftatribut, dan ready()metode:

p = multiprocessing.Pool()
rs = p.map_async(do_work, xrange(num_tasks))
p.close() # No more work
while (True):
  if (rs.ready()): break
  remaining = rs._number_left
  print "Waiting for", remaining, "tasks to complete..."
  time.sleep(0.5)

Saya tahu bahwa ini adalah pertanyaan yang agak lama, tetapi inilah yang saya lakukan ketika saya ingin melacak perkembangan kumpulan tugas dengan python.

from progressbar import ProgressBar, SimpleProgress
import multiprocessing as mp
from time import sleep

def my_function(letter):
    sleep(2)
    return letter+letter

dummy_args = ["A", "B", "C", "D"]
pool = mp.Pool(processes=2)

results = []

pbar = ProgressBar(widgets=[SimpleProgress()], maxval=len(dummy_args)).start()

r = [pool.apply_async(my_function, (x,), callback=results.append) for x in dummy_args]

while len(results) != len(dummy_args):
    pbar.update(len(results))
    sleep(0.5)
pbar.finish()

print results

Pada dasarnya, Anda menggunakan apply_async dengan callbak (dalam hal ini, ini untuk menambahkan nilai yang dikembalikan ke daftar), jadi Anda tidak perlu menunggu untuk melakukan sesuatu yang lain. Kemudian, dalam loop sementara, Anda memeriksa perkembangan pekerjaan. Dalam hal ini, saya menambahkan widget agar terlihat lebih bagus.

Hasil:

4 of 4                                                                         
['AA', 'BB', 'CC', 'DD']

Semoga membantu.

Seperti yang disarankan oleh Tim, Anda dapat menggunakan tqdmdan imapuntuk memecahkan masalah ini. Saya baru saja menemukan masalah ini dan mengubah imap_unorderedsolusinya, sehingga saya dapat mengakses hasil pemetaan. Begini cara kerjanya:

from multiprocessing import Pool
import tqdm

pool = multiprocessing.Pool(processes=4)
mapped_values = list(tqdm.tqdm(pool.imap_unordered(do_work, range(num_tasks)), total=len(values)))

Jika Anda tidak peduli dengan nilai yang dikembalikan dari pekerjaan Anda, Anda tidak perlu menetapkan daftar ke variabel apa pun.

untuk siapa saja yang mencari solusi sederhana yang bekerja dengan Pool.apply_async():

from multiprocessing import Pool
from tqdm import tqdm
from time import sleep


def work(x):
    sleep(0.5)
    return x**2

n = 10

p = Pool(4)
pbar = tqdm(total=n)
res = [p.apply_async(work, args=(
    i,), callback=lambda _: pbar.update(1)) for i in range(n)]
results = [p.get() for p in res]

Saya membuat kelas khusus untuk membuat cetakan kemajuan. Maby ini membantu:

from multiprocessing import Pool, cpu_count


class ParallelSim(object):
    def __init__(self, processes=cpu_count()):
        self.pool = Pool(processes=processes)
        self.total_processes = 0
        self.completed_processes = 0
        self.results = []

    def add(self, func, args):
        self.pool.apply_async(func=func, args=args, callback=self.complete)
        self.total_processes += 1

    def complete(self, result):
        self.results.extend(result)
        self.completed_processes += 1
        print('Progress: {:.2f}%'.format((self.completed_processes/self.total_processes)*100))

    def run(self):
        self.pool.close()
        self.pool.join()

    def get_results(self):
        return self.results

Coba pendekatan berbasis Antrean sederhana ini, yang juga dapat digunakan dengan penggabungan. Perhatikan bahwa mencetak apa pun setelah dimulainya bilah kemajuan akan menyebabkannya dipindahkan, setidaknya untuk bilah kemajuan khusus ini. (Kemajuan PyPI 1.5)

import time
from progress.bar import Bar

def status_bar( queue_stat, n_groups, n ):

    bar = Bar('progress', max = n)  

    finished = 0
    while finished < n_groups:

        while queue_stat.empty():
            time.sleep(0.01)

        gotten = queue_stat.get()
        if gotten == 'finished':
            finished += 1
        else:
            bar.next()
    bar.finish()


def process_data( queue_data, queue_stat, group):

    for i in group:

        ... do stuff resulting in new_data

        queue_stat.put(1)

    queue_stat.put('finished')  
    queue_data.put(new_data)

def multiprocess():

    new_data = []

    groups = [[1,2,3],[4,5,6],[7,8,9]]
    combined = sum(groups,[])

    queue_data = multiprocessing.Queue()
    queue_stat = multiprocessing.Queue()

    for i, group in enumerate(groups): 

        if i == 0:

            p = multiprocessing.Process(target = status_bar,
                args=(queue_stat,len(groups),len(combined)))
                processes.append(p)
                p.start()

        p = multiprocessing.Process(target = process_data,
        args=(queue_data, queue_stat, group))
        processes.append(p)
        p.start()

    for i in range(len(groups)):
        data = queue_data.get() 
        new_data += data

    for p in processes:
        p.join()