La lecture de TFRecord devient lente

Question

J'ai divisé un jeu de données en 10 fichiers tfrecords et je souhaite lire 100 points de données pour créer un lot de 10 séquences de 100 points de données. J'utilise la fonction suivante pour le faire. Le temps de chargement des données à partir des tfrecords commence lentement, puis atteint environ 0,65 seconde et après 100-200 appels sess.run, il passe à environ 10 secondes. Pouvez-vous s'il vous plaît signaler toute erreur ou suggestion qui pourrait aider à réduire le temps de lecture? De plus, le comportement que j'ai mentionné devient parfois plus erratique.

def get_data(mini_batch_size): 
    data = [] 
    for i in range(mini_batch_size): 
    filename_queue = tf.train.string_input_producer([data_path + 'Features' + str(i) + '.tfrecords']) 
    reader = tf.TFRecordReader() 
    _, serialized_example = reader.read_up_to(filename_queue,step_size) 
    features = tf.parse_example(serialized_example,features={'feature_raw': tf.VarLenFeature(dtype=tf.float32)}) 
    feature = features['feature_raw'].values 
    feature = tf.reshape(feature,[step_size, ConvLSTM.H, ConvLSTM.W, ConvLSTM.Di]) 
    data.append(feature) 
    return tf.stack(data) 

Même lorsque je tire d'un seul fichier comme suit, j'observe le même comportement. De plus, augmenter num_threads n'aide pas.

with tf.device('/cpu:0'): 
    filename_queue = tf.train.string_input_producer(['./Data/TFRecords/Features' + str(i) + '.tfrecords']) 
    reader = tf.TFRecordReader() 
    _, serialized_example = reader.read(filename_queue) 
    batch_serialized_example = tf.train.batch([serialized_example], batch_size=100, num_threads=1, capacity=100) 
    features = tf.parse_example(batch_serialized_example,features={'feature_raw': tf.VarLenFeature(dtype=tf.float32)}) 
    feature = features['feature_raw'].values 
    data.append(feature) 
data = tf.stack(data) 

init_op = tf.group(tf.global_variables_initializer(),tf.local_variables_initializer()) 
sess = tf.Session(config=tf.ConfigProto(intra_op_parallelism_threads=1,inter_op_parallelism_threads=1,allow_soft_placement=True)) 
sess.run(init_op) 

coord = tf.train.Coordinator() 
threads = tf.train.start_queue_runners(sess=sess, coord=coord) 

for i in range(1000): 
    t = time.time() 
    D = sess.run(data) 
    print(time.time()-t) 

Answer 1

Je pense que vous essayez de créer des mini-lot vous, mais vous devez utiliser tensorflow files d'attente comme tf.train.shuffle_batch ou tf.train.batch pour le faire pour vous.

Votre flux d'entrée devrait être comme:

# Create a filename queue: Read tfrecord filenames 
filename_queue = tf.train.string_input_producer 

#Create reader to populate the queue of examples 
reader = tf.TFRecordReader() 
_, serialized_example = reader.read_up_to(filename_queue,step_size) 

#Parses the example proto 
features = tf.parse_example(serialized_example,features={'feature_raw': tf.VarLenFeature(dtype=tf.float32)}) 
feature = features['feature_raw'].values 
feature = tf.reshape(feature,[step_size, ConvLSTM.H, ConvLSTM.W, ConvLSTM.Di]) 

## Shuffling queue that creates batches of data 
features = tf.train.shuffle_batch([feature], batch_size=batch_size, num_threads=2, capacity=MIN_AFTER_DEQUEUE + 3*batch_size, min_after_dequeue=MIN_AFTER_DEQUEUE) 

Pour améliorer votre temps de chargement de données, les points ci-dessous vous aidera à:

1. Réglage de la MIN_AFTER_DEQUEUE est importante param. Le réglage sur un grand nombre aura un démarrage plus lent et plus de mémoire, mais de meilleurs temps d'exécution.
2. Exécutez le input data preprocessing dans le processeur alors que le reste des opérations de calcul intensif de la matrice s'exécutent sur le GPU. L'utilisation de votre GPU n'est pas proche de 100%, cela signifie que le goulot d'étranglement provient du fait que le CPU ne charge pas assez de données.
3. Essayez de garder plus grand tfrecords au lieu de manytdrecords, afin que les données puissent être lues séquentiellement plus rapidement sans avoir à changer plusieurs fichiers.
4. Si vous traitez avec des images, n'enregistrez pas l'image raw sur le tfrecords mais utilisez à la place jpeg ou formats similaires, afin qu'ils prennent moins de taille de fichier et peuvent être lus plus rapidement. Le calcul jpeg decode est un très petit coût pour le GPU.