แสดงความคืบหน้าของพูลการประมวลผลหลายตัวของ Python imap_unordered call?

ฉันมีสคริปต์ที่ประสบความสำเร็จในการทำชุดงานพูลหลายกระบวนการด้วยการimap_unordered()โทร:

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

อย่างไรก็ตามของฉันnum_tasksอยู่ที่ประมาณ 250,000 ดังนั้นการjoin()ล็อกเธรดหลักเป็นเวลา 10 วินาทีหรือมากกว่านั้นและฉันต้องการที่จะสามารถสะท้อนออกไปยังบรรทัดคำสั่งทีละน้อยเพื่อแสดงว่ากระบวนการหลักไม่ได้ถูกล็อค สิ่งที่ต้องการ:

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)

มีวิธีการสำหรับอ็อบเจ็กต์ผลลัพธ์หรือพูลที่ระบุจำนวนงานที่เหลืออยู่หรือไม่? ฉันลองใช้multiprocessing.Valueออบเจ็กต์เป็นตัวนับ ( do_workเรียกการcounter.value += 1ดำเนินการหลังจากทำงานเสร็จแล้ว) แต่ตัวนับจะได้รับถึง ~ 85% ของมูลค่าทั้งหมดเท่านั้นก่อนที่จะหยุดการเพิ่มขึ้น

ไม่จำเป็นต้องเข้าถึงแอตทริบิวต์ส่วนตัวของชุดผลลัพธ์:

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))

รายการโปรดส่วนตัวของฉัน - ช่วยให้คุณมีแถบความคืบหน้าเล็ก ๆ น้อย ๆ และ ETA ให้เสร็จสมบูรณ์ในขณะที่สิ่งต่างๆดำเนินไปและดำเนินการควบคู่

from multiprocessing import Pool
import tqdm

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

ฉันพบว่างานเสร็จเรียบร้อยแล้วเมื่อฉันพยายามตรวจสอบความคืบหน้า นี่คือสิ่งที่ทำงานให้ฉันใช้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()

สิ่งนี้ควรใช้ได้กับทุกรสชาติของการประมวลผลหลายขั้นตอนไม่ว่าจะบล็อกหรือไม่ก็ตาม

พบคำตอบที่ตัวเองด้วยบางขุดขึ้น: Taking ดูที่__dict__ของimap_unorderedวัตถุผลผมพบว่ามันมี_indexแอตทริบิวต์ที่เพิ่มขึ้นกับแต่ละงานเสร็จสิ้น สิ่งนี้ใช้ได้กับการบันทึกโดยรวมอยู่ในwhileวง:

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)

อย่างไรก็ตามฉันพบว่าการแลกเปลี่ยนimap_unorderedfor a map_asyncทำให้การดำเนินการเร็วขึ้นมากแม้ว่าวัตถุผลลัพธ์จะแตกต่างกันเล็กน้อย แต่วัตถุผลลัพธ์จากmap_asyncมี_number_leftแอตทริบิวต์และready()วิธีการ:

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)

ฉันรู้ว่านี่เป็นคำถามที่ค่อนข้างเก่า แต่นี่คือสิ่งที่ฉันกำลังทำเมื่อต้องการติดตามความคืบหน้าของกลุ่มงานใน 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

โดยทั่วไปคุณใช้ apply_async กับ callbak (ในกรณีนี้คือการต่อท้ายค่าที่ส่งคืนไปยังรายการ) ดังนั้นคุณจึงไม่ต้องรอทำอย่างอื่น จากนั้นคุณตรวจสอบความคืบหน้าของงานภายในระยะเวลาหนึ่ง ในกรณีนี้ฉันเพิ่มวิดเจ็ตเพื่อให้ดูดีขึ้น

ผลลัพธ์:

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

หวังว่าจะช่วยได้

ตามที่ Tim แนะนำคุณสามารถใช้tqdmและimapเพื่อแก้ปัญหานี้ได้ ฉันเพิ่งสะดุดกับปัญหานี้และปรับimap_unorderedวิธีแก้ปัญหาเพื่อให้ฉันสามารถเข้าถึงผลลัพธ์ของการทำแผนที่ได้ นี่คือวิธีการทำงาน:

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)))

ในกรณีที่คุณไม่สนใจค่าที่ส่งคืนจากงานของคุณคุณไม่จำเป็นต้องกำหนดรายการให้กับตัวแปรใด ๆ

สำหรับใครก็ตามที่กำลังมองหาวิธีง่ายๆในการทำงานกับ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]

ฉันสร้างคลาสแบบกำหนดเองเพื่อสร้างงานพิมพ์ความคืบหน้า Maby สิ่งนี้ช่วย:

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

ลองใช้วิธีง่ายๆตามคิวซึ่งสามารถใช้กับการรวมกลุ่มได้ โปรดทราบว่าการพิมพ์สิ่งใด ๆ หลังจากเริ่มต้นแถบความคืบหน้าจะทำให้มีการเคลื่อนย้ายอย่างน้อยก็สำหรับแถบความคืบหน้านี้ (ความคืบหน้าของ 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()