CNN не тренируется и не проверяет должным образом

Question

Я пытаюсь решить задачу бинарной классификации. У меня есть матрица из 20 000 X 50 нулей и единиц, и 20 000 изображений каждая картинка представляет собой размерный вектор 4392, который во время процесса я изменит в 61 * 72 и пройдет через сеть.после того, как я пропущу изображения через сеть, я хочу получить для каждого изображения размерный вектор из 50 нулей и единиц, а затем сравнить предсказанные результаты с истинными значениями, которые я загрузил.у меня есть сверточная нейронная сеть, которую я построил, используя этот пример: https://pythonprogramming.net/cnn-tensorflow-convolutional-nerual-network-machine-learning-tutorial/?completed=/convolutional-neural-network-cnn-machine-learning-tutorial//У меня есть набор данных изображений, которые я делю для обучения и тестирования (обычно 80% для обучения и 20% для тестирования).но когда я запускаю код, моя точность обучения и потери не меняются, чтобы соответствовать и оставаться на одном уровне в течение всего процесса.я попытался изменить пару параметров в моем коде, включая размер данных, скорость обучения (0,001,0.1,0.01,0.0001), количество слоев (2,3,4,5), и пробовал несколько функций стоимости и вычисления точности,но это не помогает вообще.вот мой код:

 
    from <strong>future</strong> import absolute_import
    from <strong>future</strong> import division
    from <strong>future</strong> import print_function
    import csv 
    import time
    import os
    import urllib</p>

<code>import numpy as np
import tensorflow as tf
start_time = time.time()


data_in = np.transpose(np.loadtxt(open("20k_IMAGES.csv"), delimiter=","))
ones_zeros= np.loadtxt(open("activations20k.csv"), delimiter=",")
print("--- %s seconds ---" % (time.time() - start_time))

epochs=10
learning_rate=0.001
batch_size=200
n_classes=50
height=61
width=72
channels=1
n_inputs=height*width

train_X=data_in[0:16000,:]     #training set (images) (8000,4392)
test_X=data_in[16000:20000,:]   # test se (images)   (2000,4392)
train_Y=ones_zeros[0:16000,:]    #training set (labels) (8000,50)
test_Y=ones_zeros[16000:20000,:]  #test set (labels)    (2000,50)

n = train_X.shape[1] #4392
m = train_X.shape[0]
d = train_Y.shape[1] #50
k= train_Y.shape[0]
l = test_X.shape[0] #2000

x = tf.placeholder(tf.float32, shape=[None, n_inputs], name="X")

trainY = tf.placeholder(tf.float32, shape=[None,n_classes], name="trainY")
testY= tf.placeholder(tf.int32, shape=[l,d], name="testY")
testX= tf.placeholder(tf.int32, shape=[l,n], name="testX")

keep_rate = 0.8
keep_prob = tf.placeholder(tf.float32) #try to remove it


def conv2d(x, W):
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def maxpool2d(x):
    #                        size of window         movement of window
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')


def convolutional_neural_network(x):
    weights = {'W_conv1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
               'W_conv2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
               'W_conv3': tf.Variable(tf.random_normal([5, 5, 64, 128])),
               'W_conv4': tf.Variable(tf.random_normal([5, 5, 128, 256])),
               'W_conv5': tf.Variable(tf.random_normal([5, 5, 256, 512])),
               'W_fc': tf.Variable(tf.random_normal([2 * 3 * 512, 1024])), #check if 15 or 16
               'out': tf.Variable(tf.random_normal([1024, n_classes]))}

    biases = {'b_conv1': tf.Variable(tf.random_normal([32])),
              'b_conv2': tf.Variable(tf.random_normal([64])),
              'b_conv3':tf.Variable(tf.random_normal([128])),
              'b_conv4': tf.Variable(tf.random_normal([256])),
              'b_conv5': tf.Variable(tf.random_normal([512])),
              'b_fc': tf.Variable(tf.random_normal([1024])),
              'out': tf.Variable(tf.random_normal([n_classes]))}

    x = tf.reshape(x, shape=[-1, 61, 72, 1])

    conv1 = tf.nn.relu(conv2d(x, weights['W_conv1']) + biases['b_conv1'])
    conv1 = maxpool2d(conv1)

    conv2 = tf.nn.relu(conv2d(conv1, weights['W_conv2']) + biases['b_conv2'])
    conv2 = maxpool2d(conv2)

    conv3 = tf.nn.relu(conv2d(conv2, weights['W_conv3']) + biases['b_conv3'])
    conv3 = maxpool2d(conv3)

    conv4 = tf.nn.relu(conv2d(conv3, weights['W_conv4']) + biases['b_conv4'])
    conv4 = maxpool2d(conv4)

    conv5 = tf.nn.relu(conv2d(conv4, weights['W_conv5']) + biases['b_conv5'])
    conv5 = maxpool2d(conv5)

    fc = tf.reshape(conv5, [-1, 2 * 3 * 512])
    fc = tf.nn.relu(tf.matmul(fc, weights['W_fc']) + biases['b_fc'])
    fc = tf.nn.dropout(fc, keep_rate)

    output = tf.matmul(fc, weights['out']) + biases['out']
    sig_output = tf.nn.sigmoid(output)

    return sig_output

def train_neural_network(x):
    prediction = convolutional_neural_network(x)

    #cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=prediction, labels=trainY))
    #cost= tf.reduce_mean(tf.losses.sigmoid_cross_entropy(multi_class_labels=trainY, logits=prediction))
    cost=tf.losses.absolute_difference(labels=trainY, predictions=prediction)
    #cost=tf.losses.log_loss(labels=trainY, predictions=prediction)
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost)
    #optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
    # Here you check whether the index of the maximum value of the predicted image is equal to the actual labelled image. and both will be a column vector.
    correct_prediction = tf.equal(tf.argmax(prediction, 1), tf.argmax(trainY, 1))
    # calculate accuracy across all the given images and average them out.
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))


    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        for epoch in range(epochs):
            for iteration in range(len(train_X) // batch_size):

                X_batch = train_X[iteration * batch_size:iteration * batch_size + batch_size,:]
                y_batch = train_Y[iteration * batch_size:iteration * batch_size + batch_size,:]

                sess.run(optimizer, feed_dict={x: X_batch , trainY: y_batch})
                train_loss=sess.run(cost, feed_dict={x: X_batch , trainY: y_batch})
                train_acc=sess.run(accuracy, feed_dict={x: X_batch , trainY: y_batch})
                preds_train = sess.run(prediction, feed_dict={x: X_batch, trainY: y_batch})
                print("Batch:", '%04d' % (batch_size * iteration), "iteration:", '%04d' % iteration, "Epoch",
                      '%04d' % (epoch + 1), "loss=","{:.6f}".format(train_loss), ",training accuracy=", "{:.6f}".format(train_acc))  # ,"probabilities:",predictions)
                #print("train predictions:", preds_train)
        print("Optimization Finished!")


        valid_loss = sess.run([cost], feed_dict={x: test_X, trainY: test_Y}) #change trainY to y in test and training
        print("validation loss:", valid_loss)
        test_acc = sess.run([accuracy], feed_dict={x: test_X, trainY: test_Y})#change trainY to y in test and training
        print("Testing Accuracy:",test_acc)
        preds_test=sess.run(prediction, feed_dict={x: test_X, trainY: test_Y})
        print("test predictions:", preds_test)
        #pred = open('predictions.csv', 'w')
        np.savetxt("prediction4k_of20k.csv", preds_test, delimiter=",")
        np.savetxt("test_Y4k_of_20k.csv", test_Y, delimiter=",")

    train_neural_network(x)


    print("--- %s seconds ---" % (time.time() - start_time))
</code>

Что еще я могу сделать, чтобы улучшить свой код, чтобы он мог работать правильно?починить это?спасибо за помощь !!