深度学习基础----吴恩达课后编程（四）----改善神经网络

已于 2022-09-25 10:40:26 修改
阅读量683 收藏 3
点赞数
于 2022-09-21 21:32:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44934596/article/details/126967011
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

目录

前言

一、初始化参数

1.1 初始化为0

1.2 初始化为随机数

1.3 抑梯度异常初始化

二、正则化

2.1 不使用正则化

2.2 L2正则化

2.3 dropout正则化

2.4 其他正则化

2.4.1 正则化数据集

 2.4.1 early stopping

三、梯度检验

前言

  前面实验三搭建了深层神经网络，我们发现并不是神经网络层越多，效果越好。在此基础上，我们运用一些小技巧，以改善我们的神经网络。本实验参考：http://t.csdn.cn/wQveQ

一、初始化参数

目前我们一共学习了三种初始化方式

  • 对于逻辑回归。权重初始化可为0
  • 随机初始化一个很小的随机数
  • 为抑制梯度爆炸，和梯度消失的初始化

现在我们看看三种初始化方式在同一神经网络的表现：

#######初始化参数###

train_X,train_Y,test_X,test_Y=init_utils.load_dataset(is_plot=True)   ###查看数据
plt.show()


#####建立一个分类器,将蓝点与红点分开
#####init_utils中已经实现了一个三层的神经网络，现在我们来调用他进行数据初始化

####目前我门学习三种初始化的方式
###1.全部参数初始化为0
###2.初始化随机数
###3.抑梯度异常初始化

def initialize_model(X,Y,learning_rate=0.01,num_iterations=20000,print_cost=True,initialization="",is_plot=True):
    """

    Parameters
    ----------
    X----输入值
    Y----标签
    learning_rate-----学习率
    num_iterrations-----迭代次数
    print_cost------是否打印成本值，每1000次打印一次
    initialization-----选择初始化的方式
    is_plot-----绘制梯度下降的曲线图

    Returns
    -------
    parameters----学习后的参数

    """
    grads={}
    costs=[]
    m=X.shape[1]
    layers_dims=[X.shape[0],10,5,1]

    ###选择初始化参数的类型

    if initialization=="zero":
        parameters=initialize_parameters_zero(layers_dims)
    elif initialization=="random":
        parameters=initialize_parameters_random(layers_dims)
    if initialization=="he":
        parameters=initialize_parameters_he(layers_dims)

    ######开始学习######
    for i in range(0,num_iterations):
      #####前向传播
      a3,cache=init_utils.forward_propagation(X,parameters)
      ####计算成本
      cost=init_utils.compute_loss(a3,Y)
      ###后向传播
      grads=init_utils.backward_propagation(X, Y, cache)
      ###更新参数
      parameters=init_utils.update_parameters(parameters, grads, learning_rate)

      ####打印成本
      if i%1000==0:
          costs.append(cost)   #append 在列表ls最后(末尾)添加一个元素object

          if print_cost:
              print("第"+str(i)+"次迭代，成本值为："+str(cost))
    ######绘制成本
    if is_plot:
        plt.plot(costs)
        plt.ylabel('cost')
        plt.xlabel('iterations(per thousands )')
        plt.title("learning rate="+str(learning_rate))
        plt.show()

    return parameters

1.1 初始化为0

######1.初始化为0
def initialize_parameters_zero(layers_dims):
    """

    Parameters
    ----------
    layers_dims

    Returns
    -------
    parameters

    """
    parameters={}
    L=len(layers_dims)

    for l in range(1,L):
        parameters["W"+str(l)]=np.zeros((layers_dims[l],layers_dims[l-1]))
        parameters["b" + str(l)] = np.zeros((layers_dims[l], 1))

    return parameters

    ######调用该初始化模型
"""
parameters=model(train_X,train_Y,initialization="zero",is_plot=True)
"""

结果： 

可以看到在三层神经网络中，初始化为0时根本不会迭代参数，因为零初始化会导致神经网络无法打破对称性，隐藏层不起作用，最终只会得到逻辑回归的效果

1.2 初始化为随机数


#########初始化为随机数
def initialize_parameters_random(layers_dims):
    """

        Parameters
        ----------
        layers_dims

        Returns
        -------
        parameters

        """
    np.random.seed(3) ####指定随机种子
    parameters = {}
    L = len(layers_dims)

    for l in range(1, L):
        parameters["W" + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1])*0.1
        parameters["b" + str(l)] = np.zeros((layers_dims[l], 1))    ####b要初始化为0
        assert(parameters["W"+ str(l)].shape==(layers_dims[l], layers_dims[l - 1]))
        assert (parameters["b" + str(l)].shape == (layers_dims[l], 1))


    return parameters

"""
parameters=model(train_X,train_Y,initialization="random",is_plot=True)
"""

  • 初始化为0.1，迭代20w次的结果：

  • 初始化为0.01，迭代200w次的结果：

  • 初始化*10，迭代1w5次的结果：

第0次迭代，成本值为：inf
第1000次迭代，成本值为：0.625098279396
第2000次迭代，成本值为：0.59812165967
第3000次迭代，成本值为：0.56384175723
第4000次迭代，成本值为：0.55017030492
第5000次迭代，成本值为：0.544463290966
第6000次迭代，成本值为：0.5374513807
第7000次迭代，成本值为：0.476404207407
第8000次迭代，成本值为：0.397814922951
第9000次迭代，成本值为：0.393476402877
第10000次迭代，成本值为：0.392029546188
第11000次迭代，成本值为：0.389245981351
第12000次迭代，成本值为：0.386154748571
第13000次迭代，成本值为：0.38498472891
第14000次迭代，成本值为：0.382782830835
训练集：
Accuracy: 0.83
测试集：
Accuracy: 0.86

  由此可见我们不好掌握该初始化怎么样的随机数，若随机数过小，那么学习次数就会变高，训练速度就会很慢。若随机数过大，就很有可能停在sigmoid/tanh平坦的部分，从而龟速学习，减慢优化的速度

1.3 抑梯度异常初始化

因此为避免梯度消失和梯度爆炸，优化学习速度，我们使用如下公式：

def initialize_parameters_he(layers_dims):
    """

    Parameters
    ----------
    layers_dims

    Returns
    -------
    parameters
    """
    np.random.seed(3)
    parameters={}
    L=len(layers_dims)

    for l in range(1, L):
        parameters["W" + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) * np.sqrt(2/layers_dims[l-1])
        #######因为激活函数是relu，因此使用np.sqrt(2/layers_dims[l-1])
        ######若是其他的激活函数,可使用np.sqrt(1/layers_dims[l-1])
        parameters["b" + str(l)] = np.zeros((layers_dims[l], 1))  ####b要初始化为0
        assert (parameters["W" + str(l)].shape == (layers_dims[l], layers_dims[l - 1]))
        assert (parameters["b" + str(l)].shape == (layers_dims[l], 1))

    return parameters

parameters=initialize_model(train_X,train_Y,initialization="he",is_plot=True)

print("W1="+str(parameters["W1"]))
print("b1="+str(parameters["b1"]))
print("W2="+str(parameters["W2"]))
print("b2="+str(parameters["b2"]))
print("W3="+str(parameters["W3"]))
print("b3="+str(parameters["b3"]))

print("训练集：")
predictions_train=init_utils.predict(train_X,train_Y,parameters)
print("测试集：")
predictions_test=init_utils.predict(test_X,test_Y,parameters)


#######绘制决策边界
plt.title("抑梯度异常初始化")
axes=plt.gca()
axes.set_xlim([-1.5,1.5])
axes.set_ylim([-1.5,1.5])
init_utils.plot_decision_boundary(lambda x: init_utils.predict_dec(parameters,x.T),train_X,train_Y)
plt.show()

 结果：

绘制决策边界 ：

由以上可见，这种初始化方式避免了梯度消失或梯度爆炸，在保证效果的同时还优化了速度。 

二、正则化

正则化的目的：收缩权重，避免验证集与训练集的结果方差多大，避免过拟合

建立模型：

def model(X,Y,learning_rate=0.3,num_iterations=30000,print_cost=True,is_plot=True,lambd=0,keep_prob=1):
    """

    Parameters
    ----------
    X
    Y
    learning_rate
    num_iterations
    print_cost
    is_plot
    lambd--------L2正则化的超参数，实数
    keep_prob-------随机删除节点的概率

    Returns
    -------
    parameters------学习后的参数

    """

    grads={}
    parameters={}
    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:
          #不随机删除节点,使用L2正则化
          a3,cache=reg_utils.forward_propagation(X,parameters)
      elif keep_prob<1:
          #随机删除节点，使用dropout正则化
          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正则化和dropout，但是本实验不使用
      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):
              print("第"+str(i)+"次迭代，成本值为："+str(cost))

    if is_plot:
        plt.plot(costs)
        plt.ylabel('cost')
        plt.xlabel('iterations')
        plt.title("learning rate="+str(learning_rate))
        plt.show()
    return parameters

正则化实验数据集： （就是要建立一个分类器）

2.1 不使用正则化

#########不使用正则化
parameters=model(train_X,train_Y,is_plot=True,lambd=0,keep_prob=1)
print("训练集：")
predictions_train=reg_utils.predict(train_X,train_Y,parameters)
print("测试集：")
predictions_test=reg_utils.predict(test_X,test_Y,parameters)

#####绘制决策边界
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)
plt.show()

结果：

明显的过拟合，训练集与验证集有高方差 

2.2 L2正则化

L2正则化通过修改成本函数，加入正则项：

在反向传播过程中，由于增加了正则化项，w权重衰减 

############使用L2正则化
def compute_cost_with_regularization(A3,Y,parameters,lambd):
    """

    Parameters
    ----------
    A3-------正向传播的输出结果，维度为（输出节点的数量，训练/测试的数量）
    Y----标签数量，维度为（输出节点数量，训练/测试的数量）
    parameters-----包含模型学习后的参数
    lambd-----正则化参数

    Returns
    -------
    cost------使用正则化计算出来的正则化损失值

    """
    m=Y.shape[1]      ######要与原成本函数的y^的数量保持一致
    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):
    """

    Parameters
    ----------
    X
    Y
    cache
    lambd

    Returns
    -------
      grads------一个包含每个参数，激活值，和预激活值变量的梯度的字典
    """

    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)

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

    return gradins


#########使用L2正则化
parameters=model(train_X,train_Y,lambd=0.7,is_plot=True)
print("L2正则化后训练集：")
predictions_train=reg_utils.predict(train_X,train_Y,parameters)
print("L2正则化后测试集：")
predictions_test=reg_utils.predict(test_X,test_Y,parameters)

#####绘制决策边界
plt.title("model with L2regularization")
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)
plt.show()

2.3 dropout正则化

dropout 会遍历网络的每一层，随机按概率（1-keep_prob）消除每一层的节点的个数，从而精简神经网络，消除过拟合。

加入dropout之后，输入的特征有可能被随机清除，因而不能特别依赖于任何一个输入的特征，不会给设置大权重，通过传播，dropout和前述正则化一样，产生了权重收缩的效果。

使用上，在神经元少时，减少使用dropout， keep_prob=1, 神经元多时，减小keep_prob。但其使得 J 无法明确定义，难以绘图，因而一般先关闭dropout，确保收敛下降，再打开。
 

dropout1_kiank

dropout2_kiank

以上的两个图片来自何宽 http://t.csdn.cn/pDDFz  博文，我觉得很生动形象

执行步骤：

  1. 随机初始化一个与A[l]向量结构相同的矩阵D[l]
  2. 将D[l]值转化为0或1
  3. 舍弃A[i]的一些节点
  4. 为了不影响下一层的值，缩放未舍弃的节点
#######dropout正则化#######
def forward_propagation_with_dropout(X,parameters,keep_prob=0.5):
    """
    实现具有随机舍弃节点的前向传播
    Parameters
    ----------
    X------输入数据集
    parameters------
    W1-------权重矩阵，维度为（20，2）
    b1-------偏向量，维度为（20，1）
    W2-------权重矩阵，维度为（3，20）
    b2-------偏向量，维度为（3，1）
    W3-------权重矩阵，维度为（1，3）
    b3-------权重矩阵，维度为（1，1）

    keep_prob------随机删除的概率

    Returns
    -------
    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"]

    Z1=np.dot(W1,X)+b1
    A1=reg_utils.relu(Z1)

    D1=np.random.rand(A1.shape[0],A1.shape[1])########初始化矩阵D1
    D1 = D1 < keep_prob      ######将D1的值转化为0或1，python中的False和True等于0和1.
    #######即D1=0的概率为1-keep_prob
    A1=A1*D1      #######舍弃A1的一些节点
    A1=A1/keep_prob######缩放未舍弃的节点的值，为了不影响Z2

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

    D2=np.random.rand(A2.shape[0],A2.shape[1])
    D2=D2<keep_prob
    #######即D1=0的概率为1-keep_prob
    A2=A2*D2      #######舍弃A1的一些节点
    A2=A2/keep_prob######缩放未舍弃的节点的值，为了不影响Z2

    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

 前向传播改变了，后向传播也得变了：

########改变了前向传播的算法，我们也需要改变后向传播的算法

def backward_propagation_with_dropout(X,Y,cache,keep_prob):
    """
    实现我们随机删除的模型的后向传播
    Parameters
    ----------
    X----------维度为（2，示例数）
    Y---------维度为（输出节点数量，示例数量）
    cache------来自forward_propagation_with_dropout()的cache
    keep_prob-----随机删除的概率

    Returns
    -------
     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    ######使用正向传播期间相同的节点，舍弃那些关闭的节点
    dA2=dA2/keep_prob   ####缩放未舍弃的节点值
    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  ######使用正向传播期间相同的节点，舍弃那些关闭的节点
    dA1 = dA1 / keep_prob  ####缩放未舍弃的节点值

    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正则化
parameters=model(train_X,train_Y,keep_prob=0.86,lambd=0,is_plot=True,learning_rate=0.3)
print("dropout正则化后训练集：")
predictions_train=reg_utils.predict(train_X,train_Y,parameters)
print("dropout正则化后测试集：")
predictions_test=reg_utils.predict(test_X,test_Y,parameters)

#####绘制决策边界
plt.title("model with dropoutregularization")
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)
plt.show()

dropout结果： 


 

 

我们可以看到，dropout把训练集的准确度降低了，但是测试集的准确度提高了 

2.4 其他正则化

  除了以上的L2正则化，和dropout，还有以下两种

2.4.1 正则化数据集

 2.4.1 early stopping

三、梯度检验

以检验反向传播是否得以正确的实施。

#########梯度检验######

######为了验证反向传播函数是否正确，以及梯度是否下降，进行的梯度检验
######高维梯度检验######
def forward_propagation_n(X,Y,parameters):
    """
    实现途中的前向传播（并计算成本）
    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）


    Returns
    -------
    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):
    """

    Parameters
    ----------
    X------输入节点数量
    Y-----标签
    cache

    Returns
    -------
    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)
    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)
    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 = (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_propogation_n是否正确计算forward_propagation_n输出的成本梯度
    Parameters
    ----------
    parameters
    gradients
    X
    Y
    epsilon-----------计算输入的微笑漂移以近似梯度

    Returns
    -------
    difference--------近似梯度和后向传播之间的差异

    """
    #######初始化参数
    parameters_values,keys=gc_utils.dictionary_to_vector(parameters)
    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):
        thetaplus=np.copy(parameters_values)
        thetaplus[i][0]=thetaplus[i][0]+epsilon
        J_plus[i],cache=forward_propagation_n(X,Y,gc_utils.vector_to_dictionary(thetaplus))
        thetaminus=np.copy(parameters_values)
        thetaminus[i][0]=thetaplus[i][0]-epsilon
        J_minus[i],cache=forward_propagation_n(X,Y,gc_utils.vector_to_dictionary(thetaminus))

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

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

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

    return difference

######测试梯度检验
print("--------测试gradient_check----------")
x,y,parameters = testCase.gradient_check_n_test_case()
cost,cache=forward_propagation_n(x,y,parameters)
gradients=backward_propagation_n(x,y,cache)
difference=gradient_check_n(parameters,gradients,x,y,epsilon=1e-7)
print("difference="+str(difference))

 结果：

 emmmmm，梯度检查正常的误差不能超过1e-7，不知道那一步出了错。

梯度检验注意事项：

  • 不要在训练时使用梯度检验，因为它太慢了
  • 注意正则项，如果有L2正则项，梯度检验也要带上该正则项
  • 梯度检验不能与dropout同时使用

 总结

以上就是优化深层神经网络的一些方法，总体上收获了很多。但也有不足之处，比如我不知道梯度检验失败后，该如何检查。希望下次的学习，能在此基础上有所改进。加油！！！共勉！

wyjxlj666
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
吴恩达深度学习笔记之改善神经网络(一)
物理小乾乾
12-21 954
1.1 Train/dev/test sets在配置训练，验证，和测试数据集的过程中做出正确决策，会在很大程度上帮助大家创建高效的神经网络。训练神经网络的时候，我们需要做出很多决策。例如：神经网络分多少层，每层包含多少神经元，以及学习速率是多少。 实际上，应用型机器学习是一个高度迭代的过程，下面的示例图可以表示我们训练一个神经网路的过程。![这里写图片描述](http://img.blog.csd
吴恩达《深度学习》笔记二——改善神经网络
changfei_1995的博客
05-29 290
writed by changfei_lovelife~ 改善神经网络：正则化、优化算法、超参数调试 让神经网络表现良好 加快训练 第一部分 正则化 1.偏差与方差： 训练集误差与最优误差的差值——>偏差，过大时欠拟合 验证集误差与训练集误差的差值——>方差，过大时过拟合 解决偏差与方差的流程图： 2.L2正则化： 本质：在损失函数中添加正则项，改变dw值 逻辑回归实现正则化： ...
吴恩达Deep Learning编程作业 Course2- 改善深层神经网络-第三周作业：TensorFlow练习
qq_34621022的博客
03-10 1584
吴恩达Deep Learning编程作业 Course2- 改善深层神经网络-第三周作业：TensorFlow练习 到现在我们一直使用numpy来构建神经网络，接下来我们将使用深度学习框架来构建神经网络。常见的机器学习框架是TensorFlow、Paddle、Torch、Caffe、Keras等，本次作业中我们将练习使用TensorFlow，我们学习的主要内容是： 初始化参数 启动session...
吴恩达深度学习deeplearning.ai——第二门课：改善神经网络——第一节：深度学习的实践层面
weixin_43895667的博客
08-10 752
吴恩达深度学习deeplearning.ai——第二门课改善神经网络：超参数调试、正化以及优化深度神经网络——第二节：优化算法
深度学习课后作业——Course2-Week3
m0_37579232的博客
02-15 474
此篇摘自*这个巨巨*，本文只是加上了自己的总结 深度学习里的Xavier初始化 “Xavier”初始化方法是一种很有效的神经网络初始化方法，方法来源于2010年的一篇论文《Understanding the difficulty of training deep feedforward neural networks》。文章主要的目标就是使得每一层输出的方差应该尽量相等。 定义参数所在层的输入...
Deep AI 吴恩达深度学习课后检验题-机器学习和神经网络
05-04
在本课程“Deep AI 吴恩达深度学习课后检验题-机器学习和神经网络”中，我们将探讨吴恩达教授讲解的深度学习基础，特别是机器学习和神经网络的概念及其应用。吴恩达，作为全球知名的AI教育家，他的课程深入浅出，...
【吴恩达课后编程作业】Course 2 - 改善深层神经网络 - 第一周作业(1&2&3).zip
02-22
这个压缩包文件“【吴恩达课后编程作业】Course 2 - 改善深层神经网络 - 第一周作业(1&2&3).zip”包含了完成吴恩达深度学习课程第二部分，关于优化深层神经网络的第一周作业所需的所有资源。吴恩达是一位知名的...
吴恩达machine-learning课后习题集
10-04
【标题】"吴恩达machine-learning课后习题集"主要涵盖了深度学习和人工智能领域的核心课程——机器学习的练习题目。吴恩达（Andrew Ng）是斯坦福大学计算机科学教授，也是在线教育平台Coursera的联合创始人，他在...
【吴恩达课后编程作业】Course 2 - 改善深层神经网络 - 第三周作业 - TensorFlow入门.zip
02-22
在本压缩包“【吴恩达课后编程作业】Course 2 - 改善深层神经网络 - 第三周作业 - TensorFlow入门.zip”中，我们聚焦于吴恩达教授的深度学习课程第二部分，主题是如何优化深层神经网络。在这个阶段，我们将深入理解...
深度学习吴恩达课机器学习课后作业2022-Deep-Learning-Specialization【源码+讲解】
最新发布
05-15
该课程涵盖了深度学习的基础知识、卷积神经网络、循环神经网络、序列模型等内容，并提供了丰富的编程作业，帮助学习者掌握深度学习的核心概念和技术。 适合人群：对深度学习感兴趣，希望通过实践加深理解的学习者。...
3. 吴恩达深度学习--初始化、正则化、梯度校验
qq_45069496的博客
08-16 336
本文所使用的资料已上传到百度网盘【点击下载】，提取码：hnwl ，请在开始之前下载好所需资料。 一、初始化参数 读取并绘制数据 我们将要建立一个分类器把蓝点和红点分开，在此之前我们已经实现过一个 3 层的神经网络，我们将对其进行初始化，并比较三种初始化的效果。 随机初始化：将输入参数设置为随机值，权重初始化为大的随机值。参数名为：，核心代码为： 抑梯度异常初始化：参见梯度消失和梯度爆炸的那一个视频，参数名为：，核心代码为： 首先看看我们的模型是怎么样的： 1. 初始化为 0 测试一下上述代码
吴恩达深度神经网络调优笔记—正则化
m0_51447279的博客
09-30 361
在深度学习模型进行训练时，如果你的数据不是很大，就极有可能会产生过拟合的问题。它在训练集上准确率会很好，但是当你进行测试集测试时，准确率会变差。这个时候我们就需要利用正则化。例子：假设你现在是一个AI专家，你需要设计一个模型，可以用于推荐在足球场中守门员将球发至哪个位置可以让本队的球员抢到球的可能性更大。说白了，实际上就是一个二分类，一半是己方抢到球，一半就是对方抢到球。如图：看一下数据集通过对比正则化和非正则化模型来了解优劣。
抑梯度异常初始化参数（防止梯度消失和梯度爆炸）
weixin_45354497的博客
05-10 338
初始化参数的调整，改善网络性能
机器学习吴恩达编程作业题5—正则化线性回归和偏差/方差
qq_42148307的博客
07-18 621
1、正则化线性回归 1.1可视化数据集 我们将从可视化数据集开始，其中包含水位变化的历史记录x和流出水坝的水量y。将实现线性回归，并使用它来拟合数据的直线并绘制学习曲线。将实现多项式回归，以找到更好的数据拟合。复制ex5data1数据集到D:\Machine Learning\ex5目录下。直接调用plot函数进行数据集的绘制。 1.2正则化线性回归成本函数和梯度 注意，你不应该正则化θ0项。 在当前目录下建立linearRegCostFunction.m文件： function [J, grad]
深度学习第二课--第一周初始化、正则化、梯度校验
qq_37199669的博客
02-24 394
文章目录声明开始之前初始化参数读取并绘制数据初始化为零随即初始化抑梯度异常初始化正则化模型读取并绘制数据集不使用正则化使用正则化使用L2正则化随即删除节点梯度校验高维 声明 参考何宽、念师 开始之前 本文中，我们要干三件事： 初始化参数： 1.1、使用0来初始化参数。 1.2、使用随即数来初始化参数。 1.3、使用抑梯度异常初始化参数。 正则化模型： 2.1、使用二范数对二分类模型正则化，尝试避...
《吴恩达深度学习》编程作业-第二周
我的博客
07-21 2581
基于神经网络思维模式的逻辑回归_猫识别分类器
正则化方法：L1和L2 regularization、数据集扩增、dropout
热门推荐
wepon的专栏
03-14 12万+
本文是《Neural networks and deep learning》概览 中第三章的一部分，讲机器学习/深度学习算法中常用的正则化方法。（本文会不断补充）正则化方法：防止过拟合，提高泛化能力在训练数据不够多时，或者overtraining时，常常会导致overfitting（过拟合）。其直观的表现如下图所示，随着训练过程，网络在training data上的error渐渐减小，但是在验证集上
吴恩达老师的公开课，简单神经网络的作业总结
py496980138的博客
11-07 1410
定义四个变量 train_set_x shape: (209, 64, 64, 3) train_set_y shape: (1, 209) test_set_x shape: (50, 64, 64, 3) test_set_y shape: (1, 50) 分别为训练集的X，Y，测试集的X，Y。 这里有一点需要注意，作业中直接导入的文件train_catvnoncat.h5和test
吴恩达-深度学习-改善深层神经网络
04-04
吴恩达在改善深层神经网络方面提出了多种方法，包括： 1. 激活函数：使用ReLU（Rectified Linear Unit）代替传统的sigmoid函数，可以加速训练过程并提高准确率。 2. 正则化：使用L1或L2正则化，可以防止过拟合，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值