深度学习 | 正则化实践练习

Bertha 。 2022-12-22 00:56 126阅读 0赞

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

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

我的实验环境是天池的NoteBook

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

## 总任务 ##

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

## 2 正则化模型 ##

*  正则化是用来解决模型过拟合的问题的，“过拟合”的意思是模型的学习能力过强了把一些特性的东西也学成了普适性的东西，比如辨别苹果和香蕉，模型把红色的物体都识别成了苹果。

#### 0 任务描述 ####

*  你刚刚被法国足球公司聘为AI专家。他们希望你推荐预测法国守门员将球踢出的位置，以便法国队的球员可以用头将球击中。

![在这里插入图片描述][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#梯度校验
    
    %matplotlib inline
    plt.rcParams['figure.figsize']=(7.0,4.0) #设置图表默认大小
    plt.rcParams['image.interpolation']='nearest'
    plt.rcParams['image.cmap']='gray'
    
    train_X, train_Y, test_X, test_Y = reg_utils.load_2D_dataset(is_plot=True)

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

*  如图所示，蓝色是本队球员可能抢到球，红色表示对方队员能抢到球，我们需要做的就是找到适合我方队员能抢球的位置。

#### 2.1 非正则化模型 ####

*  模型如下，其中“lambd”是为了不与python中的“lambda”关键字冲突
 *  随机删除节点-将keep\_prob设置为小于1的值；“keep\_prob”指的是保留下来的程度。

def model(X,Y,learning_rate=0.3,num_iterations=30000,print_cost=True,is_plot=True,lambd=0,keep_prob=1):
        """ 实现一个三层的神经网络：LINEAR ->RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID 参数： X - 输入的数据，维度为(2, 要训练/测试的数量) Y - 标签，【0(蓝色) | 1(红色)】，维度为(1，对应的是输入的数据的标签) learning_rate - 学习速率 num_iterations - 迭代的次数 print_cost - 是否打印成本值，每迭代10000次打印一次，但是每1000次记录一个成本值 is_polt - 是否绘制梯度下降的曲线图 lambd - 正则化的超参数，实数 keep_prob - 随机删除节点的概率 返回 parameters - 学习后的参数 """
        grads = { }
        costs = []
        m = X.shape[1]
        layers_dims = [X.shape[0],20,3,1]
        
        #初始化参数
        parameters = reg_utils.initialize_parameters(layers_dims)
        
        #开始学习
        for i in range(0,num_iterations):
            #前向传播
            ##是否随机删除节点
            if keep_prob == 1:
                ###不随机删除节点
                a3 , cache = reg_utils.forward_propagation(X,parameters)
            elif keep_prob < 1:
                ###随机删除节点
                a3 , cache = forward_propagation_with_dropout(X,parameters,keep_prob)
            else:
                print("keep_prob参数错误！程序退出。")
                exit
            
            #计算成本
            ## 是否使用二范数
            if lambd == 0:
                ###不使用L2正则化
                cost = reg_utils.compute_cost(a3,Y)
            else:
                ###使用L2正则化
                cost = compute_cost_with_regularization(a3,Y,parameters,lambd)
            
            #反向传播
            ##可以同时使用L2正则化和随机删除节点，但是本次实验不同时使用。
            assert(lambd == 0  or keep_prob ==1)
            
            ##两个参数的使用情况
            if (lambd == 0 and keep_prob == 1):
                ### 不使用L2正则化和不使用随机删除节点
                grads = reg_utils.backward_propagation(X,Y,cache)
            elif lambd != 0:
                ### 使用L2正则化，不使用随机删除节点
                grads = backward_propagation_with_regularization(X, Y, cache, lambd)
            elif keep_prob < 1:
                ### 使用随机删除节点，不使用L2正则化
                grads = backward_propagation_with_dropout(X, Y, cache, keep_prob)
            
            #更新参数
            parameters = reg_utils.update_parameters(parameters, grads, learning_rate)
            
            #记录并打印成本
            if i % 1000 == 0:
                ## 记录成本
                costs.append(cost)
                if (print_cost and i % 10000 == 0):
                    #打印成本
                    print("第" + str(i) + "次迭代，成本值为：" + str(cost))
            
        #是否绘制成本曲线图
        if is_plot:
            plt.plot(costs)
            plt.ylabel('cost')
            plt.xlabel('iterations (x1,000)')
            plt.title("Learning rate =" + str(learning_rate))
            plt.show()
        
        #返回学习后的参数
        return parameters
    
    #不使用正则化测试
    parameters = model(train_X, train_Y,is_plot=True)
    print("训练集:")
    predictions_train = reg_utils.predict(train_X, train_Y, parameters)
    print("测试集:")
    predictions_test = reg_utils.predict(test_X, test_Y, parameters)

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

*  将划分结果可视化一下：

plt.title("Model without regularization")
    axes = plt.gca()
    axes.set_xlim([-0.75,0.40])
    axes.set_ylim([-0.75,0.65])
    reg_utils.plot_decision_boundary(lambda x: reg_utils.predict_dec(parameters, x.T), train_X, train_Y)

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

*  可以看到其实模型已经有点过拟合了，下面我们用L2正则化来修正模型

#### 2.2 L2正则化模型 ####

*  L2 正则化 函数：`compute_cost_with_regularization()`和`backward_propagation_with_regularization()`

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

*  利用`np.sum(np.square(Wl))`来计算以下公式：
 *  ![在这里插入图片描述][20201117141816660.png_pic_center]
 *  我们需要对 W \[ 1 \] W^\{\[1\]\} W\[1\], W \[ 2 \] W^\{\[2\]\} W\[2\], W \[ 3 \] W^\{\[3\]\} W\[3\]执行这个操作并将三项相加并乘以 1 / m ∗ λ / 2 1/m\*\{\\lambda\}/2 1/m∗λ/2

def compute_cost_with_regularization(A3,Y,parameters,lambd):
        """ 实现公式2的L2正则化计算成本 参数： A3 - 正向传播的输出结果，维度为（输出节点数量，训练/测试的数量） Y - 标签向量，与数据一一对应，维度为(输出节点数量，训练/测试的数量) parameters - 包含模型学习后的参数的字典 返回： cost - 使用公式2计算出来的正则化损失的值 """
        m = Y.shape[1]
        W1 = parameters["W1"]
        W2 = parameters["W2"]
        W3 = parameters["W3"]
        
        cross_entropy_cost = reg_utils.compute_cost(A3,Y)
        
        L2_regularization_cost = lambd * (np.sum(np.square(W1)) + np.sum(np.square(W2))  + np.sum(np.square(W3))) / (2 * m)
        
        cost = cross_entropy_cost + L2_regularization_cost
        
        return cost
    
    #当然，因为改变了成本函数，我们也必须改变向后传播的函数， 所有的梯度都必须根据这个新的成本值来计算。
    
    def backward_propagation_with_regularization(X, Y, cache, lambd):
        """ 实现我们添加了L2正则化的模型的后向传播。 参数： X - 输入数据集，维度为（输入节点数量，数据集里面的数量） Y - 标签，维度为（输出节点数量，数据集里面的数量） cache - 来自forward_propagation（）的cache输出 lambda - regularization超参数，实数 返回： 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) + ((lambd * W3) / m )
        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) + ((lambd * W2) / m)
        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) + ((lambd * W1) / m)
        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
    #测试
    parameters = model(train_X, train_Y, lambd=0.7,is_plot=True)
    print("使用正则化，训练集:")
    predictions_train = reg_utils.predict(train_X, train_Y, parameters)
    print("使用正则化，测试集:")
    predictions_test = reg_utils.predict(test_X, test_Y, parameters)

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

*  分类结果

plt.title("Model with L2-regularization")
    axes = plt.gca()
    axes.set_xlim([-0.75,0.40])
    axes.set_ylim([-0.75,0.65])
    reg_utils.plot_decision_boundary(lambda x: reg_utils.predict_dec(parameters, x.T), train_X, train_Y)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 6]**观察**

*   λ \\lambda λ的值是我们可以调整开发集的超参数
 *  L2正则化使决策边界更平滑。如果 λ \\lambda λ过大，也可能“过渡平滑”，从而使得模型偏差较高

**L2正则化的原理**

*  L2正则化基于以下假设：权重较小的模型比权重较大的模型更简单。因此，通过对损失函数中权重的平方值进行削减，可以将所有权重驱动为较小的值。比重太大会使损失过高！这将导致模型更平滑，输出随着输入的变化而变化得更慢。

**L2正则化的影响**

*  损失计算：正则化条件需要添加到损失函数中
 *  反向传播函数：在权重矩阵方面，梯度计算时也要依据正则化来做出相应的计算
 *  重量衰减：权重被逐渐改变到较小的值。

#### 2.3 Dropout函数 ####

*  Dropout是广泛用于深度学习的正则化技术，它会在每次迭代中随机关闭一些神经元
 *  Dropout  
    函数：`forward_propagation_with_dropout()`和`backward_propagation_with_dropout()`
 *  在每次迭代中，你以概率 1 − k e e p p r o b 1-keepprob 1−keepprob或以概率 k e e p p r o b keepprob keepprob（此处为50％）关闭此层的每个神经元。关闭的神经元对迭代的正向和反向传播均无助于训练。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 7]  
**带有Dropout的正向传播**

*  下面，我们将关闭第一层和第三层的一些节点，需要以下四步：
    
     *  在视频中老师讲解适用了`np.random.rand()`来初始化和 a \[ 1 \] a^\{\[1\]\} a\[1\]具有相同维度的 d \[ 1 \] d^\{\[1\]\} d\[1\]，在这里，我们将使用向量化实现，我们先来实现一个和 A \[ 1 \] A^\{\[1\]\} A\[1\]相同的随机矩阵  D \[ 1 \] D^\{\[1\]\} D\[1\]
     *  如果 D \[ 1 \] D^\{\[1\]\} D\[1\]低于`keep_prob`就设置为0，高于则为1
     *  把 A \[ 1 \] A^\{\[1\]\} A\[1\]更新成 A \[ 1 \] ∗ D \[ 1 \] A^\{\[1\]\}\*D^\{\[1\]\} A\[1\]∗D\[1\]。(我们已经关闭了一些节点)。我们可以使用 D \[ 1 \] D^\{\[1\]\} D\[1\]作为掩码。我们做矩阵相乘的时候，关闭的那些节点（值为0）就会不参与计算，因为0乘以任何值都为0。
     *  使用 A \[ 1 \] A^\{\[1\]\} A\[1\] 除以 `keep_prob`。这样做的话我们通过缩放就在计算成本的时候仍然具有相同的期望值，这叫做反向dropout。

def forward_propagation_with_dropout(X,parameters,keep_prob=0.5):
        """ 实现具有随机舍弃节点的前向传播。 LINEAR -> RELU + DROPOUT -> LINEAR -> RELU + DROPOUT -> LINEAR -> SIGMOID. 参数： X - 输入数据集，维度为（2，示例数） parameters - 包含参数“W1”，“b1”，“W2”，“b2”，“W3”，“b3”的python字典： W1 - 权重矩阵，维度为（20,2） b1 - 偏向量，维度为（20,1） W2 - 权重矩阵，维度为（3,20） b2 - 偏向量，维度为（3,1） W3 - 权重矩阵，维度为（1,3） b3 - 偏向量，维度为（1,1） keep_prob - 随机删除的概率，实数 返回： A3 - 最后的激活值，维度为（1,1），正向传播的输出 cache - 存储了一些用于计算反向传播的数值的元组 """
        np.random.seed(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 = reg_utils.relu(Z1)
        
        #下面的步骤1-4对应于上述的步骤1-4。
        D1 = np.random.rand(A1.shape[0],A1.shape[1])    #步骤1：初始化矩阵D1 = np.random.rand(..., ...)
        D1 = D1 < keep_prob                             #步骤2：将D1的值转换为0或1（使用keep_prob作为阈值）
        A1 = A1 * D1                                    #步骤3：舍弃A1的一些节点（将它的值变为0或False）
        A1 = A1 / keep_prob                             #步骤4：缩放未舍弃的节点(不为0)的值
        """ #不理解的同学运行一下下面代码就知道了。 import numpy as np np.random.seed(1) A1 = np.random.randn(1,3) D1 = np.random.rand(A1.shape[0],A1.shape[1]) keep_prob=0.5 D1 = D1 < keep_prob print(D1) A1 = 0.01 A1 = A1 * D1 A1 = A1 / keep_prob print(A1) """
        
        Z2 = np.dot(W2,A1) + b2
        A2 = reg_utils.relu(Z2)
        
        #下面的步骤1-4对应于上述的步骤1-4。
        D2 = np.random.rand(A2.shape[0],A2.shape[1])    #步骤1：初始化矩阵D2 = np.random.rand(..., ...)
        D2 = D2 < keep_prob                             #步骤2：将D2的值转换为0或1（使用keep_prob作为阈值）
        A2 = A2 * D2                                    #步骤3：舍弃A1的一些节点（将它的值变为0或False）
        A2 = A2 / keep_prob                             #步骤4：缩放未舍弃的节点(不为0)的值
        
        Z3 = np.dot(W3, A2) + b3
        A3 = reg_utils.sigmoid(Z3)
        
        cache = (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3)
        
        return A3, cache

**带有Dropout的反向传播**

*  使用存储在缓存中的掩码  D \[ 1 \] D^\{\[1\]\} D\[1\] 和  D \[ 2 \] D^\{\[2\]\} D\[2\]将舍弃的节点位置信息添加到第一个和第二个隐藏层。

def backward_propagation_with_dropout(X,Y,cache,keep_prob):
        """ 实现我们随机删除的模型的后向传播。 参数： X - 输入数据集，维度为（2，示例数） Y - 标签，维度为（输出节点数量，示例数量） cache - 来自forward_propagation_with_dropout（）的cache输出 keep_prob - 随机删除的概率，实数 返回： gradients - 一个关于每个参数、激活值和预激活变量的梯度值的字典 """
        m = X.shape[1]
        (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3) = cache
        
        dZ3 = A3 - Y
        dW3 = (1 / m) * np.dot(dZ3,A2.T)
        db3 = 1. / m * np.sum(dZ3, axis=1, keepdims=True)
        dA2 = np.dot(W3.T, dZ3)
        
        dA2 = dA2 * D2          # 步骤1：使用正向传播期间相同的节点，舍弃那些关闭的节点（因为任何数乘以0或者False都为0或者False）
        dA2 = dA2 / keep_prob   # 步骤2：缩放未舍弃的节点(不为0)的值
        
        dZ2 = np.multiply(dA2, np.int64(A2 > 0))
        dW2 = 1. / m * np.dot(dZ2, A1.T)
        db2 = 1. / m * np.sum(dZ2, axis=1, keepdims=True)
        
        dA1 = np.dot(W2.T, dZ2)
        
        dA1 = dA1 * D1          # 步骤1：使用正向传播期间相同的节点，舍弃那些关闭的节点（因为任何数乘以0或者False都为0或者False）
        dA1 = dA1 / keep_prob   # 步骤2：缩放未舍弃的节点(不为0)的值
    
        dZ1 = np.multiply(dA1, np.int64(A1 > 0))
        dW1 = 1. / m * np.dot(dZ1, X.T)
        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

*  前向/反向传播函数都写好以后，现在用dropout运行模型（keep\_prob=0.86），也就是说每次迭代中程序都可以24%的概率关闭第一层和第二层的每个神经元。

parameters = model(train_X, train_Y, keep_prob=0.86, learning_rate=0.3,is_plot=True)
    
    print("使用随机删除节点，训练集:")
    predictions_train = reg_utils.predict(train_X, train_Y, parameters)
    print("使用随机删除节点，测试集:")
    reg_utils.predictions_test = reg_utils.predict(test_X, test_Y, parameters)

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

*  查看其分类情况：

plt.title("Model with dropout")
    axes = plt.gca()
    axes.set_xlim([-0.75, 0.40])
    axes.set_ylim([-0.75, 0.65])
    reg_utils.plot_decision_boundary(lambda x: reg_utils.predict_dec(parameters, x.T), train_X, train_Y)

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

## 总结 ##

**注意：**

*  我们只能在训练中使用dropout，而不能在测试中使用
 *  深度学习框架，例如tensorflow, PaddlePaddle, keras或者 caffe 会有附带dropout层的实现。
 *  L2正则化和Dropout是两种非常有效的正则化技术。

**关于dropout应该记住：**

*  dropout是一种正则化技术，正则化将帮助减少过拟合，正则化将使权重降低到较低的值。
 *  仅在训练中使用
 *  正向反向传播都应该使用dropout
 *  在训练期间，将每个dropout层除以keep\_prob，以保持激活的期望值相同。例如，如果keep\_prob为0.5，则平均而言，我们将关闭一半的节点，因此输出将按0.5缩放，因为只有剩余的一半对解决方案有所贡献。除以0.5等于乘以2，因此输出现在具有相同的期望值。你可以检查此方法是否有效，即使keep\_prob的值不是0.5。
 *  正则化会损害训练集的性能！ 这是因为它限制了网络过拟合训练集的能力。 但是，由于它最终可以提供更好的测试准确性，因此可以为你的系统提供帮助。

**结论**

<table> 
 <thead> 
  <tr> 
   <th>模型</th> 
   <th>训练精度</th> 
   <th>测试精度</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>三层神经网络，无正则化</td> 
   <td>95％</td> 
   <td>91.50％</td> 
  </tr> 
  <tr> 
   <td>具有L2正则化的3层NN</td> 
   <td>94％</td> 
   <td>93％</td> 
  </tr> 
  <tr> 
   <td>具有dropout的3层NN</td> 
   <td>93％</td> 
   <td>95％</td> 
  </tr> 
 </tbody> 
</table>

**下篇**：[深度学习 | 梯度检验 实践练习][_ _ 1]

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

参考资料：

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

[_ _]: https://blog.csdn.net/qq_43145926/article/details/109734600
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/55ba6d7056454012a7b131b60e0ed6f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/4c534ec05c8a485c8faff798a3fa6ce0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201117141238663.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201117141440706.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201117141625664.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[20201117141816660.png_pic_center]: https://img-blog.csdnimg.cn/20201117141816660.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201117143404994.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201117143458173.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20201126100441340.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20201126104101165.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 9]: https://img-blog.csdnimg.cn/20201126104145892.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[_ _ 1]: https://editor.csdn.net/md/?articleId=109740149
[L2W1_2]: https://www.kesci.com/mw/project/5dd5f65400b0b900365fe497
[Course 2 - _ - _1_2_3_ -]: https://blog.csdn.net/u013733326/article/details/79847918