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

Posted 2021-04-26 深度学习自然语言处理

关注“深度学习自然语言处理”，一起学习一起冲鸭！

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

作者：云不见

链接：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池化。

池化层的特征：

1. 没有要学习的参数；

2. 通道数不发生变化，输入3张，输出也是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, ossys.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个阶段进行：

1. 展开输入数据

2. 求各行的最大值

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可视化

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

• 提取信息愈加复杂：

  边缘——> 纹理——> 物体部件——> 分类

1998年，CNN元祖：LeNet——> 比如手写数字识别

2012年：深度学习 AlexNet

他们都是叠加多个卷积层，池化层，最后经由全连接层输出

LeNet：

• 激活函数用sigmoid （现主要使用ReLU ）

• 通过子采样来缩小数据（现主要使用Max池化）

AlexNet：

• 激活函数用ReLU

• 使用进行局部正规化的LRN层（local responce normalization)

• 使用dropout

关于网络结构，LeNet和AlexNet没太大差别，现如今大数据和GPU的快速发展推动了深度学习的发展。

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

 
   
   
 

  
    
    
  
 
   
 
    
 
     
 
      
 
       
 
      
 
      
说个正事哈
 
      
 
       
 
      
 
     
 
    
 
    

 
   
 
   
由于微信平台算法改版，公号内容将不再以时间排序展示，如果大家想第一时间看到我们的推送，强烈建议星标我们和给我们多点点【在看】。星标具体步骤为：
 
   
（2）点击右上角的小点点，在弹出页面点击“设为星标”，就可以啦。
 
   
感谢支持，比心。
 
   

 
   

 
   
 
    
投稿或交流学习，备注：昵称-学校（公司）-方向，进入DL&NLP交流群。
 
   
 
   
 
    
方向有很多：机器学习、深度学习，python，情感分析、意见挖掘、句法分析、机器翻译、人机对话、知识图谱、语音识别等。
 
   
 
   
 
    
 
   
 
   
 
    
记得备注呦
 
   
 
   
 
    
 
   
 
  
 
   
   
 
 
   
   
 

  
    
    
  
 
   
 
    推荐两个专辑给大家： 
   
 
   
 
    专辑 |