Come leggere i dati nei batch TensorFlow dalla coda di esempio?

Question

Come si ottengono le code di esempio di TensorFlow in lotti appropriati per l'allenamento?

Ho alcune immagini ed etichette:

IMG_6642.JPG 1 
IMG_6643.JPG 2 

(sentitevi liberi di suggerire un altro formato di etichetta; credo di bisogno di un'altra fitta al passo rada ...)

ho leggere un bel po 'di tutorial, ma non ancora abbastanza insieme. Ecco cosa ho, con commenti che indicano i passaggi richiesti dalla pagina Reading Data di TensorFlow.

1. L'elenco dei nomi dei file (passaggi facoltativi rimosse per semplicità)
2. coda Nome file
3. A Reader per il formato di file
4. un decoder per un record letto dal lettore
5. Esempio di coda

E dopo la coda di esempio ho bisogno di ottenere questa coda in lotti per l'allenamento; è lì che mi sono bloccato ...

1. Elenco di nomi di file

files = tf.train.match_filenames_once('*.JPG')

4. coda Nome file

filename_queue = tf.train.string_input_producer(files, num_epochs=None, shuffle=True, seed=None, shared_name=None, name=None)

5. Un lettore

reader = tf.TextLineReader() key, value = reader.read(filename_queue)

6. Un decoder

record_defaults = [[""], [1]] col1, col2 = tf.decode_csv(value, record_defaults=record_defaults) (non credo che ho bisogno di questo gradino sotto perché ho già la mia etichetta in un tensore ma io includo comunque)

features = tf.pack([col2])

La pagina di documentazione ha un esempio per eseguire un'immagine, non ottenere le immagini e le etichette in lotti:

for i in range(1200): # Retrieve a single instance: example, label = sess.run([features, col5])

E poi sotto di esso ha una sezione di calcestruzzo:

def read_my_file_format(filename_queue): 
    reader = tf.SomeReader() 
    key, record_string = reader.read(filename_queue) 
    example, label = tf.some_decoder(record_string) 
    processed_example = some_processing(example) 
    return processed_example, label 

def input_pipeline(filenames, batch_size, num_epochs=None): 
    filename_queue = tf.train.string_input_producer(
    filenames, num_epochs=num_epochs, shuffle=True) 
    example, label = read_my_file_format(filename_queue) 
    # min_after_dequeue defines how big a buffer we will randomly sample 
    # from -- bigger means better shuffling but slower start up and more 
    # memory used. 
    # capacity must be larger than min_after_dequeue and the amount larger 
    # determines the maximum we will prefetch. Recommendation: 
    # min_after_dequeue + (num_threads + a small safety margin) *    batch_size 
    min_after_dequeue = 10000 
    capacity = min_after_dequeue + 3 * batch_size 
    example_batch, label_batch = tf.train.shuffle_batch(
    [example, label], batch_size=batch_size, capacity=capacity, 
    min_after_dequeue=min_after_dequeue) 
    return example_batch, label_batch 

La mia domanda è: come si usa il codice di esempio di cui sopra con il codice che ho sopra? Ho bisogno di lotti con cui lavorare e la maggior parte delle esercitazioni viene già fornita con i gruppi mnist.

with tf.Session() as sess: 
    sess.run(init) 

    # Training cycle 
for epoch in range(training_epochs): 
    total_batch = int(mnist.train.num_examples/batch_size) 
    # Loop over all batches 
    for i in range(total_batch): 
     batch_xs, batch_ys = mnist.train.next_batch(batch_size) 

Answer 1

Se si desidera fare questo lavoro l'immissione in pipeline, è necessario aggiungere un meccanismo di queue'ing asincrono che generano lotti di esempi. Questo viene eseguito creando un tf.RandomShuffleQueue o un tf.FIFOQueue e inserendo immagini JPEG che sono state lette, decodificate e preelaborate.

È possibile utilizzare utili costrutti che generano le code e i thread corrispondenti per l'esecuzione delle code tramite tf.train.shuffle_batch_join o tf.train.batch_join. Ecco un esempio semplificato di ciò che questo vorrebbe. Si noti che questo codice non è testato:

# Let's assume there is a Queue that maintains a list of all filenames 
# called 'filename_queue' 
_, file_buffer = reader.read(filename_queue) 

# Decode the JPEG images 
images = [] 
image = decode_jpeg(file_buffer) 

# Generate batches of images of this size. 
batch_size = 32 

# Depends on the number of files and the training speed. 
min_queue_examples = batch_size * 100 
images_batch = tf.train.shuffle_batch_join(
    image, 
    batch_size=batch_size, 
    capacity=min_queue_examples + 3 * batch_size, 
    min_after_dequeue=min_queue_examples) 

# Run your network on this batch of images. 
predictions = my_inference(images_batch) 

A seconda di come è necessario scalare il vostro lavoro, potrebbe essere necessario eseguire più thread indipendenti che leggono/decodifica/immagini pre-elaborazione e metterli in coda esempio. Un esempio completo di tale pipeline è fornito nel modello Inception/ImageNet. Date un'occhiata a batch_inputs:

https://github.com/tensorflow/models/blob/master/inception/inception/image_processing.py#L407

Infine, se si lavora con immagini JPEG> O (1000), di tenere presente che è estremamente inefficiente pronto individualmente 1000 di file di piccole dimensioni. Questo rallenterà un po 'il tuo allenamento.

Una soluzione più robusta e più veloce per convertire un set di dati di immagini in uno TFRecord sharked di Example protos. Qui è completamente funzionante script per convertire il set di dati ImageNet in tale formato. Ed ecco un set di instructions per eseguire una versione generica di questo script di pre-elaborazione su una directory arbitraria contenente immagini JPEG.