【深度学习】吴恩达深度学习-Course2改善深层神经网络：超参数调试、正则化以及优化-第一周深度学习的实用层面编程（中）——正则化

已于 2024-01-03 21:32:58 修改
阅读量571 收藏
点赞数 1
分类专栏： 深度学习 文章标签： 深度学习 神经网络 人工智能
于 2022-02-11 15:09:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/passer__jw767/article/details/122674944
版权

Remind：如果复制某一部分代码发现无法运行，可能是我粘贴了错误的代码，你可以看看六的总代码，总代码保证一定是正确的！😃

视频链接：[【中英字幕】吴恩达深度学习课程第二课 — 改善深层神经网络：超参数调试、正则化以及优化](https://www.bilibili.com/video/BV1V441127zE?p=14) 参考链接：
  1. Regularization
  2. 【中文】【吴恩达课后编程作业】Course 2 - 改善深层神经网络 - 第一周作业(1&2&3)

资源下载链接（来自参考链接2）：

  1. 本文所用资料
  2. data.mat下载后名称为9.mat，需要手动更名为data.mat

目录

〇、作业目标

深度学习模型具有很大的灵活性和容量，如果训练数据集不够大，过度拟合可能会成为一个严重的问题。当然，它在训练集上表现不错，但学习网络并没有推广到它从未见过的新例子。
在这次作业中你将学习到：

  • 在你的深度学习模型中使用正则化

一、需要导入的包

testCases由此文章中第一大点的第3小点处下载。
其他安装可参照上一篇文章的第一大点（使用Anaconda进行安装）

# import packages
import numpy as np
import matplotlib.pyplot as plt
from reg_utils import sigmoid, relu, plot_decision_boundary, initialize_parameters, load_2D_dataset, predict_dec
from reg_utils import compute_cost, predict, forward_propagation, backward_propagation, update_parameters
import sklearn
import sklearn.datasets
import scipy.io
from testCases import *

plt.rcParams['figure.figsize'] = (7.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

跑一下不报错就行，可能会有一些警告，但是没有影响。

二、问题描述（来自参考链接2）

假设你现在是一个AI专家，你需要设计一个模型，可以用于推荐在足球场中守门员将球发至哪个位置可以让本队的球员抢到球的可能性更大。说白了，实际上就是一个二分类，一半是己方抢到球，一半就是对方抢到球，我们来看一下这个图：
在这里插入图片描述

三、数据集

读取一下数据集（在前边给出的代码基础上加上如下两行）：

train_X, train_Y, test_X, test_Y = reg_utils.load_2D_dataset(is_plot=True)
plt.show()

结果如下：
在这里插入图片描述
每一个点代表球落下的可能的位置，蓝色代表己方的球员会抢到球，红色代表对手的球员会抢到球。
我们的目标：根据模型来画出一条线，找到适合我方球员能抢到球的位置。
数据集分析：这个数据集有点嘈杂，但它看起来像是一条将左上半部分（蓝色）和右下半部分（红色）分开的对角线。
首先我们将尝试未正则化的模型，然后你将学习如何正则化它并决定你会选择哪个模型来解决法国足球合作问题。

四、学习过程

1、Non-regularized model（非正则化模型）

你将使用以下神经网络（下面已经为您实现）。该模型可用于：

  • 正则化模式中：设定lambd输入一个非零值。这里我们使用“lambd”来替代“lambda”因为在Python中“lambda”是一个保存关键字
  • 在dropout（随机失活）模式中：设定一个小于1的值keep_prob

你将首先尝试一个没有任何正则化的模型，然后你需要完善：

  • L2正则化：函数“compute_cost_with_regularization()”和“backward_propagation_with_regularization()”
  • Dropout：函数“forward_propagation_with_dropout()”和“backward_propagation_with_dropout()”

在每一部分，你将使用给定的输入来跑模型以保证它会调用你所写的函数。请观察下面你熟悉的模型代码。

def model(X, Y, learning_rate = 0.3, num_iterations = 30000, print_cost = True, lambd = 0, keep_prob = 1):
    """
    Implements a three-layer neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID.
    
    Arguments:
    X -- input data, of shape (input size, number of examples)
    Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (output size, number of examples)
    learning_rate -- learning rate of the optimization
    num_iterations -- number of iterations of the optimization loop
    print_cost -- If True, print the cost every 10000 iterations
    lambd -- regularization hyperparameter, scalar
    keep_prob - probability of keeping a neuron active during drop-out, scalar.
    
    Returns:
    parameters -- parameters learned by the model. They can then be used to predict.
    """
        
    grads = {}
    costs = []                            # to keep track of the cost
    m = X.shape[1]                        # number of examples
    layers_dims = [X.shape[0], 20, 3, 1]
    
    # Initialize parameters dictionary.
    parameters = initialize_parameters(layers_dims)

    # Loop (gradient descent)

    for i in range(0, num_iterations):

        # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID.
        if keep_prob == 1:
            a3, cache = forward_propagation(X, parameters)
        elif keep_prob < 1:
            a3, cache = forward_propagation_with_dropout(X, parameters, keep_prob)
        
        # Cost function
        if lambd == 0:
            cost = compute_cost(a3, Y)
        else:
            cost = compute_cost_with_regularization(a3, Y, parameters, lambd)
            
        # Backward propagation.
        assert(lambd == 0 or keep_prob == 1)    # it is possible to use both L2 regularization and dropout, 
                                            # but this assignment will only explore one at a time
        if lambd == 0 and keep_prob == 1:
            grads = backward_propagation(X, Y, cache)
        elif lambd != 0:
            grads = backward_propagation_with_regularization(X, Y, cache, lambd)
        elif keep_prob < 1:
            grads = backward_propagation_with_dropout(X, Y, cache, keep_prob)
        
        # Update parameters.
        parameters = update_parameters(parameters, grads, learning_rate)
        
        # Print the loss every 10000 iterations
        if print_cost and i % 10000 == 0:
            print("Cost after iteration {}: {}".format(i, cost))
        if print_cost and i % 1000 == 0:
            costs.append(cost)
    
    # plot the cost
    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)
print("On the training set:")
predictions_train = predict(train_X, train_Y, parameters)
print("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)

结果如下：

Cost after iteration 0: 0.6557412523481002
Cost after iteration 10000: 0.16329987525724213
Cost after iteration 20000: 0.13851642423257488

（注：如果你plt.show()出来的图是带有数据集点的话，请在一开始加载数据集那段代码的括号内将is_plot参数置为false）
在这里插入图片描述

On the training set:
Accuracy: 0.9478672985781991
On the test set:
Accuracy: 0.915

查看划分的边界

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

结果如下：
在这里插入图片描述
非正则化显然过度拟合了训练集。它过度拟合了在蓝色区域里的红点和红色区域里的蓝点。现在我们来看两种减少过度拟合的技术。

2、L2正则化

避免过度拟合的标准方式是使用L2正则化。其涵盖适当地修改损失函数，从在这里插入图片描述
改变成了：
在这里插入图片描述
让我们修改损失函数并观察结果。

练习：完成函数compute_cost_with_regularization()、backward_propagation_with_regularization()

练习1：完成函数compute_cost_with_regularization()，使用上边改变后的公式来计算损失。
提示：当你计算在这里插入图片描述时，可以使用np.sum(np.square(Wl))。注意，你必须对W^ [1]，W^ [2]和W^ [3]这样做，然后将这三项相加并乘以(1/m)*(λ/2)。

def compute_cost_with_regularization(A3, Y, parameters, lambd):
    """
    Implement the cost function with L2 regularization. See formula (2) above.
    
    Arguments:
    A3 -- post-activation, output of forward propagation, of shape (output size, number of examples)
    Y -- "true" labels vector, of shape (output size, number of examples)
    parameters -- python dictionary containing parameters of the model
    
    Returns:
    cost - value of the regularized loss function (formula (2))
    """

写完后应如下：

def compute_cost_with_regularization(A3, Y, parameters, lambd):
    """
    Implement the cost function with L2 regularization. See formula (2) above.

    Arguments:
    A3 -- post-activation, output of forward propagation, of shape (output size, number of examples)
    Y -- "true" labels vector, of shape (output size, number of examples)
    parameters -- python dictionary containing parameters of the model

    Returns:
    cost - value of the regularized loss function (formula (2))
    """
    m = Y.shape[1]
    W1 = parameters["W1"]
    W2 = parameters["W2"]
    W3 = parameters["W3"]

    cross_entropy_cost = 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

因为你改变了损失函数，所以同时你也要改变反向传播函数。所有的梯度都必须根据这个新成本来计算。

练习2：改变反向传播，在其中考虑正则化。这些更改只涉及dW1、dW2、dW3。对于它们每一项你需要加上正则化梯度在这里插入图片描述

def backward_propagation_with_regularization(X, Y, cache, lambd):
    """
    Implements the backward propagation of our baseline model to which we added an L2 regularization.
    
    Arguments:
    X -- input dataset, of shape (input size, number of examples)
    Y -- "true" labels vector, of shape (output size, number of examples)
    cache -- cache output from forward_propagation()
    lambd -- regularization hyperparameter, scalar
    
    Returns:
    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables
    """

答案及解释如下：

def backward_propagation_with_regularization(X, Y, cache, lambd):
    """
    Implements the backward propagation of our baseline model to which we added an L2 regularization.

    Arguments:
    X -- input dataset, of shape (input size, number of examples)
    Y -- "true" labels vector, of shape (output size, number of examples)
    cache -- cache output from forward_propagation()
    lambd -- regularization hyperparameter, scalar

    Returns:
    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables
    """
    m = X.shape[1]
    (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3) = cache

    # 反向传播，如果对这一部分没有印象了可以再去看看course1的week3的课/笔记
    # 这里前向传播最后一步使用sigmoid函数。在此处，我们便是取sigmoid的导数
    # 用链式求导法则计算导数
    # 用吴恩达课上的表示法便如下： "dA3"代表dL(A3,Y)/dA3 ， “dZ3”代表dL(A,Y)/dZ3
    # "dA3" = dL(A3,Y)/dA3 = -(A3/Y) + (1-Y)/(1-A3)
    # "dZ3" = dL(A3,Y)/dA3 * dA3/dZ3 = dL(A3,Y)/dA3 * A3(1-A3) = A3 - Y
    dZ3 = A3 - Y
    # 正向传播时，Z3 = np.dot(W3, A2) + b3
    # "dW3" = dL(A3,Y)/dW3 = "dZ3" * dZ3/dW3 = "dZ3" * A2
    # 给我们的提示里说到（提示是已经为我们计算好了导数），每一项dW需要加上正则化梯度，所以我们就将提示中给出的lambda * W / m加上即可

    dW3 = (lambd * W3) / m + 1. / m * np.dot(dZ3, A2.T)
    db3 = 1. / m * np.sum(dZ3, axis=1, keepdims=True)

    # 以下同理
    # 根据链式求导法则，"dA2" = "dZ3" * dZ3/dA2
    # 在正向传播时，有：Z3 = np.dot(W3, A2) + b3
    # 由正向传播的公式，我们就可以知道dZ3/dA2 = W3
    # 从而，“dA2” = “dZ3" * W3
    dA2 = np.dot(W3.T, dZ3)
    # 在正向传播时，有A2 = relu(Z2)
    # "dZ2" = "dA2" * dA2/dZ2 = "dA2" * np,int64(g(z) > 0); 括号内是一个逻辑表达式，解释如下：
    # relu函数我们都知道是g(z) = max(0,z); 而relu函数的导数情况如下：if z<0,g'(z)=0; elif z>0,g'(z)=1; elif z=0,g'(z)=undefined(或者你可以自己定义为0/1)
    # 那么我们可以知道，relu函数的导数可以通过一个逻辑表达式“g(z) > 0”来进行判断;若g(z)>0，则结果为1。又因为g(z)=max(0,z)，我们可以知道z一定是>0的，所以g'(z)=1。
    # 通过上面一句话的推导，我们可以使用"g(z) > 0"来进行relu函数的求导
    # np.int64(a): 将a的值转换成整数
    dZ2 = np.multiply(dA2, np.int64(A2 > 0))
    dW2 = (lambd * W2) / m + 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 = (lambd * W1) / m + 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

个人认为，L2正则化的反向传播过程算是完成L2正则化过程中难的一部分。在反向传播的过程中，比较重要的是在计算dW时候，我们仍然需要加上正则化梯度λ*W/m，同时，Relu函数导数的计算也是很巧妙的点，如果无法理解也没关系，只要记住就好了。

查看损失函数变化

您可以复制粘贴用以下代码查看您损失函数的变化情况

parameters = model(train_X, train_Y, lambd=0.7)
print("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)

结果如下：
在这里插入图片描述

Cost after iteration 0: 0.6455597362665152
Cost after iteration 10000: 0.22243930284965185
Cost after iteration 20000: 0.217197697773333
On the train set:
Accuracy: 0.9383886255924171
On the test set:
Accuracy: 0.93

恭喜！test集的准确性增长到了93%！
然而我们并没有很好地拟合训练集，我们接下来看一下划分出来的边界是如何的

查看划分的边界

您可以复制粘贴以下代码查看划分的边界

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

结果如下：
在这里插入图片描述
下面对使用L2正则化的结果做一个总结

观察：

  • λ的值是一个超参数，可以使用dev集进行调整
  • L2正则化让您的决策边界变得更加光滑，如果λ太大，同样会导致“过于光滑”，导致模型出现较大的偏差（高偏差的表现就是未能够很好地拟合数据）

L2正则化实际完成了什么工作？
L2正则化依赖于“模型有较小的权重比模型有较大权重简单”这个假设。因此，通过调整成本函数中权重的平方值，可以使所有权重的值变小。当成本函数有较大的权重时，会导致成本更高！这将使得随着输入的变化，输出的变化更为缓慢，从而导致更平滑的模型。

你需要记住的与L2正则化有关的内容：

  • 成本函数的计算：在成本函数中加入一个正则化项
  • 反向传播函数：在计算梯度时有关于权重矩阵的额外项
  • 权重最终变小（权重衰减）：权重会变成更小的值

3、Dropout（随机失活）

最后，dropout对深度学习来说很特殊，它被广泛运用于正则化技术。在每一次的迭代中，这种技术会随机使几个神经单元失活（不起作用）。通过一下两个图片来明白其中的意思（参考链接2的作者提供了原图下载链接）：
在这里插入图片描述
图1：第二层启用随机节点删除
在每一次迭代中，删除一层的每个神经元的概率为 1 − k e e p _ p r o b 1 - keep\_prob 1−keep_prob，我们在这里保持概率为 k e e p _ p r o b keep\_prob keep_prob（这里为50％）。丢弃的节点都不参与迭代时的前向和后向传播。
在这里插入图片描述
图2：在第一层和第三层启用随机删除结点
1 s t 1^{st} 1st 平均40%节点被删除， 3 r d 3^{rd} 3rd 平均删除了20%的节点。
当随机删除一些结点时，实际上是修改了你的模型。随机失活的idea是在每一次迭代中，你训练一个使用神经元子集的不同模型。伴随着dropout，你的神经元会对另一个特定神经元激活变得不那么敏感 ，因为其他神经元可能会随时被关闭。

练习：完成forward_propagation_with_dropout()和backward_propagation_with_dropout()

练习1： 完成带有随机失活的前向传播函数，你将使用3层神经网络，并在第一、二层加入随机失活。我们将不会在输入层或输出层使用随机失活。
说明：你想要使得在第一、第二层的一些神经元失活。为了实现这一步，你需要跟着以下四个步骤来做：

  1. 在课程中，我们创造有着和 a [ 1 ] a^{[1]} a[1]相同维度的变量 d [ 1 ] d^{[1]} d[1]，并使用np.random.randn()来初始化获得0~1之间的随机数字。在这里，你将使用一个向量化的方法来创建有着与 A [ 1 ] A^{[1]} A[1]相同维度的随机矩阵 D [ 1 ] = [ d [ 1 ] ( 1 ) d [ 1 ] ( 2 ) . . . d [ 1 ] ( m ) ] D^{[1]}=[ d^{[1] (1)} d^{[1] (2)} ... d^{[1] (m)} ] D[1]=[d[1](1)d[1](2)...d[1](m)]。
  2. 通过适当设置阈值，将 D [ 1 ] D^{[1]} D[1]的每一条目时以概率 1 − k e e p _ p r o b 1 - keep\_prob 1−keep_prob设置为0，以概率 k e e p _ p r o b keep\_prob keep_prob设置为1。（即低于 k e e p _ p r o b keep\_prob keep_prob的值我们就将其设置为0，如果高于 k e e p _ p r o b keep\_prob keep_prob我们就将其设置为1）
    提示：要将矩阵X所有条目设置为0（如果条目小于0.5）或1（如果条目大于0.5），你可以执行以下操作：X = (X < 0.5)。注意，0和1等同于False和True
  3. 将 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。
  4. 使用 A [ 1 ] A^{[1]} A[1]除以 k e e p _ p r o b keep\_prob keep_prob。这样我们通过缩放就在计算成本时拥有相同的期望值，这叫做反向dropout。

完成以下函数：
我们指定随机种子np.random.seed(1)

def forward_propagation_with_dropout(X, parameters, keep_prob=0.5):
    """
    Implements the forward propagation: LINEAR -> RELU + DROPOUT -> LINEAR -> RELU + DROPOUT -> LINEAR -> SIGMOID.
    
    Arguments:
    X -- input dataset, of shape (2, number of examples)
    parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3":
                    W1 -- weight matrix of shape (20, 2)
                    b1 -- bias vector of shape (20, 1)
                    W2 -- weight matrix of shape (3, 20)
                    b2 -- bias vector of shape (3, 1)
                    W3 -- weight matrix of shape (1, 3)
                    b3 -- bias vector of shape (1, 1)
    keep_prob - probability of keeping a neuron active during drop-out, scalar
    
    Returns:
    A3 -- last activation value, output of the forward propagation, of shape (1,1)
    cache -- tuple, information stored for computing the backward propagation
    """

完成结果如下：

def forward_propagation_with_dropout(X, parameters, keep_prob=0.5):
    """
    Implements the forward propagation: LINEAR -> RELU + DROPOUT -> LINEAR -> RELU + DROPOUT -> LINEAR -> SIGMOID.

    Arguments:
    X -- input dataset, of shape (2, number of examples)
    parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3":
                    W1 -- weight matrix of shape (20, 2)
                    b1 -- bias vector of shape (20, 1)
                    W2 -- weight matrix of shape (3, 20)
                    b2 -- bias vector of shape (3, 1)
                    W3 -- weight matrix of shape (1, 3)
                    b3 -- bias vector of shape (1, 1)
    keep_prob - probability of keeping a neuron active during drop-out, scalar

    Returns:
    A3 -- last activation value, output of the forward propagation, of shape (1,1)
    cache -- tuple, information stored for computing the backward propagation
    """
    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 = relu(Z1)
    # Step1：创建有着与A^[1]相同维度的随机矩阵D^[1]
    D1 = np.random.rand(A1.shape[0], A1.shape[1])
    # Step2：将D^[1]的每一条目时以概率1−keep_prob设置为0，以概率keep_prob设置为1
    D1 = D1 < keep_prob
    # Step3：将A^[1]设置为A^[1] * D^[1]
    A1 = A1 * D1
    # Step4：使用A^[1]除以keep_prob
    A1 /= keep_prob

    # 第二层的写法和第一层是一样的
    Z2 = np.dot(W2, A1) + b2
    A2 = relu(Z2)
    D2 = np.random.rand(A2.shape[0], A2.shape[1])
    D2 = D2 < keep_prob
    A2 = A2 * D2
    A2 /= keep_prob

    # 第三层不用采取keep_prob的方法，所以就不用这么写了
    Z3 = np.dot(W3, A2) + b3
    A3 = sigmoid(Z3)

    cache = (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3)

    return A3, cache

练习2： 完成dropout的反向传播函数。在这之前，你需要训练三层神经网络。在第一、第二层隐藏层加上随机失活。将 D [ 1 ] D^{[1]} D[1]和 D [ 2 ] D^{[2]} D[2]存储于cache中。
说明： dropout的反向传播实际上非常简单，你只需要做下面这两步：

  1. 你在前向传播中通过A1*D1的方式关闭了一些神经元，在反向传播中，你需要通过D1 * dA1关闭同样的神经元
  2. 在前向传播中，你需要使用A1除以 k e e p _ p r o b keep\_prob keep_prob。因此在反向传播中，你需要再次使用dA1除以 k e e p _ p r o b keep\_prob keep_prob，然后它的导数dA1也会按照相同的比例进行缩放( k e e p _ p r o b keep\_prob keep_prob)

完成以下函数：

def backward_propagation_with_dropout(X, Y, cache, keep_prob):
    """
    Implements the backward propagation of our baseline model to which we added dropout.
    
    Arguments:
    X -- input dataset, of shape (2, number of examples)
    Y -- "true" labels vector, of shape (output size, number of examples)
    cache -- cache output from forward_propagation_with_dropout()
    keep_prob - probability of keeping a neuron active during drop-out, scalar
    
    Returns:
    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables
    """

完成结果如下：

def backward_propagation_with_dropout(X, Y, cache, keep_prob):
    """
    Implements the backward propagation of our baseline model to which we added dropout.

    Arguments:
    X -- input dataset, of shape (2, number of examples)
    Y -- "true" labels vector, of shape (output size, number of examples)
    cache -- cache output from forward_propagation_with_dropout()
    keep_prob - probability of keeping a neuron active during drop-out, scalar

    Returns:
    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables
    """
    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 /= 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 /= 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

查看损失函数变化

让我们以 k e e p _ p r o b = 0.86 keep\_prob=0.86 keep_prob=0.86来跑一下模型。这意味着在每一次迭代的过程中关闭1、2层神经元结点的概率为24%。在model()函数中，分别调用forward_propagation_with_dropout(...)和backward_propagation_with_dropout(...)

parameters = model(train_X, train_Y, keep_prob=0.86, learning_rate=0.3)

print("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)

结果如下：

Cost after iteration 0: 0.6543912405149825
H:\DeepLearning_wed\course2\week1\reg_utils.py:121: RuntimeWarning: divide by zero encountered in log
  logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)
H:\DeepLearning_wed\course2\week1\reg_utils.py:121: RuntimeWarning: invalid value encountered in multiply
  logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)
Cost after iteration 10000: 0.0610169865749056
Cost after iteration 20000: 0.060582435798513114
On the train set:
Accuracy: 0.9289099526066351
On the test set:
Accuracy: 0.95

在这里插入图片描述
Dropout的表现更好！在测试集上的准确度再次上升（达到了95%）。你的模型不再过度拟合训练集并在测试集上有了更好地表现。法国足球队将感激你！

查看划分的边界

您可以复制以下代码查看划分的边界：

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

在这里插入图片描述

笔记：

  • 使用dropout的一个常见错误是在训练集和测试集中都是用dropout。你应该只在训练过程中使用dropout。
  • 深度学习框架如 tensorflow, PaddlePaddle, keras或caffe都有dropout的实现。如果你不太明白也不要有太大压力，很快我们就将学习这些框架。

关于dropout我们需要记住的：

  • Dropout是一项正则化技术
  • 你只需要在训练中使用dropout，而不要在测试中使用dropout
  • 在前向传播和反向传播中都要使用dropout
  • 在训练过程中，在每一个使用dropout的层中除以 k e e p _ p r o b keep\_prob keep_prob以为激活保持相同的期望值。例如，如果 k e e p _ p r o b keep\_prob keep_prob为0.5，那么我们将要关闭一半的结点，因此，输出将被缩放0.5，因为只有剩下的一半对结果有帮助。除以0.5相当于乘以2。因此，输出现在具有相同的预期值。即使keep_prob不是0.5，您也可以检查它是否有效。

五、总结

这里有三个模型的比较：
在这里插入图片描述
注意，正规化会影响训练集的性能！这是因为它限制了网络过度适应训练集的能力。但是，由于它最终提供了更好的测试精度，它有助于完善您的神经网络。
祝贺你完成这项任务！：-）
我们从本篇文章中需要记住的：

  • 正则化将帮助减少过度拟合
  • 正则化将你的权重降到一个较低的值
  • L2正则化和Dropout是两个非常有影响力的正则化技术

六、源代码

import numpy as np
import matplotlib.pyplot as plt
from course2.week1.reg_utils import sigmoid, relu, plot_decision_boundary, initialize_parameters, load_2D_dataset, predict_dec
from course2.week1.reg_utils import compute_cost, predict, forward_propagation, backward_propagation, update_parameters
import sklearn
import sklearn.datasets
import scipy.io
from course2.week1.testCases import *

# plt.rcParams['figure.figsize'] = (7.0, 4.0) # set default size of plots
# plt.rcParams['image.interpolation'] = 'nearest'
# plt.rcParams['image.cmap'] = 'gray'

train_X, train_Y, test_X, test_Y = load_2D_dataset(is_plot=False)
# plt.show()


def model(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, lambd=0, keep_prob=1):
    """
    Implements a three-layer neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID.

    Arguments:
    X -- input data, of shape (input size, number of examples)
    Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (output size, number of examples)
    learning_rate -- learning rate of the optimization
    num_iterations -- number of iterations of the optimization loop
    print_cost -- If True, print the cost every 10000 iterations
    lambd -- regularization hyperparameter, scalar
    keep_prob - probability of keeping a neuron active during drop-out, scalar.

    Returns:
    parameters -- parameters learned by the model. They can then be used to predict.
    """

    grads = {}
    costs = []  # to keep track of the cost
    m = X.shape[1]  # number of examples
    layers_dims = [X.shape[0], 20, 3, 1]

    # Initialize parameters dictionary.
    parameters = initialize_parameters(layers_dims)

    # Loop (gradient descent)

    for i in range(0, num_iterations):

        # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID.
        if keep_prob == 1:
            a3, cache = forward_propagation(X, parameters)
        elif keep_prob < 1:
            a3, cache = forward_propagation_with_dropout(X, parameters, keep_prob)

        # Cost function
        if lambd == 0:
            cost = compute_cost(a3, Y)
        else:
            cost = compute_cost_with_regularization(a3, Y, parameters, lambd)

        # Backward propagation.
        assert (lambd == 0 or keep_prob == 1)  # it is possible to use both L2 regularization and dropout,
        # but this assignment will only explore one at a time
        if lambd == 0 and keep_prob == 1:
            grads = backward_propagation(X, Y, cache)
        elif lambd != 0:
            grads = backward_propagation_with_regularization(X, Y, cache, lambd)
        elif keep_prob < 1:
            grads = backward_propagation_with_dropout(X, Y, cache, keep_prob)

        # Update parameters.
        parameters = update_parameters(parameters, grads, learning_rate)

        # Print the loss every 10000 iterations
        if print_cost and i % 10000 == 0:
            print("Cost after iteration {}: {}".format(i, cost))
        if print_cost and i % 1000 == 0:
            costs.append(cost)

    # plot the cost
    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('iterations (x1,000)')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()

    return parameters


def compute_cost_with_regularization(A3, Y, parameters, lambd):
    """
    Implement the cost function with L2 regularization. See formula (2) above.

    Arguments:
    A3 -- post-activation, output of forward propagation, of shape (output size, number of examples)
    Y -- "true" labels vector, of shape (output size, number of examples)
    parameters -- python dictionary containing parameters of the model

    Returns:
    cost - value of the regularized loss function (formula (2))
    """
    m = Y.shape[1]
    W1 = parameters["W1"]
    W2 = parameters["W2"]
    W3 = parameters["W3"]

    cross_entropy_cost = 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):
    """
    Implements the backward propagation of our baseline model to which we added an L2 regularization.

    Arguments:
    X -- input dataset, of shape (input size, number of examples)
    Y -- "true" labels vector, of shape (output size, number of examples)
    cache -- cache output from forward_propagation()
    lambd -- regularization hyperparameter, scalar

    Returns:
    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables
    """
    m = X.shape[1]
    (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3) = cache

    # 反向传播，如果对这一部分没有印象了可以再去看看course1的week3的课/笔记
    # 这里前向传播最后一步使用sigmoid函数。在此处，我们便是取sigmoid的导数
    # 用链式求导法则计算导数
    # 用吴恩达课上的表示法便如下： "dA3"代表dL(A3,Y)/dA3 ， “dZ3”代表dL(A,Y)/dZ3
    # "dA3" = dL(A3,Y)/dA3 = -(A3/Y) + (1-Y)/(1-A3)
    # "dZ3" = dL(A3,Y)/dA3 * dA3/dZ3 = dL(A3,Y)/dA3 * A3(1-A3) = A3 - Y
    dZ3 = A3 - Y
    # 正向传播时，Z3 = np.dot(W3, A2) + b3
    # "dW3" = dL(A3,Y)/dW3 = "dZ3" * dZ3/dW3 = "dZ3" * A2
    # 给我们的提示里说到（提示是已经为我们计算好了导数），每一项dW需要加上正则化梯度，所以我们就将提示中给出的lambda * W / m加上即可

    dW3 = (lambd * W3) / m + 1. / m * np.dot(dZ3, A2.T)
    db3 = 1. / m * np.sum(dZ3, axis=1, keepdims=True)

    # 以下同理
    # 根据链式求导法则，"dA2" = "dZ3" * dZ3/dA2
    # 在正向传播时，有：Z3 = np.dot(W3, A2) + b3
    # 由正向传播的公式，我们就可以知道dZ3/dA2 = W3
    # 从而，“dA2” = “dZ3" * W3
    dA2 = np.dot(W3.T, dZ3)
    # 在正向传播时，有A2 = relu(Z2)
    # "dZ2" = "dA2" * dA2/dZ2 = "dA2" * np,int64(g(z) > 0); 括号内是一个逻辑表达式，解释如下：
    # relu函数我们都知道是g(z) = max(0,z); 而relu函数的导数情况如下：if z<0,g'(z)=0; elif z>0,g'(z)=1; elif z=0,g'(z)=undefined(或者你可以自己定义为0/1)
    # 那么我们可以知道，relu函数的导数可以通过一个逻辑表达式“g(z) > 0”来进行判断;若g(z)>0，则结果为1。又因为g(z)=max(0,z)，我们可以知道z一定是>0的，所以g'(z)=1。
    # 通过上面一句话的推导，我们可以使用"g(z) > 0"来进行relu函数的求导
    # np.int64(a): 将a的值转换成整数
    dZ2 = np.multiply(dA2, np.int64(A2 > 0))
    dW2 = (lambd * W2) / m + 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 = (lambd * W1) / m + 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 forward_propagation_with_dropout(X, parameters, keep_prob=0.5):
    """
    Implements the forward propagation: LINEAR -> RELU + DROPOUT -> LINEAR -> RELU + DROPOUT -> LINEAR -> SIGMOID.

    Arguments:
    X -- input dataset, of shape (2, number of examples)
    parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3":
                    W1 -- weight matrix of shape (20, 2)
                    b1 -- bias vector of shape (20, 1)
                    W2 -- weight matrix of shape (3, 20)
                    b2 -- bias vector of shape (3, 1)
                    W3 -- weight matrix of shape (1, 3)
                    b3 -- bias vector of shape (1, 1)
    keep_prob - probability of keeping a neuron active during drop-out, scalar

    Returns:
    A3 -- last activation value, output of the forward propagation, of shape (1,1)
    cache -- tuple, information stored for computing the backward propagation
    """
    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 = relu(Z1)
    # Step1：创建有着与A^[1]相同维度的随机矩阵D^[1]
    D1 = np.random.rand(A1.shape[0], A1.shape[1])
    # Step2：将D^[1]的每一条目时以概率1−keep_prob设置为0，以概率keep_prob设置为1
    D1 = D1 < keep_prob
    # Step3：将A^[1]设置为A^[1] * D^[1]
    A1 = A1 * D1
    # Step4：使用A^[1]除以keep_prob
    A1 /= keep_prob

    # 第二层的写法和第一层是一样的
    Z2 = np.dot(W2, A1) + b2
    A2 = relu(Z2)
    D2 = np.random.rand(A2.shape[0], A2.shape[1])
    D2 = D2 < keep_prob
    A2 = A2 * D2
    A2 /= keep_prob

    # 第三层不用采取keep_prob的方法，所以就不用这么写了
    Z3 = np.dot(W3, A2) + b3
    A3 = 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):
    """
    Implements the backward propagation of our baseline model to which we added dropout.

    Arguments:
    X -- input dataset, of shape (2, number of examples)
    Y -- "true" labels vector, of shape (output size, number of examples)
    cache -- cache output from forward_propagation_with_dropout()
    keep_prob - probability of keeping a neuron active during drop-out, scalar

    Returns:
    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables
    """
    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 /= 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 /= 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


# # Model without regularization 训练及预测
# parameters = model(train_X, train_Y)
# print("On the training set:")
# predictions_train = predict(train_X, train_Y, parameters)
# print("On the test set:")
# predictions_test = predict(test_X, test_Y, parameters)
# # Model without regularization 绘图
# plt.title("Model without regularization")
# axes = plt.gca()
# axes.set_xlim([-0.75, 0.40])
# axes.set_ylim([-0.75, 0.65])
# plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)


# # Model with L2-regularization训练及预测
# parameters = model(train_X, train_Y, lambd=0.7)
# print("On the train set:")
# predictions_train = predict(train_X, train_Y, parameters)
# print("On the test set:")
# predictions_test = predict(test_X, test_Y, parameters)
# # Model with L2-regularization绘图
# plt.title("Model with L2-regularization")
# axes = plt.gca()
# axes.set_xlim([-0.75,0.40])
# axes.set_ylim([-0.75,0.65])
# plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)

# Model with dropout训练及预测
parameters = model(train_X, train_Y, keep_prob=0.86, learning_rate=0.3)
print("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
# Model with dropout绘图
plt.title("Model with dropout")
axes = plt.gca()
axes.set_xlim([-0.75, 0.40])
axes.set_ylim([-0.75, 0.65])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)
passer__jw767
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Deep AI 吴恩达深度学习课后检验题-02.改善深层神经网络：超参数调试、正则化以及优化
05-04
Deep AI 吴恩达深度学习课后检验题-02.改善深层神经网络：超参数调试、正则化以及优化
图像处理用什么神经网络,神经网络输入图片大小
aifamao3的博客
10-05 1352
卷积神经网络有以下几种应用可供研究： 1、基于卷积网络的形状识别 物体的形状是人的视觉系统分析和识别物体的基础，几何形状是物体的本质特征的表现，并具有平移、缩放和旋转不变等特点，所以在模式识别领域，对于形状的分析和识别具有十分重要的意义，而二维图像作为三维图像的特例以及组成部分，因此二维图像的识别是三维图像识别的基础。然而，这些特征的提取太过依赖人的经验和主观意识，提取到的特征的不同对分类性能影响很大，甚至提取的特征的顺序也会影响最后的分类性能。同时，图像预处理的好坏也会影响到提取的特征。
吴恩达深度学习随笔之正则化，归一化
Androidhh的博客
09-04 339
吴恩达机器学习随笔之正则化，归一化 正则化：预防过拟合，对参数w做范式处理，使得矩阵W变得稀疏，就是将数据随机的忽略一部分，将会导致过拟合的数据，随机的消除一部分。有dropout正则化。 归一化：统一输入数据特征的方差，代价函数更加的对称，使得梯度下降寻找最小值变得更加的简单。 解决梯度消失或梯度下降的方法：选择更适合的初始化参数w,b。 ...
1.8 其他正则化方法-深度学习第二课《改善深层神经网络》-Stanford吴恩达教授
赵继超的笔记
04-08 2846
其他正则化方法 (Other Regularization Methods) 除了 L2L2L2 正则化和随机失活（dropout）正则化，还有几种方法可以减少神经网络中的过拟合: 一.数据扩增 假设你正在拟合猫咪图片分类器，如果你想通过扩增训练数据来解决过拟合，但扩增数据代价高，而且有时候我们无法扩增数据，但我们可以通过添加这类图片来增加训练集。例如，水平翻转图片，并把它添加到训练集。所以现在...
吴恩达深度学习与神经网络课程作业 - 02.改善深层神经网络：超参数调试、正则化以及优化
07-21
吴恩达深度学习与神经网络第二课的课程作业要求
吴恩达改善深层神经网络：超参数调试、正则化以及优化作业
07-17
吴恩达改善深层神经网络：超参数调试、正则化以及优化作业,5-7周全
深度学习吴恩达课程笔记(二)-浅层神经网络、深层神经网络
10-25
【深度学习】吴恩达课程笔记(二)——浅层神经网络、深层神经网络笔记
【深度学习-吴恩达】L2-3 超参数调试 作业 TensorFlow教程
08-04
包括datasets文件夹、tf_utils.py、improv_utils.py、作业L2-3以及自己的图片finger5.py
深度学习之基于YoloV5+LPRNet车牌识别系统
2301_79809972的博客
05-18 929
一、项目背景与意义在智能交通管理系统中，车牌识别技术是一项至关重要的技术。随着车辆数量的不断增长和交通环境的日益复杂，对车牌进行准确、快速的识别已成为现代交通管理不可或缺的一部分。为了满足这一需求，本项目采用了先进的YOLOv5和LPRNet算法，结合深度学习技术，开发了一套高效的车牌识别系统。二、技术原理该系统基于深度学习和目标检测技术，整合了YOLOv5目标检测框架和LPRNet文本识别模型。YOLOv5算法在目标检测领域具有出色的性能，能够快速、准确地检测图像中的目标；
深入解析自注意力机制（Self-Attention）：深度学习中的关键创新
qlkaicx的博客
05-17 1071
这一技术已经彻底改变了自然语言处理（NLP）等领域的模型架构，特别是在Transformer模型的推动下，自注意力机制成为了近年来深度学习研究的热点之一。本篇博客将详细介绍自注意力机制的起源、工作原理、数学表达和在现代深度学习中的应用。自注意力的提出标志着注意力机制的一个重大转变，即注意力也可以有效地应用于序列内部的元素之间，从而直接捕捉序列内的依赖关系。即元素 ( i ) 对元素 ( j ) 的注意力权重是 ( i ) 的查询向量与 ( j ) 的键向量的点积，通过softmax归一化后得到。
深度学习之激活函数——ReLU
m0_61787307的博客
05-14 702
整流线性单元(ReLU)，全称Rectified linear unit，是现代神经网络中最常用的激活函数，大多数前馈神经网络都默认使用该激活函数。
Pytorch学习笔记——Conv2d与Tensorboard的结合使用
weixin_50765519的博客
05-14 276
Conv2d是深度学习框架中用于执行二维卷积操作的函数或类。它接受输入数据(通常是图像)和卷积核作为参数，输出卷积特征图。这些特征图可以进一步用于分类、检测或其他计算机视觉任务。TensorBoard是一个强大的可视化工具，用于展示深度学习模型的各个方面。它可以展示模型的网络结构、参数分布、训练曲线以及图像、音频等媒体数据。通过使用TensorBoard，能够让研究人员和开发者可以更好地理解和调试模型，从而提高模型的性能和效果。
CNN的具体架构VGG
最新发布
weixin_57128596的博客
05-18 900
对于给定的感受野（与输出有关的输入图片的局部大小），采用堆积的小卷积核是优于采用大的卷积核，因为多层非线性层可以增加网络深度来保证学习更复杂的模式，而且代价还比较小（参数更少）。随着更多层的叠加，通过前一层提取的特征可以结合成更复杂的模式，如物体的部分和结构。使用三个3x3的卷积核代替一个7x7的卷积核可以显著减少参数的数量，一个7x7的卷积核包含49个参数，但是一个3x3的卷积核包含9个参数，三个则是27个参数，所以，通过使用三个3x3的卷积核，你减少了参数数量（49 vs 27），这意味着模型的。
基于transformers框架实践Bert系列2--命名实体识别
代码还是得自己扣
05-17 769
本系列用于Bert模型实践实际场景，分别包括分类器、命名实体识别、机器阅读、多选选择、文本摘要等等。（关于Bert的结构和详细这里就不做讲解，但了解Bert的基本结构是做实践的基础，因此看本系列之前，最好了解一下transformers和Bert等）本篇主要讲解命名实体识别应用场景。
深度学习之基于YoloV5钢材表面缺陷检测
2301_79810943的博客
05-18 966
一、项目背景与意义在钢铁生产过程中，钢材表面的缺陷检测是一个至关重要的环节。传统的检测方法往往依赖于人工视觉检测，这种方法不仅效率低下，而且容易受到人为因素的影响，导致检测结果的准确性和稳定性难以保证。随着深度学习技术的快速发展，基于深度学习的目标检测算法在图像识别领域取得了显著成果。其中，YoloV5（You Only Look Once version 5）作为一种高效且准确的目标检测算法，被广泛应用于各种实际场景中。
深度学习打卡实战第p7周咖啡豆识别
m0_55259388的博客
05-17 228
在训练模型时候，优化器选择adam，效果正常，测试集准确率可达99，而选用sgd时候，发现准确率恒定不变在22，查看了初始学习率为0.0001，修正为0.01，再次训练，效果较好。再次调回0.0001，不再固定，可能一开始陷入局部最优。整体训练效果较好，第一步使用pathlib查看类别名称验证能否与实际对应，使用imagefolder创建数据集,定义数据处理方式，然后可以.class查看分类，对数据集进行4：1划分，创建dataloder，到这里 数据集才算处理完成。
深度学习之基于YoloV7+OpenPose姿态识别系统
qq1744828575的博客
05-17 910
一、系统背景随着深度学习技术的快速发展，其在计算机视觉领域的应用也日益广泛。姿态识别作为计算机视觉的一个重要分支，对于人机交互、运动分析、动作捕捉、虚拟现实等领域具有重要意义。YOLOv7和OpenPose作为两种先进的深度学习算法，分别在目标检测和人体姿态估计方面表现出色。因此，结合YOLOv7和OpenPose的优势，构建基于YOLOv7+OpenPose的姿态识别系统，具有广阔的应用前景。二、系统组成。
双向长短期记忆网络（BiLSTM）简介
yiqiedouhao11的博客
05-17 494
双向长短期记忆网络（Bidirectional Long Short-Term Memory, BiLSTM）是一种改进的循环神经网络（Recurrent Neural Network, RNN），专门设计用于处理序列数据。BiLSTM 能够通过结合前向和后向两个 LSTM 网络的输出来捕捉序列中的双向依赖关系。
深度学习系列68：声音克隆项目OpenVoice
kittyzc的博客
05-14 341
OpenVoice 是 myshell ai 开源的一款基于人工智能技术的语音克隆工具。其核心功能是通过提供发言者的短音频片段（参考语音），实现声音的高效克隆。这意味着您可以使用OpenVoice来克隆任何人的声音，而且不限于特定语言。无论您是想要模仿某位名人的声音，还是需要在不同语言之间进行语音转换，OpenVoice都能够满足您的需求。OpenVoice还可以实现音色克隆和控制。
吴恩达-深度学习-改善深层神经网络
04-04
吴恩达在改善深层神经网络方面提出了多种方法，包括： 1. 激活函数：使用ReLU（Rectified Linear Unit）代替传统的sigmoid函数，可以加速训练过程并提高准确率。 2. 正则化：使用L1或L2正则化，可以防止过拟合，提高泛化能力。 3. 批量归一化：对每个批次的数据进行归一化处理，可以加速训练过程，提高准确率。 4. 参数初始化：合理的参数初始化可以避免梯度消失或爆炸的问题，提高训练效率。 5. 梯度裁剪：限制梯度的大小，可以避免梯度爆炸的问题。 6. Dropout：在训练过程中随机丢弃一部分神经元，可以防止过拟合。 7. 数据增强：通过对数据集进行旋转、平移、缩放等操作，可以增加数据量，提高模型的泛化能力。 这些方法可以单独或组合使用，根据具体情况选择适当的方法来改善深层神经网络。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值