自己着手实现深度学习框架-6 卷积层和池化层

代码堆栈: https://github.com/brandonlyg/cute-dl
(转载请注明出处!)

目的

        上个阶段使用MLP模子在在MNIST数据集上实现了92%左右的准确率,到达了tensorflow一致模子的水平。这个阶段要让cute-dl框架支持最简朴的卷积神经网络, 并在MNIST和CIFA10数据上验证,具体来说要到达如下目的:

  1. 添加2D卷积层。
  2. 添加2D最大池化层。
  3. CNN模子在MNIST数据集上到达99%以上的准确率。
  4. CNN模子在CIFA10数据集上到达70%以上在准确率。

卷积层的设计和实现

卷积运算

        卷积运算有两个要害要素: 卷积核(过滤器), 卷积运算步长。若是卷积运算的目的是二维的那么卷积核可以用矩阵示意,卷积运算步长可以用二维向量。例如用kernel_size=(3,3)示意卷积核的尺寸,strides=(1,1)示意卷积运算的步长, 如果卷积核是这样的:
自己着手实现深度学习框架-6 卷积层和池化层
        可以把它看成\(R^{3 X 3}\)矩阵。在步长strides=(1,1)的情形下卷积运算如下所示:
自己着手实现深度学习框架-6 卷积层和池化层
        其中

\[\begin{matrix} 128*0 + 97*1 + 53*0 + 35*1 + 22*0 + 25*1 + 37*0 + 24*1 + 28 * 0 = 181 \\ 97*0 + 53*1 + 201*0 + 22*1 + 25*0 + 200*1 + 24*0 + 28*1 + 197 * 0 = 303 \\ … \\ \\ 28*0 + 197*1 + 182*0 + 92*1 + 195*0 + 179*1 + 100*0 + 192*1 + 177 * 0 = 660 \end{matrix} \]

       (注重示意图中最后次运算盘算有误应该是660)
        这个卷积运算输入的是一个高h=5, 宽w=5的特征图, 卷积运算输出的是一个高h_=3, 宽w_=3的特征图。 若是已知w, h, kernel_size=\((h_k, w_k)\), strides=\((h_s, w_s)\), 那么输出特征图的高和宽划分为:

\[ \begin{matrix} h\_ = \frac{h – h_k}{h_s} + 1 \\ w\_= \frac{w – w_k}{w_s} + 1 \\ \\ h, w, h_k, w_k, h_s, w_s \text{都是正整数,}, 1<=h_k<h, 1<=w_k<w, h\_, w\_向下取整 \end{matrix} \]

        由上面两个等式可以得出: h_ <= h, w_ <= w。经由卷积运算后特征图会变小。

卷积层设计

        卷积层的设计主要思量以下几个问题:

  1. 输入层的图像数据可能有多个(颜色)通道, 卷积层要能够处置多通道的输入。
  2. 当叠加多个卷积层时,一样平常情形下特征图会逐层变小, 可以叠加的层数很少, 从而限制了模子的表达能力。卷积层要能够通过填充改变输入特征图的巨细, 控制输出特征图的巨细。
  3. 若是用循环实现卷积运算, 会导致性能很低, 要把卷积运算转换成矩阵运算。
  4. 卷积层输出的特征图最后会输入到全毗邻层中, 而全毗邻层值只支持矩阵输入,因此需要一个过渡层把特征图展平成矩阵。

初始化参数

        卷积层输入是特征图,它的形状为(m,c,h,w), 其中m是批次巨细,c是通道数,h,w划分为特征图的高、宽。输出也是特征图,形状为(m,c_,h_,w_)。前面已经给出了h_和h, w_和w的关系,已知h,w情形下确定h_,w_还需要给出\(h_k,w_k, h_s, w_s\), c_是自力的量,可以根据需要设置。因此卷积层初始化时需要给出的层参数有:卷积核巨细kernel_size=\((h_k, w_k)\), 卷积运算步长strides=\((h_s, w_s)\), 输出通道数c_。 另外还需要padding参数指定填充方式来控制输出特征图的巨细。

填充

        一样平常情形下, 特征图经由卷积层时会缩小,当h=h_时, 则有:

\[h_k = h(1-h_s) + hs \]

        其中 0 <\(h_s\) < h, 只有当\(h_s\)=1时这个等式才有意义, \(h_k=1\)。同理可以获得当w=w_时, \(w_k=w_s=1\)。因此在没有填充的情形下若是要获得巨细稳定的输出,必须把卷积核设置成kernel_size=(1,1), 步长设置成strides=(1,1), 这限制了卷积层的表达能力。
        为了能够对照自由地设置kernel_size和strides, 我们把特征图输入输出巨细关系略作调整:

\[ \begin{matrix} h\_ = \frac{h + 2*h_p – h_k}{h_s} + 1 \\ w\_= \frac{w + 2*w_p – w_k}{w_s} + 1 \\ \\ \end{matrix} \]

        其中\(h_p, w_p\)划分是在高度和宽度上的填充。在高度上,需要在顶部和底部划分填充\(h_p\)的高度。在宽度上也是一样。
        以高度偏向的填充为例:

深度学习中的一些组件及使用技巧,数据挖掘比赛/项目全流程介绍,智能推荐算法演变及学习笔记

\[h_p = \frac{h(h_s-1) + h_k – h_s}{2} \]

        若是\(h_s=1\), \(h_k\)选择[1, h]之内的随便一个奇数都等让上式有意义。当\(h_s > 1\)时, \(h_k\)会有更多的选择。然而在工程上,太多的选择并不一定是好事。太多的选择可能意味着有许多方式可以处置目的问题,也有肯能意味着很难找到有用的方式。
        前面讨论了通过填充实现h_=h, w_=w的情形。 填充也可以实现h_>h, w_>h, 这种情形没有多大意义,这里不予思量。因此padding只支持两种差别的参数: ‘valid’不填充; ‘same’填充,使输入输出特征图同样大。

把卷积运算转换成矩阵运算

        一个输入输出别为\((m, c, h, w)\), \((m, c\_, h\_, w\_)\)的卷积层, 可以把权重参数W的形状设计成\((c*h_k*w_k, c\_)\), 输入特征图转换成卷积矩阵F, 形状为\((m*w\_*h\_, c*h_k*w_k)\), W, F举行矩阵运算,转换成输出特征图的步骤如下:

  • W, F举行矩阵运算获得形状为\((m*w\_*h\_, c\_)\)矩阵。
  • 转换形状\((m*w\_*h\_, c\_)\)->\((m, h\_, w\_, c\_)\)
  • 移动通道维度\((m, h\_, w\_, c\_)\)->\((m, c\_, h\_, w\_,)\)

卷积层实现

        卷积层代码位于cutedl/cnn_layers.py中, 类名为Conv2D, 它支持2维特征图。

初始化

'''
  channels 输出通道数 int
  kernel_size 卷积核形状 (kh, kw)
  strids  卷积运算步长(sh, sw)
  padding 填充方式 'valid': 步填充. 'same': 使输出特征图和输入特征图形状相同
  inshape 输入形状 (c, h, w)
          c 输入通道数
          h 特征图高度
          w 特征图宽度
  kernel_initialier 卷积核初始化器
          uniform 均匀分布
          normal  正态分布
  bias_initialier 偏移量初始化器
          uniform 均匀分布
          normal 正态分布
          zeros  0
  '''
  def __init__(self, channels, kernel_size, strides=(1,1),
              padding='same',
              inshape=None,
              activation='relu',
              kernel_initializer='uniform',
              bias_initializer='zeros'):
      #pdb.set_trace()
      self.__ks = kernel_size
      self.__st = strides
      self.__pad = (0, 0)
      self.__padding = padding

      #参数
      self.__W = self.weight_initializers[kernel_initializer]
      self.__b = self.bias_initializers[bias_initializer]

      #输入输出形状
      self.__inshape = (-1, -1, -1)
      self.__outshape = None

      #输出形状
      outshape = self.check_shape(channels)
      if outshape is None or type(channels) != type(1):
          raise Exception("invalid channels: "+str(channels))

      self.__outshape = outshape

      #输入形状
      inshape = self.check_shape(inshape)
      if self.valid_shape(inshape):
          self.__inshape = self.check_shape(inshape)
          if self.__inshape is None or len(self.__inshape) != 3:
              raise Exception("invalid inshape: "+str(inshape))

          outshape, self.__pad = compute_2D_outshape(self.__inshape, self.__ks, self.__st, self.__padding)
          self.__outshape = self.__outshape + outshape

      super().__init__(activation)

      self.__in_batch_shape = None
      self.__in_batch = None

        如当前层是输入层, 需要inshape参数,在初始类初始化时会挪用compute_2D_outshape方式盘算输出形状,若是当前层不是输入层,会在set_prev方式中盘算输出形状。下面是compute_2D_outshape函数的实现:

'''
盘算2D卷积层的输输出和填充
'''
def compute_2D_outshape(inshape, kernel_size, strides, padding):
    #pdb.set_trace()
    _, h, w = inshape
    kh, kw = kernel_size
    sh, sw = strides

    h_ = -1
    w_ = -1
    pad = (0, 0)
    if 'same' == padding:
        #填充, 使用输入输出形状一致
        _, h_, w_ = inshape
        pad = (((h_-1)*sh - h + kh )//2, ((w_-1)*sw - w + kw)//2)
    elif 'valid' == padding:
        #不填充
        h_ = (h - kh)//sh + 1
        w_ = (w - kw)//sw + 1
    else:
        raise Exception("invalid padding: "+padding)

    #pdb.set_trace()
    outshape = (h_, w_)
    return outshape, pad

        这个函数除了返回输出形状还返回填充值,这是由于,特征图和矩阵之间举行转换时需要知道填充的巨细。

卷积运算

        卷积运算会在向前流传是执行,代码如下:

'''
  向前流传
  in_batch: 一批输入数据
  training: 是否正在训练
  '''
  def forward(self, in_batch, training=False):
      #pdb.set_trace()
      W = self.__W.value
      b = self.__b.value
      self.__in_batch_shape = in_batch.shape

      #把输入特征图展开成卷积运算的矩阵矩阵(m*h_*w_, c*kh*kw)
      in_batch = img2D_mat(in_batch, self.__ks, self.__pad, self.__st)
      #盘算输出值(m*h_*w_, c_) = (m*h_*w_, c*kh*kw) @ (c*kh*kw, c_) + (c_,)
      out = in_batch @ W + b
      #把(m*h_*w_, c_) 转换成(m, h_, w_, c_)
      c_, h_, w_ = self.__outshape
      out = out.reshape((-1, h_, w_, c_))
      #把输出值还原成(m, c_, h_, w_)
      out = np.moveaxis(out, -1, 1)

      self.__in_batch = in_batch

      return self.activation(out)

        其中img2D_mat函数把输入特征图转换成用于卷积运算的矩阵,这个函数的实现如下:

'''
把2D特征图转换成利便卷积运算的矩阵, 形状(m*h_*w_, c*kh*kw)
img 特征图 shape=(m,c,h,w)
kernel_size 核形状 shape=(kh, kw)
pad 填充巨细 shape=(ph, pw)
strides 步长 shape=(sh, sw)
'''
def img2D_mat(img, kernel_size, pad, strides):
    #pdb.set_trace()
    kh, kw = kernel_size
    ph, pw = pad
    sh, sw = strides
    #pdb.set_trace()
    m, c, h, w = img.shape
    kh, kw = kernel_size

    #获得填充的图
    pdshape = (m, c) + (h + 2*ph, w + 2*pw)
    #获得输出巨细
    h_ = (pdshape[2] - kh)//sh + 1
    w_ = (pdshape[3] - kw)//sw + 1
    #填充
    padded = np.zeros(pdshape)
    padded[:, :, ph:(ph+h), pw:(pw+w)] = img

    #转换成卷积矩阵(m, h_, w_, c, kh, kw)
    #pdb.set_trace()
    out = np.zeros((m, h_, w_, c, kh, kw))
    for i in range(h_):
        for j in range(w_):
            #(m, c, kh, kw)
            cov = padded[:, :, i*sh:i*sh+kh, j*sw:j*sw+kw]
            out[:, i, j] = cov

    #转换成(m*h_*w_, c*kh*kw)
    out = out.reshape((-1, c*kh*kw))

    return out

反向流传

        偏向偏向流传没什么稀奇的地方,主要把梯度矩阵还原到特征图上, 代码如下。

'''
矩阵形状的梯度转换成2D特征图梯度
mat 矩阵梯度 shape=(m*h_*w_, c*kh*kw)
特征图形状 imgshape=(m, c, h, w)
'''
def matgrad_img2D(mat, imgshape, kernel_size, pad, strides):
    #pdb.set_trace()
    m, c, h, w = imgshape
    kh, kw = kernel_size
    sh, sw = strides
    ph, pw = pad

    #获得填充形状
    pdshape = (m, c) + (h + 2*ph, w + 2 * pw)
    #获得输出巨细
    h_ = (pdshape[2] - kh)//sh + 1
    w_ = (pdshape[3] - kw)//sw + 1

    #转换(m*h_*w_, c*kh*kw)->(m, h_, w_, c, kh, kw)
    mat = mat.reshape(m, h_, w_, c, kh, kw)

    #还原成填充后的特征图
    padded = np.zeros(pdshape)
    for i in range(h_):
        for j in range(w_):
            #(m, c, kh, kw)
            padded[:, :, i*sh:i*sh+kh, j*sw:j*sw+kw] += mat[:, i, j]

    #pdb.set_trace()
    #获得原图(m,c,h,w)
    out = padded[:, :, ph:ph+h, pw:pw+w]

    return out

最大池化层的设计和实现

最大池化运算

        最大池化盘算和卷积运算算的历程险些一样,只有一点差别,卷积运算是把一个卷积核矩形区域的元素、权重参数按元素相乘后取和,池化层没有权重参数,它的运算结果是取池矩形区域内的最大元素值。下面是池化运算涉及到的观点:

  1. pool_size: 池巨细, 形如\((h_p, w_p)\), 其中\(h_p, w_p\)是池的高度和宽度。pool_size寄义和卷积层的kernel_size类似.
  2. strides: 步长。和卷积层一样。
  3. padding: 填充方式,和卷积层一样。

        假设最大池化层的参数为: pool_size=(2,2), strides=(1,1), padding=’valid’.

        输入数据为:
自己着手实现深度学习框架-6 卷积层和池化层
        池化运算之后的输入为:
自己着手实现深度学习框架-6 卷积层和池化层

最大池化层实现

        最大池化层的代码在cutedl/cnn_layers.py中,类名: MaxPool2D.
        相比于Conv2D, MaxPool2D要简朴许多,其代码主要集中在forward和backward方式中。
        forward实现:

def forward(self, in_batch, training=False):
    m, c, h, w = in_batch.shape
    _, h_, w_ = self.outshape
    kh, kw = self.__ks
    #把特征图转换成矩阵(m, c, h, w)->(m*h_*w_, c*kh*kw)
    in_batch = img2D_mat(in_batch, self.__ks, self.__pad, self.__st)
    #转换形状(m*w_*h_, c*kh*kw)->(m*h_*w_*c,kh*kw)
    in_batch = in_batch.reshape((m*h_*w_*c, kh*kw))
    #获得最大最索引
    idx = in_batch.argmax(axis=1).reshape(-1, 1)
    #转成in_batch相同的形状
    idx = idx @ np.ones((1, in_batch.shape[1]))
    temp = np.ones((in_batch.shape[0], 1)) @ np.arange(in_batch.shape[1]).reshape(1, -1)
    #获得boolean的符号
    self.__mark = idx == temp

    #获得最大值
    max = in_batch[self.__mark]
    max = max.reshape((m, h_, w_, c))
    max = np.moveaxis(max, -1, 1)

    return max

        这个方式的要害是获得最大值索引__mark, 有了它,在反向流传的时刻就能知道梯度值和输入元素的对应关系。

验证

        卷积层验证代码位于examples/cnn目录下,mnis_recognize.py是手写数字识别模子,cifar10_fit.py是图片分类模子,下面是两个模子的训练讲述。
        cifar10数据集下载链接: https://pan.baidu.com/s/1FIBWvJ446ta7CI5_RHdeOw 密码: mhni

mnist数据集上的分类模子

        模子界说:

model = Model([
              cnn.Conv2D(32, (5,5), inshape=inshape),
              cnn.MaxPool2D((2,2), strides=(2,2)),
              cnn.Conv2D(64, (5,5)),
              cnn.MaxPool2D((2,2), strides=(2,2)),
              nn.Flatten(),
              nn.Dense(1024),
              nn.Dropout(0.5),
              nn.Dense(10)
          ])

        训练讲述:
自己着手实现深度学习框架-6 卷积层和池化层
        经由2.6小时的训练,模子有了99.2%的准确率,到达预期目的。

cifar10数据集上的分类模子

        模子界说:

model = Model([
              cnn.Conv2D(32, (3,3), inshape=inshape),
              cnn.MaxPool2D((2,2), strides=(2,2)),
              cnn.Conv2D(64, (3,3)),
              cnn.MaxPool2D((2,2), strides=(2,2)),
              cnn.Conv2D(64, (3, 3)),
              nn.Flatten(),
              nn.Dense(64),
              nn.Dropout(0.5),
              nn.Dense(10)
          ])

        训练讲述:
自己着手实现深度学习框架-6 卷积层和池化层
        经由9小时的训练,模子有了72.2%的准确率,到达预期目的。

原创文章,作者:7h28新闻网,如若转载,请注明出处:https://www.7h28.com/archives/9936.html