Dimensions must be equal, but are 15 and 1 for 'MatMul_1' (op: 'MatMul') with input shapes: [1,15], [1,500]

Question

I cannot understand the dimension part. Is it about the shape [1,15]I set?

import tensorflow as tf
import numpy as np
import pandas as pd



with open('train.CSV', 'r') as f:  
    data0 = f.readlines()  

    for line in data0:  
        odom = line.split()         
        numbers_float0 = map(float, odom) 

with open('trainY.CSV', 'r') as f:  
    data1 = f.readlines()  

for line in data1:  
    odom = line.split()        
    numbers_float1 = map(float, odom)  

with open('test.CSV', 'r') as f:  
    data2 = f.readlines()  

    for line in data2:  
        odom = line.split()        
        numbers_float2 = map(float, odom) 

with open('Test Y.CSV', 'r') as f:  
    data3 = f.readlines()    

    for line in data3:  
        odom = line.split()      
        numbers_float3 = map(float, odom)  



train_x,train_y,test_x,test_y =             ('numbers_float0','numbers_float1','numbers_float2','numbers_float3')
n_nodes_hl1 = 500
n_nodes_hl2 = 500
n_nodes_hl3 = 500

n_classes = 2
batch_size = 100
hm_epochs = 10

x =tf.placeholder('float',[1,15])  
y = tf.placeholder('float',[1,1])

hidden_1_layer = {'f_fum':n_nodes_hl1,
                  'weight':tf.Variable(tf.random_normal([len(train_x[0]),         n_nodes_hl1])),
                  'bias':tf.Variable(tf.random_normal([n_nodes_hl1]))}

hidden_2_layer = {'f_fum':n_nodes_hl2,
                  'weight':tf.Variable(tf.random_normal([n_nodes_hl1, n_nodes_hl2])),
                  'bias':tf.Variable(tf.random_normal([n_nodes_hl2]))}

hidden_3_layer = {'f_fum':n_nodes_hl3,
                  'weight':tf.Variable(tf.random_normal([n_nodes_hl2, n_nodes_hl3])),
              'bias':tf.Variable(tf.random_normal([n_nodes_hl3]))}

output_layer = {'f_fum':None,
            'weight':tf.Variable(tf.random_normal([n_nodes_hl3, n_classes])),
                'bias':tf.Variable(tf.random_normal([n_classes])),}


# Nothing changes
def neural_network_model(data):

    l1 = tf.add(tf.matmul(data,hidden_1_layer['weight']),     hidden_1_layer['bias'])
    l1 = tf.nn.relu(l1)

    l2 = tf.add(tf.matmul(l1,hidden_2_layer['weight']),     hidden_2_layer['bias'])
    l2 = tf.nn.relu(l2)

    l3 = tf.add(tf.matmul(l2,hidden_3_layer['weight']), hidden_3_layer['bias'])
    l3 = tf.nn.relu(l3)

    output = tf.matmul(l3,output_layer['weight']) + output_layer['bias']

    return output

def train_neural_network(x):
    prediction = neural_network_model(x)
    cost =     tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(logits=prediction, labels=y))
    #tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(prediction,y) )




    optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(cost)

    with tf.Session() as sess:
        sess.run(tf.initialize_all_variables())

        for epoch in range(hm_epochs):
            epoch_loss = 0
            i=0
            while i < len(train_x):
                start = i
                end = i+batch_size
                batch_x = np.array(train_x[start:end])
                batch_y = np.array(train_y[start:end])

                _, c = sess.run([optimizer, cost], feed_dict={x: batch_x,
                                                          y: batch_y})
                epoch_loss += c
                i+=batch_size

            print('Epoch', epoch+1, 'completed out of',hm_epochs,'loss:',epoch_loss)
        correct = tf.equal(tf.argmax(prediction, 1), tf.argmax(y, 1))
        accuracy = tf.reduce_mean(tf.cast(correct, 'float'))

        print('Accuracy:',accuracy.eval({x:test_x, y:test_y}))


train_neural_network(x)

Here is the trace error: enter image description here

Here is the Data train.CSV enter image description here

The Y data I use is only one column .

Answer 1

Technically the placeholder doesn't need a shape at all. It can be defined as such.

x = tf.placeholder('float', shape=[])

In this case the place holder itself has no shape information to it. If you know the dimensions of the tensor but not it's actual numerical shape we replace the numerical value of that dimension with None because it can have a variable size.

 x = tf.placeholder('float', shape=[None, None, None])

This affects some down stream static shape analysis that tensorflow does to get the shape information but otherwise it should still work as intended.