tensorflow
Leyendo los datos

Contar ejemplos en archivo CSV

import tensorflow as tf
filename_queue = tf.train.string_input_producer(["file.csv"], num_epochs=1)
reader = tf.TextLineReader()
key, value = reader.read(filename_queue)
col1, col2 = tf.decode_csv(value, record_defaults=[[0], [0]])

with tf.Session() as sess:
  sess.run(tf.initialize_local_variables())
  tf.train.start_queue_runners()
  num_examples = 0
  try:
    while True:
      c1, c2 = sess.run([col1, col2])
      num_examples += 1
  except tf.errors.OutOfRangeError:
    print "There are", num_examples, "examples"

num_epochs=1 hace que la cola string_input_producer cierre una vez que se haya procesado cada archivo en la lista. Esto lleva a que se OutOfRangeError que se OutOfRangeError en try: Por defecto, string_input_producer produce los nombres de archivo infinitamente.

tf.initialize_local_variables() es un Op tensorflow, que, al ejecutarse, inicializa num_epoch variable local dentro string_input_producer .

tf.train.start_queue_runners() inicia pasos adicionales que manejan agregar datos a las colas de forma asíncrona.

Lea y analice el archivo TFRecord

Los archivos TFRecord son el formato binario tensorflow nativo para almacenar datos (tensores). Para leer el archivo puede usar un código similar al del ejemplo CSV:

import tensorflow as tf
filename_queue = tf.train.string_input_producer(["file.tfrecord"], num_epochs=1)
reader = tf.TFRecordReader()
key, serialized_example = reader.read(filename_queue)

Luego, debe analizar los ejemplos de la cola serialized_example . Puede hacerlo usando tf.parse_example , que requiere lotes previos, pero es más rápido o tf.parse_single_example :

batch = tf.train.batch([serialized_example], batch_size=100)
parsed_batch = tf.parse_example(batch, features={
  "feature_name_1": tf.FixedLenFeature(shape=[1], tf.int64),
  "feature_name_2": tf.FixedLenFeature(shape=[1], tf.float32)
})

tf.train.batch une valores consecutivos de determinados tensores de forma [x, y, z] a tensores de forma [batch_size, x, y, z] . features dict mapas nombres de las características a las definiciones de tensorflow de características . parse_single_example de una manera similar:

parsed_example = tf.parse_single_example(serialized_example, {
  "feature_name_1": tf.FixedLenFeature(shape=[1], tf.int64),
  "feature_name_2": tf.FixedLenFeature(shape=[1], tf.float32)
})

tf.parse_example y tf.parse_single_example devuelven los nombres de las características de mapeo de un diccionario al tensor con los valores.

Para los ejemplos por lotes que vienen de parse_single_example , debe extraer los tensores del dict y usar tf.train.batch como antes:

parsed_batch = dict(zip(parsed_example.keys(),
    tf.train.batch(parsed_example.values(), batch_size=100)

Leyó los datos como antes, pasando la lista de todos los tensores para evaluar a sess.run :

with tf.Session() as sess:
  sess.run(tf.initialize_local_variables())
  tf.train.start_queue_runners()
  try:
    while True:
      data_batch = sess.run(parsed_batch.values())
      # process data
  except tf.errors.OutOfRangeError:
    pass

Al azar barajando los ejemplos.

Para mezclar aleatoriamente los ejemplos, puede usar la función tf.train.shuffle_batch lugar de tf.train.batch , de la siguiente manera:

parsed_batch = tf.train.shuffle_batch([serialized_example],
    batch_size=100, capacity=1000,
    min_after_dequeue=200)

tf.train.shuffle_batch (así como tf.train.batch ) crea una tf.Queue y continúa agregándole tf.Queue serialized_examples .

capacity mide cuántos elementos se pueden almacenar en la cola de una vez. Una mayor capacidad lleva a un mayor uso de la memoria, pero una menor latencia causada por subprocesos que esperan llenarlo.

min_after_dequeue es el número mínimo de elementos presentes en la cola después de obtener elementos de ella. La cola shuffle_batch no está barajando los elementos de manera perfectamente uniforme, sino que está diseñada teniendo en cuenta una gran cantidad de datos, que no encajan en la memoria. En su lugar, lee entre los elementos min_after_dequeue y capacity , los almacena en la memoria y elige aleatoriamente un lote de ellos. Después de eso, pone en cola algunos elementos más, para mantener su número entre min_after_dequeue y capacity . Por lo tanto, cuanto mayor sea el valor de min_after_dequeue , más elementos aleatorios se garantiza que la elección de los elementos batch_size se tomará de al menos min_after_dequeue elementos consecutivos, pero la mayor capacity debe ser y cuanto más tiempo se tarda en llenar la cola inicialmente.

Lectura de datos para n épocas con lotes

Supongamos que sus ejemplos de datos ya están leídos en una variable de python y desea leerlos n veces, en lotes de un tamaño determinado:

import numpy as np
import tensorflow as tf
data = np.array([1, 2, 3, 4, 5])
n = 4

Para combinar datos en lotes, posiblemente con barajado aleatorio, puede usar tf.train.batch o tf.train.batch_shuffle , pero necesita pasarle el tensor que produciría datos completos n veces:

limited_tensor = tf.train.limit_epochs(data, n)
batch = tf.train.shuffle_batch([limited_tensor], batch_size=3, enqueue_many=True, capacity=4)

El limit_epochs convierte la matriz numpy a tensor debajo del capó y devuelve un tensor produciéndolo n veces y lanzando un OutOfRangeError después. El enqueue_many=True argumento enqueue_many=True pasado a shuffle_batch denota que cada tensor en la lista de tensor [limited_tensor] debe interpretarse como que contiene una cantidad de ejemplos. Tenga en cuenta que la capacidad de la cola de procesamiento por lotes puede ser menor que la cantidad de ejemplos en el tensor.

Uno puede procesar los datos como de costumbre:

with tf.Session() as sess:
  sess.run(tf.initialize_local_variables())
  tf.train.start_queue_runners()
  try:
    while True:
      data_batch = sess.run(batch)
      # process data
  except tf.errors.OutOfRangeError:
    pass

Cómo cargar imágenes y etiquetas desde un archivo TXT

No se ha explicado en la documentación de Tensorflow cómo cargar imágenes y etiquetas directamente desde un archivo TXT. El siguiente código ilustra cómo lo logré. Sin embargo, no significa que sea la mejor manera de hacerlo y que de esta manera ayudará en pasos adicionales.

Por ejemplo, estoy cargando las etiquetas en un solo valor entero {0,1}, mientras que la documentación utiliza un vector de un solo calor [0,1].

# Learning how to import images and labels from a TXT file
#
# TXT file format
#
# path/to/imagefile_1 label_1
# path/to/imagefile_2 label_2
# ...                 ...
#
# where label_X is either {0,1}

#Importing Libraries
import os
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.python.framework import ops
from tensorflow.python.framework import dtypes

#File containing the path to images and the labels [path/to/images label]
filename = '/path/to/List.txt'

#Lists where to store the paths and labels
filenames = []
labels = []

#Reading file and extracting paths and labels
with open(filename, 'r') as File:
    infoFile = File.readlines() #Reading all the lines from File
    for line in infoFile: #Reading line-by-line
        words = line.split() #Splitting lines in words using space character as separator
        filenames.append(words[0])
        labels.append(int(words[1]))

NumFiles = len(filenames)

#Converting filenames and labels into tensors
tfilenames = ops.convert_to_tensor(filenames, dtype=dtypes.string)
tlabels = ops.convert_to_tensor(labels, dtype=dtypes.int32)

#Creating a queue which contains the list of files to read and the value of the labels
filename_queue = tf.train.slice_input_producer([tfilenames, tlabels], num_epochs=10, shuffle=True, capacity=NumFiles)

#Reading the image files and decoding them
rawIm= tf.read_file(filename_queue[0])
decodedIm = tf.image.decode_png(rawIm) # png or jpg decoder

#Extracting the labels queue
label_queue = filename_queue[1]

#Initializing Global and Local Variables so we avoid warnings and errors
init_op = tf.group(tf.local_variables_initializer() ,tf.global_variables_initializer())

#Creating an InteractiveSession so we can run in iPython
sess = tf.InteractiveSession()

with sess.as_default():
    sess.run(init_op)
    
    # Start populating the filename queue.
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(coord=coord)

    for i in range(NumFiles): #length of your filenames list
        nm, image, lb = sess.run([filename_queue[0], decodedIm, label_queue])
        
        print image.shape
        print nm
        print lb
        
        #Showing the current image
        plt.imshow(image)
        plt.show()

    coord.request_stop()
    coord.join(threads)