tensorflow
placeholders

parameters

Basisprincipes van tijdelijke aanduidingen

Met tijdelijke aanduidingen kunt u waarden invoeren in een tensorflow-grafiek. Bijkomend kunt u beperkingen opgeven met betrekking tot de dimensies en het gegevenstype van de waarden die worden ingevoerd. Als zodanig zijn ze nuttig bij het creëren van een neuraal netwerk om nieuwe trainingsvoorbeelden te voeden.

Het volgende voorbeeld verklaart een tijdelijke aanduiding voor een 3 bij 4 tensor met elementen die 32 bit floats zijn (of kunnen worden getyped).

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

Plaatshouders bevatten zelf geen waarden, dus het is belangrijk om ze te voorzien van waarden tijdens het uitvoeren van een sessie, anders krijg je een foutmelding. Dit kan worden gedaan met behulp van het argument feed_dict bij het aanroepen van session.run() , bijvoorbeeld:

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

Hier is een eenvoudig voorbeeld van het hele proces van het verklaren en voeren van een 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)

De tijdelijke aanduiding neemt een reeks van 3 bij 4, en die tensor wordt dan vermenigvuldigd met 2 bij knoop b, die vervolgens terugkeert en het volgende afdrukt:

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

Tijdelijke aanduiding met standaardwaarde

Vaak wil men met tussenpozen een of meer validatiebatches uitvoeren tijdens het trainen van een diep netwerk. Typisch de trainingsgegevens worden gevoed door een wachtrij terwijl de validatiegegevens via kunnen worden doorgegeven feed_dict parameter sess.run() . tf.placeholder_with_default() is ontworpen om goed te werken in deze situatie:

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)

In dit voorbeeld worden image_batch en label_batch gegenereerd door get_training_batch() tenzij de overeenkomstige waarden worden doorgegeven als de parameter feed_dict tijdens een aanroep naar sess.run() .