Tensorflow多层神经网络训练最后输出的值都一样的，找不到是什么原因？

我tensorflow建立6层全连接神经网络，网络的输入数据2625 个，输出数据1个。理想情况下输出数据应该按照一定规规律随着输入数据的变化而变化的，但是训练到最后，无论输入数据是多，输出数据都是一个数值，loss在来回跳动，没有减小。

我的模型代码如下：

import sys
sys.path.insert(0, '/home/wcsmomo/workspace/tutorials')
#from __future__ import print_function, division
import tensorflow as tf
from sklearn.metrics import confusion_matrix
import numpy as np
from my_ant_v3 import FetchDataSets as fds
import DBUtil as dbu
from my_ant_v3 import ant_loger

class Network():
    def __init__(self, num_hidden, num_hidden_2, num_hidden_3, num_hidden_4 , num_hidden_5, batch_size ):
        self.batch_size = batch_size
        self.test_batch_size = batch_size
        # Hyper Parameters
        self.num_hidden = num_hidden
        self.num_hidden_2 = num_hidden_2
        self.num_hidden_3 = num_hidden_3
        self.num_hidden_4 = num_hidden_4
        self.num_hidden_5 = num_hidden_5
        # Graph Related
        self.graph = tf.Graph()
        self.tf_train_samples = None
        self.tf_train_labels = None
        self.tf_test_samples = None
        self.tf_test_labels = None
        self.tf_test_prediction = None

    def define_graph(self):
        with self.graph.as_default():
            self.tf_train_samples = tf.placeholder(tf.float32, shape=(self.batch_size, 375*7))
            self.tf_train_labels = tf.placeholder(tf.float32, shape=(self.batch_size, 1))
            self.tf_test_samples = tf.placeholder(tf.float32, shape=(self.test_batch_size, 375*7))
            self.tf_test_labels = tf.placeholder(tf.float32, shape=(self.test_batch_size, 1))

   # fully connected layer 1, fully connected

   fc1_weights = tf.Variable(tf.truncated_normal([375*7, self.num_hidden], stddev=0.1))

   fc1_biases = tf.Variable(tf.constant(0.0, shape=[self.num_hidden]))



   # fully connected layer 2

   fc2_weights = tf.Variable(tf.truncated_normal([self.num_hidden, self.num_hidden_2], stddev=0.1))

   fc2_biases = tf.Variable(tf.constant(0.0, shape=[self.num_hidden_2]))



   # fully connected layer 3

   fc3_weights = tf.Variable(tf.truncated_normal([self.num_hidden_2, self.num_hidden_3], stddev=0.1))

   fc3_biases = tf.Variable(tf.constant(0.0, shape=[self.num_hidden_3]))



   # fully connected layer 4

   fc4_weights = tf.Variable(tf.truncated_normal([self.num_hidden_3, self.num_hidden_4], stddev=0.1))

   fc4_biases = tf.Variable(tf.constant(0.0, shape=[self.num_hidden_4]))



   # fully connected layer 5

   fc5_weights = tf.Variable(tf.truncated_normal([self.num_hidden_4, self.num_hidden_5], stddev=0.1))

   fc5_biases = tf.Variable(tf.constant(0.0, shape=[self.num_hidden_5]))



   # fully connected layer 6 --> output layer

   fc6_weights = tf.Variable(tf.truncated_normal([self.num_hidden_5, 1], stddev=0.0))

   fc6_biases = tf.Variable(tf.constant(0.0, shape=[1]))


   def model(input_data):
    hidden = tf.nn.relu(tf.matmul(input_data, fc1_weights) + fc1_biases)
    hidden = tf.nn.dropout(hidden, 0.75)

    # fully connected layer 2
    hidden_2 = tf.nn.relu(tf.matmul(hidden, fc2_weights) + fc2_biases)
    hidden_2 = tf.nn.dropout(hidden_2, 0.75

    # fully connected layer 3
    hidden_3 = tf.nn.relu(tf.matmul(hidden_2, fc3_weights) + fc3_biases)
    hidden_3 = tf.nn.dropout(hidden_3, 0.75)

    # fully connected layer 4
    hidden_4 = tf.nn.relu(tf.matmul(hidden_3, fc4_weights) + fc4_biases)
    hidden_4 = tf.nn.dropout(hidden_4, 0.75)

    # fully connected layer 5
    hidden_5 = tf.nn.relu(tf.matmul(hidden_4, fc5_weights) + fc5_biases)
    
    return tf.matmul(hidden_5, fc6_weights) + fc6_biases

   # Training computation.
   self.logits = model(self.tf_train_samples)
   self.loss = tf.reduce_mean(tf.squared_difference(self.logits, self.tf_train_labels))

   # Optimizer.
   #self.optimizer = tf.train.RMSPropOptimizer(0.00005).minimize(self.loss)
   #self.optimizer = tf.train.AdadeltaOptimizer(0.00005).minimize(self.loss)

   self.optimizer = tf.train.AdagradOptimizer(0.00001).minimize(self.loss)
   #self.optimizer = tf.train.AdamOptimizer(0.00005).minimize(self.loss)

   # Predictions for the training, validation, and test
   self.test_prediction = model(self.tf_test_samples)

 def run(self):
  loger = ant_loger.Loger("/home/wcsmomo/workspace/tutorials/ant.log")
  self.session = tf.Session(graph=self.graph)
  with self.session as session:
   session.run(tf.global_variables_initializer())
   saver = tf.train.Saver()
   i = 0
   count = 0
   ck = fds.CreateKindleLines(self.batch_size, data_type='train')
   test_ck = fds.CreateKindleLines(self.test_batch_size, data_type='test')
   while i < ck.avg_k_count:
    if i == ck.avg_k_count -1 :
     i = 0
     ck.k = 0
     test_ck.k = 0
    i +=1
    count +=1
    bat_x,bat_y = ck.fetch_batch_slope_continue_time()

    bat_x = np.reshape(bat_x , [self.batch_size,2625])
    bat_y = np.reshape(bat_y, [self.batch_size, 1])
    logits = session.run(self.logits , feed_dict={self.tf_train_samples:bat_x, self.tf_train_labels:bat_y})
    #print(logits)
    _, los = session.run([self.optimizer, self.loss], feed_dict = {self.tf_train_samples:bat_x, self.tf_train_labels:bat_y})

    if i % 10 == 0:
     test_bat_x, test_bat_y = test_ck.fetch_batch_slope_continue_time()
     test_bat_x = np.reshape(test_bat_x, [self.test_batch_size, 2625])
     test_bat_y = np.reshape(test_bat_y, [self.test_batch_size, 1])
     pred = session.run(self.test_prediction,
        feed_dict={self.tf_test_samples:test_bat_x, self.tf_test_labels:test_bat_y})
     #accuracy = self.accuracy(pred, test_bat_y, True);
     loger.info("bat_y: "+str(bat_y))
     loger.info("pred: "+str(pred))
     print(bat_y)
     print(pred)
     print('Minibatch loss at step %d lost: %f' % (i, los))

     #print('Minibatch accuracy: %.1f%%' % accuracy[0])
    if count % 100 == 0 and self.is_save():
     path = '/home/wcsmomo/workspace/MultLayerNet.ckpt'
     save_path = saver.save(self.session, path)
     print("save_path:" , save_path)

 def accuracy(self, predictions, labels, need_confusion_matrix=False):
  '''
  @return: accuracy and confusionMatrix as a tuple
  '''

  _predictions = np.argmax(predictions, 1)
  _labels = np.argmax(labels, 1)

  cm = confusion_matrix(_labels, _predictions) if need_confusion_matrix else None
  # == is overloaded for numpy array
  accuracy = (100.0 * np.sum(_predictions == _labels) / predictions.shape[0])
  return accuracy, cm

 def is_save(self):
  conn = dbu.Conn().get_conn()
  sql = "select value from ba_site where key_name='IS_SAVE'
  cur = conn.cursor()
  cur.execute(sql)
  results = cur.fetchall()
  flg = results[0][0]
  flg_bl = flg == 'Y'
  return flg_bl

if __name__ == '__main__':
 net = Network(num_hidden=3000 , num_hidden_2=1000,
      num_hidden_3=500, num_hidden_4=200, num_hidden_5=50,
      batch_size=100)
 net.define_graph()
 net.run()