参考：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 = 2, 4 J = forward_propagation(x, theta) print ("J = " + str(J))
返回：
-----------------测试forward_propagation----------------- J = 8
2》后向传播
def backward_propagation(x,theta): """ 计算J相对于θ的导数。 参数： x - 一个实值输入 theta - 参数，也是一个实数 返回： dtheta - 相对于θ的成本梯度 """ dtheta = x return dtheta
测试：
#测试backward_propagation print("-----------------测试backward_propagation-----------------") x, theta = 2, 4 dtheta = backward_propagation(x, theta) print ("dtheta = " + str(dtheta))
返回：
-----------------测试backward_propagation----------------- dtheta = 2
然后就能够进行梯度检验了：
计算估计的gradapprox和实际计算出来的grad的差别大不大
def gradient_check(x,theta,epsilon=1e-7): """ 实现图中的反向传播。 参数： x - 一个实值输入 theta - 参数，也是一个实数 epsilon - 使用公式（3）计算输入的微小偏移以计算近似梯度 返回： 近似梯度和后向传播梯度之间的差异 """ #使用公式（3）的左侧计算gradapprox。 thetaplus = theta + epsilon # Step 1 thetaminus = theta - epsilon # Step 2 J_plus = forward_propagation(x, thetaplus) # Step 3 J_minus = forward_propagation(x, thetaminus) # Step 4 gradapprox = (J_plus - J_minus) / (2 * epsilon) # Step 5 #检查gradapprox是否足够接近backward_propagation（）的输出 grad = backward_propagation(x, theta) numerator = np.linalg.norm(grad - gradapprox) # Step 1' denominator = np.linalg.norm(grad) + np.linalg.norm(gradapprox) # Step 2' difference = numerator / denominator # Step 3' if difference < 1e-7: print("梯度检查：梯度正常!") else: print("梯度检查：梯度超出阈值!") return difference
测试：
#测试gradient_check print("-----------------测试gradient_check-----------------") x, theta = 2, 4 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 - 权重矩阵，维度为（5,4） b1 - 偏向量，维度为（5,1） W2 - 权重矩阵，维度为（3,5） b2 - 偏向量，维度为（3,1） W3 - 权重矩阵，维度为（1,3） b3 - 偏向量，维度为（1,1） 返回： cost - 成本函数（logistic） """ m = X.shape[1] 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(1 - A3), 1 - Y) cost = (1 / 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 - 输入数据点（输入节点数量，1） Y - 标签 cache - 来自forward_propagation_n（）的cache输出 返回： gradients - 一个字典，其中包含与每个参数、激活和激活前变量相关的成本梯度。 """ m = X.shape[1] (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3) = cache dZ3 = A3 - Y dW3 = (1. / m) * np.dot(dZ3,A2.T) dW3 = 1. / m * np.dot(dZ3, A2.T) db3 = 1. / m * np.sum(dZ3, axis=1, keepdims=True) dA2 = np.dot(W3.T, dZ3) dZ2 = np.multiply(dA2, np.int64(A2 > 0)) #dW2 = 1. / m * np.dot(dZ2, A1.T) * 2 # Should not multiply by 2 dW2 = 1. / m * np.dot(dZ2, A1.T) db2 = 1. / m * np.sum(dZ2, axis=1, keepdims=True) dA1 = np.dot(W2.T, dZ2) dZ1 = np.multiply(dA1, np.int64(A1 > 0)) dW1 = 1. / m * np.dot(dZ1, X.T) #db1 = 4. / m * np.sum(dZ1, axis=1, keepdims=True) # Should not multiply by 4 db1 = 1. / m * np.sum(dZ1, axis=1, 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-7): """ 检查backward_propagation_n是否正确计算forward_propagation_n输出的成本梯度 参数： parameters - 包含参数“W1”，“b1”，“W2”，“b2”，“W3”，“b3”的python字典： grad_output_propagation_n的输出包含与参数相关的成本梯度。 x - 输入数据点，维度为（输入节点数量，1） 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[0] J_plus = np.zeros((num_parameters,1)) J_minus = np.zeros((num_parameters,1)) gradapprox = np.zeros((num_parameters,1)) #计算gradapprox for i in range(num_parameters): #计算J_plus [i]。输入：“parameters_values，epsilon”。输出=“J_plus [i]” thetaplus = np.copy(parameters_values) # Step 1 thetaplus[i][0] = thetaplus[i][0] + epsilon # Step 2 J_plus[i], cache = forward_propagation_n(X,Y,gc_utils.vector_to_dictionary(thetaplus)) # Step 3 ，cache用不到 #计算J_minus [i]。输入：“parameters_values，epsilon”。输出=“J_minus [i]”。 thetaminus = np.copy(parameters_values) # Step 1 thetaminus[i][0] = thetaminus[i][0] - epsilon # Step 2 J_minus[i], cache = forward_propagation_n(X,Y,gc_utils.vector_to_dictionary(thetaminus))# Step 3 ，cache用不到 #计算gradapprox[i] gradapprox[i] = (J_plus[i] - J_minus[i]) / (2 * epsilon) #通过计算差异比较gradapprox和后向传播梯度。 numerator = np.linalg.norm(grad - gradapprox) # Step 1' denominator = np.linalg.norm(grad) + np.linalg.norm(gradapprox) # Step 2' difference = numerator / denominator # Step 3' if difference < 1e-7: print("梯度检查：梯度正常!") else: print("梯度检查：梯度超出阈值!") return difference