tensorflow
Placeholders

Paramètres

Bases des espaces réservés

Les espaces réservés vous permettent d'introduire des valeurs dans un graphique de flux de tension. Ils vous permettent également de spécifier des contraintes concernant les dimensions et le type de données des valeurs introduites. En tant que tels, ils sont utiles lors de la création d'un réseau neuronal pour alimenter de nouveaux exemples de formation.

L'exemple suivant déclare un espace réservé pour un tenseur de 3 par 4 avec des éléments qui sont (ou peuvent être transtypés) avec des flottants de 32 bits.

a = tf.placeholder(tf.float32, shape=[3,4], name='a')

Les espaces réservés ne contiennent aucune valeur, il est donc important de les alimenter en valeurs lors de l'exécution d'une session, sinon vous obtiendrez un message d'erreur. Cela peut être fait en utilisant l'argument feed_dict lors de l'appel de session.run() , par exemple:

# run the graph up to node b, feeding the placeholder `a` with values in my_array 
session.run(b, feed_dict={a: my_array})

Voici un exemple simple montrant l'ensemble du processus de déclaration et d'alimentation d'un placeholer.

import tensorflow as tf
import numpy as np

# Build a graph
graph = tf.Graph()
with graph.as_default():
    # declare a placeholder that is 3 by 4 of type float32
    a = tf.placeholder(tf.float32, shape=(3, 4), name='a')
    
    # Perform some operation on the placeholder
    b = a * 2
    
# Create an array to be fed to `a`
input_array = np.ones((3,4))

# Create a session, and run the graph
with tf.Session(graph=graph) as session:
    # run the session up to node b, feeding an array of values into a
    output = session.run(b, feed_dict={a: input_array})
    print(output)

L'espace réservé prend un tableau de 3 par 4, et ce tenseur est ensuite multiplié par 2 au nœud b, qui retourne et imprime ce qui suit:

[[ 2.  2.  2.  2.]
 [ 2.  2.  2.  2.]
 [ 2.  2.  2.  2.]]

Placeholder avec Default

Souvent, on veut exécuter par intermittence un ou plusieurs lots de validation au cours de la formation d'un réseau en profondeur. Typiquement , les données d'entraînement sont alimentés par une file d' attente tandis que les données de validation peuvent être passés à travers le feed_dict paramètre dans sess.run() . tf.placeholder_with_default() est conçu pour fonctionner correctement dans cette situation:

import numpy as np
import tensorflow as tf

IMG_SIZE = [3, 3]
BATCH_SIZE_TRAIN = 2
BATCH_SIZE_VAL = 1

def get_training_batch(batch_size):
    ''' training data pipeline '''
    image = tf.random_uniform(shape=IMG_SIZE)
    label = tf.random_uniform(shape=[])
    min_after_dequeue = 100
    capacity = min_after_dequeue + 3 * batch_size
    images, labels = tf.train.shuffle_batch(
        [image, label], batch_size=batch_size, capacity=capacity,
        min_after_dequeue=min_after_dequeue)
    return images, labels

# define the graph
images_train, labels_train = get_training_batch(BATCH_SIZE_TRAIN)
image_batch = tf.placeholder_with_default(images_train, shape=None)
label_batch = tf.placeholder_with_default(labels_train, shape=None)
new_images = tf.mul(image_batch, -1)
new_labels = tf.mul(label_batch, -1)

# start a session
with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)

    # typical training step where batch data are drawn from the training queue
    py_images, py_labels = sess.run([new_images, new_labels])
    print('Data from queue:')
    print('Images: ', py_images)  # returned values in range [-1.0, 0.0]
    print('\nLabels: ', py_labels) # returned values [-1, 0.0]

    # typical validation step where batch data are supplied through feed_dict
    images_val = np.random.randint(0, 100, size=np.hstack((BATCH_SIZE_VAL, IMG_SIZE)))
    labels_val = np.ones(BATCH_SIZE_VAL)
    py_images, py_labels = sess.run([new_images, new_labels],
                      feed_dict={image_batch:images_val, label_batch:labels_val})
    print('\n\nData from feed_dict:')
    print('Images: ', py_images) # returned values are integers in range [-100.0, 0.0]
    print('\nLabels: ', py_labels) # returned values are -1.0

    coord.request_stop()
    coord.join(threads)

Dans cet exemple, image_batch et label_batch sont générés par get_training_batch() moins que les valeurs correspondantes ne soient transmises en tant feed_dict paramètre feed_dict lors d'un appel à sess.run() .