深度学习入门--卷积神经网络的实现

我们已经实现了卷积层和池化层，现在来组合这些层，搭建进行手写数字识别的CNN。

我们要实现如下图形式CNN： 简单的CNN的网络构成

如上图，网络的构成是Convolution - ReLU - Pooling - Affine - ReLU - Affine - Sofemax，我们将它实现为名为SimpleConvNet的类。

SimpleConvNet的初始化中主要有这些参数：

• input_dim：输入数据的维度（通道，高，长）

• conv_param： 卷积层的超参数（字典），字典中关键字如下：

  • filter_num： 滤波器的数量
  • filter_size： 滤波器的大小
  • stride： 步幅
  • pad ： 填充

• hidden_size : 隐藏层的神经元数量

• output_size : 输出层的神经元数量

• weitght_int_std : 初始化时权重的标准差

SimpleConvNet的初始化的实现有点长，首先是初始化的最开始部分：

class SimpleConvNet:
    """简单的ConvNet

    conv - relu - pool - affine - relu - affine - softmax
    
    Parameters
    ----------
    input_size : 输入大小（MNIST的情况下为784）
    hidden_size_list : 隐藏层的神经元数量的列表（e.g. [100, 100, 100]）
    output_size : 输出大小（MNIST的情况下为10）
    activation : 'relu' or 'sigmoid'
    weight_init_std : 指定权重的标准差（e.g. 0.01）
        指定'relu'或'he'的情况下设定“He的初始值”
        指定'sigmoid'或'xavier'的情况下设定“Xavier的初始值”
    """
    def __init__(self, input_dim=(1, 28, 28), 
                 conv_param={'filter_num':30, 'filter_size':5, 'pad':0, 'stride':1},
                 hidden_size=100, output_size=10, weight_init_std=0.01):
        filter_num = conv_param['filter_num']
        filter_size = conv_param['filter_size']
        filter_pad = conv_param['pad']
        filter_stride = conv_param['stride']
        input_size = input_dim[1]
        conv_output_size = (input_size - filter_size + 2*filter_pad) / filter_stride + 1
        pool_output_size = int(filter_num * (conv_output_size/2) * (conv_output_size/2))

接下来是权重参数的初始化部分：

        # 初始化权重
        self.params = {}
        self.params['W1'] = weight_init_std * \
                            np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
        self.params['b1'] = np.zeros(filter_num)
        self.params['W2'] = weight_init_std * \
                            np.random.randn(pool_output_size, hidden_size)
        self.params['b2'] = np.zeros(hidden_size)
        self.params['W3'] = weight_init_std * \
                            np.random.randn(hidden_size, output_size)
        self.params['b3'] = np.zeros(output_size)

第一层的卷积层的权重，偏置分别为w1,b1。第二层的全连接层的权重，偏置分别为w2,b2。 第三层的全连接层的权重，偏置分别为w3, b3。

最后使用有序字典OrderedDict()生成必要的层:

        # 生成层
        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'] = Pooling(pool_h=2, pool_w=2, stride=2)
        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()

以上就是SimpleConvNet的初始化中进行的处理。像这样进行初始化后，再实现进行推理的predict方法和求损失函数值的loss方法：

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

        return x

    def loss(self, x, t):
        """求损失函数
        参数x是输入数据、t是教师标签
        """
        y = self.predict(x)
        return self.last_layer.forward(y, t)

接下来是基于误差反向传播法求梯度的实现：

    def gradient(self, x, t):
        """求梯度（误差反向传播法）

        Parameters
        ----------
        x : 输入数据
        t : 教师标签

        Returns
        -------
        具有各层的梯度的字典变量
            grads['W1']、grads['W2']、...是各层的权重
            grads['b1']、grads['b2']、...是各层的偏置
        """
        # 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

如上，这些就是SimpleConvNet的实现。

现在使用这个SimpleConvNet学习MNIST数据集，训练结果如下：

=============== Final Test Accuracy ===============
test acc:0.9839
Saved Network Parameters!

由于学习所耗费的时间过长，这这里我只用了5个epochs,最终测试数据的识别率达到98%。对于一个小型CNN来说，这是一个较高的识别率了。

每天学习一点点，每天进步一点点。