吴恩达深度学习作业_吴恩达深度学习笔记02W1 作业 初始化+正则化+梯度检验

最新推荐文章于 2024-03-06 02:25:04 发布
最新推荐文章于 2024-03-06 02:25:04 发布
阅读量320 收藏
点赞数
文章标签： 吴恩达深度学习作业 吴恩达深度学习编程作业 吴恩达深度学习课后作业

  • 作业1：初始化

    • 1. 神经网络模型

    • 2. 使用 0 初始化

    • 3. 随机初始化

    • 4. He 初始化

  • 作业2：正则化

    • 1. 无正则化模型

    • 2. L2 正则化

    • 3. DropOut 正则化

  • 作业3：梯度检验

    • 3.1 1维梯度检验

    • 3.2 多维梯度检验

测试题：参考博文

笔记：02.改善深层神经网络：超参数调试、正则化以及优化 W1.深度学习的实践层面

作业1：初始化

好的初始化：

  • 加快梯度下降的收敛速度
  • 增加梯度下降收敛到较低的训练(和泛化)误差的几率

导入数据

import numpy as np
import matplotlib.pyplot as plt
import sklearn
import sklearn.datasets
from init_utils import sigmoid, relu, compute_loss, forward_propagation, backward_propagation
from init_utils import update_parameters, predict, load_dataset, plot_decision_boundary, predict_dec

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

# load image dataset: blue/red dots in circles
train_X, train_Y, test_X, test_Y = load_dataset()

0d5d893d1dc5b35fe650570183cafe2e.png我们的任务是：将两类点分类

1. 神经网络模型

用一个已经实现好了的 3层神经网络

def model(X, Y, learning_rate = 0.01, num_iterations = 15000, print_cost = True, initialization = "he"):
    """
    Implements a three-layer neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID.
    Arguments:
    X -- input data, of shape (2, number of examples)
    Y -- true "label" vector (containing 0 for red dots; 1 for blue dots), of shape (1, number of examples)
    learning_rate -- learning rate for gradient descent 
    num_iterations -- number of iterations to run gradient descent
    print_cost -- if True, print the cost every 1000 iterations
    initialization -- flag to choose which initialization to use ("zeros","random" or "he")
    Returns:
    parameters -- parameters learnt by the model
    """
        
    grads = {}
    costs = [] # to keep track of the loss
    m = X.shape[1] # number of examples
    layers_dims = [X.shape[0], 10, 5, 1]
    
    # Initialize parameters dictionary.
    if initialization == "zeros":
        parameters = initialize_parameters_zeros(layers_dims)
    elif initialization == "random":
        parameters = initialize_parameters_random(layers_dims)
    elif initialization == "he":
        parameters = initialize_parameters_he(layers_dims)

    # Loop (gradient descent)

    for i in range(0, num_iterations):

        # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID.
        a3, cache = forward_propagation(X, parameters)
        
        # Loss
        cost = compute_loss(a3, Y)

        # Backward propagation.
        grads = backward_propagation(X, Y, cache)
        
        # Update parameters.
        parameters = update_parameters(parameters, grads, learning_rate)
        
        # Print the loss every 1000 iterations
        if print_cost and i % 1000 == 0:
            print("Cost after iteration {}: {}".format(i, cost))
            costs.append(cost)
            
    # plot the loss
    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('iterations (per hundreds)')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()
    
    return parameters

2. 使用 0 初始化

# GRADED FUNCTION: initialize_parameters_zeros 

def initialize_parameters_zeros(layers_dims):
    """
    Arguments:
    layer_dims -- python array (list) containing the size of each layer.
    Returns:
    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                    W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
                    b1 -- bias vector of shape (layers_dims[1], 1)
                    ...
                    WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
                    bL -- bias vector of shape (layers_dims[L], 1)
    """
    
    parameters = {}
    L = len(layers_dims)            # number of layers in the network
    
    for l in range(1, L):
        ### START CODE HERE ### (≈ 2 lines of code)
        parameters['W' + str(l)] = np.zeros((layers_dims[l], layers_dims[l-1]))
        parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))
        ### END CODE HERE ###
    return parameters

运行以下代码训练：

parameters = model(train_X, train_Y, initialization = "zeros")
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.6931471805599453
Cost after iteration 1000: 0.6931471805599453
Cost after iteration 2000: 0.6931471805599453
Cost after iteration 3000: 0.6931471805599453
Cost after iteration 4000: 0.6931471805599453
Cost after iteration 5000: 0.6931471805599453
Cost after iteration 6000: 0.6931471805599453
Cost after iteration 7000: 0.6931471805599453
Cost after iteration 8000: 0.6931471805599453
Cost after iteration 9000: 0.6931471805599453
Cost after iteration 10000: 0.6931471805599455
Cost after iteration 11000: 0.6931471805599453
Cost after iteration 12000: 0.6931471805599453
Cost after iteration 13000: 0.6931471805599453
Cost after iteration 14000: 0.6931471805599453
ad9f4f75a14e3ea2741154a2876e4ac9.png
在这里插入图片描述 
On the train set:
Accuracy: 0.5
On the test set:
Accuracy: 0.5
  • 效果很差，代价函数几乎没有下降
print ("predictions_train = " + str(predictions_train))
print ("predictions_test = " + str(predictions_test))

预测全部都是 0

predictions_train = [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0]]
predictions_test = [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]
plt.title("Model with Zeros initialization")
axes = plt.gca()
axes.set_xlim([-1.5,1.5])
axes.set_ylim([-1.5,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)

c719c0adc0d719a219c3a2535d96f468.png结论：

  • 神经网络中，不要把参数初始化为0，否则模型不能打破这种状态，一直学习同样的东西。
  • 可以将权重随机初始化，偏置初始化为0

3. 随机初始化

  • np.random.randn(layers_dims[l], layers_dims[l-1])*10，* 10 使用很大的随机数初始化权重
# GRADED FUNCTION: initialize_parameters_random

def initialize_parameters_random(layers_dims):
    """
    Arguments:
    layer_dims -- python array (list) containing the size of each layer.
    Returns:
    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                    W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
                    b1 -- bias vector of shape (layers_dims[1], 1)
                    ...
                    WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
                    bL -- bias vector of shape (layers_dims[L], 1)
    """
    
    np.random.seed(3)               # This seed makes sure your "random" numbers will be the as ours
    parameters = {}
    L = len(layers_dims)            # integer representing the number of layers
    
    for l in range(1, L):
        ### START CODE HERE ### (≈ 2 lines of code)
        parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1])*10
        parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))
        ### END CODE HERE ###

    return parameters

运行以下代码训练：

parameters = model(train_X, train_Y, initialization = "random")
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: inf
Cost after iteration 1000: 0.6239567039908781
Cost after iteration 2000: 0.5978043872838292
Cost after iteration 3000: 0.563595830364618
Cost after iteration 4000: 0.5500816882570866
Cost after iteration 5000: 0.5443417928662615
Cost after iteration 6000: 0.5373553777823036
Cost after iteration 7000: 0.4700141958024487
Cost after iteration 8000: 0.3976617665785177
Cost after iteration 9000: 0.39344405717719166
Cost after iteration 10000: 0.39201765232720626
Cost after iteration 11000: 0.38910685278803786
Cost after iteration 12000: 0.38612995897697244
Cost after iteration 13000: 0.3849735792031832
Cost after iteration 14000: 0.38275100578285265
8f2bf4f1aa168ca54a10169cf899d767.png
在这里插入图片描述 
On the train set:
Accuracy: 0.83
On the test set:
Accuracy: 0.86

决策边界

plt.title("Model with large random initialization")
axes = plt.gca()
axes.set_xlim([-1.5,1.5])
axes.set_ylim([-1.5,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)

bd1916d6d70e17907b12e77dce63b7ef.png将* 10 改为 * 1：

Cost after iteration 0: 1.9698193182646349
Cost after iteration 1000: 0.6894749458317239
Cost after iteration 2000: 0.675058063210226
Cost after iteration 3000: 0.6469210868251528
Cost after iteration 4000: 0.5398790761260324
Cost after iteration 5000: 0.4062642269764849
Cost after iteration 6000: 0.29844708868759456
Cost after iteration 7000: 0.22183734662094845
Cost after iteration 8000: 0.16926424179038072
Cost after iteration 9000: 0.1341330896982709
Cost after iteration 10000: 0.10873865543082417
Cost after iteration 11000: 0.09169443068126971
Cost after iteration 12000: 0.07991173603998084
Cost after iteration 13000: 0.07083949901112582
Cost after iteration 14000: 0.06370209022580517
On the train set:
Accuracy: 0.9966666666666667
On the test set:
Accuracy: 0.96

2bd135492b9ea1cd0e90f55ddae525f8.png将* 10 改为 * 0.1：

Cost after iteration 0: 0.6933234320329613
Cost after iteration 1000: 0.6932871248121155
Cost after iteration 2000: 0.6932558729405607
Cost after iteration 3000: 0.6932263488895136
Cost after iteration 4000: 0.6931989886931527
Cost after iteration 5000: 0.6931076575962486
Cost after iteration 6000: 0.6930655602542224
Cost after iteration 7000: 0.6930202936477311
Cost after iteration 8000: 0.6929722630100763
Cost after iteration 9000: 0.6929185743666864
Cost after iteration 10000: 0.6928576152283971
Cost after iteration 11000: 0.6927869030178897
Cost after iteration 12000: 0.6927029749978133
Cost after iteration 13000: 0.6926024266332704
Cost after iteration 14000: 0.6924787835871681
On the train set:
Accuracy: 0.6
On the test set:
Accuracy: 0.57
b213a2cc7c9532ca5d4be67063d0c88e.png
在这里插入图片描述
  • 使用合适的初始化权重非常重要！！！
  • 不好的初始化会造成梯度消失/爆炸，降低了学习速度

4. He 初始化

是以一个人的名字命名的。

  • 如果使用ReLu激活函数(最常用)，
  • 如果使用tanh激活函数，，或者
# GRADED FUNCTION: initialize_parameters_he

def initialize_parameters_he(layers_dims):
    """
    Arguments:
    layer_dims -- python array (list) containing the size of each layer.
    Returns:
    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                    W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
                    b1 -- bias vector of shape (layers_dims[1], 1)
                    ...
                    WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
                    bL -- bias vector of shape (layers_dims[L], 1)
    """
    
    np.random.seed(3)
    parameters = {}
    L = len(layers_dims) - 1 # integer representing the number of layers
     
    for l in range(1, L + 1):
        ### START CODE HERE ### (≈ 2 lines of code)
        parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1])*np.sqrt(2/layers_dims[l-1])
        parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))
        ### END CODE HERE ###
        
    return parameters
parameters = model(train_X, train_Y, initialization = "he")
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.8830537463419761
Cost after iteration 1000: 0.6879825919728063
Cost after iteration 2000: 0.6751286264523371
Cost after iteration 3000: 0.6526117768893807
Cost after iteration 4000: 0.6082958970572938
Cost after iteration 5000: 0.5304944491717495
Cost after iteration 6000: 0.4138645817071794
Cost after iteration 7000: 0.3117803464844441
Cost after iteration 8000: 0.23696215330322562
Cost after iteration 9000: 0.18597287209206836
Cost after iteration 10000: 0.15015556280371817
Cost after iteration 11000: 0.12325079292273552
Cost after iteration 12000: 0.09917746546525932
Cost after iteration 13000: 0.08457055954024274
Cost after iteration 14000: 0.07357895962677362
337188cba27a26b86a4e7aa9a4285a96.png
在这里插入图片描述 
On the train set:
Accuracy: 0.9933333333333333
On the test set:
Accuracy: 0.96
plt.title("Model with He initialization")
axes = plt.gca()
axes.set_xlim([-1.5,1.5])
axes.set_ylim([-1.5,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)
1c287c77d358852960697e58d9a1e30f.png
在这里插入图片描述
模型训练准确率问题
3-layer NN with 「zeros」 initialization50%fails to break symmetry
3-layer NN with 「large random」 initialization83%too large weights
3-layer NN with 「He」 initialization99%recommended method

作业2：正则化

过拟合是个严重的问题，它表现为在训练集上表现的很好，但是泛化性能较差

# 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 *

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

问题引入：

法国足球守门员发球，把球踢到什么位置，他的队友可以用头顶球。e0ac2e7753f2f8a99d3ef08597ded993.png

train_X, train_Y, test_X, test_Y = load_2D_dataset()

e1dda0aede74ba4c8426446aac976f0e.png法国守门员从左侧发球，蓝色是自己队友顶球位置，红色是对方顶球位置

肉眼看，好像可以用一条45°左右的斜线分开

1. 无正则化模型

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.13851642423245572
f52a134a7d330d21f91d98e315dd6a72.png
在这里插入图片描述 
On the training set:
Accuracy: 0.9478672985781991
On the test set:
Accuracy: 0.915
5ff747ff4ca85b66b08be5258310b3d9.png
决策边界
  • 没有正则化的模型「过拟合」了，它拟合了一些噪声点

2. L2 正则化

  • 注意在损失函数里「加入正则化项」

无正则项的损失函数：

加入正则化项的损失函数：

>>> w1 = np.array([[1,2],[2,3]])    
>>> w1   
array([[1, 2],
       [2, 3]])
>>> np.sum(np.square(w1))    
18
# GRADED FUNCTION: compute_cost_with_regularization

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) # This gives you the cross-entropy part of the cost
    
    ### START CODE HERE ### (approx. 1 line)
    L2_regularization_cost = lambd/(2*m)*(np.sum(np.square(W1)) + np.sum(np.square(W2)) + np.sum(np.square(W3)))
    ### END CODER HERE ###
    
    cost = cross_entropy_cost + L2_regularization_cost
    
    return cost
  • 反向传播，计算梯度时也要根据 新的损失函数 dw 需要加入 项
# GRADED FUNCTION: backward_propagation_with_regularization

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
    
    dZ3 = A3 - Y
    
    ### START CODE HERE ### (approx. 1 line)
    dW3 = 1./m * np.dot(dZ3, A2.T) + lambd/m*W3
    ### END CODE HERE ###
    db3 = 1./m * np.sum(dZ3, axis=1, keepdims = True)
    
    dA2 = np.dot(W3.T, dZ3)
    dZ2 = np.multiply(dA2, np.int64(A2 > 0))
    ### START CODE HERE ### (approx. 1 line)
    dW2 = 1./m * np.dot(dZ2, A1.T) + lambd/m*W2
    ### END CODE HERE ###
    db2 = 1./m * np.sum(dZ2, axis=1, keepdims = True)
    
    dA1 = np.dot(W2.T, dZ2)
    dZ1 = np.multiply(dA1, np.int64(A1 > 0))
    ### START CODE HERE ### (approx. 1 line)
    dW1 = 1./m * np.dot(dZ1, X.T) + lambd/m*W1
    ### END CODE HERE ###
    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 正则化( = 0.7)的模型(使用上面两个函数计算损失、梯度)
Cost after iteration 0: 0.6974484493131264
Cost after iteration 10000: 0.26849188732822393
Cost after iteration 20000: 0.2680916337127301
8b3657d16719defa50b0817c7815dae9.png
在这里插入图片描述 
On the train set:
Accuracy: 0.9383886255924171
On the test set:
Accuracy: 0.93

模型「没有过拟合」79823b5c50b17412632a9758876fd04f.pngL2 正则化使得 权重衰减，其基于假设：小的权重 W 的模型更简单，所以模型会惩罚 大的 W，小的权重 使得输出变化比较平和，不会剧烈变化 形成复杂的边界(造成过拟合)

调整 做点对比：083deb074ccbac9f1039b89f142650b2.png

On the train set:
Accuracy: 0.919431279620853
On the test set:
Accuracy: 0.945
On the train set:
Accuracy: 0.9383886255924171
On the test set:
Accuracy: 0.95
badb7366ff701cf81ff704c479f1ea56.png
在这里插入图片描述

(正则化作用很弱)

On the train set:
Accuracy: 0.9289099526066351
On the test set:
Accuracy: 0.915

(有点过拟合)bbd0d2fe05c3fa08a39cbc6d43c90978.png

On the train set:
Accuracy: 0.9241706161137441
On the test set:
Accuracy: 0.93

5d12ffb10dbeb0202a52842145c80b10.png

On the train set:
Accuracy: 0.919431279620853
On the test set:
Accuracy: 0.92
a0ae9fe8c40f6b5c11658a47a5ed498e.png
在这里插入图片描述
  • 太大，正则化太强，W 被压缩的很小，决策边界过度平滑(都直线了)，造成高的偏差

3. DropOut 正则化

83d60277602b3d5f392b8d00d92c36a6.gifDropOut 正则化 在每次迭代的时候 「随机」关闭一些神经元 被关闭的神经元在当次迭代时，对前向和后向传播都没有贡献

drop-out背后的思想是，每次迭代时，使用部分神经元子集的不同模型，神经元对另一个特定神经元的激活变得不那么敏感，因为另一个神经元随时可能被关闭

3.1 带dropout的前向传播

对一个3层神经网络实施 dropout，只对第1，2层进行，不包括输入和输出层

  • 用 np.random.rand() 建立与   一样维度的
  • 以一定的概率，设置 元素为0(概率 1-keep_prob), 1(概率 keep_prob)X = (X < keep_prob)
  • 关闭某些神经元，
  • ，此步确保损失函数的期望值与 没有dropout 时一样(「inverted dropout」)
# GRADED FUNCTION: forward_propagation_with_dropout

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)
    
    # retrieve parameters
    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 = relu(Z1)
    ### START CODE HERE ### (approx. 4 lines)         # Steps 1-4 below correspond to the Steps 1-4 described above. 
    D1 = np.random.rand(A1.shape[0], A1.shape[1])   # Step 1: initialize matrix D1 = np.random.rand(..., ...)
    D1 = D1 # Step 2: convert entries of D1 to 0 or 1 (using keep_prob as the threshold)
    A1 = A1*D1                                      # Step 3: shut down some neurons of A1
    A1 = A1/keep_prob                               # Step 4: scale the value of neurons that haven't been shut down
    ### END CODE HERE ###
    Z2 = np.dot(W2, A1) + b2
    A2 = relu(Z2)
    ### START CODE HERE ### (approx. 4 lines)
    D2 = np.random.rand(A2.shape[0], A2.shape[1])  # Step 1: initialize matrix D2 = np.random.rand(..., ...)
    D2 = D2 # Step 2: convert entries of D2 to 0 or 1 (using keep_prob as the threshold)
    A2 = A2*D2                                    # Step 3: shut down some neurons of A2
    A2 = A2/keep_prob                             # Step 4: scale the value of neurons that haven't been shut down
    ### END CODE HERE ###
    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
3.2 带dropout的后向传播

上面我们用 把神经元关闭了

  • 使用相同的 关闭
  • ，导数跟上面保持一致的系数
# GRADED FUNCTION: backward_propagation_with_dropout

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)
    ### START CODE HERE ### (≈ 2 lines of code)
    dA2 = dA2 * D2        # Step 1: Apply mask D2 to shut down the same neurons as during the forward propagation
    dA2 = dA2/keep_prob   # Step 2: Scale the value of neurons that haven't been shut down
    ### END CODE HERE ###
    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)
    ### START CODE HERE ### (≈ 2 lines of code)
    dA1 = dA1 * D1        # Step 1: Apply mask D1 to shut down the same neurons as during the forward propagation
    dA1 = dA1/keep_prob   # Step 2: Scale the value of neurons that haven't been shut down
    ### END CODE HERE ###
    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
3.3 运行模型

参数：keep_prob = 0.86，前后向传播 使用上面的两个函数

c49f8255b29c876860937d46ca26e54a.png
在这里插入图片描述 
On the train set:
Accuracy: 0.9289099526066351
On the test set:
Accuracy: 0.95

模型没有过拟合，且 test 集上的准确率达到了 95%

d9a6212f67f6e804d5bf9b0864e9726e.png「注意：」

  • 只能在「训练」的时候，使用dropout，测试的时候「不要」使用
  • 前向、后向均应该使用
「model」「train accuracy」「test accuracy」
3-layer NN 「without」 regularization95%91.5%
3-layer NN with 「L2」-regularization94%93%
3-layer NN with 「dropout」93%95%

正则化限制了在训练集上的过拟合，训练准确率下降了，但是测试集准确率上升了，这是个好现象

作业3：梯度检验

梯度检验 确保 反向传播 是正确的，没有 bug

3.1 1维梯度检验

3ba16a9aaf4d0dfb96f724ac99561fc6.png
在这里插入图片描述
  • 计算理论梯度
# GRADED FUNCTION: forward_propagation

def forward_propagation(x, theta):
    """
    Implement the linear forward propagation (compute J) presented in Figure 1 (J(theta) = theta * x)
    Arguments:
    x -- a real-valued input
    theta -- our parameter, a real number as well
    Returns:
    J -- the value of function J, computed using the formula J(theta) = theta * x
    """
    
    ### START CODE HERE ### (approx. 1 line)
    J = theta * x
    ### END CODE HERE ###
    
    return J
# GRADED FUNCTION: backward_propagation

def backward_propagation(x, theta):
    """
    Computes the derivative of J with respect to theta (see Figure 1).
    Arguments:
    x -- a real-valued input
    theta -- our parameter, a real number as well
    Returns:
    dtheta -- the gradient of the cost with respect to theta
    """
    
    ### START CODE HERE ### (approx. 1 line)
    dtheta = x
    ### END CODE HERE ###
    
    return dtheta
  • 计算近似梯度
  • 反向传播，计算理论梯度 grad
  • 比较两者误差
np.linalg.norm(...)
  • 检查上式是否足够小(10^-7^)
# GRADED FUNCTION: gradient_check

def gradient_check(x, theta, epsilon = 1e-7):
    """
    Implement the backward propagation presented in Figure 1.
    Arguments:
    x -- a real-valued input
    theta -- our parameter, a real number as well
    epsilon -- tiny shift to the input to compute approximated gradient with formula(1)
    Returns:
    difference -- difference (2) between the approximated gradient and the backward propagation gradient
    """
    
    # Compute gradapprox using left side of formula (1). epsilon is small enough, you don't need to worry about the limit.
    ### START CODE HERE ### (approx. 5 lines)
    thetaplus = theta + epsilon                     # Step 1
    thetaminus = theta - epsilon                    # Step 2
    J_plus = forward_propagation(x, thetaplus)      # Step 3
    J_minus = forward_propagation(x, thetaminus)    # Step 4
    gradapprox = (J_plus - J_minus)/(2*epsilon)    # Step 5
    ### END CODE HERE ###
    
    # Check if gradapprox is close enough to the output of backward_propagation()
    ### START CODE HERE ### (approx. 1 line)
    grad = backward_propagation(x, theta)
    ### END CODE HERE ###
    
    ### START CODE HERE ### (approx. 1 line)
    numerator = np.linalg.norm(grad - gradapprox)  # Step 1'
    denominator = np.linalg.norm(grad) + np.linalg.norm(gradapprox) # Step 2'
    difference = numerator/denominator  # Step 3'
    ### END CODE HERE ###
    
    if difference 1e-7:
        print ("The gradient is correct!")
    else:
        print ("The gradient is wrong!")
    
    return difference

3.2 多维梯度检验

4ac94ef105a30c9d04d7d5341f1ce55f.png
在这里插入图片描述 
def forward_propagation_n(X, Y, parameters):
    """
    Implements the forward propagation (and computes the cost) presented in Figure 3.
    Arguments:
    X -- training set for m examples
    Y -- labels for m examples 
    parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3":
                    W1 -- weight matrix of shape (5, 4)
                    b1 -- bias vector of shape (5, 1)
                    W2 -- weight matrix of shape (3, 5)
                    b2 -- bias vector of shape (3, 1)
                    W3 -- weight matrix of shape (1, 3)
                    b3 -- bias vector of shape (1, 1)
    Returns:
    cost -- the cost function (logistic cost for one example)
    """
    
    # retrieve parameters
    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 = relu(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = relu(Z2)
    Z3 = np.dot(W3, A2) + b3
    A3 = sigmoid(Z3)

    # Cost
    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):
    """
    Implement the backward propagation presented in figure 2.
    Arguments:
    X -- input datapoint, of shape (input size, 1)
    Y -- true "label"
    cache -- cache output from forward_propagation_n()
    Returns:
    gradients -- A dictionary with the gradients of the cost 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
    
    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) * 2
    db2 = 1./m * np.sum(dZ2, axis=1, keepdims = True)
    
    dA1 = np.dot(W2.T, dZ2)
    dZ1 = np.multiply(dA1, np.int64(A1 > 0))
    dW1 = 1./m * np.dot(dZ1, X.T)
    db1 = 4./m * np.sum(dZ1, axis=1, keepdims = True)
    
    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
# GRADED FUNCTION: gradient_check_n

def gradient_check_n(parameters, gradients, X, Y, epsilon = 1e-7):
    """
    Checks if backward_propagation_n computes correctly the gradient of the cost output by forward_propagation_n
    Arguments:
    parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3":
    grad -- output of backward_propagation_n, contains gradients of the cost with respect to the parameters. 
    x -- input datapoint, of shape (input size, 1)
    y -- true "label"
    epsilon -- tiny shift to the input to compute approximated gradient with formula(1)
    Returns:
    difference -- difference (2) between the approximated gradient and the backward propagation gradient
    """
    
    # Set-up variables
    parameters_values, _ = dictionary_to_vector(parameters)
    grad = 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))
    
    # Compute gradapprox
    for i in range(num_parameters):
        
        # Compute J_plus[i]. Inputs: "parameters_values, epsilon". Output = "J_plus[i]".
        # "_" is used because the function you have to outputs two parameters but we only care about the first one
        ### START CODE HERE ### (approx. 3 lines)
        thetaplus = np.copy(parameters_values)                # Step 1
        thetaplus[i][0] = thetaplus[i][0] + epsilon          # Step 2
        J_plus[i], _ = forward_propagation_n(X, Y, vector_to_dictionary(thetaplus)) # Step 3
        ### END CODE HERE ###
        
        # Compute J_minus[i]. Inputs: "parameters_values, epsilon". Output = "J_minus[i]".
        ### START CODE HERE ### (approx. 3 lines)
        thetaminus = np.copy(parameters_values)               # Step 1
        thetaminus[i][0] = thetaminus[i][0] - epsilon        # Step 2        
        J_minus[i], _ = forward_propagation_n(X, Y, vector_to_dictionary(thetaminus)) # Step 3
        ### END CODE HERE ###
        
        # Compute gradapprox[i]
        ### START CODE HERE ### (approx. 1 line)
        gradapprox[i] = (J_plus[i] - J_minus[i])/(2*epsilon)
        ### END CODE HERE ###
    
    # Compare gradapprox to backward propagation gradients by computing difference.
    ### START CODE HERE ### (approx. 1 line)
    numerator = np.linalg.norm(gradapprox - grad)              # Step 1'
    denominator = np.linalg.norm(gradapprox)+np.linalg.norm(grad) # Step 2'
    difference = numerator/denominator                           # Step 3'
    ### END CODE HERE ###

    if difference > 1e-7:
        print ("\033[93m" + "There is a mistake in the backward propagation! difference = " + str(difference) + "\033[0m")
    else:
        print ("\033[92m" + "Your backward propagation works perfectly fine! difference = " + str(difference) + "\033[0m")
    
    return difference
  • 老师给的 backward_propagation_n 函数里面有错误，尝试去找到它。
X, Y, parameters = 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)
There is a mistake in the backward propagation! 
difference = 0.2850931567761624
  • 寻找错误 db1 改成：db1 = 1./m * np.sum(dZ1, axis=1, keepdims = True)dW2 改成：dW2 = 1./m * np.dot(dZ2, A1.T)

误差下来了，但略微超过 10^-7^, 所以显示错误，应该问题不大

There is a mistake in the backward propagation! 
difference = 1.1890913023330276e-07

注意：

  • 梯度检验「非常慢」，计算很耗时，所以我们训练时，不运行梯度检验，只运行几次检查梯度是否正确
  • 梯度检验时，需要「关掉 dropout」

我的CSDN博客地址 https://michael.blog.csdn.net/

长按或扫码关注我的公众号(Michael阿明)，一起加油、一起学习进步！3863bc64442fcbdc222d4db81e421bc0.png

weixin_39610722
关注
深度学习：吴恩达编程作业问题L2W1
weixin_43868020的博客
09-04 589
作业：随机初始化 将权重随机初始化为非常大，放大十倍 parameters[‘W’ + str(l)] = np.random.randn(layers_dims[l],layers_dims[l-1]) *10 运行结果： On the train set:Accuracy: 0.83 On the test set:Accuracy: 0.86 实验：不放大十倍，随机初始化的效果 权重矩阵W随机初始化为 parameters[‘W’ + str(l)] = np.random.randn(layers_
吴恩达《深度学习专项》笔记+代码实战（五）：深度学习的实践层面（数据集划分、偏差与方差、参数初始化、正则化）
a119334的博客
06-15 653
学习机器学习中的常用技术：数据集划分、参数初始化、正则化
【吴恩达深度学习编程作业】2.1改善深层神经网络——初始化、正则化、梯度校验
打瞌睡_的博客
10-21 548
参考文章：改善深层神经网络-初始化、正则化、梯度校验 至今为止，数据集的加载、决策边界的曲线绘制代码不熟悉，向量与字典的相互转化的代码没细看。 代码实现功能如下： 初始化参数： 1.1：使用0来初始化参数 1.2：使用随机数来初始化参数 1.3：使用抑梯度异常初始化参数（参见视频中的梯度消失和梯度爆炸） 正则化模型： 2.1：使用二范数对二分类模型正则化，尝试避免过拟合。 2.2：使用随机删除节点的方法精简模型，同样是为了尝试避免过拟合。 梯度校验 ： 对模型使用梯度校验，检测它是否在梯度下降的过程中出
吴恩达深度学习L2W1——神经网络权重初始化方法、正则化
qq_41488595的博客
10-15 1169
文章目录神经网络的初始化初始化数据模型搭建简单函数零初始化——initialize_parameters_zeros随机初始化——initialize_parameters_randomHe初始化三种初始化结果对比在神经网络中使用正则化导入数据模型搭建非正则化模型L2正则化dropout三种模型的对比 神经网络的初始化 主要是看权重的不同初始化方法的影响 导包 import numpy as np import matplotlib.pyplot as plt import sklearn import s
吴恩达深度学习L1W2作业2
weixin_47798560的博客
05-26 620
吴恩达《深度学习》L1W2作业2 知识点：用神经网络思想实现逻辑回归
吴恩达深度学习课程第五课作业
02-24
吴恩达深度学习课程第五课作业， jupter notebook 打开
吴恩达深度学习L2W3作业
m0_67611983的博客
12-07 1154
欢迎来到本周的编程作业。到目前为止，你一直使用numpy来构建神经网络。现在，我们将引导你使用深度学习框架，该框架将使你可以更轻松地构建神经网络。TensorFlow，PaddlePaddle，Torch，Caffe，Keras等机器学习框架可以极大地加快你的机器学习开发速度。所有这些框架也都有很多文档，你应该随时阅读学习。编程框架不仅可以缩短编码时间，而且有时还可以进行优化以加快代码速度。
吴恩达深度学习 C2_W1
weixin_55835175的博客
05-30 595
C2_W1 刚刚把大物的PPT做完，突然想起有什么东西好久没做了。于是赶紧对这一周的学习进行一个整理。 训练_开发_测试集 经过了第一部分深度学习神经网络概念的学习，我们对于神经网络是什么，长什么样，有什么作用，该如何构建，已经有了一个非常粗浅的了解(这点存疑)。在这一部分，我们将继续去学习如何有效运作神经网络，内容包括超参数调优，数据处理和算法优化等一系列保证神经网络正确且快速运作的方法。 在建立一个神经网络时，我们首先要考虑如下一些问题： 这些数据显然我们不能一下子就能够预测出最准确的值。因此，我们
吴恩达深度学习L1W3作业
m0_67611983的博客
12-05 1142
练习：定义三个变量：- n_x：输入层的大小- n_h：隐藏层的大小（将其设置为4）- n_y：输出层的大小提示：使用shape来找到n_x和n_y。另外，将隐藏层大小硬编码为4。
吴恩达机器学习基础课程笔记
最新发布
tjujackson的博客
03-06 953
吴恩达机器学习2022笔记
深度学习作业L2W1（1）Initialization
awake020
04-18 172
本次实验帮助我们了解合理的参数初始化对神经网络学习的影响 这里只贴出要求我们写的代码以及我的心得体会 0初始化 在这个部分，我们把参数全初始化为0。然而通过前置知识我们知道，如果w相同，则会导致每一层的所有神经元在每次反向传播时梯度数值都相同，每次的参数更新也相同。相当于只有一个神经元，模型复杂度很低。 况且如果w都是0，每次反向传播导数都会是0，相当于啥都没学 所以这种方式完全不可取 # GRA...
吴恩达深度学习2-Week1课后作业2-正则化
Apple_hzc的博客
10-20 647
一、Deeplearning-assignment 这一节作业的重点是理解各个正则化方法的原理，以及它们的优缺点，而不是去注重算法实现的具体末节。 问题陈述：希望你通过一个数据集训练一个合适的模型，从而帮助推荐法国守门员应该踢球的位置，这样法国队的球员可以用头打。法国过去10场比赛中的二维数据集如下： 每个点对应于法国守门员在足球场左侧击球之后，其他运动员用头将球击中的足球场上的位置。 ...
吴恩达神经网络学习-L2W1作业2
MarkAssassin的博客
09-24 174
【代码】吴恩达神经网络学习-L2W1作业2。
吴恩达深度学习deeplearning第一课课后测验及编程作业（含答案）
12-24
吴恩达深度学习deeplearning第一课课后测验及编程作业（含答案）
深度学习吴恩达作业题（4）
qq_42148307的博客
08-16 289
import numpy as np import matplotlib.pyplot as plt import h5py def sigmoid(Z): """ Implements the sigmoid activation in numpy Arguments: Z -- numpy array of any shape Returns: A -- output of sigmoid(z), same shape as Z c
吴恩达深度学习第二课第三周作业及学习心得体会 ——softmax、batchnorm
weixin_42604446的博客
08-31 2114
写在前面 本周课程用了两周完成，因为课程让用tensorflow实现，编码时还是更希望自己手写代码实现，而在实现过程中，低估了batchnorm反向计算的难度，导致算法出现各种bug，开始是维度上的bug导致代码无法运行，等代码可以运行时，训练神经网络的时候成本又总会发散，于是静下心来把整个运算的前向和反向过程认真推导了好几遍，期间参考网上一些资料，但感觉都没有把问题真正说清楚，连续三天的推导后...
2020-5-21 吴恩达-改善深层NN-w1 深度学习的实用层面(1.6 Dropout 正则化-inverted dropout反向随机失活)
weixin_42555985的博客
06-22 403
1.视频网站：mooc慕课https://mooc.study.163.com/university/deeplearning_ai#/c 2.详细笔记网站(中文)：http://www.ai-start.com/dl2017/ 3.github课件+作业+答案：https://github.com/stormstone/deeplearning.ai 1.6 Dropout 正则化 Dropout regularization1.工作原理2.反向随机失活 inverted dropout2.1训练阶段2.
吴恩达机器学习课后作业（笔记）（目前更新到ex2正则化逻辑回归
hexo-github建立中出现的问题
09-28 598
ex1 数据集https://www.kesci.com/home/project/5da16a37037db3002d441810/dataset import numpy as np import pandas as pd import matplotlib.pyplot as plt # https://www.kesci.com/home/project/5da16a37037db3002d441810/code # 吴恩达机器学习 单变量线性回归梯度下降python实现 path = r'C
吴恩达深度学习l2week1编程作业—Gradient Checking（中文跑通版）
na__D的博客
12-27 1015
你是一个致力于在全球范围内提供移动支付的团队的一员，并被要求建立一个深度学习模型来检测欺诈行为——每当有人付款时，你都想看看付款是否可能是欺诈性的，比如用户的账户是否被黑客接管。因为这是一个任务关键型应用程序，您公司的首席执行官希望真正确定您的反向传播实施是正确的。请注意，grad是使用函数gradients_to_vector计算的，该函数使用backward_propation_n函数的梯度输出。也就是，计算关于𝜃的导数𝐽(𝜃)=𝜃𝑥 ，得到𝑑𝑡ℎ𝑒𝑡𝑎=∂𝐽/∂𝜃=x。numerator 分子；
NG深度学习第二门课作业1-1 深度学习的实践
SpringRolls的博客
08-15 272
初始化 欢迎来到“改进深层神经网络”的第一个任务。 训练神经网络需要指定权重的初始值，精心选择的初始化方法将有助于学习。 如果您完成了本专业的上一门课程，您可能会按照我们的说明进行重量初始化，并且到目前为止已经完成了。但是你如何为一个新的神经网络选择初始化？在本节中，您将看到不同的初始化如何导致不同的结果。 选择一个好的初始化可以: 加速梯度下降的收敛 增加梯度下降收敛到较低训练(和泛化)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值