以下实现参考吴恩达的作业。
一、 padding
def zero_pad(X, pad): """ Pad with zeros all images of the dataset X. The padding is applied to the height and width of an image, as illustrated in Figure 1. Argument: X -- python numpy array of shape (m, n_H, n_W, n_C) representing a batch of m images pad -- integer, amount of padding around each image on vertical and horizontal dimensions Returns: X_pad -- padded image of shape (m, n_H + 2*pad, n_W + 2*pad, n_C) """ X_pad = np.pad(X, ((0,0),(pad,pad),(pad,pad),(0,0)), 'constant', constant_values=(0,0)) return X_pad
从zero_pad的函数中，我们可以看出，我们只需要对原图片矩阵进行padding操作，而m是图片的个数，n_C则是channel的个数，这两个维度并不需要我们做任何操作。
二、 卷积计算
def conv_single_step(a_slice_prev, W, b): s = a_slice_prev * W Z = np.sum(s) Z = Z + float(b) return Z
卷积计算的过程中，a_slice_prev是我们在图片矩阵中的窗口，而W是filter的参数。随后我们对求得的结果进行求和，然后加上常数b。
三、 卷积forward
1 def conv_forward(A_prev, W, b, hparameters): 2 """ 3 Implements the forward propagation for a convolution function 4 5 Arguments: 6 A_prev -- output activations of the previous layer, numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev) 7 W -- Weights, numpy array of shape (f, f, n_C_prev, n_C) 8 b -- Biases, numpy array of shape (1, 1, 1, n_C) 9 hparameters -- python dictionary containing "stride" and "pad" 10 11 Returns: 12 Z -- conv output, numpy array of shape (m, n_H, n_W, n_C) 13 cache -- cache of values needed for the conv_backward() function 14 """ 15 16 ### START CODE HERE ### 17 # Retrieve dimensions from A_prev's shape (≈1 line) 18 (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape 19 20 # Retrieve dimensions from W's shape (≈1 line) 21 (f, f, n_C_prev, n_C) = W.shape 22 23 # Retrieve information from "hparameters" (≈2 lines) 24 stride = hparameters['stride'] 25 pad = hparameters['pad'] 26 27 # Compute the dimensions of the CONV output volume using the formula given above. Hint: use int() to floor. (≈2 lines) 28 n_H = int((n_H_prev + 2 * pad - f) / stride + 1) 29 n_W = int((n_W_prev + 2 * pad - f) / stride + 1) 30 31 # Initialize the output volume Z with zeros. (≈1 line) 32 Z = np.zeros((m, n_H, n_W, n_C)) 33 34 # Create A_prev_pad by padding A_prev 35 A_prev_pad = zero_pad(A_prev, pad) 36 37 for i in range(m): # loop over the batch of training examples 38 a_prev_pad = A_prev_pad[i] # Select ith training example's padded activation 39 for h in range(n_H): # loop over vertical axis of the output volume 40 for w in range(n_W): # loop over horizontal axis of the output volume 41 for c in range(n_C): # loop over channels (= #filters) of the output volume 42 43 # Find the corners of the current "slice" (≈4 lines) 44 vert_start = h * stride 45 vert_end = h * stride + f 46 horiz_start = w * stride 47 horiz_end = w * stride + f 48 49 # Use the corners to define the (3D) slice of a_prev_pad (See Hint above the cell). (≈1 line) 50 a_slice_prev = a_prev_pad[vert_start : vert_end, horiz_start : horiz_end] 51 52 # Convolve the (3D) slice with the correct filter W and bias b, to get back one output neuron. (≈1 line) 53 Z[i, h, w, c] = conv_single_step(a_slice_prev,W[:,:,:,c],b[:,:,:,c]) 54 55 ### END CODE HERE ### 56 57 # Making sure your output shape is correct 58 assert(Z.shape == (m, n_H, n_W, n_C)) 59 60 # Save information in "cache" for the backprop 61 cache = (A_prev, W, b, hparameters) 62 63 return Z, cache
参数中包含我们的图片A_prev，W，b以及超参数padding和strides。我们首先通过元组的方式获取了所有形状参数。根据形状对输出结果初始化。随后我们便可以对每一个图片中的每一个窗口进行遍历。通过f窗口长度的加法计算，我们得到窗口的横纵坐标位置。随后通过卷积计算得到最终结果。注意这里的参数适用于图中的每一个窗口。
四、 池化层
def pool_forward(A_prev, hparameters, mode = "max"): """ Implements the forward pass of the pooling layer Arguments: A_prev -- Input data, numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev) hparameters -- python dictionary containing "f" and "stride" mode -- the pooling mode you would like to use, defined as a string ("max" or "average") Returns: A -- output of the pool layer, a numpy array of shape (m, n_H, n_W, n_C) cache -- cache used in the backward pass of the pooling layer, contains the input and hparameters """ # Retrieve dimensions from the input shape (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape # Retrieve hyperparameters from "hparameters" f = hparameters["f"] stride = hparameters["stride"] # Define the dimensions of the output n_H = int(1 + (n_H_prev - f) / stride) n_W = int(1 + (n_W_prev - f) / stride) n_C = n_C_prev # Initialize output matrix A A = np.zeros((m, n_H, n_W, n_C)) ### START CODE HERE ### for i in range(m): # loop over the training examples for h in range(n_H): # loop on the vertical axis of the output volume for w in range(n_W): # loop on the horizontal axis of the output volume for c in range (n_C): # loop over the channels of the output volume # Find the corners of the current "slice" (≈4 lines) vert_start = h * stride vert_end = vert_start + f horiz_start = w * stride horiz_end = horiz_start + f # Use the corners to define the current slice on the ith training example of A_prev, channel c. (≈1 line) a_prev_slice = A_prev[i, vert_start : vert_end, horiz_start : horiz_end, c] # Compute the pooling operation on the slice. Use an if statment to differentiate the modes. Use np.max/np.mean. if mode == "max": A[i, h, w, c] = np.max(a_prev_slice) elif mode == "average": A[i, h, w, c] = np.mean(a_prev_slice) ### END CODE HERE ### # Store the input and hparameters in "cache" for pool_backward() cache = (A_prev, hparameters) # Making sure your output shape is correct assert(A.shape == (m, n_H, n_W, n_C)) return A, cache
池化层的计算和之前的卷积层大同小异；我们需要注意的就是这里的参数中存在mode，其中包括max和average两种模式。
五、 卷积层backward
def conv_backward(dZ, cache): """ Implement the backward propagation for a convolution function Arguments: dZ -- gradient of the cost with respect to the output of the conv layer (Z), numpy array of shape (m, n_H, n_W, n_C) cache -- cache of values needed for the conv_backward(), output of conv_forward() Returns: dA_prev -- gradient of the cost with respect to the input of the conv layer (A_prev), numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev) dW -- gradient of the cost with respect to the weights of the conv layer (W) numpy array of shape (f, f, n_C_prev, n_C) db -- gradient of the cost with respect to the biases of the conv layer (b) numpy array of shape (1, 1, 1, n_C) """ ### START CODE HERE ### # Retrieve information from "cache" (A_prev, W, b, hparameters) = cache # Retrieve dimensions from A_prev's shape (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape # Retrieve dimensions from W's shape (f, f, n_C_prev, n_C) = W.shape # Retrieve information from "hparameters" stride = hparameters['stride'] pad = hparameters['pad'] # Retrieve dimensions from dZ's shape (m, n_H, n_W, n_C) = dZ.shape # Initialize dA_prev, dW, db with the correct shapes dA_prev = np.zeros(A_prev.shape) dW = np.zeros(W.shape) db = np.zeros(b.shape) # Pad A_prev and dA_prev A_prev_pad = zero_pad(A_prev, pad) dA_prev_pad = zero_pad(dA_prev, pad) for i in range(m): # loop over the training examples # select ith training example from A_prev_pad and dA_prev_pad a_prev_pad = A_prev_pad[i] da_prev_pad = dA_prev_pad[i] for h in range(n_H): # loop over vertical axis of the output volume for w in range(n_W): # loop over horizontal axis of the output volume for c in range(n_C): # loop over the channels of the output volume # Find the corners of the current "slice" vert_start = h * stride vert_end = h * stride + f horiz_start = w * stride horiz_end = w * stride + f # Use the corners to define the slice from a_prev_pad a_slice = a_prev_pad[vert_start : vert_end, horiz_start : horiz_end, : ] # Update gradients for the window and the filter's parameters using the code formulas given above 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] # Set the ith training example's dA_prev to the unpaded da_prev_pad (Hint: use X[pad:-pad, pad:-pad, :]) dA_prev[i, :, :, :] = da_prev_pad[pad:-pad, pad:-pad, :] ### END CODE HERE ### # Making sure your output shape is correct assert(dA_prev.shape == (m, n_H_prev, n_W_prev, n_C_prev)) return dA_prev, dW, db
这里对于dW，db的计算与BP神经网络的计算相似。在更新参数时，我们对整个图片所有位置进行遍历，进行一次计算。
六、池化层backward
我们了解池化层的原理之后，就需要根据其特征构造backward，对于max池，我们需要创建一个mask来获得我们的有效窗口。
def create_mask_from_window(x): """ Creates a mask from an input matrix x, to identify the max entry of x. Arguments: x -- Array of shape (f, f) Returns: mask -- Array of the same shape as window, contains a True at the position corresponding to the max entry of x. """ ### START CODE HERE ### (≈1 line) mask = (x == np.max(x)) ### END CODE HERE ### return mask
对于average我们需要分配到窗口中的每个值。
def distribute_value(dz, shape): """ Distributes the input value in the matrix of dimension shape Arguments: dz -- input scalar shape -- the shape (n_H, n_W) of the output matrix for which we want to distribute the value of dz Returns: a -- Array of size (n_H, n_W) for which we distributed the value of dz """ ### START CODE HERE ### # Retrieve dimensions from shape (≈1 line) (n_H, n_W) = shape # Compute the value to distribute on the matrix (≈1 line) average = n_H * n_W # Create a matrix where every entry is the "average" value (≈1 line) a = dz / average * np.ones((n_H, n_W)) ### END CODE HERE ### return a
之后我们便可以通过和卷积层backward相同的方法，对图片进行遍历，我们将每一次得到的有效输出dZ进行累加得到这一层的dZ。
def pool_backward(dA, cache, mode = "max"): """ Implements the backward pass of the pooling layer Arguments: dA -- gradient of cost with respect to the output of the pooling layer, same shape as A cache -- cache output from the forward pass of the pooling layer, contains the layer's input and hparameters mode -- the pooling mode you would like to use, defined as a string ("max" or "average") Returns: dA_prev -- gradient of cost with respect to the input of the pooling layer, same shape as A_prev """ ### START CODE HERE ### # Retrieve information from cache (≈1 line) (A_prev, hparameters) = cache # Retrieve hyperparameters from "hparameters" (≈2 lines) stride = hparameters['stride'] f = hparameters['f'] # Retrieve dimensions from A_prev's shape and dA's shape (≈2 lines) m, n_H_prev, n_W_prev, n_C_prev = A_prev.shape m, n_H, n_W, n_C = dA.shape # Initialize dA_prev with zeros (≈1 line) dA_prev = np.zeros(A_prev.shape) for i in range(m): # loop over the training examples # select training example from A_prev (≈1 line) a_prev = A_prev[i] for h in range(n_H): # loop on the vertical axis for w in range(n_W): # loop on the horizontal axis for c in range(n_C): # loop over the channels (depth) # Find the corners of the current "slice" (≈4 lines) vert_start = h * stride vert_end = vert_start + f horiz_start = w * stride horiz_end = horiz_start + f # Compute the backward propagation in both modes. if mode == "max": # Use the corners and "c" to define the current slice from a_prev (≈1 line) a_prev_slice = a_prev[vert_start : vert_end, horiz_start : horiz_end, c] # Create the mask from a_prev_slice (≈1 line) mask = create_mask_from_window(a_prev_slice) # Set dA_prev to be dA_prev + (the mask multiplied by the correct entry of dA) (≈1 line) dA_prev[i, vert_start: vert_end, horiz_start: horiz_end, c] += mask * dA[i, h, w, c] elif mode == "average": # Get the value a from dA (≈1 line) da = dA[i, h, w, c] # Define the shape of the filter as fxf (≈1 line) shape = (f, f) # Distribute it to get the correct slice of dA_prev. i.e. Add the distributed value of da. (≈1 line) dA_prev[i, vert_start: vert_end, horiz_start: horiz_end, c] += distribute_value(da, shape) ### END CODE ### # Making sure your output shape is correct assert(dA_prev.shape == A_prev.shape) return dA_prev