टेंसर फ्लो में फ़ाइल कतार से फ़ाइल नाम तक पहुंच

Question

मेरे पास छवियों की एक निर्देशिका है, और लेबल के लिए एक अलग फ़ाइल मिलान छवि फ़ाइल नाम हैं।

train/001.jpg 1 
train/002.jpg 2 
... 

मैं आसानी से फ़ाइल नाम से एक filequeue बनाकर टेन्सर फ्लो में छवि निर्देशिका से छवियों को लोड कर सकते हैं:: तो छवियों की निर्देशिका की तरह 'ट्रेन/001.jpg' और जैसे लेबलिंग फ़ाइल लग रहा है फ़ाइलें है

filequeue = tf.train.string_input_producer(filenames) 
reader = tf.WholeFileReader() 
img = reader.read(filequeue) 

लेकिन मुझे इन फ़ाइलों को लेबलिंग फ़ाइल से लेबल के साथ जोड़ने के लिए नुकसान हुआ है। ऐसा लगता है कि मुझे प्रत्येक चरण में कतार के अंदर फ़ाइल नामों तक पहुंच की आवश्यकता है। क्या उन्हें पाने का कोई तरीका है? इसके अलावा, मेरे पास फ़ाइल नाम होने के बाद, मुझे फ़ाइल नाम से लेबल किए गए लेबल को देखने में सक्षम होना चाहिए। ऐसा लगता है कि एक मानक पायथन शब्दकोश काम नहीं करेगा क्योंकि ग्राफ में प्रत्येक चरण में इन गणनाओं को होने की आवश्यकता है।

Answer 1

यह देखते हुए कि आपके डेटा एक पायथन सरणी के रूप में फ़ाइल नामों की सूची प्रदान करने के लिए बहुत बड़ा नहीं है, मैं सुझाव देता हूं कि केवल पायथन में प्रीप्रोकैसिंग करना। फ़ाइल नामों और लेबलों की दो सूचियों (एक ही क्रम) बनाएं, और उनको एक यादृच्छिक शफलक्यू या कतार में डालें, और उस से हटा दें। यदि आप string_input_producer के "लूप असीमित" व्यवहार चाहते हैं, तो आप प्रत्येक युग की शुरुआत में 'enqueue' को फिर से चला सकते हैं।

एक बहुत ही खिलौना उदाहरण:

import tensorflow as tf 

f = ["f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8"] 
l = ["l1", "l2", "l3", "l4", "l5", "l6", "l7", "l8"] 

fv = tf.constant(f) 
lv = tf.constant(l) 

rsq = tf.RandomShuffleQueue(10, 0, [tf.string, tf.string], shapes=[[],[]]) 
do_enqueues = rsq.enqueue_many([fv, lv]) 

gotf, gotl = rsq.dequeue() 

with tf.Session() as sess: 
    sess.run(tf.initialize_all_variables()) 
    tf.train.start_queue_runners(sess=sess) 
    sess.run(do_enqueues) 
    for i in xrange(2): 
     one_f, one_l = sess.run([gotf, gotl]) 
     print "F: ", one_f, "L: ", one_l 

महत्वपूर्ण यह है कि आप प्रभावी रूप से फ़ाइल नाम/लेबल के जोड़े enqueueing रहे हैं जब आप enqueue करते हैं, और उन जोड़े dequeue द्वारा दिया जाता है।

Answer 2

यहां मैं क्या करने में सक्षम था। तब

lv = tf.constant(labels) 
label_fifo = tf.FIFOQueue(len(filenames),tf.int32, shapes=[[]]) 
file_fifo = tf.train.string_input_producer(filenames, shuffle=False, capacity=len(filenames)) 
label_enqueue = label_fifo.enqueue_many([lv]) 

:

मैं पहली बार फ़ाइल नामों को बदल दिया और अजगर में उनमें लेबल मिलान नहीं हुआ:

np.random.shuffle(filenames) 
labels = [label_dict[f] for f in filenames] 

फिर बंद शफ़ल साथ फ़ाइल नामों के लिए एक string_input_producer बनाया है, और लेबल के लिए एक फीफो छवि को पढ़ने के लिए मैं एक होलफाइल रीडर का उपयोग कर सकता हूं और लेबल प्राप्त करने के लिए मैं फीफो को हटा सकता हूं:

reader = tf.WholeFileReader() 
image = tf.image.decode_jpeg(value, channels=3) 
image.set_shape([128,128,3]) 
result.uint8image = image 
result.label = label_fifo.dequeue() 

और इस प्रकार बैचों उत्पन्न:

min_fraction_of_examples_in_queue = 0.4 
min_queue_examples = int(num_examples_per_epoch * 
         min_fraction_of_examples_in_queue) 
num_preprocess_threads = 16 
images, label_batch = tf.train.shuffle_batch(
    [result.uint8image, result.label], 
    batch_size=FLAGS.batch_size, 
    num_threads=num_preprocess_threads, 
    capacity=min_queue_examples + 3 * FLAGS.batch_size, 
    min_after_dequeue=min_queue_examples) 

Answer 3

है tf.py_func() आप लेबल करना फ़ाइल पथ से एक मानचित्रण लागू करने के लिए उपयोग कर सकता है।

files = gfile.Glob(data_pattern) 
filename_queue = tf.train.string_input_producer(
files, num_epochs=num_epochs, shuffle=True) # list of files to read 

def extract_label(s): 
    # path to label logic for cat&dog dataset 
    return 0 if os.path.basename(str(s)).startswith('cat') else 1 

def read(filename_queue): 
    key, value = reader.read(filename_queue) 
    image = tf.image.decode_jpeg(value, channels=3) 
    image = tf.cast(image, tf.float32) 
    image = tf.image.resize_image_with_crop_or_pad(image, width, height) 
    label = tf.cast(tf.py_func(extract_label, [key], tf.int64), tf.int32) 
    label = tf.reshape(label, []) 

training_data = [read(filename_queue) for _ in range(num_readers)] 

... 

tf.train.shuffle_batch_join(training_data, ...) 

Answer 4

मैं इस्तेमाल किया यह:

filename = filename.strip().decode('ascii') 

Answer 5

एक और सुझाव TFRecord प्रारूप में अपने डेटा को बचाने के लिए है। इस मामले में आप एक ही फाइल में सभी छवियों और सभी लेबलों को सहेजने में सक्षम होंगे।फ़ाइलों की एक बड़ी संख्या के लिए यह फायदे का एक बहुत देता है:

• एक ही जगह
• डेटा एक ही स्थान पर (विभिन्न निर्देशिका याद करने की कोई जरूरत)
• अगर पर आवंटित किया जाता है पर डेटा और लेबल स्टोर कर सकते हैं वहाँ कई फाइलें (छवियां) हैं, फाइल खोलना/बंद करना समय लेने वाला है। एसएसडी/एचडीडी से फ़ाइल के स्थान की तलाश में समय लगता है