Невозможно передать значение тензора заполнителя

Я написал простую двунаправленную версию lstm для классификации предложений. Но он продолжает давать мне "Вы должны подкорректировать значение для тензора" train_x "тензор заполнителя", и, похоже, это происходит с этапа инициализации переменной.

Я попытался переместить инициализацию placeholder train_x и train_y до init = tf.initialize_all_variables() и передать их в RNNClassifier() как два аргумента, но он все равно дает ту же ошибку. Почему?

Ответы

Ответ 1

Похоже, проблема заключается в этом методе, в 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')

Два тензорных аргумента tf.train.batch() - это self._train_x и self._train_y. В конструкторе RNNClassifier кажется, что вы создаете их как tf.placeholder() тензоры:

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')

... хотя я предполагаю, что разница между self._train_x и self.train_x является ошибкой копирования-вставки, потому что self._train_x, похоже, не определяется где-либо еще.

Теперь одна из удивительных вещей о tf.train.batch() заключается в том, что он потребляет свои входы в полностью отдельном потоке, называемом "бегун очереди", и запускается, когда вы вызываете tf.train.start_queue_runners(). Этот поток вызывает Session.run() на подграфе, который зависит от ваших заполнителей, но не знает, как кормить эти заполнители, так что именно этот вызов который не работает, что приводит к ошибке, которую вы видите.

Как же вы должны это исправить? Один из вариантов заключается в использовании "run queue runner" , для которого имеется экспериментальная поддержка. Более простой вариант заключается в использовании tf.train.slice_input_producer() для создания срезов из ваших входных данных следующим образом:

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)

Ответ 2

Это то, что я сделал.

Я мог бы изменить способ инициализации входных переменных следующим образом:

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

with tf.Session() as sess:
    sess.run(init)
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    for epoch in range(FLAGS.max_max_epoch):
        sess.run(model.train_step)
        loss, acc = sess.run([model.mean_cost, model.accuracy])
        print("Epoch {:2d}: Loss = {:.6f}; Training Accuracy = {:.5f}".format(epoch+1, loss, acc))
    print()
    coord.request_stop()
    coord.join(threads)

И в классе RNNClassifier я мог бы заменить

    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])

(и удалите use_embedding()) до

def __init__(self, FLAGS, data):
    self._train_x = tf.convert_to_tensor(data.train_x, dtype=tf.int32)
    self._train_y = tf.convert_to_tensor(data.train_y, dtype=tf.int32)
    embedding = tf.get_variable("embedding", shape=self.embedding_shape, trainable=False)
    self.embedding_init = embedding.assign(data.glove_vec)

Таким образом, все инициализируется с помощью RNNClassifier(FLAGS, data) перед тем, как сделать вызов для бегунов очереди.

Я до сих пор не знаю, почему предыдущий способ, как использование заполнителей, не работал. Я проверил dtype и форму данных, они все совпадают. Этот пост, похоже, имеет аналогичную проблему, и "ответ" предлагает заменить placeholder на tf.Variable. Я пробовал это - теперь можно вводить входные значения, но obvs не работает, поскольку заполнители делают и поддерживают только инициализированные значения.

ОБНОВЛЕНИЕ: Я думаю, что ошибка может быть вызвана операциями ввода пакетов в классе RNNClassifier, что каким-то образом повлияло на подачу входных данных на график (повторите, пожалуйста, исправьте меня, если вы знаете причину ошибки, благодарю!). Вместо этого я переместил свои функции пакетной и встраивания в свой основной код перед инициализацией сеанса, поэтому я думаю, что он гарантирует, что все входы будут определены в основном конвейере, а пакетная и предварительная выборка будут обрабатываться внутри графика tf (не используя заполнители).

Здесь мой код:

def batch(x, y):
    with tf.device("/cpu:0"):
        x = tf.convert_to_tensor(x, dtype=tf.int32)
        y = tf.convert_to_tensor(y, dtype=tf.int32)
        batched_x, batched_y = tf.train.batch(
            tensors=[x, y],
            batch_size=50,
            dynamic_pad=True,
            enqueue_many=True,
            name='batching'
            )
    return (batched_x, batched_y)


def embed(df):
    with tf.device("/cpu:0"), tf.variable_scope("embed"):
        embedding = tf.get_variable("embedding", shape=df.embed_shape, trainable=False)
        embedding_init = embedding.assign(df.embed_vec)
    return embedding_init


data = load_data(FLAGS.data)
pretrained_embed = embed(data)
batched_train_x, batched_train_y = batch(data.train_x, data.train_y)
batched_test_x, batched_test_y = batch(data.train_x, data.train_y)

model = RNNClassifier(FLAGS, pretrained_embed)
logits = model.inference(batched_train_x)
test_pred = model.inference(batched_test_x, reuse=True)
loss = model.loss(logits, batched_train_y)
test_loss = model.loss(test_pred, batched_test_y)
train_op = model.training(loss[0])

init = tf.group(tf.initialize_all_variables(),
                tf.initialize_local_variables())


with tf.Session() as sess:
    t0 = time.time()
    sess.run(init)
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    np.random.seed(FLAGS.random_state)
    for epoch in range(FLAGS.max_max_epoch):
        _, output = sess.run([train_op, loss])
        loss_value, acc = output
        print("Epoch {:2d}: Loss = {:.6f}; Training Accuracy = {:.5f}".format(epoch+1, loss_value, acc))
    print()
    coord.request_stop()
    coord.join(threads)

И RNNClassifier:

class RNNClassifier:

    def __init__(self, FLAGS, embedding_init):
        self.batch_size = FLAGS.batch_size
        self.num_hidden = FLAGS.num_hidden
        self.num_classes = FLAGS.num_classes
        self.seq_len = FLAGS.seq_len
        self.embedding_init = embedding_init

    def inference(self, batched_inputs, reuse=None):
        embed_inputs = tf.nn.embedding_lookup(self.embedding_init, tf.transpose(batched_inputs))

        with tf.variable_scope('hidden', reuse=reuse):
            with tf.variable_scope('forward_lstm'):
                lstm_fw_cell = tf.nn.rnn_cell.LSTMCell(num_units=self.num_hidden, use_peepholes=False, 
                                                    activation=tf.nn.relu, forget_bias=0.0, 
                                                    initializer=tf.random_uniform_initializer(-1.0, 1.0),
                                                    state_is_tuple=True)
                lstm_fw_cell = tf.nn.rnn_cell.DropoutWrapper(cell=lstm_fw_cell, input_keep_prob=0.7)

            with tf.variable_scope('backward_lstm'):
                lstm_bw_cell = tf.nn.rnn_cell.LSTMCell(num_units=self.num_hidden, use_peepholes=False, 
                                                    activation=tf.nn.relu, forget_bias=0.0, 
                                                    initializer=tf.random_uniform_initializer(-1.0, 1.0),
                                                    state_is_tuple=True)
                lstm_bw_cell = tf.nn.rnn_cell.DropoutWrapper(cell=lstm_bw_cell, input_keep_prob=0.7)

            fw_initial_state = lstm_fw_cell.zero_state(self.batch_size, tf.float32)
            bw_initial_state = lstm_bw_cell.zero_state(self.batch_size, tf.float32)

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

        with tf.variable_scope('output', reuse=reuse):
            with tf.variable_scope('softmax'):
                W = tf.get_variable('W', [self.num_hidden*2, self.num_classes],
                                    initializer=tf.truncated_normal_initializer(stddev=0.1))
                b = tf.get_variable('b', [self.num_classes], initializer=tf.constant_initializer(0.1))
            logits = tf.matmul(rnn_outputs[-1], W) + b
        return logits


    def loss(self, logits, labels):
        cost = tf.nn.softmax_cross_entropy_with_logits(logits, tf.cast(labels, tf.float32))
        # self.total_cost = tf.reduce_sum(self.cost)
        mean_cost = tf.reduce_mean(cost)
        correct_pred = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
        return mean_cost, accuracy


    def training(self, cost):
        optimizer = tf.train.AdamOptimizer(learning_rate=0.001)
        train_op = optimizer.minimize(cost)
        return train_op

На стороне примечания, я бы хотел, чтобы сообщество Tensorflow в stackoverflow было более активным.