CNNでの学習がうまく行われない

Question

前提・実現したいこと

CNNを用いて画像を識別させようとしています。
損失関数と評価関数のグラフを描こうとしています。

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

エラーメッセージは出ていないのですが、損失関数と評価関数のグラフが真横の直線になってしまいます。
（test_loss と train_lossが重なって真横の直線（epoch数を増やしても変わらず）になってしまっています。また、test_accuracy と train_accuracy も重なって同じように真横の直線になってしまっています。）
原因がわからず、教えていただきたいです。

該当のソースコード

###データ(3000枚、0~14の15種類)は事前に読み込ませています
###このデータを学習用とテスト用に分けて使っています
train_data.shape= (3000, 1, 28, 28)
train_label.shape= (3000, 15)

# 正規化
train_data = (train_data - train_data.min()) / train_data.max()
train_data = train_data.astype('float32')

# 配列形式の変更
train_data = train_data.reshape(-1, 28*28)

# 学習用とテスト用に分割
X_train, X_test, y_train, y_test = train_test_split(train_data, train_label, test_size=0.3, random_state=1234, shuffle=True)  

from sklearn.preprocessing import LabelBinarizer
lb = LabelBinarizer()

train = X_train/255
test = X_test/255
train = train.reshape(-1, 1, 28, 28)
test = test.reshape(-1, 1, 28, 28)

train_labels = lb.fit_transform(y_train)
test_labels = lb.fit_transform(y_test)

x = train
t = train_labels

#学習
epochs = 10
batch_size = 100
optimizer = RMSProp(lr=0.01, rho=0.95)

# 繰り返し回数
xsize = x.shape[0]
iter_num = np.ceil(xsize / batch_size).astype(np.int)


# CNNのオブジェクト生成
snet = SimpleConvNet(input_dim=(1, 28, 28), conv_param={'filter_num':30, 'filter_size':5, 'pad':0, 'stride':1}, pool_param={'pool_size':2, 'pad':0, 'stride':2}, hidden_size=100, output_size=15, weight_init_std=0.01)

train_loss = []
test_loss = []
train_accuracy = []
test_accuracy = []

for epoch in range(epochs):
    print("epoch=%s"%epoch)

    idx = np.arange(xsize)
    np.random.shuffle(idx)

    for it in range(iter_num):
        print("it=", it)
        mask = idx[batch_size*it : batch_size*(it+1)]

        # ミニバッチの生成
        x_train = x[mask]
        t_train = t[mask]

        # 勾配の計算 
        grads = snet.gradient(x_train, t_train)

        # 更新
        optimizer.update(snet.params, grads)

    #学習経過の記録 
    train_loss.append(snet.loss(x, t))
    test_loss.append(snet.loss(test, test_labels))
    train_accuracy.append(snet.accuracy(x, t))
    test_accuracy.append(snet.accuracy(test, test_labels))

# 損失関数のグラフを作成
df_log = pd.DataFrame({"train_loss":train_loss,
             "test_loss":test_loss,
             "train_accuracy":train_accuracy,
             "test_accuracy":test_accuracy})
df_log.plot(style=['r-', 'r--', 'b-', 'b--'])
plt.ylabel("loss or accuracy")
plt.xlabel("epochs")
plt.show()


### 別ファイルでクラスはそれぞれ作成しています。

class SimpleConvNet:
    def __init__(self, input_dim=(1, 28, 28), conv_param={'filter_num':30, 'filter_size':5, 'pad':0, 'stride':1}, pool_param={'pool_size':2, 'pad':0, 'stride':2}, hidden_size=100, output_size=15, weight_init_std=0.01):

        input_size : tuple
        conv_param : dict
        pool_param : dict
        hidden_size : int
        output_size : int
        weight_init_std ： float

        filter_num = conv_param['filter_num']
        filter_size = conv_param['filter_size']
        filter_pad = conv_param['pad']
        filter_stride = conv_param['stride']

        pool_size = pool_param['pool_size']
        pool_pad = pool_param['pad']
        pool_stride = pool_param['stride']

        input_size = input_dim[1]
        conv_output_size = (input_size + 2*filter_pad - filter_size) // filter_stride + 1
        pool_output_size = (conv_output_size + 2*pool_pad - pool_size) // pool_stride + 1
        pool_output_pixel = filter_num * pool_output_size * pool_output_size

        self.params = {}
        std = weight_init_std
        self.params['W1'] = std * np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
        self.params['b1'] = np.zeros(filter_num)
        self.params['W2'] = std *  np.random.randn(pool_output_pixel, hidden_size)
        self.params['b2'] = np.zeros(hidden_size)
        self.params['W3'] = std *  np.random.randn(hidden_size, output_size)
        self.params['b3'] = np.zeros(output_size)

        self.layers = OrderedDict()
        self.layers['Conv1'] = Convolution(self.params['W1'], self.params['b1'], conv_param['stride'], conv_param['pad']
        self.layers['ReLU1'] = ReLU()
        self.layers['Pool1'] = MaxPooling(pool_h=pool_size, pool_w=pool_size, stride=pool_stride, pad=pool_pad)
        self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
        self.layers['ReLU2'] = ReLU()
        self.layers['Affine2'] = Affine(self.params['W3'], self.params['b3'])

        self.last_layer = SoftmaxWithLoss()

    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)

        return x

    def loss(self, x, t):
        y = self.predict(x)
        return self.last_layer.forward(y, t)

    def accuracy(self, x, t, batch_size=100):
        if t.ndim != 1 : t = np.argmax(t, axis=1)

        acc = 0.0

        for i in range(int(x.shape[0] / batch_size)):
            tx = x[i*batch_size:(i+1)*batch_size]
            tt = t[i*batch_size:(i+1)*batch_size]
            y = self.predict(tx)
            y = np.argmax(y, axis=1)
            acc += np.sum(y == tt) 

        return acc / x.shape[0]

    def gradient(self, x, t):
        # forward
        self.loss(x, t)

        # backward
        dout = 1
        dout = self.last_layer.backward(dout)

        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)

        grads = {}
        grads['W1'], grads['b1'] = self.layers['Conv1'].dW, self.layers['Conv1'].db
        grads['W2'], grads['b2'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grads['W3'], grads['b3'] = self.layers['Affine2'].dW, self.layers['Affine2'].db

        return grads


#その他、Convolution、ReLU、Poolなども同様に作成してます。
                                                                                                                                                                                                                         

試したこと

ソースは書籍（ゼロから作るdeep learning）などを参照しました。
変数名が違っているなどが原因かな？と思い調べてみたのですが、なかなか解決できない状況です。
![

Comments

[quickquip]

> 損失関数のグラフ
test_lossの話ですか、train_lossの話（=両方）ですか。（質問に追記しましょう）

[saruu]

コメントありがとうございます。
test_loss と train_lossが重なって真横の直線（epoch数を増やしても変わらず）になってしまっている状態です。
またほかに、test_accuracy と train_accuracy も重なって同じように真横の直線になってしまっている状態です。
質問欄にも追記します。

[nnkkmto]

train_loss, test_lossの最終的な中身を貼ってもらうことってできますでしょうか？

[saruu]

コメントありがとうございます。
最終的な中身というのは値のことでしょうか？

[toast-uz]

フレームワークを使わずに、ゼロから〜をもとにCNNを自作しているのは、何か理由があるのでしょうか？
また、このソースでMNISTの分類タスクを実行してみましたでしょうか？
・フレームワークを使っていないため、細かいソースを追って不具合を見つける必要がある
・独自のデータセットでの不具合であるため、回答者としては再現テストをする方法がない
のダブルで、難易度が高い質問になってしまっています。どちらかの制約を緩めて質問すべきです。

[saruu]

コメントありがとうございます。
勉強であえてフレームワークを使わずに実装しようとしています。
MNISTのデータを使っての分類はできたので、そのソースを少し変更して実装しようとしています。

[toast-uz]

だとするとデータセットや前処理に問題があるように思います。なおさらデータがわからない回答者には回答しようがありません。
フレームワークを使って、現在のデータセットで学習できることは確認できていますか？
その後にフレームワークを使わずに実装してみるべきでしょう。基礎を飛ばして応用を試みているようです。

[saruu]

フレームワークを用いての実装は以前やってみました。
前処理の部分を見直してみます。