TensorFlow - Lire tous les exemples d'un TFRecords à la fois?

Question

Comment avez-vous lu tous les exemples à partir d'un TFRecords à la fois?

J'ai été en utilisant tf.parse_single_example à la lecture des exemples à l'aide de code similaire à celui donné dans la méthode read_and_decode dans l' exemple de la fully_connected_reader. Cependant, je veux courir le réseau contre toute ma validation dataset à la fois, et donc à charger dans leur intégralité à la place.

Je ne suis pas entièrement sûr, mais la documentation semble suggérer que je peux utiliser tf.parse_example au lieu de tf.parse_single_example à la charge de l'ensemble de la TFRecords fichier à la fois. Je n'arrive pas à obtenir que cela fonctionne bien. Je devine que cela a à voir avec la façon dont je spécifier les fonctionnalités, mais je ne suis pas sûr de savoir comment en fonction de la spécification de l'etat qu'il existe de multiples exemples.

En d'autres termes, ma tentative d'utiliser quelque chose de similaire à:

reader = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue)
features = tf.parse_example(serialized_example, features={
    'image_raw': tf.FixedLenFeature([], tf.string),
    'label': tf.FixedLenFeature([], tf.int64),
})

ne fonctionne pas, et je suppose que c'est parce que les fonctionnalités ne s'attendent pas à de multiples exemples à la fois (mais encore une fois, je ne suis pas sûr). [Il en résulte une erreur de ValueError: Shape () must have rank 1]

Est-ce la bonne façon de lire tous les enregistrements à la fois? Et si oui, que dois-je changer de lire les documents? Merci beaucoup!

Answer 1

Juste pour plus de clarté, j'ai quelques milliers d'images en une seule .tfrecords fichier, ils sont de 720 x 720 rvb fichiers png. Les étiquettes sont un des 0,1,2,3.

J'ai aussi essayé d'utiliser le parse_example et ne pouvait pas faire ce travail, mais cette solution fonctionne avec le parse_single_example.

L'inconvénient est que pour l'instant, j'ai besoin de savoir le nombre d'éléments dans chaque .tf enregistrement, ce qui est un problème. Si je trouve une meilleure façon, je vais mettre à jour la réponse. Aussi, soyez prudent de sortir des limites du nombre d'enregistrements dans la .tfrecords fichier, il démarre au premier enregistrement si vous boucle passé le dernier enregistrement

L'astuce est d'avoir la file d'attente coureur de l'utilisation d'un coordinateur.

J'ai laissé le code ici pour enregistrer les images en cours de lecture vous pouvez vérifier l'image est correcte.

from PIL import Image
import numpy as np
import tensorflow as tf

def read_and_decode(filename_queue):
 reader = tf.TFRecordReader()
 _, serialized_example = reader.read(filename_queue)
 features = tf.parse_single_example(
  serialized_example,
  # Defaults are not specified since both keys are required.
  features={
      'image_raw': tf.FixedLenFeature([], tf.string),
      'label': tf.FixedLenFeature([], tf.int64),
      'height': tf.FixedLenFeature([], tf.int64),
      'width': tf.FixedLenFeature([], tf.int64),
      'depth': tf.FixedLenFeature([], tf.int64)
  })
 image = tf.decode_raw(features['image_raw'], tf.uint8)
 label = tf.cast(features['label'], tf.int32)
 height = tf.cast(features['height'], tf.int32)
 width = tf.cast(features['width'], tf.int32)
 depth = tf.cast(features['depth'], tf.int32)
 return image, label, height, width, depth


def get_all_records(FILE):
 with tf.Session() as sess:
   filename_queue = tf.train.string_input_producer([ FILE ])
   image, label, height, width, depth = read_and_decode(filename_queue)
   image = tf.reshape(image, tf.pack([height, width, 3]))
   image.set_shape([720,720,3])
   init_op = tf.initialize_all_variables()
   sess.run(init_op)
   coord = tf.train.Coordinator()
   threads = tf.train.start_queue_runners(coord=coord)
   for i in range(2053):
     example, l = sess.run([image, label])
     img = Image.fromarray(example, 'RGB')
     img.save( "output/" + str(i) + '-train.png')

     print (example,l)
   coord.request_stop()
   coord.join(threads)

get_all_records('/path/to/train-0.tfrecords')

Answer 2

Pour lire toutes les données qu'une fois, vous devez passer num_epochs de la string_input_producer. Quand tout le dossier sont lus, .read méthode de lecture lèvera une erreur, que vous pouvez prendre. Exemple simplifié:

import tensorflow as tf

def read_and_decode(filename_queue):
 reader = tf.TFRecordReader()
 _, serialized_example = reader.read(filename_queue)
 features = tf.parse_single_example(
  serialized_example,
  features={
      'image_raw': tf.FixedLenFeature([], tf.string)
  })
 image = tf.decode_raw(features['image_raw'], tf.uint8)
 return image


def get_all_records(FILE):
 with tf.Session() as sess:
   filename_queue = tf.train.string_input_producer([FILE], num_epochs=1)
   image = read_and_decode(filename_queue)
   init_op = tf.initialize_all_variables()
   sess.run(init_op)
   coord = tf.train.Coordinator()
   threads = tf.train.start_queue_runners(coord=coord)
   try:
     while True:
       example = sess.run([image])
   except tf.errors.OutOfRangeError, e:
     coord.request_stop(e)
   finally:
     coord.request_stop()
     coord.join(threads)

get_all_records('/path/to/train-0.tfrecords')

Et pour utiliser tf.parse_example (ce qui est plus rapide que d' tf.parse_single_example) dont vous avez besoin pour le premier lot d'exemples comme ça:

batch = tf.train.batch([serialized_example], num_examples, capacity=num_examples)
parsed_examples = tf.parse_example(batch, feature_spec)

Malheureusement, de cette façon, vous auriez besoin de connaître le nombre d'exemples à l'avance.

Answer 3

Si vous avez besoin de lire toutes les données de TFRecord à la fois, vous pouvez écrire de la façon la plus simple solution en quelques lignes de code à l'aide de tf_record_iterator:

Un itérateur qui lire les enregistrements à partir d'un TFRecords fichier.

Pour ce faire, vous avez juste:

1. créer un exemple
2. itérer sur les registres de l'itérateur
3. analyser chaque dossier et de lire chaque élément en fonction de son type

Voici un exemple avec une explication sur la façon de lire chaque type.

example = tf.train.Example()
for record in tf.python_io.tf_record_iterator(<tfrecord_file>):
    example.ParseFromString(record)
    f = example.features.feature
    v1 = f['int64 feature'].int64_list.value[0]
    v2 = f['float feature'].float_list.value[0]
    v3 = f['bytes feature'].bytes_list.value[0]
    # for bytes you might want to represent them in a different way (based on what they were before saving)
    # something like `np.fromstring(f['img'].bytes_list.value[0], dtype=np.uint8
    # Now do something with your v1/v2/v3

Answer 4

Vous pouvez également utiliser tf.python_io.tf_record_iterator manuellement itérer tous les exemples en TFRecord.

Je test avec une illustration de code ci-dessous:

import tensorflow as tf

X = [[1, 2],
     [3, 4],
     [5, 6]]


def _int_feature(value):
    return tf.train.Feature(int64_list=tf.train.Int64List(value=value))


def dump_tfrecord(data, out_file):
    writer = tf.python_io.TFRecordWriter(out_file)
    for x in data:
        example = tf.train.Example(
            features=tf.train.Features(feature={
                'x': _int_feature(x)
            })
        )
        writer.write(example.SerializeToString())
    writer.close()


def load_tfrecord(file_name):
    features = {'x': tf.FixedLenFeature([2], tf.int64)}
    data = []
    for s_example in tf.python_io.tf_record_iterator(file_name):
        example = tf.parse_single_example(s_example, features=features)
        data.append(tf.expand_dims(example['x'], 0))
    return tf.concat(0, data)


if __name__ == "__main__":
    dump_tfrecord(X, 'test_tfrecord')
    print('dump ok')
    data = load_tfrecord('test_tfrecord')

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        Y = sess.run([data])
        print(Y)

Bien sûr, vous devez utiliser votre propre feature de la spécification.

L'inconvénient est que je ne sais pas comment l'utiliser multi-threads de cette façon. Cependant, la plupart des occasion, nous avons lu tous les exemples, c'est quand nous évaluons la validation de l'ensemble de données, qui n'est généralement pas très grande. Donc, je pense que l'efficacité est peut-être pas un goulot d'étranglement.

Et j'ai une autre question quand je test ce problème, qui est que je dois spécifier la longueur de caractéristique. Au lieu de tf.FixedLenFeature([], tf.int64), je dois écrire tf.FixedLenFeature([2], tf.int64), dans le cas contraire, InvalidArgumentError s'est produite. Je n'ai aucune idée comment faire pour éviter cela.

Python: 3.4
Tensorflow: 0.12.0

Answer 5

Je ne sais pas si c'est encore une rubrique active. Je tiens à partager les meilleures pratiques je sais, c'est une question il y a un an mais.

Dans le tensorflow, nous avons une méthode très utile pour le problème de ce genre-de lire ou de parcourir les tas de données d'entrée et de générer de formation pour le jeu de données de test au hasard. 'tf.le train.shuffle_batch " peut générer l'ensemble de données de base sur le flux d'entrée (comme le lecteur.read()) sur vous vous comportez. Comme par exemple, vous pouvez générer un ensemble de 1000 jeu de données, en fournissant la liste des arguments comme ceci:

reader = tf.TFRecordReader()
_, serialized = reader.read(filename_queue)
features = tf.parse_single_example(
    serialized,
    features={
        'label': tf.FixedLenFeature([], tf.string),
        'image': tf.FixedLenFeature([], tf.string)
    }
)
record_image = tf.decode_raw(features['image'], tf.uint8)

image = tf.reshape(record_image, [500, 500, 1])
label = tf.cast(features['label'], tf.string)
min_after_dequeue = 10
batch_size = 1000
capacity = min_after_dequeue + 3 * batch_size
image_batch, label_batch = tf.train.shuffle_batch(
    [image, label], batch_size=batch_size, capacity=capacity, min_after_dequeue=min_after_dequeue
)