Tensorflow: low loss resulting in low accuracy

Question

I am trying to use Tensorflow and build a simple logistic regression classifier. The training set consists of around half a million (480, 000) data points. I am training on batches of size 100.

When training the model the loss falls from 0.002 to 0.000000034 within 20 training epochs ( the whole training set is traversed batch by batch in each epoch).

However this gives an accuracy of 0.671725 on the training set, which seems very low. To my understanding the accuracy on the training set should be near 1.00 (100%). As I am quite new to Tensorflow I am not sure if I am missing a crucial detail in my calculations.

1. Changing the batch size to 1000 does not make much of a difference - from 0.671698 to 0.671725.

2. Could be overfitting, but I still can't understand why it lowers the accuracy on the training set as well.

3. Decreasing the epochs to 10 gives the same accuracy.

4. Increasing the epochs to 100 does not change the accuracy.

5. Increasing the learning rate from 0.001 to 0.01 yields 0.000000000 after 75 epochs. The value is very small to fit in the precision. The training accuracy stays the same

Code snippet:

x = tf.placeholder(tf.float32, [None, window_size]) # data with the size of the window currently set to 6
y = tf.placeholder(tf.float32, [None, 2])

W = tf.Variable(tf.zeros([window_size, 2]))
b = tf.Variable(tf.zeros([2]))

# Construct model
model = tf.nn.sigmoid(tf.matmul(x, W) + b) #Sigmoid

cost = tf.reduce_mean(-tf.reduce_sum(y * tf.log(model), reduction_indices=1))

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

# Inirializing the variables
init = tf.initialize_all_variables()

print (len(feed_windows_np))

batch_size = 1000


#Splitting to train and test
train = feed_windows_np[:len(feed_windows_np)//2 - ((len(feed_windows_np)//2) % batch_size)]
train_labels = labels[:len(feed_windows_np)//2 - ((len(feed_windows_np)//2) % batch_size)]
test = feed_windows_np[(len(feed_windows_np) * 2) // 3:]
test_labels = labels[(len(feed_windows_np) * 2) // 3:]

total_batches = int(math.floor(len(train) / batch_size))

avg_costs = []

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

# Training cycle
for epoch in range(epochs):
avg_cost = 0.
for i in range(total_batches):
    feed_dict = {
        x: train[i * batch_size:(i + 1) * batch_size],
        y: labels[i * batch_size:(i + 1) * batch_size]
    }
    _, c = sess.run([optimizer, cost], feed_dict=feed_dict)
    #sess.run(optimizer, feed_dict=feed_dict)
    # updating the loss
    avg_cost += c / total_batches
if (epoch + 1) % display_step == 0:
    print ('Epoch:', '%04d' % (epoch + 1), 'cost=', '{:.9f}'.format(avg_cost))
    avg_costs.append(avg_cost)
print ('Optimisation Finished!')


plt.plot(avg_costs)
plt.show()

# Training accuracy
correct_prediction = tf.equal(tf.argmax(model, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
accuracy_val= sess.run(accuracy, feed_dict={x: train, y: train_labels})
print ('Accuracy on training data:', accuracy_val)

Any idea what could be causing this behaviour? Is it the size that is big, because when going down to 80 training data points the accuracy gets to one as it should be?