【基础详解】手磕实现 CNN卷积神经网络！

zenRRan

发布于 2020-08-24 16:45:16

2.3K0

发布于 2020-08-24 16:45:16

文章被收录于专栏：深度学习自然语言处理

设为星标，第一时间获取更多干货

作者：云不见

链接：https://blog.csdn.net/Walk_OnTheRoad/article/details/108048101

编辑：王萌澳门城市大学(深度学习冲鸭公众号)

此笔记是基于《深度学习入门》这本书的重点知识汇总连载。

接着《深度学习入门：基于Python的理论与实现》学习笔记（2）继续学习笔记的记载。

目录：

一、CNN大致框架

二、卷积层

2.1 卷积运算

2.2 填充（padding）

2.3 步幅（stride）

2.4 三维数据的卷积运算

2.5 批处理

三、池化层

四、Conv层和Pooling层的实现

4.1 4维数组

4.2 基于im2col的展开

4.3 卷积层的实现

4.4 池化层的实现

四、CNN实现

五、CNN可视化

本文重点知识点：

CNN的大致框架
卷积层
池化层
卷积层和池化层的实现
CNN的实现
CNN可视化介绍

如有细节处没有写到的，请继续精读《深度学习入门：基于Python的理论与实现》，对小白来说真的是非常好的深度学习的入门书籍，通俗易懂。（书中的例子主要是基于CV的）

一、CNN大致框架

神经网络：就是组装层的过程。

CNN出现了新的层：卷积层、池化层。

Q：如何组装构成CNN？

全连接层：用Affine实现的：Affine-ReLU （Affine仿射变换 y = xw+b），如下为基于全连接层的5层神经网络。

ReLU也可替换成Sigmoid层，这里由4层Affine-ReLU组成，最后由Affine-Softmax输出最终结果（概率）

常见的CNN：Affine-ReLU 变 Conv-ReLU-(Pooling)，如下为基于CNN的五层神经网络。

Q：全连接层有什么问题嘛？为什么要改进为Conv层？

全连接层“忽视”了数据的形状，3维数据被拉平为1维数据；形状因含有重要的空间信息：①空间临近的像素为相似的值，相距较远的像素没什么关系；②RBG的各个通道之间分别有密切的关联性等；③3维形状中可能隐藏有值得提取的本质模式。
而卷积层可以保持形状不变。可以正确理解图像等具有形状的数据。

特征图：输入、输出数据

二、卷积层

2.1 卷积运算

输入特征图与卷积核作乘积累加运算，窗口以一定的步长滑动，得到输出特征图，也可以加偏置（1*1）

卷积核（滤波器）相当于全连接层中的权重。

卷积完后，偏置将应用于所有数据

2.2 填充（padding）

向输入数据的周围填入固定的数据（比如0等）

填充的目的：调整输出的大小。扩大输入特征图，得到大一些的输出。一般填充为0。

为什么要调整输出的大小？

因为比如输入（4×4），卷积核为（3×3），得到输出为（2×2），随着层的加深，卷积完的输出越来越小，直到输出变1以后将无法再进行卷积运行。为了避免这样的情况发生，需要用到填充，使输出至少不会减小。

2.3 步幅（stride）

用途：指定滤波器的间隔。

步幅增大，输出减小；填充增大，输出增大。

计算输出的大小：

其中：

(OH,OW) 输出大小
(H,W) 输入大小
(FH,FW) 滤波器大小
P 填充
S 步幅

注：式（7.1）中最好可以除尽。if无法除尽，需报错。或者向最接近的整数四舍五入，不进行报错而继续运行。

2.4 三维数据的卷积运算

(通道方向，高，长)：比二维数据多了一个：通道方向，特征图增加了

(Channel,height,width)

(C,H,W)

方块思维，上下两张图是一个意思。

输入数据和滤波器的通道数是保持一致的。

每个通道分别卷积计算出值，再将各通道的值相加得到最终的一个输出值。

这样只能得到一个通道数的输出，怎样使得输出也多通道讷？

应用多个滤波器（权重），比如FN个。如下图所示。

滤波器变四维，一个滤波器对应一个输出特征图。还可追加偏置(FN,1,1)

作为4维数据，滤波器按(output_channel, input_channel, height, width) 的顺序书写。

比如，通道数为 3、大小为 5 × 5 的滤波器有20个时，可以写成(20, 3, 5, 5)。

不同形状的方块相加时，可以基于NumPy的广播功能轻松实现（1.5.5节）。

2.5 批处理

目的：实现数据的高效化，打包N个数据一起处理。即将N次处理汇总为一次 3维——> 4维，即(C,H,W) ——> (N,C,H,W)

三、池化层

目的：缩小H，W方向上的空间的运算。比如将2 × 2区域集约成1个元素来处理，缩小空间大小。

Max池化：获取最大值的运算

一般设置：池化的窗口大小和步幅设定成相同的值。比如这里都是2。

在图像识别中，主要用Max池化。

池化层的特征：

没有要学习的参数；
通道数不发生变化，输入3张，输出也是3张；
对微小的位置变化具有鲁棒性（健壮），即输入数据发生微小偏差时，池化也可以返回相同的结果；即池化能吸收输入数据的偏差。

四、Conv层和Pooling层的实现

4.1 4维数组

例如：随机生成一个四维数据（10，1，28，28） 10个通道数为1，高长为28的数据

>>> x = np.random.rand(10, 1, 28, 28) # 随机生成10个通道数为1，高长为28的输入数据
>>> x.shape
(10, 1, 28, 28)

>>> x[0].shape # (1, 28, 28)   x[0]：第一个数据（第一个方块）
>>> x[1].shape # (1, 28, 28)   x[1]：第二个数据
>>> x[0, 0] # 或者x[0][0]  第一个数据的第一个通道
>>> x[1, 0] # 或者x[1][0]  第二个数据的第一个通道

4.2 基于im2col的展开

问题：实现卷积运行，需要重复好几层for，麻烦，而且numPy访问元素最好不要用 for（慢）
解决：用im2col函数（image to column 从图像到矩阵）：将输入数据展开以合适滤波器（权重）

将4维数据 ——> 2维数据

(N,C,H,W)，即(批处理器，通道数，高，长)

使用im2col更消耗内存，但转换为矩阵运算更高效，可有效利用线性代数库。

4.3 卷积层的实现

im2col函数：将4维数据输入——> 2维数据输入

x 输入 4维——> 2维矩阵

W 滤波器 4维——> 2维矩阵

矩阵乘积 X*W + b ——> 输出2维 —(reshape)—> 输出4维

im2col (input_data, filter_h, filter_w, stride=1, pad=0)

卷积层forward的代码实现

import sys, os
sys.path.append(os.pardir)
from common.util import im2col

x1 = np.random.rand(1, 3, 7, 7) # 批大小为1、通道为3的7 × 7的数据
col1 = im2col(x1, 5, 5, stride=1, pad=0)
print(col1.shape) # (9, 75)

x2 = np.random.rand(10, 3, 7, 7) # 批大小为10、通道为3的7 × 7的数据
col2 = im2col(x2, 5, 5, stride=1, pad=0)
print(col2.shape) # (90, 75)

# 卷积层类
class Convolution:
    def __init__(self, W, b, stride=1, pad=0):
        self.W = W
        self.b = b
        self.stride = stride
        self.pad = pad
        
    # 正向传播
    def forward(self, x):
        FN, C, FH, FW = self.W.shape
        N, C, H, W = x.shape
        out_h = int(1 + (H + 2*self.pad - FH) / self.stride)
        out_w = int(1 + (W + 2*self.pad - FW) / self.stride)
        col = im2col(x, FH, FW, self.stride, self.pad)
        col_W = self.W.reshape(FN, -1).T # 滤波器的展开
        out = np.dot(col, col_W) + self.b
        out = out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2)
        return out
        
    # 反向传播在 common/layer.py中，必须进行im2col的逆处理 ——> col2im（矩阵转图像）

4.4 池化层的实现

使用im2col函数

在通道方向独立，按通道单独展开（卷积层是最后各个通道相加）

池化层的forward实现代码

class Pooling:
    def __init__(self, pool_h, pool_w, stride=1, pad=0):
        self.pool_h = pool_h
        self.pool_w = pool_w
        self.stride = stride
        self.pad = pad
    
    def forward(self, x):
        N, C, H, W = x.shape
        # 计算输出大小
        out_h = int(1 + (H - self.pool_h) / self.stride)
        out_w = int(1 + (W - self.pool_w) / self.stride)
        
        # 展开(1)    1.展开输入数据
        col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)
        col = col.reshape(-1, self.pool_h*self.pool_w)
        
        # 最大值(2)  2.求各行的最大值
        out = np.max(col, axis=1)
        
        # 转换(3)    3.转换为合适的输出大小
        out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)
        return out

池化层的实现按下面3个阶段进行：

展开输入数据
求各行的最大值
转换为合适的输出大小

四、CNN实现

class SimpleConvNet:
    """简单的ConvNet

    conv - relu - pool - affine - relu - affine - softmax
    
    Parameters
    ----------
    input_size : 输入大小（MNIST的情况下为784，三维(1, 28, 28)）
    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): # 30个5*5的滤波器
         # 取滤波器参数到conv_param字典中，备用
        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]  # 28
        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)) # 池化层输出，H，W减半

        # 初始化权重，三层
        self.params = {}
        # 滤波器就是第一层的权重 W1 = (30,1,5,5)（四维数据），即30个高、长为5，通道数为1的数据
        self.params['W1'] = weight_init_std * \
                            np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
        # 每一个滤波器都加一个偏置b1，有30个
        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)

        # 生成层，用以调用
        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()

    # 前向传播，从头开始依次调用层，并将结果传给下一层
    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)

        return x

    # 除了使用predict，还要进行forward，直到到达最后的SoftmaxWithLoss层
    def loss(self, x, t):
        """求损失函数
        参数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 numerical_gradient(self, x, t):
        """求梯度（数值微分）

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

        Returns
        -------
        具有各层的梯度的字典变量
            grads['W1']、grads['W2']、...是各层的权重
            grads['b1']、grads['b2']、...是各层的偏置
        """
        loss_w = lambda w: self.loss(x, t)

        grads = {}
        for idx in (1, 2, 3):
            grads['W' + str(idx)] = numerical_gradient(loss_w, self.params['W' + str(idx)])
            grads['b' + str(idx)] = numerical_gradient(loss_w, self.params['b' + str(idx)])

        return grads

    # 调用各层的backward，并把权重参数的梯度存到grads字典中
    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

五、CNN可视化

滤波器会提取边缘或斑块等原始信息。随着层的加深，提取的信息也愈加复杂。