Unable to feed value for placeholder tensor

Question

I have written a simple version bidirectional lstm for sentence classification. But it keeps giving me "You must feed a value for placeholder tensor 'train_x'" error and it seems this come from the variable initialization step.

data = load_data(FLAGS.data)
model = RNNClassifier(FLAGS)
init = tf.initialize_all_variables()

with tf.Session() as sess:
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    sess.run(init)
    print("Graph initialized..")
    print()
    np.random.seed(FLAGS.random_state)
    for epoch in range(FLAGS.max_max_epoch):

        loss = sess.run(model.cost, feed_dict={model.train_x: data.train_x, model.train_y: data.train_y, 
                                        model.embedding_placeholder: data.glove_vec})
        print("Epoch {:2d}: Loss = {:.6f} = {:.5f}".format(epoch+1, loss))
    coord.request_stop()
    coord.join(threads)

And the RNNClassifier class code (in a different directory):

class RNNClassifier:

    def __init__(self, FLAGS):
        self.params = FLAGS
        with tf.device("/cpu:0"):
            self.train_x = tf.placeholder(tf.int32, [6248, 42], name='train_x')
            self.train_y = tf.placeholder(tf.int32, [6248, 3], name='train_y')
            self.embedding_placeholder = tf.placeholder(tf.float32, [1193515, 100])

        with tf.variable_scope('forward_lstm'):
            lstm_fw_cell = tf.nn.rnn_cell.LSTMCell(num_units=self.params.num_hidden, use_peepholes=False, 
                                                activation=tf.nn.relu, forget_bias=0.0, 
                                                state_is_tuple=True)
        with tf.variable_scope('backward_lstm'):
            lstm_bw_cell = tf.nn.rnn_cell.LSTMCell(num_units=self.params.num_hidden, use_peepholes=False, 
                                                activation=tf.nn.relu, forget_bias=0.0, 
                                                state_is_tuple=True)

        fw_initial_state = lstm_fw_cell.zero_state(self.params.batch_size, tf.float32)
        bw_initial_state = lstm_bw_cell.zero_state(self.params.batch_size, tf.float32)
        self._initial_state = [fw_initial_state, bw_initial_state]

        with tf.device("/cpu:0"), tf.variable_scope('softmax'):
            self.W = tf.get_variable('W', [self.params.num_hidden*2, self.params.num_classes])
            self.b = tf.get_variable('b', [self.params.num_classes], initializer=tf.constant_initializer(0.0))

        batched_inputs, batched_labels = self.batch_data()
        embed_inputs = self.use_embedding(batched_inputs)


        rnn_outputs, output_state_fw, output_state_bw  = tf.nn.bidirectional_rnn(
            cell_fw=lstm_fw_cell,
            cell_bw=lstm_bw_cell,
            inputs=embed_inputs,
            initial_state_fw=fw_initial_state,
            initial_state_bw=bw_initial_state
            )


        logits = tf.matmul(rnn_outputs[-1], self.W) + self.b

        self._cost = cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits, tf.cast(batched_labels, tf.float32)))
        optimizer = tf.train.AdamOptimizer(learning_rate=0.05).minimize(cost)


    def batch_data(self):
        # inputs = tf.convert_to_tensor(train_x, dtype=tf.int32)
        # labels = tf.convert_to_tensor(train_y, dtype=tf.int32)
        batched_inputs, batched_labels = tf.train.batch(
            tensors=[self._train_x, self._train_y],
            batch_size=self.params.batch_size,
            dynamic_pad=True,
            enqueue_many=True,
            name='batching'
    )
    return batched_inputs, batched_labels


    def use_embedding(self, batched_inputs):
        with tf.device("/cpu:0"), tf.name_scope("input_embedding"):
            embedding = tf.get_variable("embedding", shape=[1193515, 100], trainable=False)
            embedding_init = embedding.assign(self.embedding_placeholder)
            embed_inputs = tf.split(1, self.params.seq_len, tf.nn.embedding_lookup(embedding_init, batched_inputs))
            embed_inputs = [tf.squeeze(input_, [1]) for input_ in embed_inputs]
    return embed_inputs

    @property
    def cost(self):
        return self._cost

The output (including the error):

I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:925] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
I tensorflow/core/common_runtime/gpu/gpu_init.cc:102] Found device 0 with properties: 
name: GeForce GTX 750 Ti
major: 5 minor: 0 memoryClockRate (GHz) 1.0845
pciBusID 0000:01:00.0
Total memory: 2.00GiB
Free memory: 1.41GiB
I tensorflow/core/common_runtime/gpu/gpu_init.cc:126] DMA: 0 
I tensorflow/core/common_runtime/gpu/gpu_init.cc:136] 0:   Y 
I tensorflow/core/common_runtime/gpu/gpu_device.cc:839] Creating TensorFlow device (/gpu:0) -> (device: 0, name: GeForce GTX 750 Ti, pci bus id: 0000:01:00.0)
E tensorflow/core/client/tensor_c_api.cc:485] You must feed a value for placeholder tensor 'train_x' with dtype int32 and shape [6248,42]
     [[Node: train_x = Placeholder[dtype=DT_INT32, shape=[6248,42], _device="/job:localhost/replica:0/task:0/cpu:0"]()]]

Graph initialized..

W tensorflow/core/framework/op_kernel.cc:936] Out of range: PaddingFIFOQueue '_0_batching/padding_fifo_queue' is closed and has insufficient elements (requested 50, current size 0)
     [[Node: batching = QueueDequeueMany[_class=["loc:@batching/padding_fifo_queue"], component_types=[DT_INT32, DT_INT32], timeout_ms=-1, _device="/job:localhost/replica:0/task:0/cpu:0"](batching/padding_fifo_queue, batching/n)]]
W tensorflow/core/framework/op_kernel.cc:936] Out of range: PaddingFIFOQueue '_0_batching/padding_fifo_queue' is closed and has insufficient elements (requested 50, current size 0)
     [[Node: batching = QueueDequeueMany[_class=["loc:@batching/padding_fifo_queue"], component_types=[DT_INT32, DT_INT32], timeout_ms=-1, _device="/job:localhost/replica:0/task:0/cpu:0"](batching/padding_fifo_queue, batching/n)]]
E tensorflow/core/client/tensor_c_api.cc:485] PaddingFIFOQueue '_0_batching/padding_fifo_queue' is closed and has insufficient elements (requested 50, current size 0)
     [[Node: batching = QueueDequeueMany[_class=["loc:@batching/padding_fifo_queue"], component_types=[DT_INT32, DT_INT32], timeout_ms=-1, _device="/job:localhost/replica:0/task:0/cpu:0"](batching/padding_fifo_queue, batching/n)]]
     [[Node: batching/_9 = _Recv[client_terminated=false, recv_device="/job:localhost/replica:0/task:0/gpu:0", send_device="/job:localhost/replica:0/task:0/cpu:0", send_device_incarnation=1, tensor_name="edge_1191_batching", tensor_type=DT_INT32, _device="/job:localhost/replica:0/task:0/gpu:0"]()]]
Traceback (most recent call last):
  File "train_lstm.py", line 66, in <module>
    model.embedding_placeholder: data.glove_vec})
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/client/session.py", line 382, in run
    run_metadata_ptr)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/client/session.py", line 655, in _run
    feed_dict_string, options, run_metadata)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/client/session.py", line 723, in _do_run
    target_list, options, run_metadata)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/client/session.py", line 743, in _do_call
    raise type(e)(node_def, op, message)
tensorflow.python.framework.errors.OutOfRangeError: PaddingFIFOQueue '_0_batching/padding_fifo_queue' is closed and has insufficient elements (requested 50, current size 0)
     [[Node: batching = QueueDequeueMany[_class=["loc:@batching/padding_fifo_queue"], component_types=[DT_INT32, DT_INT32], timeout_ms=-1, _device="/job:localhost/replica:0/task:0/cpu:0"](batching/padding_fifo_queue, batching/n)]]
     [[Node: batching/_9 = _Recv[client_terminated=false, recv_device="/job:localhost/replica:0/task:0/gpu:0", send_device="/job:localhost/replica:0/task:0/cpu:0", send_device_incarnation=1, tensor_name="edge_1191_batching", tensor_type=DT_INT32, _device="/job:localhost/replica:0/task:0/gpu:0"]()]]
Caused by op u'batching', defined at:
  File "train_lstm.py", line 49, in <module>
    model = RNNClassifier(FLAGS)
  File "/home/ccrmad/Code/TDLSTM/models/rnn_classifier.py", line 34, in __init__
    batched_inputs, batched_labels = self.batch_data()
  File "/home/ccrmad/Code/TDLSTM/models/rnn_classifier.py", line 74, in batch_data
    name='batching'
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/training/input.py", line 595, in batch
    dequeued = queue.dequeue_many(batch_size, name=name)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/ops/data_flow_ops.py", line 435, in dequeue_many
    self._queue_ref, n=n, component_types=self._dtypes, name=name)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/ops/gen_data_flow_ops.py", line 867, in _queue_dequeue_many
    timeout_ms=timeout_ms, name=name)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/framework/op_def_library.py", line 703, in apply_op
    op_def=op_def)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/framework/ops.py", line 2310, in create_op
    original_op=self._default_original_op, op_def=op_def)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/framework/ops.py", line 1232, in __init__
    self._traceback = _extract_stack()

I have tried move the train_x and train_y placeholder initialization before init = tf.initialize_all_variables() and feed them to RNNClassifier() as two args but it still give the same error. Why?

Answer 1

It looks like the problem is in this method, in RNNClassifier:

def batch_data(self):
    # ...
    batched_inputs, batched_labels = tf.train.batch(
        tensors=[self._train_x, self._train_y],
        batch_size=self.params.batch_size,
        dynamic_pad=True,
        enqueue_many=True,
        name='batching')

The two tensor arguments to tf.train.batch() are self._train_x and self._train_y. In the RNNClassifier constructor, it seems like you create these as tf.placeholder() tensors:

def __init__(self, FLAGS):
    # ...
    with tf.device("/cpu:0"):
        self.train_x = tf.placeholder(tf.int32, [6248, 42], name='train_x')
        self.train_y = tf.placeholder(tf.int32, [6248, 3], name='train_y')

...though I'm assuming that the difference between self._train_x and self.train_x is a copy-paste error, because self._train_x doesn't seem to be defined anywhere else.

Now, one of the surprising things about tf.train.batch() is that it consumes its inputs in a completely separate thread, called a "queue runner", and started when you call tf.train.start_queue_runners(). This thread calls Session.run() on a subgraph that depends on your placeholders, but doesn't know how to feed these placeholders, so it is this call that fails, leading to the error you are seeing.

How then should you fix it? One option would be to use a "feeding queue runner", for which there is experimental support. A simpler option would be to use the tf.train.slice_input_producer() to produce slices from your input data, as follows:

def batch_data(self, train_x, train_y):
    input_slice, label_slice = tf.train.slice_input_producer([train_x, train_y])
    batched_inputs, batched_labels = tf.train.batch(
        tensors=[input_slice, label_slice],
        batch_size=self.params.batch_size,
        dynamic_pad=False,   # All rows are the same shape.
        enqueue_many=False,  # tf.train.slice_input_producer() produces one row at a time.
        name='batching')
    return batched_inputs, batched_labels

# ...
# Create batches from the entire training data, where `array_input` and
# `array_labels` are two NumPy arrays.
batched_inputs, batched_labels = model.batch_data(array_input, array_labels)