Çoklu işlem: bir ilerleme çubuğu görüntülemek için tqdm kullanın

Kodumu daha "pitonik" ve daha hızlı yapmak için, "çoklu işlem" ve ona a) işlevi ve b) yineleme aralığını göndermek için bir harita işlevi kullanıyorum.

İmplante çözüm (yani, tqdm.tqdm aralığında doğrudan tqdm çağrısı yapın (aralık (0, 30)) çoklu işlemle çalışmaz (aşağıdaki kodda formüle edildiği gibi).

İlerleme çubuğu% 0 ile% 100 arasında görüntülenir (python kodu okuduğunda?) Ancak harita işlevinin gerçek ilerlemesini göstermez.

'Harita' işlevinin hangi adımda olduğunu gösteren bir ilerleme çubuğu nasıl görüntülenir?

from multiprocessing import Pool
import tqdm
import time

def _foo(my_number):
   square = my_number * my_number
   time.sleep(1)
   return square 

if __name__ == '__main__':
   p = Pool(2)
   r = p.map(_foo, tqdm.tqdm(range(0, 30)))
   p.close()
   p.join()

Herhangi bir yardım veya öneriye açığız ...

İşlenmiş değerlerin bir yineleyicisini döndüren harita yerine imap kullanın.

from multiprocessing import Pool
import tqdm
import time

def _foo(my_number):
   square = my_number * my_number
   time.sleep(1)
   return square 

if __name__ == '__main__':
   with Pool(2) as p:
      r = list(tqdm.tqdm(p.imap(_foo, range(30)), total=30))

Çözüm Bulundu: Dikkatli olun! Çoklu işlem nedeniyle, tahmin süresi (döngü başına yineleme, toplam süre, vb.) Kararsız olabilir, ancak ilerleme çubuğu mükemmel şekilde çalışır.

Not: Havuz için bağlam yöneticisi yalnızca Python sürüm 3.3'te mevcuttur.

from multiprocessing import Pool
import time
from tqdm import *

def _foo(my_number):
   square = my_number * my_number
   time.sleep(1)
   return square 

if __name__ == '__main__':
    with Pool(processes=2) as p:
        max_ = 30
        with tqdm(total=max_) as pbar:
            for i, _ in enumerate(p.imap_unordered(_foo, range(0, max_))):
                pbar.update()

Geç kaldığım için üzgünüm ama tek ihtiyacınız olan eşzamanlı bir harita ise, bu işlevi şuraya ekledim tqdm>=4.42.0:

from tqdm.contrib.concurrent import process_map  # or thread_map
import time

def _foo(my_number):
   square = my_number * my_number
   time.sleep(1)
   return square 

if __name__ == '__main__':
   r = process_map(_foo, range(0, 30), max_workers=2)

Referanslar: https://tqdm.github.io/docs/contrib.concurrent/ ve https://github.com/tqdm/tqdm/blob/master/examples/parallel_bars.py

Bu destekler max_workersve chunksizede kolayca geçiş yapabilirsiniz process_mapiçin thread_map.

Bunun p_tqdmyerine kullanabilirsiniz .

https://github.com/swansonk14/p_tqdm

from p_tqdm import p_map
import time

def _foo(my_number):
   square = my_number * my_number
   time.sleep(1)
   return square 

if __name__ == '__main__':
   r = p_map(_foo, list(range(0, 30)))

Xavi Martínez'in cevabına dayanarak fonksiyonu yazdım imap_unordered_bar. imap_unorderedBir işleme çubuğunun gösterildiği tek farkla aynı şekilde kullanılabilir .

from multiprocessing import Pool
import time
from tqdm import *

def imap_unordered_bar(func, args, n_processes = 2):
    p = Pool(n_processes)
    res_list = []
    with tqdm(total = len(args)) as pbar:
        for i, res in tqdm(enumerate(p.imap_unordered(func, args))):
            pbar.update()
            res_list.append(res)
    pbar.close()
    p.close()
    p.join()
    return res_list

def _foo(my_number):
    square = my_number * my_number
    time.sleep(1)
    return square 

if __name__ == '__main__':
    result = imap_unordered_bar(_foo, range(5))

Paralel çalıştırma işlevlerinizden sonuçları geri almanız gerektiğinde burada benim alacağım. Bu işlev birkaç şey yapar (bunu daha ayrıntılı açıklayan başka bir gönderi var) ancak kilit nokta bekleyen bir görev ve tamamlanmış bir görev sırası olmasıdır. Çalışanlar bekleme sırasındaki her görevle işlerini bitirirken, sonuçları tamamlanan görevler kuyruğuna eklerler. Tqdm ilerleme çubuğu ile denetimi tamamlanan görevler kuyruğuna kaydırabilirsiniz. Buraya do_work () işlevinin uygulamasını koymuyorum, bununla ilgili değil, çünkü buradaki mesaj tamamlanan görevleri sıraya koymak ve her sonuç geldiğinde ilerleme çubuğunu güncellemek.

def par_proc(job_list, num_cpus=None, verbose=False):

# Get the number of cores
if not num_cpus:
    num_cpus = psutil.cpu_count(logical=False)

print('* Parallel processing')
print('* Running on {} cores'.format(num_cpus))

# Set-up the queues for sending and receiving data to/from the workers
tasks_pending = mp.Queue()
tasks_completed = mp.Queue()

# Gather processes and results here
processes = []
results = []

# Count tasks
num_tasks = 0

# Add the tasks to the queue
for job in job_list:
    for task in job['tasks']:
        expanded_job = {}
        num_tasks = num_tasks + 1
        expanded_job.update({'func': pickle.dumps(job['func'])})
        expanded_job.update({'task': task})
        tasks_pending.put(expanded_job)

# Set the number of workers here
num_workers = min(num_cpus, num_tasks)

# We need as many sentinels as there are worker processes so that ALL processes exit when there is no more
# work left to be done.
for c in range(num_workers):
    tasks_pending.put(SENTINEL)

print('* Number of tasks: {}'.format(num_tasks))

# Set-up and start the workers
for c in range(num_workers):
    p = mp.Process(target=do_work, args=(tasks_pending, tasks_completed, verbose))
    p.name = 'worker' + str(c)
    processes.append(p)
    p.start()

# Gather the results
completed_tasks_counter = 0

with tqdm(total=num_tasks) as bar:
    while completed_tasks_counter < num_tasks:
        results.append(tasks_completed.get())
        completed_tasks_counter = completed_tasks_counter + 1
        bar.update(completed_tasks_counter)

for p in processes:
    p.join()

return results

import multiprocessing as mp
import tqdm


some_iterable = ...

def some_func():
    # your logic
    ...


if __name__ == '__main__':
    with mp.Pool(mp.cpu_count()-2) as p:
        list(tqdm.tqdm(p.imap(some_func, iterable), total=len(iterable)))

Bu yaklaşım basit ve işe yarıyor.

from multiprocessing.pool import ThreadPool
import time
from tqdm import tqdm

def job():
    time.sleep(1)
    pbar.update()

pool = ThreadPool(5)
with tqdm(total=100) as pbar:
    for i in range(100):
        pool.apply_async(job)
    pool.close()
    pool.join()