Нейронная сеть Tensorflow: моя модель дает точность 1,0 каждый раз

Question

Любительская проблема, но я не могу решить эту проблему самостоятельно.
Я пытался создать нейронную сеть для набора данных моделирования оттока на банковских данных

Каждый раз, когда я запускаю эту сеть, я получаю точность 1,0, поэтому я думаю, что что-то не так, и она не работает. Может кто-нибудь помочь мне понять, что не так?
Также, пожалуйста, объясните, как я могу избежать подобных проблем в будущем

Код:

import pandas as pd
import numpy as np
data = pd.read_csv('D:\Churn_Modelling.csv')
X = data.iloc[:, 3:13].values
Y = data.iloc[:, 13].values

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
label_encoder_x_1 = LabelEncoder()
X[:, 1] = label_encoder_x_1.fit_transform(X[:, 1])
label_encoder_x_2 = LabelEncoder()
X[:, 2] = label_encoder_x_2.fit_transform(X[:, 2])
one_hot_encoder = OneHotEncoder(categorical_features = [1])
X = one_hot_encoder.fit_transform(X).toarray()
X = X[:, 1:]

from sklearn.model_selection import train_test_split
X_train, X_test, Y_train, Y_test = 
                          train_test_split(X, Y, test_size = 0.2)

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.fit_transform(X_test)

import tensorflow as tf

epochs = 20
batch_size = 50
learning_rate = 0.003
n_output = 1
n_input = X_train.shape[1]

X_placeholder = tf.placeholder("float32", [None, n_input], name = "X")
Y_placeholder = tf.placeholder("float32", [None, 1], name = "y")

n_neurons_1 = 64
n_neurons_2 = 32
n_neurons_3 = 16

layer_1 = {'weights': tf.Variable
                           (tf.random_normal([n_input, n_neurons_1])),
           'biases': tf.Variable(tf.random_normal([n_neurons_1]))   
        }

layer_2 = {'weights': tf.Variable
                         (tf.random_normal([n_neurons_1, n_neurons_2])),
           'biases': tf.Variable(tf.random_normal([n_neurons_2]))   
        }

layer_3 = {'weights': tf.Variable
                    (tf.random_normal([n_neurons_2, n_neurons_3])),
           'biases': tf.Variable(tf.random_normal([n_neurons_3]))   
        }

output_layer = {'weights': tf.Variable(
                    tf.random_normal([n_neurons_3, n_output])),
           'biases': tf.Variable(tf.random_normal([n_output]))   
        }

l1 = tf.add(tf.matmul(X_placeholder, 
                  layer_1['weights']),    layer_1['biases'])
l1 = tf.nn.relu(l1)

l2 = tf.add(tf.matmul(l1, layer_2['weights']), 
                      layer_2['biases'])
l2 = tf.nn.relu(l2)

l3 = tf.add(tf.matmul(l2, layer_3['weights']), 
                  layer_3['biases'])
l3 = tf.nn.relu(l3)

output_layer = tf.matmul(l3, 
            output_layer['weights']) + output_layer['biases']
output_layer = tf.nn.sigmoid(output_layer)

cost = tf.reduce_mean(tf.reduce_sum(
   tf.square(Y_placeholder - output_layer), reduction_indices = [1]))
optimizer = tf.train.AdamOptimizer().minimize(cost)

correct_prediction = tf.equal(tf.argmax(
           Y_placeholder, 1), tf.argmax(output_layer, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))


def next_batch(size, x, y):
    idx = np.arange(0, len(x))
    np.random.shuffle(idx)
    idx = idx[:size]
    x_shuffle = [x[ i] for i in idx]
    y_shuffle = [y[ i] for i in idx]
    return np.asarray(x_shuffle), np.asarray(y_shuffle)


with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    total_batches = int(len(X_train) / batch_size)

    for epoch in range(epochs):
        avg_cost = 0
        print('epoch: ', epoch)
        for batch in range(total_batches):
            x_batch_data, y_batch_data = 
                 next_batch(batch_size, X_train, Y_train)
            y_batch_data = y_batch_data.reshape((50, 1))
            _, c = sess.run([optimizer, cost], 
                      feed_dict = {X_placeholder: x_batch_data,
                      Y_placeholder: y_batch_data})
            avg_cost += c / total_batches

        print("Epoch:", (epoch + 1), "cost =", "{:.3f}".format(avg_cost))

    Y_test_temp = Y_test.reshape((2000, 1))
    print('accuracy: ', sess.run(accuracy, 
      feed_dict = {X_placeholder: X_test, Y_placeholder: Y_test_temp}))