deep_convnet.py

mnist-master/deep_convnet.py

@@ -0,0 +1,136 @@
+# coding: utf-8
+import sys, os
+sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
+import pickle
+import numpy as np
+from collections import OrderedDict
+from common.layers import *
+
+
+class DeepConvNet:
+    """识别率为99%以上的高精度的ConvNet
+
+    网络结构如下所示
+        conv - relu - conv- relu - pool -
+        conv - relu - conv- relu - pool -
+        conv - relu - conv- relu - pool -
+        affine - relu - dropout - affine - dropout - softmax
+    """
+    def __init__(self, input_dim=(1, 28, 28),
+                 conv_param_1 = {'filter_num':16, 'filter_size':3, 'pad':1, 'stride':1},
+                 conv_param_2 = {'filter_num':16, 'filter_size':3, 'pad':1, 'stride':1},
+                 conv_param_3 = {'filter_num':32, 'filter_size':3, 'pad':1, 'stride':1},
+                 conv_param_4 = {'filter_num':32, 'filter_size':3, 'pad':2, 'stride':1},
+                 conv_param_5 = {'filter_num':64, 'filter_size':3, 'pad':1, 'stride':1},
+                 conv_param_6 = {'filter_num':64, 'filter_size':3, 'pad':1, 'stride':1},
+                 hidden_size=50, output_size=10):
+        # 初始化权重===========
+        # 各层的神经元平均与前一层的几个神经元有连接（TODO:自动计算）
+        pre_node_nums = np.array([1*3*3, 16*3*3, 16*3*3, 32*3*3, 32*3*3, 64*3*3, 64*4*4, hidden_size])
+        wight_init_scales = np.sqrt(2.0 / pre_node_nums)  # 使用ReLU的情况下推荐的初始值
+        
+        self.params = {}
+        pre_channel_num = input_dim[0]
+        for idx, conv_param in enumerate([conv_param_1, conv_param_2, conv_param_3, conv_param_4, conv_param_5, conv_param_6]):
+            self.params['W' + str(idx+1)] = wight_init_scales[idx] * np.random.randn(conv_param['filter_num'], pre_channel_num, conv_param['filter_size'], conv_param['filter_size'])
+            self.params['b' + str(idx+1)] = np.zeros(conv_param['filter_num'])
+            pre_channel_num = conv_param['filter_num']
+        self.params['W7'] = wight_init_scales[6] * np.random.randn(64*4*4, hidden_size)
+        self.params['b7'] = np.zeros(hidden_size)
+        self.params['W8'] = wight_init_scales[7] * np.random.randn(hidden_size, output_size)
+        self.params['b8'] = np.zeros(output_size)
+
+        # 生成层===========
+        self.layers = []
+        self.layers.append(Convolution(self.params['W1'], self.params['b1'], 
+                           conv_param_1['stride'], conv_param_1['pad']))
+        self.layers.append(Relu())
+        self.layers.append(Convolution(self.params['W2'], self.params['b2'], 
+                           conv_param_2['stride'], conv_param_2['pad']))
+        self.layers.append(Relu())
+        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
+        self.layers.append(Convolution(self.params['W3'], self.params['b3'], 
+                           conv_param_3['stride'], conv_param_3['pad']))
+        self.layers.append(Relu())
+        self.layers.append(Convolution(self.params['W4'], self.params['b4'],
+                           conv_param_4['stride'], conv_param_4['pad']))
+        self.layers.append(Relu())
+        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
+        self.layers.append(Convolution(self.params['W5'], self.params['b5'],
+                           conv_param_5['stride'], conv_param_5['pad']))
+        self.layers.append(Relu())
+        self.layers.append(Convolution(self.params['W6'], self.params['b6'],
+                           conv_param_6['stride'], conv_param_6['pad']))
+        self.layers.append(Relu())
+        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
+        self.layers.append(Affine(self.params['W7'], self.params['b7']))
+        self.layers.append(Relu())
+        self.layers.append(Dropout(0.5))
+        self.layers.append(Affine(self.params['W8'], self.params['b8']))
+        self.layers.append(Dropout(0.5))
+        
+        self.last_layer = SoftmaxWithLoss()
+
+    def predict(self, x, train_flg=False):
+        for layer in self.layers:
+            if isinstance(layer, Dropout):
+                x = layer.forward(x, train_flg)
+            else:
+                x = layer.forward(x)
+        return x
+
+    def loss(self, x, t):
+        y = self.predict(x, train_flg=True)
+        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, train_flg=False)
+            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)
+
+        tmp_layers = self.layers.copy()
+        tmp_layers.reverse()
+        for layer in tmp_layers:
+            dout = layer.backward(dout)
+
+        # 设定
+        grads = {}
+        for i, layer_idx in enumerate((0, 2, 5, 7, 10, 12, 15, 18)):
+            grads['W' + str(i+1)] = self.layers[layer_idx].dW
+            grads['b' + str(i+1)] = self.layers[layer_idx].db
+
+        return grads
+
+    def save_params(self, file_name="params.pkl"):
+        params = {}
+        for key, val in self.params.items():
+            params[key] = val
+        with open(file_name, 'wb') as f:
+            pickle.dump(params, f)
+
+    def load_params(self, file_name="params.pkl"):
+        with open(file_name, 'rb') as f:
+            params = pickle.load(f)
+        for key, val in params.items():
+            self.params[key] = val
+
+        for i, layer_idx in enumerate((0, 2, 5, 7, 10, 12, 15, 18)):
+            self.layers[layer_idx].W = self.params['W' + str(i+1)]
+            self.layers[layer_idx].b = self.params['b' + str(i+1)]