web-dev-qa-db-fra.com

Comment lire des données dans des lots TensorFlow à partir d'un exemple de file d'attente?

Comment obtenir des exemples de files d'attente TensorFlow en lots appropriés pour la formation?

J'ai quelques images et étiquettes:

IMG_6642.JPG 1
IMG_6643.JPG 2

(n'hésitez pas à suggérer un autre format d'étiquette; je pense que j'ai peut-être besoin d'une autre étape dense à clairsemée ...)

J'ai lu pas mal de tutoriels mais je ne les ai pas encore tous ensemble. Voici ce que j'ai, avec des commentaires indiquant les étapes requises de la page Reading Data de TensorFlow.

  1. La liste des noms de fichiers (étapes facultatives supprimées par souci de simplicité)
  2. File d'attente de nom de fichier
  3. Un lecteur pour le format de fichier
  4. Un décodeur pour un enregistrement lu par le lecteur
  5. Exemple de file d'attente

Et après l'exemple de file d'attente, j'ai besoin de mettre cette file d'attente en lots pour la formation; c'est là que je suis coincé ...

1. Liste des noms de fichiers

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

4. File d'attente de nom de fichier

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

5. Un lecteur

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

6. Un décodeur

record_defaults = [[""], [1]] col1, col2 = tf.decode_csv(value, record_defaults=record_defaults) (je ne pense pas avoir besoin de cette étape ci-dessous car j'ai déjà mon étiquette dans un tenseur mais je l'inclus quand même)

features = tf.pack([col2])

La page de documentation a un exemple pour exécuter une image, pas pour obtenir les images et les étiquettes en lots:

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

Et puis en dessous, il a une section de traitement par lots:

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

Ma question est: comment utiliser l'exemple de code ci-dessus avec le code que j'ai ci-dessus? J'ai besoin de lots pour travailler avec, et la plupart des tutoriels sont déjà livrés avec des lots 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)
pythonnumpyclassificationtensorflow
18
JohnAllen

Si vous souhaitez faire fonctionner ce pipeline d'entrée, vous devrez ajouter un mécanisme de file d'attente asynchrone qui génère des lots d'exemples. Pour cela, créez un tf.RandomShuffleQueue ou un tf.FIFOQueue et en insérant des images JPEG lues, décodées et prétraitées.

Vous pouvez utiliser des constructions pratiques qui généreront les files d'attente et les threads correspondants pour exécuter les files d'attente via tf.train.shuffle_batch_join ou tf.train.batch_join. Voici un exemple simplifié de ce que cela voudrait. Notez que ce code n'est pas testé:

# 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)

Selon la façon dont vous devez faire évoluer votre travail, vous devrez peut-être exécuter plusieurs threads indépendants qui lisent/décodent/prétraitent les images et les vident dans votre file d'attente d'exemple. Un exemple complet d'un tel pipeline est fourni dans le modèle Inception/ImageNet. Jeter un coup d'œil à batch_inputs:

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

Enfin, si vous travaillez avec des images JPEG> O (1000), gardez à l'esprit qu'il est extrêmement inefficace de préparer individuellement des milliers de petits fichiers. Cela ralentira un peu votre entraînement.

Une solution plus robuste et plus rapide pour convertir un ensemble de données d'images en TFRecord de Example protos fragmentés. Voici un script entièrement travaillé pour convertir l'ensemble de données ImageNet dans un tel format. Et voici un ensemble de instructions pour exécuter une version générique de ce script de prétraitement sur un répertoire arbitraire contenant des images JPEG.

14
user5869947