畳み込み処理でのエラー”ValueError: not enough values to unpack (expected 4, got 2)”

前提・実現したいこと

SimpleConvNetを使って文字の識別をしようとしています。
以下のようなエラーになってしまい、学習が進みません。
おそらくConvolutionの
FN, C, FH, FW = self.W.shape
N, C, H, W = x.shape
out_h = (H + 2self.pad - FH) // self.stride + 1
out_w =(W + 2self.pad - FW) // self.stride + 1
の部分で発生してしまってるように思うのですが解決方法がわからず、教えていただきたいです。

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

ValueError: not enough values to unpack (expected 4, got 2)

該当のソースコード

python
1
2
3snet = SimpleConvNet(input_dim=(1, 28, 28), 
4                     conv_param={'filter_num':30, 'filter_size':5, 'pad':0, 'stride':1},
5                     pool_param={'pool_size':2, 'pad':0, 'stride':2},
6                     hidden_size=100, output_size=10, weight_init_std=0.01)
7
8train_loss = []
9test_loss = []
10train_accuracy = []
11test_accuracy = []
12
13for epoch in range(epochs):
14    print("epoch=%s"%epoch)
15
16    idx = np.arange(xsize)
17    np.random.shuffle(idx)
18
19    for it in range(iter_num):
20
21        print("it=", it)
22        mask = idx[batch_size*it : batch_size*(it+1)]
23
24        x_train = x[mask]
25        t_train = t[mask]
26
27        grads = snet.gradient(x_train, t_train)
28
29        optimizer.update(snet.params, grads)
30   
31    train_loss.append(snet.loss(x,  train_labels))
32    test_loss.append(snet.loss(test, test_labels))
33    train_accuracy.append(snet.accuracy(x, train_labels))
34    test_accuracy.append(snet.accuracy(test, test_labels))
35
36別ファイルで以下の通り、クラスは作成してます。
37
38class SimpleConvNet:
39    def __init__(self, input_dim=(1, 28, 28), 
40                 conv_param={'filter_num':30, 'filter_size':5, 'pad':0, 'stride':1},
41                 pool_param={'pool_size':2, 'pad':0, 'stride':2},
42                 hidden_size=100, output_size=10, weight_init_std=0.01):
43
44        input_size : tuple
45        conv_param : dict
46        pool_param : dict
47        hidden_size : int
48        output_size : int
49        weight_init_std ： float
50                
51        filter_num = conv_param['filter_num']
52        filter_size = conv_param['filter_size']
53        filter_pad = conv_param['pad']
54        filter_stride = conv_param['stride']
55        
56        pool_size = pool_param['pool_size']
57        pool_pad = pool_param['pad']
58        pool_stride = pool_param['stride']
59        
60        input_size = input_dim[1]
61        conv_output_size = (input_size + 2*filter_pad - filter_size) // filter_stride + 1
62        pool_output_size = (conv_output_size + 2*pool_pad - pool_size) // pool_stride + 1
63        pool_output_pixel = filter_num * pool_output_size * pool_output_size
64        
65        self.params = {}
66        std = weight_init_std
67        self.params['W1'] = std * np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
68        self.params['b1'] = np.zeros(filter_num)
69        self.params['W2'] = std *  np.random.randn(pool_output_pixel, hidden_size)
70        self.params['b2'] = np.zeros(hidden_size)
71        self.params['W3'] = std *  np.random.randn(hidden_size, output_size)
72        self.params['b3'] = np.zeros(output_size)
73
74        self.layers = OrderedDict()
75        self.layers['Conv1'] = Convolution(self.params['W1'], self.params['b1'], conv_param['stride'], conv_param['pad']
76        self.layers['ReLU1'] = ReLU()
77        self.layers['Pool1'] = MaxPooling(pool_h=pool_size, pool_w=pool_size, stride=pool_stride, pad=pool_pad)
78        self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
79        self.layers['ReLU2'] = ReLU()
80        self.layers['Affine2'] = Affine(self.params['W3'], self.params['b3'])
81
82        self.last_layer = SoftmaxWithLoss()
83
84    def predict(self, x):
85        for layer in self.layers.values():
86            x = layer.forward(x)
87
88        return x
89
90    def loss(self, x, t):
91        y = self.predict(x)
92        return self.last_layer.forward(y, t)
93
94    def accuracy(self, x, t, batch_size=100):
95        if t.ndim != 1 : t = np.argmax(t, axis=1)
96        
97        acc = 0.0
98        
99        for i in range(int(x.shape[0] / batch_size)):
100            tx = x[i*batch_size:(i+1)*batch_size]
101            tt = t[i*batch_size:(i+1)*batch_size]
102            y = self.predict(tx)
103            y = np.argmax(y, axis=1)
104            acc += np.sum(y == tt) 
105        
106        return acc / x.shape[0]
107
108    def gradient(self, x, t):
109        # forward
110        self.loss(x, t)
111
112        # backward
113        dout = 1
114        dout = self.last_layer.backward(dout)
115
116        layers = list(self.layers.values())
117        layers.reverse()
118        for layer in layers:
119            dout = layer.backward(dout)
120
121        grads = {}
122        grads['W1'], grads['b1'] = self.layers['Conv1'].dW, self.layers['Conv1'].db
123        grads['W2'], grads['b2'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
124        grads['W3'], grads['b3'] = self.layers['Affine2'].dW, self.layers['Affine2'].db
125
126        return grads
127
128
129class Convolution:
130    def __init__(self, W, b, stride, pad):
131        self.W = W
132        self.b = b
133        self.stride = stride
134        self.pad = pad
135
136        self.x = None   
137        self.col = None
138        self.col_W = None
139        self.dcol = None
140        self.dW = None
141        self.db = None
142
143    def forward(self, x):
144        
145        FN, C, FH, FW = self.W.shape
146        N, C, H, W = x.shape
147        out_h = (H + 2*self.pad - FH) // self.stride + 1
148        out_w =(W + 2*self.pad - FW) // self.stride + 1
149
150        col = im2col(x, FH, FW, self.stride, self.pad)
151        
152        col_W = self.W.reshape(FN, -1).T
153
154        out = np.dot(col, col_W) + self.b
155
156        out = out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2)
157
158        self.x = x
159        self.col = col
160        self.col_W = col_W
161
162        return out
163
164    def backward(self, dout):
165
166        FN, C, FH, FW = self.W.shape
167        
168        dout = dout.transpose(0,2,3,1).reshape(-1, FN)
169
170        self.db = np.sum(dout, axis=0)
171        
172        self.dW = np.dot(self.col.T, dout)
173
174        self.dW = self.dW.transpose(1, 0).reshape(FN, C, FH, FW)
175
176        dcol = np.dot(dout, self.col_W.T)
177        
178        dx = col2im(dcol, self.x.shape, FH, FW, self.stride, self.pad, is_backward=True)
179
180        self.dcol = dcol 
181
182        return dx
183
184（その他、ReLU、Poolなども同様に作成してます。）