吴恩达 week4 Building your Deep Neural Network: Step by Step 编程作业及讲解（中文）

1.导入package

numpy是使用Python进行科学计算的主要软件包。

matplotlib是一个用Python绘制图形的库。

dnn_utils为这个笔记本提供了一些必要的功能。

testCases提供了一些测试用例来评估函数的正确性

np.random.seed(1)用于保持所有随机函数调用的一致性。

import numpy as np
import h5py
import matplotlib.pyplot as plt
from testCases import *
from dnn_utils import sigmoid, sigmoid_backward, relu, relu_backward
from public_tests import *

import copy
%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)

2.Outline大纲

为了构建你的神经网络，你将实现几个“辅助函数”:

initialize_parameters_deep(layer_dims) :初始化L层神经网络的参数

linear_forward(A, W, b)

linear_activation_forward(A_prev, W, b, activation)

L_model_forward(X, parameters)

compute_cost(AL, Y)

linear_backward(dZ, cache)

linear_activation_backward(dA, cache, activation)

这些辅助函数将在下一个任务中用于构建两层神经网络和L层神经网络。

以下是本作业中的步骤概述：

1. 初始化两层和L层神经网络的参数
2. 实现正向传播模块（如下图中紫色所示）
3. 完成前向传播的线性部分（得出𝑍[𝑙])
4. ACTIVATION function提高sigmoid或者ReLu（激活函数）
5. 将前两个步骤合并为一个新的[LINEAR->ACTIVATION]正向函数。
6. 堆叠[LINEAR->RELU]正向函数L-1层（对于层1到L-1），并在末尾添加[LINEAR->SIGMOID]（对于最终层𝐿).这将为您提供一个新的L_model_forward函数。
7. 计算损失值（loss）
8. 实现反向传播模块（下图中用红色表示）
9. 完成层的反向传播步骤的线性部分
10. ACTIVATION函数的梯度提供sigmoid或者ReLu（激活函数）
11. 将前两个步骤合并为一个新的[LINEAR->ACTIVATION]向后函数
12. 向后堆叠[LINEAR->RELU]L-1层，并在新的L_model_backward函数中向后添加[LINEAR->SIGMOID]
13. 更新参数

注：

对于每个前向函数，都有一个相应的反向函数。这就是为什么在转发模块的每一步，您都会在缓存中存储一些值。这些缓存的值对于计算梯度非常有用。

在反向传播模块中，您可以使用缓存来计算梯度。别担心，这项作业将向你展示如何执行这些步骤！

3.Initialization初始化

您将编写两个辅助函数来初始化模型的参数。第一个函数将用于初始化两层模型的参数。第二个将初始化过程概括为𝐿层。

3.1 两层神经网络

Exercise 1 - initialize_parameters

该模型的结构为：线性->RELU->线性->SIGMOID。

将此随机初始化用于具有正确形状的权重矩阵：np.random.randn（d0，d1，…，dn）*0.01

对偏差使用零初始化：np.zeros（shape）

def initialize_parameters(n_x, n_h, n_y):
"""
    Argument:
    n_x -- size of the input layer
    n_h -- size of the hidden layer
    n_y -- size of the output layer
    
    Returns:
    parameters -- python dictionary containing your parameters:
                    W1 -- weight matrix of shape (n_h, n_x)
                    b1 -- bias vector of shape (n_h, 1)
                    W2 -- weight matrix of shape (n_y, n_h)
                    b2 -- bias vector of shape (n_y, 1)
"""
    
    np.random.seed(1)

    W1 = np.random.randn(n_h, n_x)*0.01
    b1 = np.zeros((n_h, 1))
    W2 = np.random.randn(n_y, n_h)*0.01
    b2 = np.zeros((n_y, 1))
    
    assert(W1.shape==(n_h, n_x))
    assert(b1.shape==(n_h, 1))
    assert(W2.shape==(n_y, n_h))
    assert(b2.shape==(n_y, 1))
    
    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}
    
    return parameters    

print("Test Case 1:\n")
parameters = initialize_parameters(3,2,1)

print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

initialize_parameters_test_1(initialize_parameters)

print("\033[90m\nTest Case 2:\n")
parameters = initialize_parameters(4,3,2)

print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

initialize_parameters_test_2(initialize_parameters)

得出结果

3.2 L层神经网络

在完成initialize_parameters_deep函数时，应确保每层之间的尺寸匹配

例如，如果输入的大小𝑋 是（12288，209），有𝑚=209 示例

Exercise 2 - initialize_parameters_deep

模型结构：[LINEAR -> RELU] ×(L-1) -> LINEAR -> SIGMOID

有𝐿−1层使用ReLU激活函数和第L层用Sigmoid激活函数

对权重矩阵使用随机初始化，使用np.random.randn（d0，d1，…，dn）*0.01

对偏差使用零初始，使用np.zeros（shape）

不同层中的单元数，在变量layer_dims中。layer_dims为[2,4,1]：有两个输入，一个隐藏层有4个隐藏单元，另一个输出层有1个输出单元。这意味着W1的形状是（4,2），b1是（4,1），W2是（1,4），b2是（1,1）。现在将把它概括为𝐿分层！

def initialize_parameters_deep(layer_dims):
    """
    此函数是为了初始化多层网络参数而使用的函数。
    参数：
        layers_dims - 包含我们网络中每个图层的节点数量的列表
    
    返回：
        parameters - 包含参数“W1”，“b1”，...，“WL”，“bL”的字典：
                     W1 - 权重矩阵，维度为（layers_dims [1]，layers_dims [1-1]）
                     bl - 偏向量，维度为（layers_dims [1]，1）
    """

    np.random.seed(3)
    parameters = {}
    L = len(layer_dims)  # 网络层数

    for l in range(1, L):
        parameters["W" + str(l)] = np.random.randn(layer_dims[l],layer_dims[l-1]) * 0.01          
        parameters["b" + str(l)] = np.zeros((layer_dims[l],1))
        
        # 确保我要的数据的格式是正确的
        assert(parameters['W' + str(l)].shape == (layer_dims[l], layer_dims[l-1]))
        assert(parameters['b' + str(l)].shape == (layer_dims[l], 1))
        
    return parameters

print("Test Case 1:\n")
parameters = initialize_parameters_deep([5,4,3])

print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

initialize_parameters_deep_test_1(initialize_parameters_deep)

print("\033[90m\nTest Case 2:\n")
parameters = initialize_parameters_deep([4,3,2])

print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
initialize_parameters_deep_test_2(initialize_parameters_deep)

得出结果

4.前向传播

4.1 Linear Forward 线性前向

按步骤完成下面这三个函数：

• LINEAR
• LINEAR -> ACTIVATION (ReLU or Sigmoid)
• [LINEAR -> RELU] ×(L-1) -> LINEAR -> SIGMOID (whole model)

其中LINEAR中实现：

X是输入集

Exercise 3 - linear_forward

提醒：此单元的数学表示为𝑍[𝑙]=𝑊[𝑙]𝐴[𝑙−1]+𝑏[𝑙]。 np.dot（）很有用。如果尺寸不匹配，打印W.shape可能会有所帮助。

def linear_forward(A, W, b):

"""
Arguments参数:
A——前一层的激活（或输入数据）：（前一层大小，示例数）

W——权重矩阵：形状的numpy数组（当前层的大小，上一层的大小）

b——偏置矢量，形状的numpy数组（当前层的大小，1）

Return：
Z——激活函数的输入，也称为预激活参数

cache——包含“a”、“W”和“b”的python元组；存储以有效地计算反向通过
"""

    Z = np.dot(W, A) + b

    assert (Z.shape == (W.shape[0], A.shape[1])) # 确保了矩阵相乘后的结果矩阵Z的形状=矩阵 W 的行数和矩阵A的列数

    cache = (A, W, b)
    
    return Z, cache

t_A, t_W, t_b = linear_forward_test_case()
t_Z, t_linear_cache = linear_forward(t_A, t_W, t_b)
print("Z = " + str(t_Z))

linear_forward_test(linear_forward)

得出结果

4.2 - Linear-Activation Forward 线性激活前向

使用到下列两个激活函数：

• sigmoid函数会返回两个值：激活值a和cache（包含Z，用于计算反向传播

A, activation_cache = sigmoid(Z)

• 

A, activation_cache = relu(Z)

Exercise 4 - linear_activation_forward

实现LINER->ACTIVATION层的正向传播。数学关系为：𝐴[𝑙]=𝑔(𝑍[𝑙])=𝑔(𝑊[𝑙]𝐴[𝑙−1]+𝑏[𝑙])

其中激活“g”可以是sigmoid（）或relu（）。使用linear_forward（）和正确的激活函数。

def linear_activation_forward(A_prev, W, b, activation):
"""
参数：
A_prev——上一层的激活（或输入数据）：（上一层大小，示例数）
W——权重矩阵：形状的numpy数组（当前层的大小，上一层的大小）
b——偏置矢量，形状的numpy数组（当前层的大小，1）
activation——要在此层中使用的激活，存储为文本字符串：“sigmoid”或“relu”

Return:
A——激活函数的输出，也称为激活后值
cache——一个python元组，包含“linear_cache”和“activation_cache”；存储以有效地计算反向通过
"""

  if activation == "sigmoid":
       
        Z, linear_cache = linear_forward(A_prev,W,b)
        A, activation_cache = sigmoid(Z)
        
    
    elif activation == "relu":

        Z, linear_cache = linear_forward(A_prev,W,b)
        A, activation_cache = relu(Z)
        
    cache = (linear_cache, activation_cache)

    return A, cache

t_A_prev, t_W, t_b = linear_activation_forward_test_case()

t_A, t_linear_activation_cache = linear_activation_forward(t_A_prev, t_W, t_b, activation = "sigmoid")
print("With sigmoid: A = " + str(t_A))

t_A, t_linear_activation_cache = linear_activation_forward(t_A_prev, t_W, t_b, activation = "relu")
print("With ReLU: A = " + str(t_A))

linear_activation_forward_test(linear_activation_forward)

得出结果

4.3 L-Layer Model

为了在实现时更加方便𝐿-层神经网络，您将需要一个复制前一个的函数（linear_activation_forward with RELU）𝐿−1次，然后用SIGMOID进行一次linear_activation_forward

Exercise 5 - L_model_forward

在下面的代码中，变量AL将表示𝐴[𝐿]=𝜎(𝑍[𝐿])=𝜎(𝑊[𝐿]𝐴[𝐿−1]+𝑏[𝐿])（有时也称为Yhat）
提示：

使用您以前编写的函数

使用for循环复制[LINEAR->RELU]（L-1）次

不要忘记跟踪“缓存”列表中的缓存。要向列表中添加新值c，可以使用list.append（c）

def L_model_forward(X, parameters):
"""
参数：
X——数据，形状的numpy数组（输入大小，示例数）
parameters——initialize_parameters_deep（）的输出

Return：
AL——输出（最后）层的激活值
caches—包含以下内容的缓存列表：linear_activati_forward（）的每个缓存（有L个缓存，索引从0到L-1）
"""
    caches = []
    A = X
    L = len(parameters) // 2                  # 神经网络的层数
 caches = []
    A = X
    L = len(parameters) // 2                  # number of layers in the neural network
    
    for l in range(1, L):
        A_prev = A 
        A, cache = linear_activation_forward(A_prev,parameters["W" + str(l)],parameters['b' + str(l)], activation = "relu")
        caches.append(cache)
    

    AL, cache = linear_activation_forward(A,parameters["W" + str(L)],parameters["b" + str(L)],activation = "sigmoid")
    caches.append(cache)
    

    return AL, caches

t_X, t_parameters = L_model_forward_test_case_2hidden()
t_AL, t_caches = L_model_forward(t_X, t_parameters)

print("AL = " + str(t_AL))

L_model_forward_test(L_model_forward)

得出结果

您已经实现了一个完整的正向传播，它接受输入X并输出一个行向量𝐴[𝐿]包含您的预测。它还将所有中间值记录在“缓存”中。使用𝐴[𝐿]，您可以计算预测的成本。

5.Cost Function

现在您可以实现正向和反向传播了！你需要计算cost，以检查你的模型是否真的在学习。

Exercise 6 - compute_cost

计算交叉熵成本cross-entropy cost 𝐽

def compute_cost(AL, Y):
"""
参数：
AL——与标签预测相对应的概率向量，形状（1，示例数）
Y——真正的“标签”矢量（例如：如果不是cat，则包含0，如果是cat，则为1），形状（1，示例数）

Return：
cost——交叉熵成本
"""
   m = Y.shape[1]
   cost = (-1/m) * np.sum(np.dot(Y, np.log(AL).T) + np.dot((np.ones(Y.shape) - Y), np.log(1 - AL).T))
   cost = np.squeeze(cost) #为了确保成本形状符合预期。例如，这将[[17]]转化为17）

Return cost

t_Y, t_AL = compute_cost_test_case()
t_cost = compute_cost(t_AL, t_Y)

print("Cost: " + str(t_cost))

compute_cost_test(compute_cost)

得出结果：

6.后向传播

反向传播用于计算损失函数相对于参数的梯度

反向传播的步骤和前向传播一样

b是具有1列和n行的矩阵（np.ndarray）；np.sum对ndarray的元素执行求和；axis=1或axis=0指定总和是按行执行还是按列执行；keepdims指定是否必须保留矩阵的原始维度

A = np.array([[1, 2], [3, 4]])

print('axis=1 and keepdims=True')
print(np.sum(A, axis=1, keepdims=True))
print('axis=1 and keepdims=False')
print(np.sum(A, axis=1, keepdims=False))
print('axis=0 and keepdims=True')
print(np.sum(A, axis=0, keepdims=True))
print('axis=0 and keepdims=False')
print(np.sum(A, axis=0, keepdims=False))

6.1 Linear Backward 线性后向

Exercise 7 - linear_backward

In numpy you can get the transpose of an ndarray A using A.T or A.transpose()

def linear_backward(dZ, cache):
"""
参数：
dZ——相对于（当前层l的）线性输出的成本梯度
cache——来自当前层中正向传播的值的元组（A_prev，W，b）

Return：
dA_prev——相对于激活（前一层l-1）的成本梯度，与A_prev形状相同
dW——相对于W（当前层l）的成本梯度，与W形状相同
db——相对于b（当前层l）的成本梯度，与b形状相同
"""
    A_prev, W, b = cache
    m = A_prev.shape[1]
    dW = 1 / m * np.dot(dZ ,A_prev.T)
    db = 1 / m * np.sum(dZ,axis = 1 ,keepdims=True)
    dA_prev = np.dot(W.T,dZ) 

    
    return dA_prev, dW, db

t_dZ, t_linear_cache = linear_backward_test_case()
t_dA_prev, t_dW, t_db = linear_backward(t_dZ, t_linear_cache)

print("dA_prev: " + str(t_dA_prev))
print("dW: " + str(t_dW))
print("db: " + str(t_db))

linear_backward_test(linear_backward)

得出结果

6.2 - Linear-Activation Backward

为了帮助您实现linear_activation_backward，提供了两个向后功能：

sigmoid_backward：实现sigmoid单元的反向传播。

dZ=sigmoid_backward（dA，activation_cache）

relu_backward：实现relu单元的反向传播。您可以这样称呼它：

dZ=relu_backward（dA，activation_cache）

如果𝑔（.）是激活函数，sigmoid_backward和relu_backward计算𝑑𝑍[𝑙]=𝑑𝐴[𝑙]∗𝑔′(𝑍[𝑙])

def linear_activation_backward(dA, cache, activation):
"""
实现LINER->ACTIVATION层的反向传播。

参数：
dA——电流层l的激活后梯度
cache——我们存储的值的元组（linear_cache，activation_cache），用于高效地计算反向传播
activation——要在此层中使用的激活，存储为文本字符串：“sigmoid”或“relu”

Return：
dA_prev——相对于激活（前一层l-1）的成本梯度，与A_prev形状相同
dW——相对于W（当前层l）的成本梯度，与W形状相同
db——相对于b（当前层l）的成本梯度，与b形状相同
"""
    linear_cache, activation_cache = cache
    if activation == "relu":
        dZ = relu_backward(dA, activation_cache)
        dA_prev, dW, db = linear_backward(dZ, linear_cache)

    elif activation =="signoid":
        dZ = sigmoid_backward(dA, activation_cache)
        dA_prev, dW, db = linear_backward(dZ, linear_cache)
        
    return dA_prev, dW, db

t_dAL, t_linear_activation_cache = linear_activation_backward_test_case()

t_dA_prev, t_dW, t_db = linear_activation_backward(t_dAL, t_linear_activation_cache, activation = "sigmoid")
print("With sigmoid: dA_prev = " + str(t_dA_prev))
print("With sigmoid: dW = " + str(t_dW))
print("With sigmoid: db = " + str(t_db))

t_dA_prev, t_dW, t_db = linear_activation_backward(t_dAL, t_linear_activation_cache, activation = "relu")
print("With relu: dA_prev = " + str(t_dA_prev))
print("With relu: dW = " + str(t_dW))
print("With relu: db = " + str(t_db))

linear_activation_backward_test(linear_activation_backward)

6.3 - L-Model Backward

回想一下，当您实现L_model_forward函数时，在每次迭代时，您都存储了一个包含（X、W、b和z）的缓存。在反向传播模块中，您将使用这些变量来计算梯度。因此，在L_model_backward函数中，您将从层开始向后迭代所有隐藏层𝐿.在每个步骤中,用缓存值进行反向传播

初始化反向传播：

dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))   # AL的成本导数

然后，你可以使用这个激活后的梯度dAL来保持后退。如图5所示，您现在可以将dAL输入到您实现的LINEAR->SIGMOID向后函数中（该函数将使用L_model_forward函数存储的缓存值）。

之后，您将不得不使用for循环来使用LINERAL->RELU向后函数迭代所有其他层。您应该将每个dA、dW和db存储在梯度字典中。为此，请使用以下公式：

def L_model_backward(AL, Y, caches):
"""
参数：
AL——概率矢量，前向传播的输出（L_model_forward（））
Y——真“标签”矢量（如果不是cat，则包含0，如果是cat，则为1）
caches—包含以下内容的缓存列表：
linear_activation_forward（）的每个缓存都带有“relu”（它是缓存[l]，对于范围（l-1）内的l，即l=0…l-2）
linear_activation_forward（）的缓存带有“sigmoid”（它的缓存[L-1]）
Return:
grads -- A dictionary with the gradients
grads["dA" + str(l)] = ... 
grads["dW" + str(l)] = ...
grads["db" + str(l)] = ... 
"""
grads = {}
    L = len(caches) # the number of layers
    m = AL.shape[1]
    Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL
    
    # Initializing the backpropagation
    #(1 line of code)
    # dAL = ...
    # YOUR CODE STARTS HERE
    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
    
    # YOUR CODE ENDS HERE
    
    # Lth layer (SIGMOID -> LINEAR) gradients. Inputs: "dAL, current_cache". Outputs: "grads["dAL-1"], grads["dWL"], grads["dbL"]
    #(approx. 5 lines)
    # current_cache = ...
    # dA_prev_temp, dW_temp, db_temp = ...
    # grads["dA" + str(L-1)] = ...
    # grads["dW" + str(L)] = ...
    # grads["db" + str(L)] = ...
    # YOUR CODE STARTS HERE
    current_cache = caches[L-1]
    dA_prev_temp, dW_temp, db_temp = linear_activation_backward(dAL, current_cache, "sigmoid")
    grads["dA" + str(L-1)], grads["dW" + str(L)], grads["db" + str(L)] = dA_prev_temp, dW_temp, db_temp
    # YOUR CODE ENDS HERE
    
    # Loop from l=L-2 to l=0
    for l in reversed(range(L-1)):
       
        current_cache = caches[l]
        dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads["dA" + str(l + 1)], current_cache, "relu")
        grads["dA" + str(l)] = dA_prev_temp
        grads["dW" + str(l + 1)] = dW_temp
        grads["db" + str(l + 1)] = db_temp


    return grads

t_AL, t_Y_assess, t_caches = L_model_backward_test_case()
grads = L_model_backward(t_AL, t_Y_assess, t_caches)

print("dA0 = " + str(grads['dA0']))
print("dA1 = " + str(grads['dA1']))
print("dW1 = " + str(grads['dW1']))
print("dW2 = " + str(grads['dW2']))
print("db1 = " + str(grads['db1']))
print("db2 = " + str(grads['db2']))

L_model_backward_test(L_model_backward)

得出结果

6.4 - Update Parameters

Exercise 10 - update_parameters

实现update_parameters（）以使用渐变下降更新参数

说明：在每个上使用梯度下降更新参数𝑊[𝑙]和𝑏[𝑙]对于𝑙=1,2，。。。，𝐿

def update_parameters(params, grads, learning_rate):
"""
参数：
params——包含参数的python字典
grades——包含渐变的python字典，L_model_backward的输出

Return：
parameters——包含更新参数的python字典
parameters["W" + str(l)] = ... 
parameters["b" + str(l)] = ...
"""
 parameters = copy.deepcopy(params)
    L = len(parameters) // 2 # number of layers in the neural network
    for l in range(L):
        parameters["W" + str(l+1)] = parameters["W" + str(l+1)] - learning_rate * grads["dW" + str(l+1)]
        parameters["b" + str(l+1)] = parameters["b" + str(l+1)] - learning_rate * grads["db" + str(l+1)]
        
    return parameters

t_parameters, grads = update_parameters_test_case()
t_parameters = update_parameters(t_parameters, grads, 0.1)

print ("W1 = "+ str(t_parameters["W1"]))
print ("b1 = "+ str(t_parameters["b1"]))
print ("W2 = "+ str(t_parameters["W2"]))
print ("b2 = "+ str(t_parameters["b2"]))

update_parameters_test(update_parameters)