tensorflow
segnaposto

Parametri

Nozioni di base dei segnaposto

I segnaposti consentono di alimentare i valori in un grafico di tensorflow. Aditamente consentono di specificare i vincoli relativi alle dimensioni e al tipo di dati dei valori che vengono alimentati. Pertanto sono utili quando si crea una rete neurale per alimentare nuovi esempi di addestramento.

L'esempio seguente dichiara un segnaposto per un tensore 3 per 4 con elementi che sono (o possono essere convertiti in typecast) in float a 32 bit.

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

I segnaposto non conterranno alcun valore per conto proprio, quindi è importante dar loro da mangiare con i valori quando si esegue una sessione, altrimenti si otterrà un messaggio di errore. Questo può essere fatto usando l'argomento feed_dict quando si chiama session.run() , ad esempio:

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

Ecco un semplice esempio che mostra l'intero processo di dichiarazione e alimentazione di un spacciatore.

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)

Il segnaposto prende una matrice 3 per 4 di quelli, e quel tensore viene quindi moltiplicato per 2 al nodo b, che poi restituisce e stampa quanto segue:

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

Segnaposto con valore predefinito

Spesso si desidera eseguire in modo intermittente uno o più batch di convalida durante l'addestramento di una rete profonda. In genere i dati di allenamento sono alimentati da una coda, mentre i dati di convalida potrebbero essere passate attraverso il feed_dict parametro sess.run() . tf.placeholder_with_default() è progettato per funzionare bene in questa situazione:

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 questo esempio image_batch e label_batch sono generati da get_training_batch() meno che i valori corrispondenti non vengano passati come parametro feed_dict durante una chiamata a sess.run() .