Как получить предсказание от Tensorflow

Question

Я взял динамический пример РНН из aymericdamian: https://github.com/aymericdamien/TensorFlow-Examples/blob/master/examples/3_NeuralNetworks/dynamic_rnn.py

и модифицировать его немного, чтобы соответствовать моим данным. Данные представляют собой список из 7500 наборов данных из 60 записей.

В качестве выходных данных имеется 5 ярлыков.

Код работает идеально, и я получаю точность 75%.

Теперь я хочу, чтобы накормить модель с набором данных и получить прогнозируемую метку назад, но я получаю следующее сообщение об ошибке:

tensorflow.python.framework.errors_impl.InvalidArgumentError: Вы должны кормить значение для заполнителя тензор 'Placeholder_2' с dtype int32

Код указан ниже, а две последние строки - это то, где я хочу получить прогноз назад.

Что я делаю неправильно?

# ========== 
# MODEL 
# ========== 

# Parameters 
learning_rate = 0.01 
training_iters = 1000000 
batch_size = 128 
display_step = 10 

# Network Parameters 
seq_max_len = 60 # Sequence max length 
n_hidden = 64 # hidden layer num of features 
n_classes = 5 # large rise, small rise, almost equal, small drop, large drop 

trainset = ToySequenceData(n_samples=7500, max_seq_len=seq_max_len) 
testset = copy.copy(trainset) 

# take 50% of total data to use for training 
trainpart = int(0.2 * trainset.data.__len__()) 

pred_data = testset.data[testset.data.__len__() - 2:testset.labels.__len__() - 1][:] 
pred_label = testset.labels[testset.labels.__len__() - 1:][:] 

trainset.data = trainset.data[:trainpart][:] 
testset.data = testset.data[trainpart:testset.data.__len__() - 2][:] 

trainset.labels = trainset.labels[:trainpart][:] 
testset.labels = testset.labels[trainpart:testset.labels.__len__() - 2][:] 

trainset.seqlen = trainset.seqlen[:trainpart][:] 
testset.seqlen = testset.seqlen[trainpart:testset.seqlen.__len__() - 2] 

# tf Graph input 
x = tf.placeholder("float", [None, seq_max_len, 1]) 
y = tf.placeholder("float", [None, n_classes]) 
# A placeholder for indicating each sequence length 
seqlen = tf.placeholder(tf.int32, [None]) 

# Define weights 
weights = { 
    'out': tf.Variable(tf.random_normal([n_hidden, n_classes])) 
} 
biases = { 
    'out': tf.Variable(tf.random_normal([n_classes])) 
} 


def dynamic_rnn(x, seqlen, weights, biases): 

    # Prepare data shape to match `rnn` function requirements 
    # Current data input shape: (batch_size, n_steps, n_input) 
    # Required shape: 'n_steps' tensors list of shape (batch_size, n_input) 

    # Permuting batch_size and n_steps 
    x = tf.transpose(x, [1, 0, 2]) 
    # Reshaping to (n_steps*batch_size, n_input) 
    x = tf.reshape(x, [-1, 1]) 
    # Split to get a list of 'n_steps' tensors of shape (batch_size, n_input) 
    x = tf.split(0, seq_max_len, x) 

    # Define a lstm cell with tensorflow 
    lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(n_hidden) 

    # Get lstm cell output, providing 'sequence_length' will perform dynamic 
    # calculation. 
    outputs, states = tf.nn.rnn(lstm_cell, x, dtype=tf.float32, 
           sequence_length=seqlen) 

    # When performing dynamic calculation, we must retrieve the last 
    # dynamically computed output, i.e., if a sequence length is 10, we need 
    # to retrieve the 10th output. 
    # However TensorFlow doesn't support advanced indexing yet, so we build 
    # a custom op that for each sample in batch size, get its length and 
    # get the corresponding relevant output. 

    # 'outputs' is a list of output at every timestep, we pack them in a Tensor 
    # and change back dimension to [batch_size, n_step, n_input] 
    outputs = tf.pack(outputs) 
    outputs = tf.transpose(outputs, [1, 0, 2]) 

    # Hack to build the indexing and retrieve the right output. 
    batch_size = tf.shape(outputs)[0] 
    # Start indices for each sample 
    index = tf.range(0, batch_size) * seq_max_len + (seqlen - 1) 
    # Indexing 
    outputs = tf.gather(tf.reshape(outputs, [-1, n_hidden]), index) 

    # Linear activation, using outputs computed above 
    return tf.matmul(outputs, weights['out']) + biases['out'] 

pred = dynamic_rnn(x, seqlen, weights, biases) 

# Define loss and optimizer 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y)) 
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost) 

# Evaluate model 
correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) 
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) 

# Initializing the variables 
init = tf.initialize_all_variables() 

# Launch the graph 
with tf.Session() as sess: 
    sess.run(init) 
    step = 1 
    # Keep training until reach max iterations 
    while step * batch_size < training_iters: 
     batch_x, batch_y, batch_seqlen = trainset.next(batch_size) 
     # Run optimization op (backprop) 
     sess.run(optimizer, feed_dict={x: batch_x, y: batch_y, 
             seqlen: batch_seqlen}) 
     if step % display_step == 0: 
      # Calculate batch accuracy 
      acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y, 
               seqlen: batch_seqlen}) 
      # Calculate batch loss 
      loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y, 
              seqlen: batch_seqlen}) 

      print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + 
        "{:.6f}".format(loss) + ", Training Accuracy= " + 
        "{:.5f}".format(acc)) 
     step += 1 
    print("Optimization Finished!") 

    # Calculate accuracy 
    test_data = testset.data 
    test_label = testset.labels 
    test_seqlen = testset.seqlen 
    print("Testing Accuracy:", 
      sess.run(accuracy, feed_dict={x: test_data, y: test_label, 
        seqlen: test_seqlen})) 
    print(pred.eval(feed_dict={x: pred_data})) 
    print(pred_label) 

Answer 1

В TensorFlow, когда вы не обеспечивают name к tf.placeholder, он принимает имя по умолчанию "Placeholder". Следующий созданный заполнитель называется "Placeholder_1", а третий - "Placeholder_2".

Это делается для однозначного определения каждого заполнителя. Теперь в вашей последней строке вы пытаетесь получить значение pred.eval(). Глядя на ваш dynamic_rnn код, кажется, вам нужно значение в seq_len заполнителем, который является третьим заполнителем определено (именно поэтому "Placeholder_2". Просто добавьте следующий ключ-значение для вашего feed_dict,

print(pred.eval(feed_dict={x: pred_data, seqlen: pred_seqlen})) 

Конечно, вам нужно будет определить pred_seqlen правильно, как вы определили другие две переменные seq_len.