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

前提・実現したいこと

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

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

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

該当のソースコード

python
1
2###データ(3000枚、0~14の15種類)は事前に読み込ませています
3###このデータを学習用とテスト用に分けて使っています
4train_data.shape= (3000, 1, 28, 28)
5train_label.shape= (3000, 15)
6
7# 正規化
8train_data = (train_data - train_data.min()) / train_data.max()
9train_data = train_data.astype('float32')
10
11# 配列形式の変更
12train_data = train_data.reshape(-1, 28*28)
13
14# 学習用とテスト用に分割
15X_train, X_test, y_train, y_test = train_test_split(train_data, train_label, test_size=0.3, random_state=1234, shuffle=True)  
16
17from sklearn.preprocessing import LabelBinarizer
18lb = LabelBinarizer()
19
20train = X_train/255
21test = X_test/255
22train = train.reshape(-1, 1, 28, 28)
23test = test.reshape(-1, 1, 28, 28)
24
25train_labels = lb.fit_transform(y_train)
26test_labels = lb.fit_transform(y_test)
27
28x = train
29t = train_labels
30
31#学習
32epochs = 10
33batch_size = 100
34optimizer = RMSProp(lr=0.01, rho=0.95)
35
36# 繰り返し回数
37xsize = x.shape[0]
38iter_num = np.ceil(xsize / batch_size).astype(np.int)
39
40
41# CNNのオブジェクト生成
42snet = 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)
43
44train_loss = []
45test_loss = []
46train_accuracy = []
47test_accuracy = []
48
49for epoch in range(epochs):
50    print("epoch=%s"%epoch)
51
52    idx = np.arange(xsize)
53    np.random.shuffle(idx)
54
55    for it in range(iter_num):
56        print("it=", it)
57        mask = idx[batch_size*it : batch_size*(it+1)]
58
59        # ミニバッチの生成
60        x_train = x[mask]
61        t_train = t[mask]
62
63        # 勾配の計算 
64        grads = snet.gradient(x_train, t_train)
65
66        # 更新
67        optimizer.update(snet.params, grads)
68
69    #学習経過の記録 
70    train_loss.append(snet.loss(x, t))
71    test_loss.append(snet.loss(test, test_labels))
72    train_accuracy.append(snet.accuracy(x, t))
73    test_accuracy.append(snet.accuracy(test, test_labels))
74
75# 損失関数のグラフを作成
76df_log = pd.DataFrame({"train_loss":train_loss,
77             "test_loss":test_loss,
78             "train_accuracy":train_accuracy,
79             "test_accuracy":test_accuracy})
80df_log.plot(style=['r-', 'r--', 'b-', 'b--'])
81plt.ylabel("loss or accuracy")
82plt.xlabel("epochs")
83plt.show()
84
85
86### 別ファイルでクラスはそれぞれ作成しています。
87
88class SimpleConvNet:
89    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):
90
91        input_size : tuple
92        conv_param : dict
93        pool_param : dict
94        hidden_size : int
95        output_size : int
96        weight_init_std ： float
97
98        filter_num = conv_param['filter_num']
99        filter_size = conv_param['filter_size']
100        filter_pad = conv_param['pad']
101        filter_stride = conv_param['stride']
102
103        pool_size = pool_param['pool_size']
104        pool_pad = pool_param['pad']
105        pool_stride = pool_param['stride']
106
107        input_size = input_dim[1]
108        conv_output_size = (input_size + 2*filter_pad - filter_size) // filter_stride + 1
109        pool_output_size = (conv_output_size + 2*pool_pad - pool_size) // pool_stride + 1
110        pool_output_pixel = filter_num * pool_output_size * pool_output_size
111
112        self.params = {}
113        std = weight_init_std
114        self.params['W1'] = std * np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
115        self.params['b1'] = np.zeros(filter_num)
116        self.params['W2'] = std *  np.random.randn(pool_output_pixel, hidden_size)
117        self.params['b2'] = np.zeros(hidden_size)
118        self.params['W3'] = std *  np.random.randn(hidden_size, output_size)
119        self.params['b3'] = np.zeros(output_size)
120
121        self.layers = OrderedDict()
122        self.layers['Conv1'] = Convolution(self.params['W1'], self.params['b1'], conv_param['stride'], conv_param['pad']
123        self.layers['ReLU1'] = ReLU()
124        self.layers['Pool1'] = MaxPooling(pool_h=pool_size, pool_w=pool_size, stride=pool_stride, pad=pool_pad)
125        self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
126        self.layers['ReLU2'] = ReLU()
127        self.layers['Affine2'] = Affine(self.params['W3'], self.params['b3'])
128
129        self.last_layer = SoftmaxWithLoss()
130
131    def predict(self, x):
132        for layer in self.layers.values():
133            x = layer.forward(x)
134
135        return x
136
137    def loss(self, x, t):
138        y = self.predict(x)
139        return self.last_layer.forward(y, t)
140
141    def accuracy(self, x, t, batch_size=100):
142        if t.ndim != 1 : t = np.argmax(t, axis=1)
143
144        acc = 0.0
145
146        for i in range(int(x.shape[0] / batch_size)):
147            tx = x[i*batch_size:(i+1)*batch_size]
148            tt = t[i*batch_size:(i+1)*batch_size]
149            y = self.predict(tx)
150            y = np.argmax(y, axis=1)
151            acc += np.sum(y == tt) 
152
153        return acc / x.shape[0]
154
155    def gradient(self, x, t):
156        # forward
157        self.loss(x, t)
158
159        # backward
160        dout = 1
161        dout = self.last_layer.backward(dout)
162
163        layers = list(self.layers.values())
164        layers.reverse()
165        for layer in layers:
166            dout = layer.backward(dout)
167
168        grads = {}
169        grads['W1'], grads['b1'] = self.layers['Conv1'].dW, self.layers['Conv1'].db
170        grads['W2'], grads['b2'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
171        grads['W3'], grads['b3'] = self.layers['Affine2'].dW, self.layers['Affine2'].db
172
173        return grads
174
175
176#その他、Convolution、ReLU、Poolなども同様に作成してます。
177                                                                                                                                                                                                                         
178

試したこと

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

quickquip

2021/07/05 01:47

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

saruu

2021/07/05 04:54

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

nnkkmto

2021/07/08 03:10

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

saruu

2021/07/08 12:54

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

toast-uz

2021/07/17 01:35 編集

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

saruu

2021/07/17 04:38

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

toast-uz

2021/07/17 04:57 編集

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

saruu

2021/07/17 07:37

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