深度学习 | 用1层隐藏层的神经网络分类二维数据

小灰灰 2022-11-22 12:51 253阅读 0赞

本文是吴恩达《深度学习》课程的L1W3编程作业，主要也是跟着参考资料里面的博主实现了一遍，也加了一些自己的理解和补充。希望自己早日掌握这些神奇的知识！

我用的环境是天池的notebook

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

## 1 实验目标 ##

*  实现具有单个隐藏层的2分类神经网络
 *  使用具有非线性激活函数的神经元，例如tanh
 *  计算交叉熵损失
 *  实现前向和后向传播

## 2 准备工作 ##

#### 2.1 安装包 ####

python中需要用到的软件包：

*  numpy-科学计算
 *  sklearn-用于数据挖掘和分析
 *  matplotlib-可视化

课程提供的数据包，资料在第二个参考链接里面博主有提供：

*  testCases-提供了测试示例用以评估函数的正确性
 *  planar\_utils提供了作业中需要用到的函数

导入需要的包：

import numpy as np
    import matplotlib.pyplot as plt
    from testCases import *
    import sklearn
    import sklearn.datasets
    import sklearn.linear_model
    from planar_utils import plot_decision_boundary, sigmoid,load_planar_dataset,load_extra_datasets;
    
    %matplotlib inline
    
    np.random.seed(1)#设置一个随机种子，以保证接下来的步骤中结果与我一致

#### 2.2 数据集 ####

查看数据集：

*  X：一个numpy的矩阵，包含了这些数据点的数值
 *  Y：一个numpy的向量，对应着的是X的标签【0 | 1】（红色:0 ， 蓝色 :1）

X,Y=load_planar_dataset()
    plt.scatter(X[0,:],X[1,:],c=Y,s=40,cmap=plt.cm.Spectral)#绘制散点图

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

## 3 简单Logistic回归 ##

*  在搭建神经网络之前，先看看之前学的逻辑回归的分类结果怎么样。
 *  先用sklearn的内置函数来训练逻辑回归分类器。

clf=sklearn.linear_model.LogisticRegressionCV()
    clf.fit(X.T,Y.T)#T是转置的意思

shape_X=X.shape
    shape_Y=Y.shape
    m=Y.shape[1] #训练集里面的数量
    
    print("X的维度为："+str(shape_X))
    print("Y的维度为："+str(shape_Y))
    print("数据集里面的数据有："+str(m)+"个")

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

*  绘制分类：

plot_decision_boundary(lambda x:clf.predict(x),X,Y) #绘制决策边界
    plt.title("Logistic Regression")#图标题
    LR_predictions=clf.predict(X.T)
    print("逻辑回归的准确性：%d"%float((np.dot(Y,LR_predictions)+
                              np.dot(1-Y,1-LR_predictions))/float(Y.size)*100)+
         "%"+"(正确标记的数据点所占的百分比)")

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

*  如上结果可见，逻辑回归分类准确定还不到50%，并不是很好。

## 4 神经网络模型 ##

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

*  建立神经网络的一般方法：
    
     *  定义神经网络结构（输入单元，隐藏单元数等）
     *  初始化模型参数
     *  循环：
        
         *  实现前向传播
         *  计算损失
         *  后向传播以获得梯度
         *  更新参数（梯度下降）

#### 4.1 定义神经网络结构 ####

*  定义三个变量：
    
     *  n\_x：输入层的大小
     *  n\_h：隐藏层的大小（将其设置为4）
     *  n\_y：输出层的大小
 *  参数：
    
     *  X - 输入数据集,维度为（输入的数量，训练/测试的数量）
     *  Y - 标签，维度为（输出的数量，训练/测试数量）
 *  定义神经网络结构并测试：

def layer_sizes(X,Y):
        n_x=X.shape[0]#输入层
        n_h=4 #隐藏层，硬编码为4
        n_y=Y.shape[0] #输出层
        
        return (n_x,n_h,n_y)
    
    #测试layer_sizes
    print("=========================测试layer_sizes=========================")
    X_asses , Y_asses = layer_sizes_test_case()
    (n_x,n_h,n_y) =  layer_sizes(X_asses,Y_asses)
    print("输入层的节点数量为: n_x = " + str(n_x))
    print("隐藏层的节点数量为: n_h = " + str(n_h))
    print("输出层的节点数量为: n_y = " + str(n_y))

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

#### 4.2 初始化模型参数 ####

*  目标：实现initialize\_parameters()
 *  随机初始化一个维度为（a,b）的矩阵`np.random.randn(a,b)*0.01`
 *  用零初始化矩阵（a，b）`np.zeros((a,b))`

def initialize_parameters(n_x,n_h,n_y):
        np.random.seed(2)
        W1=np.random.randn(n_h,n_x)*0.01
        b1=np.zeros(shape=(n_h,1))
        W2=np.random.randn(n_y,n_h)*0.01
        b2=np.zeros(shape=(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
    
    #测试initialize_parameters
    print("=========================测试initialize_parameters=========================")    
    n_x , n_h , n_y = initialize_parameters_test_case()
    parameters = initialize_parameters(n_x , n_h , n_y)
    print("W1 = " + str(parameters["W1"]))
    print("b1 = " + str(parameters["b1"]))
    print("W2 = " + str(parameters["W2"]))
    print("b2 = " + str(parameters["b2"]))

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

#### 4.3 循环 ####

*  目标：实现前向传播函数：`forward_propagation()`

def forward_propagation( X , parameters ):
        """ 参数： X - 维度为（n_x，m）的输入数据。 parameters - 初始化函数（initialize_parameters）的输出 返回： A2 - 使用sigmoid()函数计算的第二次激活后的数值 cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典类型变量 """
        W1 = parameters["W1"]
        b1 = parameters["b1"]
        W2 = parameters["W2"]
        b2 = parameters["b2"]
        #前向传播计算A2
        Z1 = np.dot(W1 , X) + b1
        A1 = np.tanh(Z1)
        Z2 = np.dot(W2 , A1) + b2
        A2 = sigmoid(Z2)
        #使用断言确保我的数据格式是正确的
        assert(A2.shape == (1,X.shape[1]))
        cache = { "Z1": Z1,
                 "A1": A1,
                 "Z2": Z2,
                 "A2": A2}
        
        return (A2, cache)
    
    #测试forward_propagation
    print("=========================测试forward_propagation=========================") 
    X_assess, parameters = forward_propagation_test_case()
    A2, cache = forward_propagation(X_assess, parameters)
    print(np.mean(cache["Z1"]), np.mean(cache["A1"]), np.mean(cache["Z2"]), np.mean(cache["A2"]))

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

#### 4.5 计算损失 ####

*  计算损失函数的公式如下：  
    ![在这里插入图片描述][20201105082223325.png_pic_center]
 *  计算交叉熵损失可以：
    
     *  先使用`np.multiply()`再使用`np.sum()`
     *  或者直接使用`np.dot()`
 *  构建计算成本的函数：

def compute_cost(A2,Y,parameters):#A2是使用sigmoid函数计算的第二次激活后的数值
        m=Y.shape[1] #“True”向量标签，维度为（1，数量）
        W1=parameters["W1"]#parameters:一个包含W1，B1，W2,B2的字典类型的变量
        W2=parameters["W2"]
        
        #计算成本
        logprobs=logprobs=np.multiply(np.log(A2),Y)+np.multiply((1-Y),np.log(1-A2))
        cost=-np.sum(logprobs)/m
        cost=float(np.squeeze(cost))
        
        assert(isinstance(cost,float))
        
        return cost
    
    #测试compute_cost
    print("=========================测试compute_cost=========================") 
    A2 , Y_assess , parameters = compute_cost_test_case()
    print("cost = " + str(compute_cost(A2,Y_assess,parameters)))

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

#### 4.6 后向传播 ####

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

*  tanh激活函数：大多数情况下tanh函数的性能都比sigmoid优越，所以一般采用tanh，但是当时二元分类时需要输出y\[0,1\]在0-1之间的话还是sigmoid更合适。  
    ![在这里插入图片描述][20201105084223813.png_pic_center]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 7]
 *  激活函数的导数：  
    ![在这里插入图片描述][20201105084249388.png_pic_center]
 *  我们需要用`(1-np.power(A1,2))`来计算![在这里插入图片描述][20201105084649685.png_pic_center]

def backward_propagation(parameters,cache,X,Y):#cache是包含Z1,A1,Z2,A2的字典类型变量
        m=X.shape[1]
        W1=parameters["W1"]
        W2=parameters["W2"]
        
        A1=cache["A1"]
        A2=cache["A2"]
        
        dZ2=A2-Y
        dW2=(1/m)*np.dot(dZ2,A1.T)
        db2=(1/m)*np.sum(dZ2,axis=1,keepdims=True)
        dZ1=np.multiply(np.dot(W2.T,dZ2),1-np.power(A1,2))
        dW1=(1/m)*np.dot(dZ1,X.T)
        db1=(1/m)*(np.sum(dZ1,axis=1,keepdims=True))
        grads={ "dW1":dW1,
              "db1":db1,
              "dW2":dW2,
              "db2":db2}
        return grads #包含W，b的导数的一个字典类型的变量
        
    #测试backward_propagation
    print("=========================测试backward_propagation=========================")
    parameters, cache, X_assess, Y_assess = backward_propagation_test_case()
    
    grads = backward_propagation(parameters, cache, X_assess, Y_assess)
    print ("dW1 = "+ str(grads["dW1"]))
    print ("db1 = "+ str(grads["db1"]))
    print ("dW2 = "+ str(grads["dW2"]))
    print ("db2 = "+ str(grads["db2"]))

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

#### 4.7 用梯度下降实现参数更新 ####

*  使用梯度下降，你必须使用（dW1，db1，dW2，db2）才能更新（W1，b1，W2，b2）。
 *  一般梯度下降的规则：其中θ代表参数，α代表学习率。  
    ![在这里插入图片描述][20201105085835831.png_pic_center]
 *  我们需要选择一个合适的学习率，选得好的话梯度下降如图1最终会收敛，不好的话可能如图2始终是发散的  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 9]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 10]

def update_parameters(parameters,grads,learning_rate=1.2):
        W1,W2=parameters["W1"],parameters["W2"]
        b1,b2=parameters["b1"],parameters["b2"]
        
        dW1,dW2=grads["dW1"],grads["dW2"]
        db1,db2=grads["db1"],grads["db2"]
        
        W1=W1-learning_rate*dW1
        b1=b1-learning_rate*db1
        W2=W2-learning_rate*dW2
        b2=b2-learning_rate*db2
        
        parameters={ "W1":W1,
                   "b1":b1,
                   "W2":W2,
                   "b2":b2}
        return parameters
    
    #测试update_parameters
    print("=========================测试update_parameters=========================")
    parameters, grads = update_parameters_test_case()
    parameters = update_parameters(parameters, grads)
    
    print("W1 = " + str(parameters["W1"]))
    print("b1 = " + str(parameters["b1"]))
    print("W2 = " + str(parameters["W2"]))
    print("b2 = " + str(parameters["b2"]))

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

#### 4.8 整合所有函数 ####

*  将所有函数整合到nn\_model()中，神经网络必须以正确的顺序使用先前的功能

def nn_model(X,Y,n_h,num_iterations,print_cost=False):
        """ 参数： X - 数据集,维度为（2，示例数） Y - 标签，维度为（1，示例数） n_h - 隐藏层的数量 num_iterations - 梯度下降循环中的迭代次数 print_cost - 如果为True，则每1000次迭代打印一次成本数值 返回： parameters - 模型学习的参数，它们可以用来进行预测。 """
         
        np.random.seed(3) #指定随机种子
        n_x = layer_sizes(X, Y)[0]
        n_y = layer_sizes(X, Y)[2]
        
        parameters = initialize_parameters(n_x,n_h,n_y)
        W1 = parameters["W1"]
        b1 = parameters["b1"]
        W2 = parameters["W2"]
        b2 = parameters["b2"]
        
        for i in range(num_iterations):
            A2 , cache = forward_propagation(X,parameters)
            cost = compute_cost(A2,Y,parameters)
            grads = backward_propagation(parameters,cache,X,Y)
            parameters = update_parameters(parameters,grads,learning_rate = 0.5)
            
            if print_cost:
                if i%1000 == 0:
                    print("第 ",i," 次循环，成本为："+str(cost))
        return parameters
    
    
    #测试nn_model
    print("=========================测试nn_model=========================")
    X_assess, Y_assess = nn_model_test_case()
    
    parameters = nn_model(X_assess, Y_assess, 4, num_iterations=10000, print_cost=False)
    print("W1 = " + str(parameters["W1"]))
    print("b1 = " + str(parameters["b1"]))
    print("W2 = " + str(parameters["W2"]))
    print("b2 = " + str(parameters["b2"]))

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

*  上面红色部分说我在算log的时候遇到0了，但是我目前还没有排查出来原因。。

#### 4.9 预测 ####

*  预测的判别公式：  
    ![在这里插入图片描述][20201105092250368.png_pic_center]
 *  使用学习的参数，为X中的每个示例预测一个类

def predict(parameters,X):
        A2,cache=forward_propagation(X,parameters)
        predictions=np.round(A2)
        
        return predictions #predictions - 我们模型预测的向量（红色：0 /蓝色：1）
    
    #测试predict
    print("=========================测试predict=========================")
    
    parameters, X_assess = predict_test_case()
    
    predictions = predict(parameters, X_assess)
    print("预测的平均值 = " + str(np.mean(predictions)))

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

*  正式运行：

parameters = nn_model(X, Y, n_h = 4, num_iterations=10000, print_cost=True)
    
    #绘制边界
    plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)
    plt.title("Decision Boundary for hidden layer size " + str(4))
    
    predictions = predict(parameters, X)
    print ('准确率: %d' % float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100) + '%')

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

*  更改隐藏层节点的数量，看是否会对结果造成影响

plt.figure(figsize=(16, 32))
    hidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50] #隐藏层数量
    for i, n_h in enumerate(hidden_layer_sizes):
        plt.subplot(5, 2, i + 1)
        plt.title('Hidden Layer of size %d' % n_h)
        parameters = nn_model(X, Y, n_h, num_iterations=5000)
        plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)
        predictions = predict(parameters, X)
        accuracy = float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100)
        print ("隐藏层的节点数量： {} ，准确率: {} %".format(n_h, accuracy))

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

参考资料：

*  [吴恩达《深度学习》L1W3作业][L1W3]
 *  [【中文】【吴恩达课后编程作业】Course 1 - 神经网络和深度学习 - 第三周作业][Course 1 - _ -]
 *  [Sigmoid、Relu、Tanh激活函数][Sigmoid_Relu_Tanh]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20201104160340393.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[20201104160858473.png_pic_center]: /images/20221120/bdd440a974a04c60b819cc532cbd9b05.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201104161333382.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 2]: https://img-blog.csdnimg.cn/20201104161822282.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/20201104161954334.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/20201104162043675.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[20201104162839625.png_pic_center]: https://img-blog.csdnimg.cn/20201104162839625.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201104164041470.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[20201104164923909.png_pic_center]: https://img-blog.csdnimg.cn/20201104164923909.png#pic_center
[20201105082223325.png_pic_center]: https://img-blog.csdnimg.cn/20201105082223325.png#pic_center
[20201105083713534.png_pic_center]: https://img-blog.csdnimg.cn/20201105083713534.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201105083827718.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[20201105084223813.png_pic_center]: https://img-blog.csdnimg.cn/20201105084223813.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20201105084302753.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[20201105084249388.png_pic_center]: https://img-blog.csdnimg.cn/20201105084249388.png#pic_center
[20201105084649685.png_pic_center]: https://img-blog.csdnimg.cn/20201105084649685.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20201105085630766.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[20201105085835831.png_pic_center]: https://img-blog.csdnimg.cn/20201105085835831.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 9]: https://img-blog.csdnimg.cn/20201105090041121.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 10]: https://img-blog.csdnimg.cn/20201105090046349.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 11]: https://img-blog.csdnimg.cn/20201105090719125.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 12]: https://img-blog.csdnimg.cn/20201105092048516.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[20201105092250368.png_pic_center]: https://img-blog.csdnimg.cn/20201105092250368.png#pic_center
[20201105092548511.png_pic_center]: https://img-blog.csdnimg.cn/20201105092548511.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 13]: https://img-blog.csdnimg.cn/20201105093116523.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[2020110509334641.png_pic_center]: https://img-blog.csdnimg.cn/2020110509334641.png#pic_center
[L1W3]: https://www.kesci.com/mw/project/5dd3946900b0b900365f3a48
[Course 1 - _ -]: https://blog.csdn.net/u013733326/article/details/79702148
[Sigmoid_Relu_Tanh]: https://blog.csdn.net/zhuiyuanzhongjia/article/details/80576779?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160453687719195264757785%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=160453687719195264757785&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v28-1-80576779.pc_first_rank_v2_rank_v28&utm_term=tanh%E6%BF%80%E6%B4%BB%E5%87%BD%E6%95%B0&spm=1018.2118.3001.4449