Matplotlib: एकाधिक धागे में एक साथ प्लॉटिंग

Question

मैं बड़ी बैच नौकरियों को जल्दी से समाप्त करने के समानांतर में कुछ साजिश करने की कोशिश कर रहा हूं। इस अंत में, मैं प्रत्येक प्लॉट के लिए एक थ्रेड शुरू करता हूं जिसे मैं बनाने की योजना बना रहा हूं।

मुझे उम्मीद थी कि प्रत्येक धागा अपनी साजिश समाप्त कर देगा और खुद को बंद कर देगा (जैसा कि मैं इसे समझता हूं, पाइथन रन() में सभी कथनों के माध्यम से धागे को बंद करता है)। नीचे कुछ कोड है जो इस व्यवहार को दिखाता है।

यदि कोई आंकड़ा उत्पन्न करने वाली रेखा पर टिप्पणी की जाती है, तो यह अपेक्षा के अनुसार चलता है। एक और व्यावहारिक रूप से उपयोगी टिड्बिट यह है कि यह केवल एक धागे को जन्म देने पर अपेक्षित रूप से चलता है।

import matplotlib.pyplot as plt 
import time 
import Queue 
import threading 

def TapHistplots(): 
    ## for item in ['str1']: 
# # it behaves as expected if the line above is used instead of the one below 
    for item in ['str1','str2']: 
     otheritem = 1 
     TapHistQueue.put((item, otheritem)) 
     makeTapHist().start() 

class makeTapHist(threading.Thread): 
    def run(self): 
     item, otheritem = TapHistQueue.get() 
     fig = FigureQueue.get() 
     FigureQueue.put(fig+1) 
     print item+':'+str(fig)+'\n', 
     time.sleep(1.3) 
     plt.figure(fig) # comment out this line and it behaves as expected 
     plt.close(fig) 

TapHistQueue = Queue.Queue(0) 
FigureQueue = Queue.Queue(0) 
def main(): 
    start = time.time() 
    """Code in here runs only when this module is run directly""" 
    FigureQueue.put(1) 
    TapHistplots() 
    while threading.activeCount()>1: 
     time.sleep(1) 
     print 'waiting on %d threads\n' % (threading.activeCount()-1), 
    print '%ds elapsed' % (time.time()-start) 

if __name__ == '__main__': 
    main() 

किसी भी मदद की सराहना की जाती है।

Answer 1

pylab इंटरफ़ेस के लिए Asynchronous plotting with threads समाधान है।

pylab के बिना प्रत्येक matplotlib के बैकएंड (क्यूटी, जीटीके, डब्ल्यूएक्स, टीके) के लिए अलग-अलग समाधान हो सकते हैं। समस्या यह है कि प्रत्येक जीयूआई टूलकिट में प्रत्येक का जीयूआई मेनलोप होता है। आप देख सकते हैं कि ipython इसके साथ कैसे व्यवहार करता है।

Answer 2

क्यों मल्टीप्रोसेसिंग का उपयोग नहीं करते? जहां तक ​​मैं आपके विवरण से बता सकता हूं, थ्रेडिंग आपको बहुत मदद नहीं करेगा, वैसे भी ...

Matplotlib पहले से ही धागे ताकि आप एक साथ कई आंकड़ों को प्रदर्शित और बातचीत कर सकें। यदि आप एक मल्टीकोर मशीन पर बैच प्रोसेसिंग को तेज करना चाहते हैं, तो आपको बिना किसी मल्टीप्रोसेसिंग की आवश्यकता होगी।

एक बुनियादी उदाहरण के रूप में: आप वास्तव में नहीं कहा है क्या गलत हो जाता है, हालांकि यह की तरह लगता है (चेतावनी इस में 20 छोटे .png फ़ाइलें जो कुछ निर्देशिका आप में इसे चलाने पैदा करेगा!)

import multiprocessing 
import matplotlib.pyplot as plt 
import numpy as np 

def main(): 
    pool = multiprocessing.Pool() 
    num_figs = 20 
    input = zip(np.random.randint(10,1000,num_figs), 
       range(num_figs)) 
    pool.map(plot, input) 

def plot(args): 
    num, i = args 
    fig = plt.figure() 
    data = np.random.randn(num).cumsum() 
    plt.plot(data) 
    plt.title('Plot of a %i-element brownian noise sequence' % num) 
    fig.savefig('temp_fig_%02i.png' % i) 

main()