Lire la matrice numpy par lots dans Tensorflow

Question

J'essaye d'exécuter quelques modèles de régression sur le GPU. Alors que j'obtiens une très faible utilisation du GPU jusqu'à 20%. Après avoir passé le code,

for i in range(epochs): 
    rand_index = np.random.choice(args.train_pr, 
     size=args.batch_size) 
    rand_x = X_train[rand_index] 
    rand_y = Y_train[rand_index] 

J'utilise ces trois lignes pour sélectionner un lot aléatoire pour chaque itération. Donc, je voulais demander quand la formation est en cours, puis-je préparer un autre lot pour la prochaine itération?

Je travaille sur un problème de régression et non sur un problème de classification. J'ai déjà vu le filetage dans Tensorflow mais j'ai trouvé les exemples uniquement pour les images et il n'y a pas d'exemple pour une grosse matrice de taille 100000X1000 qui est utilisée pour l'entrainement.

Answer 1

Ceci est un bon cas d'utilisation pour les générateurs. Vous pouvez configurer une fonction de générateur pour produire des tranches de vos matrices numpy un morceau à la fois. Si vous utilisez un package comme Keras, vous pouvez fournir le générateur directement à la fonction train_on_batch. Si vous préférez utiliser Tensorflow directement, vous pouvez utiliser:

sess = tf.Session() 
sess.run(init) 
batch_gen = generator(data) 
batch = batch_gen.next() 
sess.run([optimizer, loss, ...], feed_dict = {X: batch[0], y: batch[1]}) 

Note: J'utilise des espaces réservés pour l'optimiseur et la perte, vous devez remplacer vos définitions. Notez que votre générateur doit produire un tuple (x, y). Si vous n'êtes pas familier avec les expressions du générateur, il y a beaucoup d'exemples en ligne, mais voici un exemple simple de la documentation Keras qui montre comment vous pouvez lire dans numpy matrices à partir d'un fichier en lots:

def generate_arrays_from_file(path): 
    while 1: 
     f = open(path) 
     for line in f: 
      x, y = process_line(line) 
      yield (x, y) 
     f.close() 

Mais aussi plus fondamentalement , une faible utilisation du GPU n'indique pas vraiment de problème lors du chargement des lots, mais plutôt que la taille de votre lot peut être trop petite.

Answer 2

Vous avez un grand nombre de tableaux qui se trouve dans la mémoire de l'hôte. Vous voulez pouvoir le traiter en parallèle sur la CPU et envoyer des lots à l'appareil. C'est un bon scénario pour l'utilisation de queues.

Voici un exemple simple qui extrait simplement des tranches aléatoires d'un tableau numpy (comme vous le faites) et vous laisse faire prétraiter en python avec vos outils préférés:

import numpy as np 
import tensorflow as tf 

def make_batch(x, y, batch_size): 
    rand_index = np.random.choice(x.shape[0], size=batch_size) 
    x_batch, y_batch = x[rand_index], y[rand_index] 
    # Do all your pre-processing here 
    # ... 
    return (x_batch, y_batch) 

x = np.arange(10, dtype=np.float32) 
y = np.arange(10, dtype=np.int32) 
batch_size = 2 
tf_make_batch = tf.py_func(make_batch, [x,y,batch_size], (tf.float32, tf.int32)) 

queue = tf.FIFOQueue(capacity=1000, dtypes=(tf.float32, tf.int32)) 
enqueue_op = queue.enqueue(tf_make_batch) 
inputs = queue.dequeue() 
qr = tf.train.QueueRunner(queue, [enqueue_op] * 4) 
with tf.Session() as sess: 
    coord = tf.train.Coordinator() 
    enqueue_threads = qr.create_threads(sess, coord=coord, start=True) 
    for step in range(10): 
    print(sess.run(inputs)) 
    coord.request_stop() 
    coord.join(enqueue_threads) 

Il utilise un FIFOQueue depuis un échantillonnage aléatoire déjà arrive dans make_batch.

Bien sûr, pour vraiment bénéficier du multithreading, make_batch devrait faire plus de cet échantillonnage. Vous pouvez commencer à voir des différences significatives lorsque vous ajoutez un prétraitement lourd à votre pipeline.