吴恩达课后作业学习2-week1-3梯度校验

参考：https://blog.csdn.net/u013733326/article/details/79847918

希望大家直接到上面的网址去查看代码，下面是本人的笔记

5.梯度校验

在我们执行反向传播的计算过程中，反向传播函数的计算过程是比较复杂的。为了验证我们得到的反向传播函数是否正确，现在你需要编写一些代码来验证反向传播函数的正确性

1）一维线性（从简单的情况开始）

1》前向传播

def forward_propagation(x,theta):
    """

    实现图中呈现的线性前向传播（计算J）（J（theta）= theta * x）

    参数：
    x  - 一个实值输入
    theta  - 参数，也是一个实数

    返回：
    J  - 函数J的值，用公式J（theta）= theta * x计算
    """
    J = np.dot(theta,x)

    return J

测试：

#测试forward_propagation
print("-----------------测试forward_propagation-----------------")
x, theta = ,
J = forward_propagation(x, theta)
print ("J = " + str(J))

返回：

-----------------测试forward_propagation-----------------
J = 

2》后向传播

def backward_propagation(x,theta):
    """
    计算J相对于θ的导数。

    参数：
        x  - 一个实值输入
        theta  - 参数，也是一个实数

    返回：
        dtheta  - 相对于θ的成本梯度
    """
    dtheta = x

    return dtheta

测试：

#测试backward_propagation
print("-----------------测试backward_propagation-----------------")
x, theta = ,
dtheta = backward_propagation(x, theta)
print ("dtheta = " + str(dtheta))

返回：

-----------------测试backward_propagation-----------------
dtheta = 

然后就能够进行梯度检验了：

计算估计的gradapprox和实际计算出来的grad的差别大不大

def gradient_check(x,theta,epsilon=1e-):
    """

    实现图中的反向传播。

    参数：
        x  - 一个实值输入
        theta  - 参数，也是一个实数
        epsilon  - 使用公式（）计算输入的微小偏移以计算近似梯度

    返回：
        近似梯度和后向传播梯度之间的差异
    """

    #使用公式（）的左侧计算gradapprox。
    thetaplus = theta + epsilon                               # Step
    thetaminus = theta - epsilon                              # Step
    J_plus = forward_propagation(x, thetaplus)                # Step
    J_minus = forward_propagation(x, thetaminus)              # Step
    gradapprox = (J_plus - J_minus) / ( * epsilon)           # Step 

    #检查gradapprox是否足够接近backward_propagation（）的输出
    grad = backward_propagation(x, theta)

    numerator = np.linalg.norm(grad - gradapprox)                      # Step '
    denominator = np.linalg.norm(grad) + np.linalg.norm(gradapprox)    # Step '
    difference = numerator / denominator                               # Step '

    if difference < 1e-:
        print("梯度检查：梯度正常!")
    else:
        print("梯度检查：梯度超出阈值!")

    return difference

测试：

#测试gradient_check
print("-----------------测试gradient_check-----------------")
x, theta = ,
difference = gradient_check(x, theta)
print("difference = " + str(difference))

返回：

-----------------测试gradient_check-----------------
梯度检查：梯度正常!
difference = 2.919335883291695e-10

2）高维

高维的区别在于：

然而，θ即参数不再是标量，而是一个名为“parameters”的字典。

在这里实现了一个函数“dictionary_to_vector()”，它将“parameters”字典转换为一个称为“values”的向量，通过将所有参数（W1，b1，W2，b2，W3，b3）转为向量并将它们连接起来而获得。

反函数是“vector_to_dictionary”，它返回“parameters”字典。

所以差别就是需要对多个参数进行梯度检验

前后向传播函数为：

def forward_propagation_n(X,Y,parameters):
    """
    实现图中的前向传播（并计算成本）。

    参数：
        X - 训练集为m个例子
        Y -  m个示例的标签
        parameters - 包含参数“W1”，“b1”，“W2”，“b2”，“W3”，“b3”的python字典：
            W1  - 权重矩阵，维度为（,）
            b1  - 偏向量，维度为（,）
            W2  - 权重矩阵，维度为（,）
            b2  - 偏向量，维度为（,）
            W3  - 权重矩阵，维度为（,）
            b3  - 偏向量，维度为（,）

    返回：
        cost - 成本函数（logistic）
    """
    m = X.shape[]
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    W3 = parameters["W3"]
    b3 = parameters["b3"]

    # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID
    Z1 = np.dot(W1,X) + b1
    A1 = gc_utils.relu(Z1)

    Z2 = np.dot(W2,A1) + b2
    A2 = gc_utils.relu(Z2)

    Z3 = np.dot(W3,A2) + b3
    A3 = gc_utils.sigmoid(Z3)

    #计算成本
    logprobs = np.multiply(-np.log(A3), Y) + np.multiply(-np.log( - A3),  - Y)
    cost = ( / m) * np.sum(logprobs)

    cache = (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3)

    return cost, cache

def backward_propagation_n(X,Y,cache):
    """
    实现图中所示的反向传播。

    参数：
        X - 输入数据点（输入节点数量，）
        Y - 标签
        cache - 来自forward_propagation_n（）的cache输出

    返回：
        gradients - 一个字典，其中包含与每个参数、激活和激活前变量相关的成本梯度。
    """
    m = X.shape[]
    (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3) = cache

    dZ3 = A3 - Y
    dW3 = (. / m) * np.dot(dZ3,A2.T)
    dW3 = . / m * np.dot(dZ3, A2.T)
    db3 = . / m * np.sum(dZ3, axis=, keepdims=True)

    dA2 = np.dot(W3.T, dZ3)
    dZ2 = np.multiply(dA2, np.int64(A2 > ))
    #dW2 = . / m * np.dot(dZ2, A1.T) *   # Should not multiply by
    dW2 = . / m * np.dot(dZ2, A1.T)
    db2 = . / m * np.sum(dZ2, axis=, keepdims=True)

    dA1 = np.dot(W2.T, dZ2)
    dZ1 = np.multiply(dA1, np.int64(A1 > ))
    dW1 = . / m * np.dot(dZ1, X.T)
    #db1 = . / m * np.sum(dZ1, axis=, keepdims=True) # Should not multiply by
    db1 = . / m * np.sum(dZ1, axis=, keepdims=True)

    gradients = {"dZ3": dZ3, "dW3": dW3, "db3": db3,
                 "dA2": dA2, "dZ2": dZ2, "dW2": dW2, "db2": db2,
                 "dA1": dA1, "dZ1": dZ1, "dW1": dW1, "db1": db1}

    return gradients

梯度检验函数为：

def gradient_check_n(parameters,gradients,X,Y,epsilon=1e-):
    """
    检查backward_propagation_n是否正确计算forward_propagation_n输出的成本梯度

    参数：
        parameters - 包含参数“W1”，“b1”，“W2”，“b2”，“W3”，“b3”的python字典：
        grad_output_propagation_n的输出包含与参数相关的成本梯度。
        x  - 输入数据点，维度为（输入节点数量，）
        y  - 标签
        epsilon  - 计算输入的微小偏移以计算近似梯度

    返回：
        difference - 近似梯度和后向传播梯度之间的差异
    """
    #初始化参数
    parameters_values , keys = gc_utils.dictionary_to_vector(parameters) #keys用不到
    grad = gc_utils.gradients_to_vector(gradients)
    num_parameters = parameters_values.shape[]
    J_plus = np.zeros((num_parameters,))
    J_minus = np.zeros((num_parameters,))
    gradapprox = np.zeros((num_parameters,))

    #计算gradapprox
    for i in range(num_parameters):
        #计算J_plus [i]。输入：“parameters_values，epsilon”。输出=“J_plus [i]”
        thetaplus = np.copy(parameters_values)                                                  # Step
        thetaplus[i][] = thetaplus[i][] + epsilon                                             # Step
        J_plus[i], cache = forward_propagation_n(X,Y,gc_utils.vector_to_dictionary(thetaplus))  # Step  ，cache用不到

        #计算J_minus [i]。输入：“parameters_values，epsilon”。输出=“J_minus [i]”。
        thetaminus = np.copy(parameters_values)                                                 # Step
        thetaminus[i][] = thetaminus[i][] - epsilon                                           # Step
        J_minus[i], cache = forward_propagation_n(X,Y,gc_utils.vector_to_dictionary(thetaminus))# Step  ，cache用不到

        #计算gradapprox[i]
        gradapprox[i] = (J_plus[i] - J_minus[i]) / ( * epsilon)

    #通过计算差异比较gradapprox和后向传播梯度。
    numerator = np.linalg.norm(grad - gradapprox)                                     # Step '
    denominator = np.linalg.norm(grad) + np.linalg.norm(gradapprox)                   # Step '
    difference = numerator / denominator                                              # Step '

    if difference < 1e-:
        print("梯度检查：梯度正常!")
    else:
        print("梯度检查：梯度超出阈值!")

    return difference