tensorflow
Placeholders

Parámetros

Fundamentos de los marcadores de posición

Los marcadores de posición le permiten introducir valores en un gráfico de tensorflow. Adicionalmente, le permiten especificar restricciones con respecto a las dimensiones y el tipo de datos de los valores que se ingresan. Como tales, son útiles al crear una red neuronal para alimentar nuevos ejemplos de capacitación.

El siguiente ejemplo declara un marcador de posición para un tensor de 3 por 4 con elementos que son (o pueden tipificarse como) flotadores de 32 bits.

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

Los marcadores de posición no contendrán ningún valor por sí mismos, por lo que es importante proporcionarles valores al ejecutar una sesión, de lo contrario, aparecerá un mensaje de error. Esto se puede hacer usando el argumento feed_dict al llamar a session.run() , por ejemplo:

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

Aquí hay un ejemplo simple que muestra el proceso completo de declarar y alimentar a un tapicero.

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)

El marcador de posición toma una matriz de 3 por 4, y ese tensor se multiplica por 2 en el nodo b, que luego devuelve e imprime lo siguiente:

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

Marcador de posición con valor predeterminado

A menudo, uno quiere ejecutar intermitentemente uno o más lotes de validación durante el curso de entrenamiento de una red profunda. Típicamente los datos de entrenamiento son alimentados por una cola, mientras que los datos de validación pueden ser pasados a través de la feed_dict parámetro en sess.run() . tf.placeholder_with_default() está diseñado para funcionar bien en esta situación:

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)

En este ejemplo, image_batch y label_batch son generados por get_training_batch() menos que los valores correspondientes se pasen como el parámetro feed_dict durante una llamada a sess.run() .