[PYTHON] Lecture de données avec TensorFlow

J'ai essayé de décomposer le mécanisme de lecture des données du fichier dans TensorFlow en une série de flux. Je pense que ce sera une référence pour savoir comment saisir les données d'image binaire de CIFAR-10, utiliser Queue et l'envoyer au graphique en tant que tenseur dans Session.

j'ai découvert ・ Comme indiqué dans les [Données de lecture] officielles (https://www.tensorflow.org/versions/r0.9/how_tos/reading_data/index.html), la lecture à partir d'un fichier est effectuée en 7 étapes. -La raison pour laquelle FilenameQueue est mordu est de mélanger les données et d'exécuter le traitement dans plusieurs threads. ・ La structure suivante est utilisée

tf.Graph().as_default()

    sess=tf.Session()
    tf.train.start_queue_runners(sess=sess)

    for i in range():
        sess.run([ .. ])
```

 Etc.

 De plus, [Essayez d'utiliser la classe Reader de TensorFlow](http://qiita.com/knok/items/2dd15189cbca5f9890c5) explique la partie la plus importante de la gestion des images jpeg. Se il vous plaît se référer.


 On suppose que les données de cifar10 sont enregistrées sous / tmp / cifar10_data / .. Si vous exécutez le code suivant, les données d'image seront sorties sous forme de tenseur.
 Ce script extrait les éléments de base du chargement et du prétraitement des données du grand nombre de fonctions du didacticiel cifar10. Voir cifar10_input.py pour plus de traitement.







#### **`tensorflow_experiment3.py`**
```py


#coding:utf-8
#Jusqu'à ce que le fichier image Cifar10 soit lu et converti en tenseur.
import tensorflow as tf


FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_integer('max_steps', 1,
                            """Number of batches to run.""")
tf.app.flags.DEFINE_integer('batch_size', 128,
                            """Number of images to process in a batch.""")
NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN = 50000



with tf.Graph().as_default(): 
	# 1.Liste des noms de fichiers
	filenames = ['/tmp/cifar10_data/cifar-10-batches-bin/data_batch_1.bin',
		'/tmp/cifar10_data/cifar-10-batches-bin/data_batch_2.bin',
        '/tmp/cifar10_data/cifar-10-batches-bin/data_batch_3.bin', 
        '/tmp/cifar10_data/cifar-10-batches-bin/data_batch_4.bin', 
        '/tmp/cifar10_data/cifar-10-batches-bin/data_batch_5.bin']
    # 2.Pas de lecture aléatoire des noms de fichiers
    # 3.Aucun réglage de limite d'époque


    # 4.Création d'une file d'attente pour la "liste des noms de fichiers"
	filename_queue = tf.train.string_input_producer(filenames)


	# 5.Créer un lecteur qui correspond au format de données
	class CIFAR10Record(object):
		pass
	result = CIFAR10Record()

	label_bytes = 1 
	result.height = 32
	result.width = 32
	result.depth = 3
	image_bytes = result.height * result.width * result.depth
	record_bytes = label_bytes + image_bytes

	reader = tf.FixedLengthRecordReader(record_bytes=record_bytes)

	##Ouvrez le fichier en passant la file d'attente au lecteur
	result.key, value = reader.read(filename_queue)


	# 6.décoder les données à partir des résultats de lecture
	record_bytes = tf.decode_raw(value, tf.uint8)


    # 7.Mise en forme des données
    # 7-1.Mise en forme de base
	result.label = tf.cast(tf.slice(record_bytes, [0], [label_bytes]), tf.int32)
	depth_major = tf.reshape(tf.slice(record_bytes, [label_bytes], [image_bytes]),
                                [result.depth, result.height, result.width])
	result.uint8image = tf.transpose(depth_major, [1, 2, 0])

	read_input = result
	reshaped_image = tf.cast(read_input.uint8image, tf.float32)
	float_image = reshaped_image

	# 7-2.Préparation à la lecture aléatoire des données
	min_fraction_of_examples_in_queue = 0.4
	min_queue_examples = int(NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN *
                            min_fraction_of_examples_in_queue)
	print ('Filling queue with %d CIFAR images before starting to train. '
            'This will take a few minutes.' % min_queue_examples)

    # 7-3.Créer un lot(Avec shuffle)
	batch_size = FLAGS.batch_size
	num_preprocess_threads = 16
	images, label_batch = tf.train.shuffle_batch(
	[float_image, read_input.label],
        batch_size=batch_size,
        num_threads=num_preprocess_threads,
        capacity=min_queue_examples + 3 * batch_size,
        min_after_dequeue=min_queue_examples)

	images=images
	labels = tf.reshape(label_batch, [batch_size])


	# 8.Courir
	sess = tf.Session()
	tf.train.start_queue_runners(sess=sess)
	for step in xrange(FLAGS.max_steps):
		img_label = sess.run([images, labels])
		print(img_label)
	print("FIN.")
```