TensorFlow: Die Netzwerkausgabe hat keine Form erwartet

Question

Ich implementiere ein Netzwerk mit TensorFlow. Das Netzwerk nimmt einen binären Merkmalsvektor als Eingabe und sollte einen Gleitkommawert als Ausgabe vorhersagen. Ich erwarte ein (1,1) Tensor-Objekt als Ausgabe für meine Funktion multilayer_perceptron(), stattdessen, wenn pred läuft, gibt es einen Vektor der gleichen Länge meiner Eingabedaten (X, 1).

Da ich neu in diesem Framework bin, erwarte ich, dass der Fehler sehr trivial ist. Was mache ich falsch?

import tensorflow as tf 

print "**** Defining parameters..." 
# Parameters 
learning_rate = 0.001 
training_epochs = 15 
batch_size = 1 
display_step = 1 

print "**** Defining Network..." 
# Network Parameters 
n_hidden_1 = 10 # 1st layer num features 
n_hidden_2 = 10 # 2nd layer num features 
n_input = Xa.shape[1] # data input(feature vector length) 
n_classes = 1 # total classes (IC50 value) 

# tf Graph input 
x = tf.placeholder("int32", [batch_size, None]) 
y = tf.placeholder("float", [None, n_classes]) 

# Create model 
def multilayer_perceptron(_X, _weights, _biases): 
    lookup_h1 = tf.nn.embedding_lookup(_weights['h1'], _X) 
    layer_1 = tf.nn.relu(tf.add(tf.reduce_sum(lookup_h1, 0), _biases['b1'])) #Hidden layer with RELU activation 
    layer_2 = tf.nn.relu(tf.add(tf.matmul(layer_1, _weights['h2']), _biases['b2'])) #Hidden layer with RELU activation 
    pred = tf.matmul(layer_2, _weights['out']) + _biases['out'] 

    return pred 

# Store layers weight & bias 
weights = { 
      'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])), 
      'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])), 
      'out': tf.Variable(tf.random_normal([n_hidden_2, n_classes])) 
      } 
biases = { 
     'b1': tf.Variable(tf.random_normal([n_hidden_1])), 
     'b2': tf.Variable(tf.random_normal([n_hidden_2])), 
     'out': tf.Variable(tf.random_normal([n_classes])) 
} 

# Construct model 
pred = multilayer_perceptron(x, weights, biases) 

# Define loss and optimizer 
cost = tf.reduce_mean(tf.square(tf.sub(pred, y))) # MSE 
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) #Gradient descent 

# 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() 

print "**** Launching the graph..." 
# Launch the graph 
with tf.Session() as sess: 
    sess.run(init) 

    print "**** Training..." 
    # Training cycle 
    for epoch in range(training_epochs): 
    avg_cost = 0. 
    total_batch = int(Xa.tocsc().shape[0]/batch_size) 
    # Loop over all batches 
    for i in range(total_batch): 
     # Extract sample 
     batch_xs = Xa.tocsc()[i,:].tocoo() 
     batch_ys = np.reshape(Ya.tocsc()[i,0], (batch_size,1)) 
     #**************************************************************************** 
     # Extract sparse indeces from input matrix (They will be used as actual input) 
     ids = batch_xs.nonzero()[1] 
     # Fit training using batch data 
     sess.run(optimizer, feed_dict={x: ids, y: batch_ys}) 
     # Compute average loss 
     avg_cost += sess.run(cost, feed_dict={x: ids, y: batch_ys})/total_batch 
     # Display logs per epoch step 
    if epoch % display_step == 0: 
     print "Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost) 
    print "Optimization Finished!" 

Answer 1

Ihre pred sollte [n_input, n_class] der Form sein, weil Sie weights['out'] und biases['out'] auf diese Weise definieren. Der einzige Weg, wie Sie einen (1,1) Tensor von pred erhalten, ist Ihr n_class = 1 ...