吴恩达深度神经网络笔记—搭建卷积神经网络模型
大纲
我们要实现一个拥有卷积层（CONV）和池化层（POOL）的网络，它包含了前向和反向传播。将实现卷积神经网络的构建模块，下面将列举要实现的模块的函数功能：
- 卷积模块，包含了以下函数：
- 使用0扩充边界
- 卷积窗口
- 前向卷积
- 反向卷积
- 池化模块，包含了以下函数：
- 前向池化
- 创建掩码
- 值分配
- 反向池化
先利用numpy来实现这些功能，后续更改为TensorFlow。模型结构如下：
对于每个前向函数，都有对应的反向等价函数。因此，在前向模块的每一步，你都将在缓存中存储一些参数。这些参数用于在反向传播过程中计算梯度。
导入库
第一步导入所需的库：
import numpy as np
import h5py
import matplotlib.pyplot as plt
%matplotlib inline
plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
%load_ext autoreload
%autoreload 2
np.random.seed(1)
构建卷积层
构建卷积层首先实现两个辅助函数：一个用于零填充，另一个用于计算卷积。
卷积层将输入转换成不同维度的输出，如下所示。
边界填充
边界填充将会在图像边界周围添加值为0的像素点，如下图所示：
为什么要这样做：
- 卷积了上一层之后的CONV层，没有缩小高度和宽度。 这对于建立更深的网络非常重要，否则在更深层时，高度/宽度会缩小。 一个重要的例子是“same”卷积，其中高度/宽度在卷积完一层之后会被完全保留。
- 它可以帮助我们在图像边界保留更多信息。在没有填充的情况下，卷积过程中图像边缘的极少数值会受到过滤器的影响从而导致信息丢失。
我们将实现一个边界填充函数，它会把所有的样本图像X都使用0进行填充。
np.pad(array，pad_width，mode，**kwargs) # 返回填充后的numpy数组
array：要填充的numpy数组【要对谁进行填充】
pad_width：每个轴要填充的数据的数目【每个维度前、后各要填充多少个数据】
mode：填充的方式【采用哪种方式填充】
轴的定义：所在维度的方向
def zero_pad(X, pad):
X_pad = np.pad(X,((0,0),(pad,pad),(pad,pad),(0,0)),'constant')
return X_pad
测试：
np.random.seed(1)
x = np.random.randn(4, 3, 3, 2)
x_pad = zero_pad(x, 2)
print ("x.shape =", x.shape)
print ("x_pad.shape =", x_pad.shape)
print ("x[1,1] =", x[1,1])
print ("x_pad[1,1] =", x_pad[1,1])
fig, axarr = plt.subplots(1, 2)
axarr[0].set_title('x')
axarr[0].imshow(x[0,:,:,0])
axarr[1].set_title('x_pad')
axarr[1].imshow(x_pad[0,:,:,0])
结果：
x.shape = (4, 3, 3, 2)
x_pad.shape = (4, 7, 7, 2)
x[1,1] = [[ 0.90085595 -0.68372786]
[-0.12289023 -0.93576943]
[-0.26788808 0.53035547]]
x_pad[1,1] = [[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]]
单步卷积
要实现第一步卷积，就要使用一个过滤器来卷积输入的数据。
在计算机视觉应用中，左侧矩阵中的每个值都对应一个像素值，我们通过将其值与原始矩阵元素相乘，然后对它们进行求和来将3x3滤波器与图像进行卷积。我们需要实现一个函数，可以将一个3x3滤波器与单独的切片块进行卷积并输出一个实数。
def conv_single_step(a_slice_prev, W, b):
s = np.multiply(a_slice_prev,W)+b
Z = np.sum(s)
return Z
测试：
np.random.seed(1)
a_slice_prev = np.random.randn(4, 4, 3)
W = np.random.randn(4, 4, 3)
b = np.random.randn(1, 1, 1)
Z = conv_single_step(a_slice_prev, W, b)
print("Z =", Z)
结果：
Z = -23.16021220252078
前向传播
在前向传播的过程中，我们将使用多种过滤器对输入的数据进行卷积操作，每个过滤器会产生一个2D的矩阵，我们可以把它们堆叠起来，于是这些2D的卷积矩阵就变成了高维的矩阵。
我们需要实现一个函数以实现对激活值进行卷积。我们需要在激活值矩阵Aprev上使用过滤器W进行卷积，该函数的输入是前一层的激活输出AprevF个过滤器，其权重矩阵为W、偏置矩阵为b，每个过滤器只有一个偏置，最后，我们需要一个包含了步长s和填充p的字典类型的超参数。
如果我要在矩阵A_prev（shape = (5,5,3)）的左上角选择一个2x2的矩阵进行切片操作:
a_slice_prev = a_prev[0:2,0:2,:]
如果我想要自定义切片，我们可以这么做：先定义要切片的位置，vert_start、vert_end、 horiz_start、 horiz_end，它们的位置我们看一下下面的图就明白了。
将卷积的输出形状与输入形状联系起来的公式为:
nC=过滤器数量
def conv_forward(A_prev, W, b, hparameters):
(m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape
(f, f, n_C_prev, n_C) = W.shape
stride = hparameters["stride"]
pad = hparameters["pad"]
n_H = int((n_H_prev + 2 * pad - f) / stride) + 1
n_W = int((n_W_prev + 2 * pad - f) / stride) + 1
Z = np.zeros((m,n_H,n_W,n_C))
A_prev_pad = zero_pad(A_prev, pad)
for i in range(m):
a_prev_pad = A_prev_pad[i]
for h in range(n_H):
for w in range(n_W):
for c in range(n_C):
vert_start = h * stride
vert_end = vert_start + f
horiz_start = w * stride
horiz_end = horiz_start + f
a_slice_prev = a_prev_pad[vert_start:vert_end,horiz_start:horiz_end,:]
Z[i,h,w,c] = conv_single_step(a_slice_prev,W[:,:,:,c],b[0,0,0,c])
assert(Z.shape == (m, n_H, n_W, n_C))
cache = (A_prev, W, b, hparameters)
return Z, cache
测试：
np.random.seed(1)
A_prev = np.random.randn(10,4,4,3)
W = np.random.randn(2,2,3,8)
b = np.random.randn(1,1,1,8)
hparameters = {"pad" : 2,
"stride": 1}
Z, cache_conv = conv_forward(A_prev, W, b, hparameters)
print("Z's mean =", np.mean(Z))
print("cache_conv[0][1][2][3] =", cache_conv[0][1][2][3])
结果：
Z's mean = 0.15585932488906465
cache_conv[0][1][2][3] = [-0.20075807 0.18656139 0.41005165]
最后，CONV层还应该包含一个激活，在这种情况下，我们将添加以下代码行:
A[i, h, w, c] = activation(Z[i, h, w, c])
构建池化层
池化层会减少输入的宽度和高度，这样它会较少计算量的同时也使特征检测器对其在输入中的位置更加稳定。下面介绍两种类型的池化层：
- 最大值池化层：在输入矩阵中滑动一个大小为fxf的窗口，选取窗口里的值中的最大值，然后作为输出的一部分。
- 均值池化层：在输入矩阵中滑动一个大小为fxf的窗口，计算窗口里的值中的平均值，然后这个均值作为输出的一部分。
池化层没有用于进行反向传播的参数，但是它们有像窗口的大小为f的超参数，它指定fxf窗口的高度和宽度，我们可以计算出最大值或平均值。
池化层的前向传播
现在我们要在同一个函数中实现最大值池化层和均值池化层，和之前计算输出维度一样，池化层的计算也是一样的。
def pool_forward(A_prev, hparameters, mode = "max"):
(m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape
f = hparameters["f"]
stride = hparameters["stride"]
n_H = int(1 + (n_H_prev - f) / stride)
n_W = int(1 + (n_W_prev - f) / stride)
n_C = n_C_prev
A = np.zeros((m, n_H, n_W, n_C))
for i in range(m):
for h in range(n_H):
for w in range(n_W):
for c in range(n_C):
vert_start = h * stride
vert_end = vert_start + f
horiz_start = w * stride
horiz_end = horiz_start + f
A_slice_prev = A_prev[i,vert_start:vert_end,horiz_start:horiz_end,c]
if mode == "max":
A[ i , h , w , c ] = np.max(A_slice_prev)
elif mode == "average":
A[ i , h ,w , c ] = np.mean(A_slice_prev)
cache = (A_prev, hparameters)
assert(A.shape == (m, n_H, n_W, n_C))
return A, cache
测试：
np.random.seed(1)
A_prev = np.random.randn(2, 4, 4, 3)
hparameters = {"stride" : 1, "f": 4}
A, cache = pool_forward(A_prev, hparameters)
print("mode = max")
print("A =", A)
print()
A, cache = pool_forward(A_prev, hparameters, mode = "average")
print("mode = average")
print("A =", A)
结果：
mode = max
A = [[[[1.74481176 1.6924546 2.10025514]]]
[[[1.19891788 1.51981682 2.18557541]]]]
mode = average
A = [[[[-0.09498456 0.11180064 -0.14263511]]]
[[[-0.09525108 0.28325018 0.33035185]]]]
卷积神经网络中的反向传播
计算dA
公式如下：
Wc是过滤器， dZhw 是一个标量， dZhw是卷积层第h行第w列的使用点乘计算后的输出Z的梯度。注意，每次更新dA时，我们用相同的过滤器Wc乘以不同的dZ。我们这样做的主要原因是，在计算正向传播时，每个过滤器都用不同的a_slice点乘和求和。因此，在计算dA的backprop时，我们只是将所有a_slice的梯度相加。代码如下：
da_prev_pad[vert_start:vert_end, horiz_start:horiz_end, :] += W[:,:,:,c] * dZ[i, h, w, c]
计算dW
公式如下：
其中，aslice 对应着Zij的激活值。由此，我们就可以推导W的梯度，因为我们使用了过滤器来对数据进行窗口滑动，在这里，我们实际上是切出了和过滤器一样大小的切片，切了多少次就产生了多少个梯度，所以我们需要把它们加起来得到这个数据集的整体dW。代码如下：
db[:,:,:,c] += dZ[i, h, w, c]
卷积反向代码：
def conv_backward(dZ, cache):
(A_prev, W, b, hparameters) = cache
(m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape
(f, f, n_C_prev, n_C) = W.shape
stride = hparameters["stride"]
pad = hparameters["pad"]
(m, n_H, n_W, n_C) = dZ.shape
dA_prev = np.zeros((m, n_H_prev, n_W_prev, n_C_prev))
dW = np.zeros((f, f, n_C_prev, n_C))
db = np.zeros((1,1,1,n_C))
A_prev_pad = zero_pad(A_prev,pad)
dA_prev_pad = zero_pad(dA_prev,pad)
for i in range(m):
a_prev_pad = A_prev_pad[i]
da_prev_pad = dA_prev_pad[i]
for h in range(n_H):
for w in range(n_W):
for c in range(n_C):
vert_start = h * stride
vert_end = vert_start + f
horiz_start = w * stride
horiz_end = horiz_start + f
a_slice = a_prev_pad[vert_start:vert_end,horiz_start:horiz_end,:]
da_prev_pad[vert_start:vert_end,horiz_start:horiz_end,:] += W[:,:,:,c] * dZ[i, h, w, c]
dW[:,:,:,c] += a_slice * dZ[i, h, w, c]
db[:,:,:,c] += dZ[i, h, w, c]
dA_prev[i,:,:,:] = da_prev_pad[pad:-pad,pad:-pad,:]
assert(dA_prev.shape == (m, n_H_prev, n_W_prev, n_C_prev))
return dA_prev, dW, db
测试：
np.random.seed(1)
dA, dW, db = conv_backward(Z, cache_conv)
print("dA_mean =", np.mean(dA))
print("dW_mean =", np.mean(dW))
print("db_mean =", np.mean(db))
结果：
dA_mean = 9.608990675868995
dW_mean = 10.581741275547566
db_mean = 76.37106919563735
池化层的反向传播
最大值池化层的反向传播
在开始池化层的反向传播之前，我们需要创建一个create_mask_from_window()的函数，我们来看一下它是干什么的：
正如你所看到的，这个函数创建了一个掩码矩阵，以保存最大值的位置，当为1的时候表示最大值的位置，其他的为0，这个是最大值池化层，均值池化层的向后传播也和这个差不多，但是使用的是不同的掩码。
def create_mask_from_window(x):
mask = x == np.max(x)
return mask
测试：
np.random.seed(1)
x = np.random.randn(2,3)
mask = create_mask_from_window(x)
print('x = ', x)
print("mask = ", mask)
结果：
x = [[ 1.62434536 -0.61175641 -0.52817175]
[-1.07296862 0.86540763 -2.3015387 ]]
mask = [[ True False False]
[False False False]]
为什么我们要创建这一个掩码矩阵呢？想一下我们的正向传播首先是经过卷积层，然后滑动地取卷积层最大值构成了池化层，如果我们不记录最大值的位置，那么我们怎样才能反向传播到卷积层呢？
均值池化层的反向传播
在最大值池化层中，对于每个输入窗口，输出的所有值都来自输入中的最大值，但是在均值池化层中，因为是计算均值，所以输入窗口的每个元素对输出有一样的影响，我们来看看如何反向传播吧
def distribute_value(dz, shape):
(n_H, n_W) = shape
average = dz / (n_H*n_W)
a = np.ones(shape)*average
return a
测试：
a = distribute_value(2, (2,2))
print('distributed value =', a)
结果：
distributed value = [[0.5 0.5]
[0.5 0.5]]
池化层的反向传播
def pool_backward(dA, cache, mode = "max"):
(A_prev,hparameters) = cache
stride = hparameters["stride"]
f = hparameters["f"]
(m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape
(m, n_H, n_W, n_C) = dA.shape
dA_prev = np.zeros_like(A_prev)
for i in range(m):
a_prev = A_prev[i]
for h in range(n_H):
for w in range(n_W):
for c in range(n_C):
vert_start = h * stride
vert_end = vert_start + f
horiz_start = w * stride
horiz_end = horiz_start + f
if mode =="max":
a_prev_slice = a_prev[vert_start:vert_end,horiz_start:horiz_end,c]
mask = create_mask_from_window(a_prev_slice)
dA_prev[i,vert_start:vert_end,horiz_start:horiz_end,c] += np.multiply(mask,dA[i,h,w,c])
elif mode == "average":
da = dA[i,h,w,c]
shape = (f,f)
dA_prev[i,vert_start:vert_end,horiz_start:horiz_end,c] += distribute_value(da,shape)
assert(dA_prev.shape == A_prev.shape)
return dA_prev
测试：
np.random.seed(1)
A_prev = np.random.randn(5, 5, 3, 2)
hparameters = {"stride" : 1, "f": 2}
A, cache = pool_forward(A_prev, hparameters)
dA = np.random.randn(5, 4, 2, 2)
dA_prev = pool_backward(dA, cache, mode = "max")
print("mode = max")
print('mean of dA = ', np.mean(dA))
print('dA_prev[1,1] = ', dA_prev[1,1])
print()
dA_prev = pool_backward(dA, cache, mode = "average")
print("mode = average")
print('mean of dA = ', np.mean(dA))
print('dA_prev[1,1] = ', dA_prev[1,1])
结果：
mode = max
mean of dA = 0.14571390272918056
dA_prev[1,1] = [[ 0. 0. ]
[ 5.05844394 -1.68282702]
[ 0. 0. ]]
mode = average
mean of dA = 0.14571390272918056
dA_prev[1,1] = [[ 0.08485462 0.2787552 ]
[ 1.26461098 -0.25749373]
[ 1.17975636 -0.53624893]]