Невозможно получить меньшие потери с большим количеством слоев в нейронной сети для проблемы регрессии

Question

Я только что написал код с Tensorflow для решения линейных уравнений Ax = b с нейронной сетью.

Проблема, которую я хочу решить, очень похожа на проблему регрессии: обучающий набор генерируется из некоторого случайногоУравнения Ax = b решены с помощью Numpy, диагональные элементы левой матрицы A заданы постоянными, правый вектор b также постоянен, A также симметричен. Тогда входом сети могут быть элементы в верхней (или нижней) части треугольника A. Следовательно, это просто проблема регрессии для функции большой размерности (некоторые элементы A -> решение линейного уравнения).

Однако в коде показаны 2 проблемы: 1. Когда я обучаю сеть, потери быстро уменьшаются и, по-видимому, достигают конвергенции (менее чем за 100 эпох), но после большого количества прошедших эпох (более 2000)потери начинают увеличиваться и, наконец, колебаться вокруг постоянной (намного большей, чем значение «конвергенции»). 2. Мне бы хотелось, чтобы точность сети могла быть лучше при использовании большего количества скрытых слоев, но даже я использую 7 скрытых слоев с 1000 узлами. на каждом слое точность не изменилась, но скорость сходимости и скорость обучения сильно уменьшаются.

Вот проблемы, с которыми я столкнулся, Искренне спасибо за чтение моего вопроса

import tensorflow as tf
import time
import numpy as np

x_size = tf.constant(30) #Size of the Matrix
input_size = x_size*(x_size-1)/2
train_size = tf.constant(5000) #Size of the training set
test_size = tf.constant(1000) #Size of the test set

batch_size = tf.constant(100)
n_batch = train_size/batch_size

diag_const = tf.constant(30)
solving_const = tf.constant(10)

N_L1 = tf.constant(100)
N_L2 = tf.constant(100)

sess = tf.InteractiveSession()

# Training set generation
for t in range(train_size.eval()):
    A_ori = np.random.normal(0,1,(x_size.eval(),x_size.eval()))
    A_ori += np.transpose(A_ori)
    A_train = A_ori-np.diag(np.diag(A_ori))+diag_const.eval()*np.eye(x_size.eval())
    x_sol = np.triu(A_ori,1).flatten()
    y_sol = np.linalg.solve(A_train,solving_const.eval()*np.ones(x_size.eval()))
    if t==0:
        x_train = np.array([x_sol[x_sol!=0]])
        y_train = np.array([y_sol])
    else:
        x_train=np.concatenate((x_train,np.array([x_sol[x_sol!=0]])),axis=0)
        y_train=np.concatenate((y_train,np.array([y_sol])),axis=0)
print("Training Set Generation done!")

with tf.name_scope('intput'):
    input_L1 = tf.placeholder("float32", [None,input_size.eval()],name='A-intput')
    train_batch = tf.placeholder("float32", [None,x_size.eval()],name='train-output')

with tf.name_scope('layer1'):
    with tf.name_scope('weight1'):
        weight_L1 = tf.Variable(tf.random_normal([input_size.eval(), N_L1]),name='W1')
    with tf.name_scope('bias1'):
        bias_L1 = tf.Variable(tf.random_normal([N_L1]),name='b1')
    with tf.name_scope('output1'):
        output_L1 = tf.nn.dropout(tf.nn.tanh(tf.matmul(input_L1, weight_L1)+bias_L1),0.8)

with tf.name_scope('layer2'):
    with tf.name_scope('weight2'):
        weight_L2 = tf.Variable(tf.random_normal([N_L1, N_L2]),name='W2')
    with tf.name_scope('bias2'):
        bias_L2 = tf.Variable(tf.random_normal([N_L2]),name='b2')
    with tf.name_scope('output2'):
        output_L2 = tf.nn.dropout(tf.nn.tanh(tf.matmul(output_L1, weight_L2)+bias_L2),0.8)


with tf.name_scope('layer_final'):
    with tf.name_scope('weight_final'):
        weight_L = tf.Variable(tf.random_normal([N_L2, x_size]))
    with tf.name_scope('bias_final'):
        bias_L = tf.Variable(tf.random_normal([x_size]))
    with tf.name_scope('output_final'):
        output_L = tf.matmul(output_L2, weight_L)+bias_L

with tf.name_scope('loss'):
    loss = tf.reduce_mean(tf.square(train_batch-output_L))
    sum_loss = tf.summary.scalar('loss',loss)
with tf.name_scope('train'):
    train_step = tf.train.AdamOptimizer(0.01).minimize(loss)

init = tf.global_variables_initializer()
sess.run(init)

n_b = 100
b_s = 5000//n_b

for _ in range(2000):
    for b_ in range(n_b):
        sess.run(train_step,feed_dict={input_L1: x_train[b_*b_s:(b_+1)*b_s,:], train_batch: y_train[b_*b_s:(b_+1)*b_s,:]})

Кривая эпохи потерь с другой сетью: (3x100 означает, что 3 скрытых слоя с 100 элементами на каждом слое)