tensorflow
Lecture des données

Compter les exemples dans un fichier 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 string_input_producer file d'attente string_input_producer après avoir traité chaque fichier de la liste une fois. Elle conduit à élever OutOfRangeError qui est pris dans try: . Par défaut, string_input_producer produit les noms de fichiers à l'infini.

tf.initialize_local_variables() est une op tensorflow, qui, lorsqu'il est exécuté, initialise num_epoch variable locale à l' intérieur de string_input_producer .

tf.train.start_queue_runners() démarre des pistes supplémentaires qui gèrent l'ajout de données aux files d'attente de manière asynchrone.

Lire et analyser le fichier TFRecord

Les fichiers TFRecord sont le format binaire de tensorflow natif pour stocker des données (tenseurs). Pour lire le fichier, vous pouvez utiliser un code similaire à l'exemple 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)

Ensuite, vous devez analyser les exemples de la file d'attente serialized_example . Vous pouvez le faire soit en utilisant tf.parse_example , qui nécessite un traitement par lot précédent, mais qui est plus rapide ou 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 relie des valeurs consécutives de tenseurs donnés de forme [x, y, z] à des tenseurs de forme [batch_size, x, y, z] . features mappe les noms des entités aux définitions de entités de tensorflow. Vous utilisez parse_single_example de la même manière:

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 et tf.parse_single_example renvoient un dictionnaire mappant des noms d' tf.parse_single_example au tenseur avec les valeurs.

Pour parse_single_example exemples provenant de parse_single_example vous devez extraire les tenseurs du dict et utiliser tf.train.batch comme précédemment:

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

Vous lisez les données comme avant, en passant la liste de tous les tenseurs à évaluer à 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éatoire battant les exemples

Pour mélanger aléatoirement les exemples, vous pouvez utiliser la fonction tf.train.shuffle_batch au lieu de tf.train.batch , comme suit:

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

tf.train.shuffle_batch (ainsi que tf.train.batch ) crée un tf.Queue et y ajoute des tf.Queue serialized_examples .

capacity mesure le nombre d'éléments pouvant être stockés dans la file d'attente en une fois. Une plus grande capacité entraîne une plus grande utilisation de la mémoire, mais une latence plus faible causée par les threads en attente de le remplir.

min_after_dequeue est le nombre minimal d'éléments présents dans la file d'attente après en avoir extrait des éléments. La file d'attente shuffle_batch ne mélange pas les éléments de manière parfaitement uniforme - elle est conçue avec des données shuffle_batch ne shuffle_batch pas à la mémoire. Au lieu de cela, il lit entre les éléments min_after_dequeue et capacity , les stocke en mémoire et en choisit un lot au hasard. Après cela, il met en file d'attente d'autres éléments, pour conserver son numéro entre min_after_dequeue et capacity . Ainsi, plus la valeur de min_after_dequeue , plus les éléments aléatoires sont nombreux - le choix des éléments batch_size est garanti pour au moins les éléments consécutifs min_after_dequeue , mais la plus grande capacity doit être min_after_dequeue pour remplir la file d'attente.

Lecture des données pour n époques avec traitement par lots

Supposons que vos exemples de données soient déjà lus dans la variable d'un python et que vous souhaitez le lire n fois, par lots de taille donnée:

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

Pour fusionner des données par lots, éventuellement avec un mélange aléatoire, vous pouvez utiliser tf.train.batch ou tf.train.batch_shuffle , mais vous devez lui transmettre le tenseur qui produirait des données entières n fois:

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

Le limit_epochs convertit le tableau numpy en tenseur sous le capot et retourne un tenseur le produisant n fois, puis en lançant une erreur OutOfRangeError. L'argument enqueue_many=True passé à shuffle_batch indique que chaque tenseur de la liste des tenseurs [limited_tensor] doit être interprété comme contenant un certain nombre d'exemples. Notez que la capacité de la file d'attente de traitement par lots peut être inférieure au nombre d'exemples du tenseur.

On peut traiter les données comme d'habitude:

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

Comment charger des images et des étiquettes à partir d'un fichier TXT

La documentation de Tensorflow n'a pas expliqué comment charger des images et des étiquettes directement à partir d'un fichier TXT. Le code ci-dessous illustre comment je l'ai réalisé. Cependant, cela ne signifie pas que c'est la meilleure façon de le faire et que cette façon aidera dans les étapes suivantes.

Par exemple, je charge les étiquettes dans une seule valeur entière {0,1}, tandis que la documentation utilise un vecteur à un seul point [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)