tensorflow
Placeholders
Recherche…
Paramètres
Paramètre | Détails |
---|---|
type de données (type) | en particulier l'un des types de données fournis par le package tensorflow. Par exemple tensorflow.float32 |
forme des données (forme) | Dimensions de l'espace réservé en tant que liste ou tuple. None ne peut être utilisé pour des dimensions inconnues. Par exemple (Aucun, 30) définirait un espace réservé de dimension (? X 30) |
nom nom) | Un nom pour l'opération (facultatif). |
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()
.