python - tensores - tensorflow documentacion

¿Cómo leer datos en lotes TensorFlow de la cola de ejemplo?

Question

¿Cómo obtengo colas de ejemplo de TensorFlow en lotes adecuados para la capacitación?

Tengo algunas imágenes y etiquetas:

IMG_6642.JPG 1
IMG_6643.JPG 2

(No dude en sugerir otro formato de etiqueta; creo que puedo necesitar otro paso denso a escaso ...)

He leído algunos tutoriales pero todavía no los tengo todos juntos. Esto es lo que tengo, con comentarios que indican los pasos requeridos desde la página de datos de lectura de TensorFlow.

1. La lista de nombres de archivos (pasos opcionales eliminados por simplicidad)
2. Cola de nombre de archivo
3. Un lector para el formato de archivo.
4. Un decodificador para un registro leído por el lector.
5. Ejemplo de cola

Y después de la cola de ejemplo, necesito hacer esta cola en lotes para entrenamiento; ahí es donde estoy atrapado ...

1. Lista de nombres de archivos

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

4. Cola de nombre de archivo

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

5. un lector

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

6. un decodificador

record_defaults = [[""], [1]] col1, col2 = tf.decode_csv(value, record_defaults=record_defaults) (No creo que necesite este paso a continuación porque ya tengo mi etiqueta en un tensor pero la record_defaults = [[""], [1]] col1, col2 = tf.decode_csv(value, record_defaults=record_defaults) de todos modos)

features = tf.pack([col2])

La página de documentación tiene un ejemplo para ejecutar una imagen, no obtener las imágenes y las etiquetas en lotes:

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

Y luego a continuación tiene una sección de lotes:

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

Mi pregunta es: ¿cómo uso el código de ejemplo anterior con el código que tengo arriba? Necesito lotes para trabajar, y la mayoría de los tutoriales ya vienen con lotes 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

Si desea que este flujo de entrada funcione, deberá agregar un mecanismo de cola asíncrono que genere lotes de ejemplos. Esto se realiza creando un tf.RandomShuffleQueue o un tf.FIFOQueue e insertando imágenes JPEG que han sido leídas, decodificadas y preprocesadas.

Puede usar construcciones prácticas que generarán las colas y los hilos correspondientes para ejecutar las colas a través de tf.train.shuffle_batch_join o tf.train.batch_join . Aquí hay un ejemplo simplificado de lo que esto le gustaría. Tenga en cuenta que este código no está probado:

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

Dependiendo de cómo necesite escalar su trabajo, es posible que deba ejecutar varios subprocesos independientes que leen / descodifican / preprocesan las imágenes y las vuelcan en la cola de ejemplo. Un ejemplo completo de tal canalización se proporciona en el modelo Inception / ImageNet. Echa un vistazo a batch_inputs :

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

Finalmente, si está trabajando con imágenes JPEG> O (1000), tenga en cuenta que es extremadamente ineficiente para miles de archivos pequeños preparados individualmente. Esto ralentizará tu entrenamiento un poco.

Una solución más robusta y más rápida para convertir un conjunto de datos de imágenes en un TFRecord de TFRecord de Example TFRecord . Aquí hay una script de script completamente trabajada para convertir el conjunto de datos de ImageNet a tal formato. Y aquí hay un conjunto de instructions para ejecutar una versión genérica de este script de preprocesamiento en un directorio arbitrario que contiene imágenes JPEG.