卷积神经网络cnn的实现

卷积神经网络

代码:https://github.com/TimVerion/cat

卷积层

卷积层:通过在原始图像上平移来提取特征,每一个特征就是一个特征映射

原理:基于人脑的图片识别过程,我们可以认为图像的空间联系也是局部的像素联系比较紧密,而较远的像素相关性比较弱,所以每个神经元没有必要对全局图像进行感知,只要对局部进行感知,而在更高层次对局部的信息进行综合操作得出全局信息;即局部感知。

卷积分的知识

 

过程:

作用:

局部感知:在进行计算的时候,将图片划分为一个个的区域进行计算/考虑; 参数共享机制:假设每个神经元连接数据窗的权重是固定的 滑动窗口重叠:降低窗口与窗口之间的边缘不平滑的特性。

不同的过滤器产生不同的效果:

 

真实做了什么?

一步有一步的浓缩,产生更加靠谱更加准确的特征

 

一张图片卷积后高和宽如何变化?

# 卷积函数
def conv_fun(cache):
   x, w, b = cache["a"], cache["w"], cache["b"]
   pad, stride = cache["pad"], cache["stride"]
   N, C, H, W = x.shape
   F, C, HH, WW = w.shape
   # numpy提供的可以填充0的api,constant代表用一样的值填充前两维不填,后两维各自填充pad行
   x_padded = np.pad(x, ((0, 0), (0, 0), (pad, pad), (pad, pad)), mode='constant')
   H_new = int((H + 2 * pad - HH) / stride) + 1
   W_new = int((W + 2 * pad - WW) / stride) + 1
   s = stride
   out = np.zeros((N, F, H_new, W_new))
   for i in range(N):  # ith image
       for f in range(F):  # fth filter
           for j in range(H_new):
               for k in range(W_new):
                   out[i, f, j, k] = np.sum
                  (x_padded[i, :, j * s:(HH + j * s), k * s:(WW + k * s)] * w[f]) +b[f]
   return out

 

池化层

池化层:通过特征后稀疏参数来减少学习的参数,降低网络的复杂度,(最大池化和平均池化)

# 前向池化
def max_pool_forward(cache):
  x, HH, WW, s = cache["net"], cache["HH"], cache["WW"], cache["s"]
  N, C, H, W = x.shape
  H_new = 1 + int((H - HH) / s)
  W_new = 1 + int((W - WW) / s)
  out = np.zeros((N, C, H_new, W_new))
  for i in range(N):
      for j in range(C):
          for k in range(H_new):
              for l in range(W_new):
                  # 定位到某个窗口
                  window = x[i, j, k * s:HH + k * s, l * s:WW + l * s]
                  # 找到该窗口的最大值,然后赋值
                  out[i, j, k, l] = np.max(window)
  return out

ReLU层

http://playground.tensorflow.org/

作用:增加网络非线性的分割能力

# Relu函数
def Relu(x):
   return np.maximum(0, x)

全连接层

# 全连接
def fc(net, w, b):
   N = net.shape[0]
   # 把每个像素提取出来
   x_row = net.reshape(N, -1)
   out = np.dot(x_row, w) + b
   return out

CNN反向传播的不同之处

首先要注意的是,一般神经网络中每一层输入输出a,z都只是一个向量,而CNN中的a,z是一个三维张量,即由若干个输入的子矩阵组成。其次:

  1. 池化层没有激活函数。这个问题倒比较好解决,我们可以令池化层的激活函数为σ(z)=z,即激活后就是自己本身。这样池化层激活函数的导数为1。

  2. 池化层在前向传播的时候,对输入进行了压缩,那么我们向前反向推导上一层的误差时,需要做upsample处理

  3. 卷积层是通过张量卷积,或者说若干个矩阵卷积求和而得到当前层的输出,这和一般的网络直接进行矩阵乘法得到当前层的输出不同。这样在卷积层反向传播的时候,上一层误差的递推计算方法肯定有所不同。

  4. 对于卷积层,由于W使用的运算是卷积,那么由该层误差推导出该层的所有卷积核的W,b的方式也不同。

池化层的反向传播

这时候假如前向的时候是最大化池化:

这时候要用到前向传播的时候最大值位置进行还原:

如果是平均:

 

卷积层的反向传播

吴恩达笔记中的推导:

卷积神经网络中的反向传播(可选/非梯度)

在现代深度学习框架中,你只需要执行正向传递,这个框架负责向后传递,所以大多数深度学习工程师不会这样做

需要麻烦的细节向后传递。卷积的向后传递网络是复杂的。但是,如果您愿意,您可以完成这个可选部分

来了解卷积网络中的backprop是什么样子的。

在之前的课程中,你实现了一个简单的(完全连接的)神经网络,使用反向传播来计算关于更新成本的导数

参数。类似地,在卷积神经网络中你可以计算为了更新参数对代价求导。backprop方程不是平常那样的,我们在课堂上没有推导出来,但是我们简单地介绍了一下:

Convolutional layer backward pass

让我们从实现CONV层的向后传递开始。

 
  1. 计算dA:

这是计算dA对于一定的过滤器Wc的代价的公式以及一个给定的训练例子:

 

其中Wc是一个过滤器,dZhw是上一层传递过来的梯度,每次我们都将相同的过滤器Wc乘以不同的dZ更新的。我们这样做主要是因为当计算正向传播时,每个过滤器都是由不同的a_slice点乘求和。因此,当计算dA的反向传播的时候,我们也是把所有a_slice的梯度相加。

在代码中,在合适的for循环中,这个公式可以转化为:

da_prev_pad[vert_start:vert_end, horiz_start:horiz_end, :] 
+=,W[:,:,:,c] * dZ[i, h, w, c]
  1. 计算dW: 这是计算dWc (dWc是一个过滤器的导数)关于损失的公式:

     

    其中aslice是原样本的一个窗口。因此,这就得到了W关于这个窗口的梯度。这是相同的W,我们将所有这些梯度相加得到dW。

    在代码中,在合适的for循环中,这个公式可以转化为:

    dW[:,:,:,c] += a_slice * dZ[i, h, w, c]
  2. 计算db: 这是计算db对于一个过滤器Wc的代价的公式:

     

    正如您之前在基本神经网络中看到的,db是通过求和dZ来计算的。在本例中只需对conv输出(Z)的所有梯度求和。

    在代码中,在合适的for循环中,这个公式可以转化为:

    db[:,:,:,c] += dZ[i, h, w, c]

真实代码:

def conv_backward(dout, cache):
    x, w, b = cache["a"], cache["w"], cache["b"]
    pad, stride = cache["pad"], cache["stride"]
    F, C, HH, WW = w.shape
    N, C, H, W = x.shape
    H_new = 1 + int((H + 2 * pad - HH) / stride)
    W_new = 1 + int((W + 2 * pad - WW) / stride)
​
    dx = np.zeros_like(x)
    dw = np.zeros_like(w)
    db = np.zeros_like(b)
​
    s = stride
    x_padded = np.pad(x, ((0, 0), (0, 0), (pad, pad), (pad, pad)), 'constant')
    dx_padded = np.pad(dx, ((0, 0), (0, 0), (pad, pad), (pad, pad)), 'constant')
​
    for i in range(N):  # ith image
        for f in range(F):  # fth filter
            for j in range(H_new):
                for k in range(W_new):
                    window = x_padded[i, :, j * s:HH + j * s, k * s:WW + k * s]
                    # db = dout //  dw=dout*x // dx = dout*w
                    db[f] += dout[i, f, j, k]
                    dw[f] += window * dout[i, f, j, k]
                    dx_padded[i, :, j * s:HH + j * s, k * s:WW + k * s] 
                    += w[f] * dout[i, f, j, k]

 

 

posted @ 2019-08-22 21:11  Timcode  阅读(...)  评论(...编辑  收藏