深度学习 | 梯度检验实践练习

谁借莪１个温暖的怀抱￠ 2022-12-24 00:57 178阅读 0赞

本文是吴恩达《深度学习》L2W1的编程作业2。

本文是跟着参考资料的步骤过了一遍作业，做到加深理解的目的，其中所有需要下载的资料都在第二条参考资料里面。

我的实验环境是天池的NoteBook

--------------------

## 总任务 ##

1.  初始化参数，详见上篇[《深度学习 | 初始化参数 实践练习》][_ _]  
    1.1 使用0来初始化参数  
    1.2 使用随机数来初始化参数  
    1.3 使用抑梯度异常（如梯度消失和梯度爆炸）初始化参数
2.  正则化模型，详见上篇[《深度学习 | 正则化 实践练习》][_ _ 1]  
    2.1 使用二范数对二分类模型正则化，尝试避免过拟合  
    2.2 使用随机删除节点方法精简模型，尝试避免过拟合
3.  梯度校验  
    3.1 对模型使用梯度校验，检测它是否在梯度下降的过程中出现了误差过大的情况。

--------------------

## 3 梯度校验 ##

#### 3.1 梯度校验原理 ####

*  使用正向传播和损失函数来计算 J J J
 *  导数（梯度）的定义：  
    ![在这里插入图片描述][20201126105842869.png_pic_center]
 *  一维线性模型梯度检查计算过程：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center]
 *  导入包和数据集

import numpy as np
    import matplotlib.pyplot as plt
    import sklearn
    import sklearn.datasets
    import init_utils #初始化
    import reg_utils #正则化
    import gc_utils#梯度校验

*  测试一下一维线性模型的正向/反向传播

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))
    
    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))

![在这里插入图片描述][20201126110306877.png_pic_center]

#### 3.2 一维梯度检验 ####

*  为了展示`backward_propagation（）`函数正确计算了梯度，让我们实施梯度检验。步骤如下：
    
     *  首先使用以下式子和 ε ε ε的极小值计算gradapprox，5步为：  
        ![在这里插入图片描述][20201126105842869.png_pic_center]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 1]
     *  然后使用反向传播计算梯度，并将结果存储在变量“grad”中
     *  最后，使用以下公式计算“gradapprox”和“grad”之间的相对差：当difference小于  1 0 − 7 10^\{-7\} 10−7时，我们通常认为我们计算的结果是正确的。  
        ![在这里插入图片描述][2020112611082988.png_pic_center]

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))

![在这里插入图片描述][20201126111031191.png_pic_center]

#### 3.2 高维梯度检验 ####

*  下图描述了欺诈检测模型的正向传播和反向传播：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 2]
 *  正向/反向传播

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

**梯度检验原理**

*  与1和2中一样，你想将“gradapprox”与通过反向传播计算的梯度进行比较。公式仍然是：  
    ![在这里插入图片描述][20201126111438796.png_pic_center]
 *  但是 θ θ θ不再是标量。 而是一个叫做“参数”的字典。我们为你实现了一个函数"`dictionary_to_vector()`"。它将“参数”字典转换为称为“值”的向量，该向量是通过将所有参数(W1,  
    b1, W2, b2, W3, b3)重塑为向量并将它们串联而获得的。
    
    反函数是“`vector_to_dictionary`”，它输出回“parameters”字典。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 3]

**梯度检查**

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

## 总结 ##

*  梯度检验可验证反向传播的梯度与梯度的数值近似值之间的接近度（使用正向传播进行计算）。
 *  梯度检验很慢！逼近梯度在计算上是很耗费资源的。因此，我们不会在训练期间的每次迭代中都进行梯度检验。只需检查几次梯度是否正确。
 *  至少如我们介绍的那样，梯度检验不适用于dropout。通常，你将运行不带dropout的梯度检验算法以确保你的backprop是正确的，然后添加dropout。

--------------------

参考资料：

*  [吴恩达《深度学习》L2W1作业3][L2W1_3]
 *  [【中文】【吴恩达课后编程作业】Course 2 - 改善深层神经网络 - 第一周作业(1&2&3) - 初始化、正则化、梯度校验][Course 2 - _ - _1_2_3_ -]

[_ _]: https://blog.csdn.net/qq_43145926/article/details/109734600
[_ _ 1]: https://blog.csdn.net/qq_43145926/article/details/109740149
[20201126105842869.png_pic_center]: /images/20221120/5c57d27322624f47a810c12b1edfbc29.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/0c00ded3cd024355bb06cf0127931908.png
[20201126110306877.png_pic_center]: https://img-blog.csdnimg.cn/20201126110306877.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/202011261107490.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[2020112611082988.png_pic_center]: https://img-blog.csdnimg.cn/2020112611082988.png#pic_center
[20201126111031191.png_pic_center]: https://img-blog.csdnimg.cn/20201126111031191.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201126111158492.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[20201126111438796.png_pic_center]: https://img-blog.csdnimg.cn/20201126111438796.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201126111508319.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[L2W1_3]: https://www.kesci.com/mw/project/5dd603e600b0b900365fee15
[Course 2 - _ - _1_2_3_ -]: https://blog.csdn.net/u013733326/article/details/79847918