थ्रेडिंग tensorflow के इनपुट पाइप लाइन में

Question

पृष्ठभूमि

tensorflow में ठेठ इनपुट पाइप लाइन इस प्रकार की तरह दिखता है:

    tf.train.string_input_producer(list_of_filenames) 
         (creates queue of filenames) 
            | 
            \|/ 
      fixed length reader reads records from the files 
            | 
            \|/ 
    Read records are decoded and processed(eg if dealing with images then cropping,flipping etc) 
            | 
            \|/ 
      tf.train.shuffle_batch(tensors,num_threads) 
     (creates a shuffling queue and returns batches of tensors) 

समस्या

क्यू 1) वहाँ समारोह tf में NUM_THREADS का कोई तर्क है .train.string_input_producer()। क्या इसका मतलब यह है कि केवल एक धागा फ़ाइल नाम कतार से फ़ाइल नाम पढ़ने के लिए समर्पित है?

प्रश्न 2) tf.train.shuffle_batch() यानी फ़ंक्शन के num_threads तर्क का दायरा क्या है, यानी यहां वर्णित धागे की संख्या का उपयोग फ़ाइलों को पढ़ने, डीकोड करने और संसाधित करने के लिए भी किया जाता है या वे बैच बनाने के लिए उपयोग किए जाते हैं टेंसर के?

क्यू 3) क्या प्रिंट करने का कोई तरीका है कि कौन सा थ्रेड किसी विशेष फ़ाइल से फ़ाइल नाम या रिकॉर्ड पढ़ता है यानी प्रत्येक धागे द्वारा किए गए कार्यों का रिकॉर्ड?

Answer 1

आपके सभी डेटा लोडिंग ऑपरेशंस tensorflow ग्राफ के भीतर किए जाते हैं, आप जो करना चाहते हैं वह पाठक/एनक्यूयू ऑपरेशंस पर फिर से शुरू करने के लिए एक या अधिक धागे लॉन्च करना है। Tensorflow एक QueueRunner कक्षा प्रदान करता है जो वास्तव में करता है। समन्वयक वर्ग आपको धागे को बहुत ही कम प्रबंधित करने की अनुमति देता है।

https://www.tensorflow.org/programmers_guide/threading_and_queues

यह ऊपर के लिंक से उदाहरण कोड है:

# Create a queue runner that will run 4 threads in parallel to enqueue 
# examples. 
qr = tf.train.QueueRunner(queue, [enqueue_op] * 4) 

# Launch the graph. 
sess = tf.Session() 
# Create a coordinator, launch the queue runner threads. 
coord = tf.train.Coordinator() 
enqueue_threads = qr.create_threads(sess, coord=coord, start=True) 
# Run the training loop, controlling termination with the coordinator. 
for step in xrange(1000000): 
    if coord.should_stop(): 
     break 
    sess.run(train_op) 
# When done, ask the threads to stop. 
coord.request_stop() 
# And wait for them to actually do it. 
coord.join(enqueue_threads) 

यदि आप लोड हो रहा है कर रहे थे/ग्राफ के बाहर नमूने preprocessing (अपने खुद के कोड में, TF संचालन का उपयोग नहीं), तो आप QueueRunner का उपयोग नहीं करेंगे, इसके बजाय आप एक लूप में sess.run(enqueue_op, feed_dict={...}) कमांड का उपयोग करके डेटा को एनक्यू करने के लिए अपनी कक्षा का उपयोग करेंगे।

Q1: qr.create_threads(sess, coord=coord, start=True)

Q2:: थ्रेड की संख्या के साथ नियंत्रित किया जाता है TF सत्र धागा सुरक्षित हैं, tf.run(...) की प्रत्येक कॉल की, जब यह शुरू के रूप में वर्तमान चर का एक सुसंगत स्नैपशॉट देखता है। आपके QueueRunner enqueue ops किसी भी संख्या में धागे चला सकते हैं। वे थ्रेड-सुरक्षित तरीके से कतारबद्ध होंगे।

Q3: मैं अपने आप को tf.train.string_input_producer उपयोग नहीं किया है, लेकिन मुझे लगता है कि आप ग्राफ में बाद में एक टेन्सर अनुरोध करने के लिए कि dequeued डेटा, सिर्फ इतना है कि टेन्सर अनुरोधों की अपनी सूची में sess.run([train_op, dequeue_op])