回帰型ニューラルネットワークの学習にて発生する問題点

Question

前提・実現したいこと

Pythonでニューラルネットワークを作成しております。
*** 詳細 ***

• 回帰型3層誤差逆伝播法(SGD)ニューラルネットワーク
• 中間層の活性化関数はReLU関数
• 出力層の活性化関数は恒等関数
• 損失関数は二乗和誤差関数
• 教師データから一定数のデータを抽出し勾配を計算するミニバッチ学習(確率的勾配降下法を使用)

現在は、ライブラリscikit learnの中のload_bostonのデータを簡略化し、
入力信号1:出力信号1としています。
また中間層における、ニューロン数は5としています。

参考:ゼロから作るDeep Learning (オライリージャパン)

発生している問題・エラーメッセージ

学習が進むにつれて出力信号yが一定値となってしまいます。
初回の順伝播処理では入力に対して出力yは様々な値をとっていることを確認したため、
逆伝播処理に問題があるのではないかと考えております。
原因調査を進めていたのですが、完全に手詰まりです。
どなたかご教授願えないでしょうか。

該当のソースコード

・逆伝播処理が含まれるのは2. TLNet.pyとなります

1. main.py

import time
import numpy as np
import matplotlib.pyplot as plt
from TLNet import TwoLayerNet

# 開始時刻
time1 = time.time()

# データのインポート
train = np.loadtxt('train_data.csv', delimiter=',')
test  = np.loadtxt('test_data.csv', delimiter=',')

# データの分割
x_train = train[:, 0]
t_train = train[:, 1]
x_test  = test[:, 0]
t_test  = test[:, 1]

# 初期設定
input_size = 1
output_size = 1
hidden_size = 5

# ニューラルネットワークの初期化
network = TwoLayerNet(input_size, hidden_size, output_size)

# 設定
itr_num = 1000
train_size = x_train.shape[0]
batch_size = 10
learning_rate = 0.1

train_loss_list = []
itr_list        = []
x_batch = np.zeros((batch_size, input_size))
t_batch = np.zeros((batch_size, output_size))

iter_per_epoch = max(train_size/batch_size, 1)

# start learning NewralNetwork
for itr in range(itr_num):
    
    itr_list.append(itr)
    
    # 学習データをピック
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch[:,0] = x_train[batch_mask]
    t_batch[:,0] = t_train[batch_mask]
    
    # forward
    fw_p = network.forward(x_batch, t_batch)
    
    # 誤差の記録
    train_loss_list.append(fw_p['loss'])
    
    # backward
    dout = 1
    bw_p = network.backward(fw_p, dout)
    grad = {}
    for name in ('W1','b1', 'W2', 'b2'):
        grad[name] = bw_p['d' + name]

    # update parameter
    network.update(grad, learning_rate)

plt.plot(itr_list, train_loss_list)
plt.show()
print('start', train_loss_list[0], 'fin', train_loss_list[itr_num-1])

total_time = time.time() - time1
print('Analysis Time : ', total_time)

2. TLNet.py

import numpy as np
import functions

class TwoLayerNet:
    def __init__(self, input_size, hidden_size, output_size, \
                 weight_init_std = 0.01):
        # パラメータの初期化
        self.params = {}
        self.params['W1'] = weight_init_std* \
                            np.random.randn(input_size, hidden_size)
        self.params['b1'] = weight_init_std * np.random.randn(hidden_size)
        self.params['W2'] = weight_init_std* \
                            np.random.randn(hidden_size, output_size)
        self.params['b2'] = weight_init_std * np.random.randn(output_size)
        
        self.t = None
    
    def forward(self, x, t):
        fw_p = {}
        fw_p['p0'] = x
        self.t = t      # 今回のイタレーションにおける正解ラベル(t_batch)を格納
        # forward処理
        fw_p['p1'] = np.dot(x , self.params['W1']) + self.params['b1'] 
        fw_p['relu_mask'], fw_p['p2'] = functions.relu(fw_p['p1'])
        fw_p['p3'] = np.dot(fw_p['p2'], self.params['W2']) + self.params['b2']
        fw_p['y'] = functions.identity(fw_p['p3'])
        fw_p['loss'] = functions.sum_squared_error(fw_p['y'], self.t)
        
        return fw_p
    
    def backward(self, fw_p, dout=1):
        bw_p = {}
        # --- SGD part ---
        batch_size = self.t.shape[0]
        dout = (fw_p['y'] - self.t) / batch_size   ? identity layer
        
        # Affine2 layer
        bw_p['db2'] = np.sum(dout, axis=0)
        bw_p['dW2'] = np.dot(fw_p['p2'].T, dout)
        dout = np.dot(dout, self.params['W2'].T)
        
        # ReLU layer
        dout[fw_p['relu_mask']] = 0.
        
        # Affine1 layer
        bw_p['db1'] = np.sum(dout, axis=0)
        bw_p['dW1'] = np.dot(fw_p['p0'].T, dout)
        return bw_p

    def update(self, grad, learning_rate):
        # update parameter
        for key in ('W1','b1', 'W2', 'b2'):
            self.params[key] -= learning_rate * grad[key]

3. functions.py

import numpy as np

# 恒等関数
def identity(x):
    return x

# 二乗和誤差関数
def sum_squared_error(y, t):
    return np.sum((y-t)**2) / 2

# ReLU関数
def relu(x):
    mask = (x <= 0)
    out = x.copy()
    out[mask] = 0
    return mask, out

補足情報（FW/ツールのバージョンなど）

入出力のデータが必要な場合は解答欄にご記入ください。