【一文读懂卷积神经网络（三）】可能是你看过的最全的CNN（步长不为1，无填充）

本系列将由浅入深的介绍卷积神经网络的前向传播与后向传播，池化层的前向传播与后向传播，并分别介绍在不同步长与不同填充的情况下卷积层和池化层的前向传播与后向传播又有哪些不同。最后给出完整的Python实现代码。

完整目录如下：

一、CNN$\Rightarrow$步长为1，无填充的卷积神经网络

二、CNN$\Rightarrow$步长为1，有填充的卷积神经网络

三、CNN$\Rightarrow$步长不为1，无填充的卷积神经网络

四、CNN$\Rightarrow$步长不为1，有填充的卷积神经网络

上一篇文章已经介绍了有填充，步长为1的卷积神经网络,本文将继续由浅入深的介绍无填充，步长不为1的卷积神经网络的前向传播与后向传播，有填充的池化层的前向传播与后向传播。

1. CNN的前向传播（无填充，步长strides不为1）

1.1 卷积层的前向传播

给定输入4x4的矩阵A，2x2的卷积核W，让A和W做无填充，步长为2的卷积，得到2x2的矩阵Z。示意图如下。

1.2 池化层的前向传播

给定输入4x4的矩阵Ain，2x2的池化核，对Ain做步长为2的池化后可以得到2x2的矩阵Aout，示意图如下。

2. CNN的反向传播（无填充，步长strides不为1）

对于上述前向传播，我们将损失定义为loss，我们的目标是去minimize loss，记loss对某个参数x的偏导数为dx，先来看看池化层的反向传播。

2.1 池化层的反向传播

loss对池化层输入$A^1$的偏导数为$d{A}_{in}^1$，池化层的反向传播的数学表达式可写为$d{A}_{in}^1=d{A}_{out}^1\times \frac{d{A}_{out}^1}{d{A}_{in}^1}$，其中最关键的一步是搞清楚$\frac{d{A}_{out}^1}{d{A}_{in}^1}$怎么求。我们由之前的介绍可知，池化层分为最大池化和均值池化，我们来分别探讨这两种情况。

2.1.1 最大池化的反向传播

假定给定2x2的池化核，设定步长为2，每个池化核区域内的最大值由彩色方框框出。则对输入矩阵Ain进行最大池化的示意图如下。

则我们可知

$A11=1\times a11+0\times a12+0\times a21+0\times a22$

$A12=0\times a13+0\times a14+0\times a23+1\times a24$

$A21=0\times a31+0\times a32+0\times a41+1\times a42$

$A22=0\times a33+1\times a34+0\times a43+0\times a44$

所以可得

$\frac{dA11}{da11}=1,\frac{dA11}{da12}=0,\frac{dA11}{da21}=0,\frac{dA11}{da22}=0$

$\frac{dA12}{da13}=0,\frac{dA12}{da14}=0,\frac{dA12}{da23}=0,\frac{dA12}{da24}=1$

$\frac{dA21}{da31}=0,\frac{dA21}{da32}=0,\frac{dA21}{da41}=0,\frac{dA21}{da42}=1$

$\frac{dA22}{da33}=0,\frac{dA22}{da34}=1,\frac{dA22}{da43}=0,\frac{dA22}{da44}=0$

因此我们可得步长为2的最大池化的反向传播为

即$d{A}_{in}^1=upsample(d{A}_{out}^1)$，其中upsample是指将$d{A}_{out}^1$上采样至和$d{A}_{in}^1$一样的shape，而$d{A}_{out}^1$里的每个值所在位置由$d{A}_{in}^1$里每个池化核区域内的最大值决定，同时池化核区域移动的步长由和正向传播时的步长一样。
可知，我们需要在正向传播时记住各个池化核大小区域内最大值的位置和步长，在反向传播时即可正确计算。
以下给出这一方法的python实现（为了简便易懂，假设只有一个输入样本且为单通道，但实际情况往往不是这样。）

    def max_pool_backward(self,dAout,Ain,filterSize,strides):
    	#params说明
    	#params dAout为传入的dAout
    	#params Ain为我们记录的正向传播时当前层池化的输入，我们将用来它来计算每个池化核区域内的最大值
    	#params filterSize为池化核的大小
    	#params strides为池化层的步长
    	#return dAin
        dAin=np.zeros_like(Ain)  #初始化dAin为shape和Ain相同，值为0的矩阵
        n_H,n_W=dAout.shape   #n_H,n_W分别是dAout的高和宽
        for h in range(n_H):   #遍历行
             for w in range(n_W):  #遍历列
                     h_start=h*strides  #当前池化区域行的开头
                     h_end=h_start+filterSize  #当前池化区域行的结尾
                     w_start=w*strides  #当前池化区域列的开头
                     w_end=w_start+filterSize  #当前池化区域列的结尾
                     mask=(Ain[h_start:h_end,w_start:w_end]==np.max(Ain[h_start:h_end,w_start:w_end]))
                     #找到当前池化区域内最大值的位置，在mask内，最大值的位置将会等于True(1)，其他位置都等于False(0)
                     dAin[h_start:h_end,w_start:w_end]=mask*dAout[h,w]  #实现对dAout的upsample

        return dAin

2.1.2 均值池化的反向传播

假定给定2x2的池化核，设定步长为2，以下是均值池化正向传播的示意图。

我们可知

$A11=(a11+a12+a21+a22)÷4$

$A12=(a13+a14+a23+a24)÷4$

$A21=(a31+a32+a41+a42)÷4$

$A22=(a33+a34+a43+a44)÷4$

可得

$\frac{dA11}{da11}=\frac{dA11}{da12}=\frac{dA11}{da21}=\frac{dA11}{da22}=\frac{1}{4}$

$\frac{dA12}{da13}=\frac{dA12}{da14}=\frac{dA12}{da23}=\frac{dA12}{da24}=\frac{1}{4}$

$\frac{dA21}{da31}=\frac{dA21}{da32}=\frac{dA21}{da41}=\frac{dA21}{da42}=\frac{1}{4}$

$\frac{dA22}{da33}=\frac{dA22}{da34}=\frac{dA22}{da43}=\frac{dA22}{da44}=\frac{1}{4}$

因此我们可得步长为2的均值池化的反向传播为

即$d{A}_{in}^1=upsample(d{A}_{out}^1)$，这里的upsample和最大池化里的略有不同，是将$d{A}_{out}^1$上采样至和$A_{in}^1$一样的shape，每个位置上的值为对应的$d{A}_{out}^1$的值除上池化核大小的平方。
可见我们只需要知道池化核的大小及步长，就能完成反向传播的计算。
以下给出这一方法的python实现（为了简便易懂，假设只有一个输入样本且为单通道，但实际情况往往不是这样。）

    def average_pool_backward(self,dAout,Ain,filterSize,strides):
    	#params说明
    	#params dAout为传入的dAout
    	#params Ain为我们记录的正向传播时当前层池化的输入，我们将用来它来计算每个池化核区域内的平均值
    	#params filterSize为池化核的大小
    	#params strides为池化层的步长
    	#return dAin
        dAin = np.zeros_like(Ain)  #初始化dAin为shape和Ain相同，值为0的矩阵
        n_H, n_W = dAout.shape  #n_H,n_W分别是dAout的高和宽
        for h in range(n_H):  #遍历行
             for w in range(n_W):  #遍历列
                     h_start = h * strides  #当前池化区域行的开头
                     h_end = h_start + filterSize  #当前池化区域行的结尾
                     w_start = w * strides  #当前池化区域列的开头
                     w_end = w_start + filterSize  #当前池化区域列的结尾
                     dAin[h_start:h_end,w_start:w_end]+=np.ones((filterSize,filterSize))*(dAout[h,w]/(filterSize**2))
                     #1/(filterSize**2)为池化区域内对每个值的导数，再将它上采样至池化核的大小

        return dAin

2.2 卷积层的反向传播

关于卷积层的反向传播，我们需要求三个值，一个是dW,第二个是dA（即上一池化层的输出，本层的输入），第三个是db，当求得dW，db后，就可以选用梯度下降法，Adam等优化算法来更新参数，直至满足停止条件最终得到模型。
首先来看看如何求dW。

2.2.1 求dW

求dW的反向传播的数学表达式可写为$d{W}^0=d{Z}^1\times \frac{d{Z}^1}{d{W}^0}$，其中$d{Z}^1$已由上面池化层的反向传播和relu的反向传播求得，关键就是求解$\frac{d{Z}^1}{d{W}^0}$，先回顾一下卷积层的正向传播，给定4x4的输入矩阵A，2x2的卷积核W，W对A做步长为2无填充的卷积，可以得到2x2的矩阵Z。注意这里的A为上一层池化层的输出！！（如果为第一层的话，则为输入样本数据）

我们可以得到

$z11=a11\times w11+a12\times w12+a21\times w21+a22\times w22$

$z12=a13\times w11+a14\times w12+a23\times w21+a24\times w22$

$z21=a31\times w11+a32\times w12+a41\times w21+a42\times w22$

$z22=a33\times w11+a34\times w12+a43\times w21+a44\times w22$

于是

$dw11=dz11\times a11+dz12\times a13+dz21\times a31+dz22\times a33$

$dw12=dz11\times a12+dz12\times a14+dz21\times a32+dz22\times a34$

$dw21=dz11\times a21+dz12\times a23+dz21\times a41+dz22\times a43$

$dw22=dz11\times a22+dz12\times a24+dz21\times a42+dz22\times a44$

将上述公式总结一下，给出一张示意图帮助理解。

对于A_ranged，我们可以由两种理解。
1.将A的第2列与第3列交换，在把A的第3行与第3行交换。更普遍的，将A的第j列与第j-1+strides列交换，在把A的第j行与第j-1+strides行交换，之后依此类推。
2.对于每个卷积区域的元素，我们可以这样得到，以第一个卷积区域为例，应该是对正常的A取(1,1),(1,1+strides),(1+strides,1),(1+strides,1+strides)这四个元素得到，取出来正好也等于a11,a13,a31,a33，之后的卷积区域依此类推。

由此可见，我们在正向传播时应把上一层池化后的输出A和步长记录下来，在反向传播求dW时，只需将记录的正向传播时的上一层池化层的输出A作为输入，对A按上述两种方法处理得到A_ranged，之后与dZ做步长为2（同正向传播时的步长相同），无填充的卷积，即可完成计算。
以下给出这一方法的python实现（为了简便易懂，假设只有一个输入样本且为单通道，但实际情况往往不是这样。）

    def conv_backward(self,dZ,Aout,filterSize,strides):   #卷积层的后向传播
    	#params说明
    	#params dZ传入的对当前卷积层输出的导数
    	#params Aout当前卷积层正向传播时的输入，我们用它来与dZ做卷积
    	#params filterSize卷积核的大小
    	#params strides卷积的步长
    	#return dW
        dW=np.zeros((filterSize,filterSize))  #初始化dW
        n_H,n_W=dZ.shape  #dZ的高宽
        for m in range(filterSize):  #遍历行
            for n in range(filterSize):  #遍历列
            	for i in range(n_H):
            		for j in range(n_W):	
                		h= i * strides + m
		                w= j * strides + n 
		                dW[m,n]+=Aout[h,w]*dZ[i,j]
        return dW

2.3.2 求dA

借助上述卷积层的正向传播，我们可以得到

$da11=dz11\times w11，da12=dz11\times w12，da21=dz11\times w21,da22=dz11\times w22$

$da13=dz12\times w11，da14=dz12\times w12，da23=dz12\times w21,da24=dz12\times w22$

$da31=dz21\times w11，da32=dz21\times w12，da41=dz21\times w21,da42=dz21\times w22$

$da33=dz22\times w11，da34=dz22\times w12，da43=dz22\times w21,da44=dz22\times w22$

我们整理一下，可以得到下图

即$dA=pad(insert(dZ))\ast rot180(W)$，
我们可以看到对于求反向传播时的dA，我们首先需要对dZ做insert操作，即填充(strides-1)行和填充(strides-1)列，然后再对dZ做pad操作（填充），填充的大小为$pad=\frac{(n_H-1)-n_{Hprev}+f}{2}=\frac{4-1-3+2}{2}=1$，然后与卷积核W做步长为1！！！步长为1！！！步长为1！！！的卷积操作（无论正向传播时strides是多少），即可完成计算。
以下给出这一方法的python实现（为了简便易懂，假设只有一个输入样本且为单通道，但实际情况往往不是这样。）

    def zero_insert(self,dZ,insert_size):
        H,W=dZ.shape
        dZout=dZ
        insert_values_h=np.zeros((insert_size,W))
        insert_values_w=np.zeros((H,insert_size))
        for h in range(H-1):
            dZout=np.insert(dZout,h+1,values=insert_values_h,axis=0)
        for w in range(W-1):
            dZout=np.insert(dZout,w+1,values=insert_values_w,axis=1)
        return dZout

    def conv_backward(self,dZ,Aout,convFilter,filterSize,strides):   #卷积层的后向传播
    	#params说明
    	#params dZ传入的对当前卷积层输出的导数
    	#params Aout正向传播时该层的输入，上层的输出
    	#params convFilter当前卷积层正向传播时的卷积核
    	#params filterSize卷积核的大小
    	#params strides卷积的步长
    	#return dA
        convFilter=convFilter[:,:,::-1,::-1]
        n_H,n_W=Aout.shape
        dA=np.zeros_like(Aout)   #初始化dA和Aout一样的shape，数值为0
        dZ_inserted = self.zero_insert(dZ, strides - 1)  #对dZ做insert操作
        pad_size=filterSize-1  #填充的大小
		dZ_paded=np.pad(dZ,(pad_size,pad_size),'constant') #对dZ做填充，填充大小为filterSize-1，填充的值为0
        for h in range(n_H): 
             for w in range(n_W): 
                  dA[h,w]=np.sum(np.multiply(dZ_paded[h:h+filterSize,w:w+filterSize],convFilter))  #卷积操作
        return dA

2.3.3 求db

对于求db比较简单，db=dZ，只是需要对dZ在某个维度上做累加运算即可得到。
以下给出求db的python实现（为了简便易懂，假设只有一个输入样本且为单通道，但实际情况往往不是这样。）

 def conv_backward(self,dZ):   #卷积层的后向传播 
        db=np.sum(dZ)
        return db

以上就是无填充，步长不为1的卷积神经网络的原理，可以看到，步长是否为1的反向传播的区别就在于A是否要重排列和dZ是否要insert和pad，下一节我们将对有填充，步长为1的卷积神经网络进行讲解。

所有源代码在文末

码字作图实属不易，前前后后断断续续用了不少时间，希望大家看后能有所收获，觉得可以的给点赞赏，让我有走下去的动力。谢谢大家！

大家看完python实现的方法是否会发现效率过于低下，因为其中有大量的for循环，博主本人花费了一些时间优化了代码，使速度有了很大的提升（最快的由6个for循环降为2个for循环），有兴趣的小伙伴可以在打赏我后评论或私聊我，我将代码发给你。请见谅。

3. 全部代码

Github见所有Python代码