吴恩达深度学习_2_Week1深度学习的实用层面

1、初始化
2、正则化
3、梯度检查

---

第二门课：改善深层神经网络：超参数调参、正则化以及优化
第一周：深度学习的实用层面

一、初始化

选择合适的初始化可以：
1、加快梯度下降的收敛速度
2、增加梯度下降收敛到较低训练(和泛化)误差的几率

函数包

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

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_dataset()          

1、神经网络模型

三种初始化方法：
1、零初始化 – 在输入参数中设置 initialization = “zeros”
2、随机初始化 – 在输入参数中设置 initialization = “random”，这将把权重初始化为较大的随机值
3、He初始化 – 在输入参数中设置 initialization = “he”，这将根据He等人在2015年的一篇论文，将权重初始化为按比例缩放的随机值
实现一个三层神经网络：线性层->ReLU激活函数->线性层->ReLU激活函数->线性层->Sigmoid激活函数

# 参数：
#   X -- 输入数据，形状为(2, 样本数)
#   Y -- 真实的标签向量（包含0表示红点，1表示蓝点），形状为(1, 样本数)
#   learning_rate -- 梯度下降的学习率
#   num_iterations -- 梯度下降迭代的次数
#   print_cost -- 若为True，则每1000次迭代打印一次成本
#   initialization -- 选择初始化方法的标志（"zeros"、"random"或"he"）
# 返回：
#   parameters -- 模型学习到的参数

def model(X, Y, learning_rate=0.01, num_iterations=15000, print_cost=True, initialization="he"):
    grads = {}
    costs = []  
    m = X.shape[1]  
    layers_dims = [X.shape[0], 10, 5, 1]

    # 初始化参数字典
    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)

    # 循环(梯度下降)
    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)

    # 绘制损失图
    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('iterations (per hundreds)')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()
    return parameters

2、零初始化

在神经网络中，有两种类型的参数需要初始化：
1、权重矩阵（𝑊[1]，𝑊[2]，𝑊[3]，…，𝑊[𝐿−1]，𝑊[𝐿]）
2、偏置向量（𝑏[1]，𝑏[2]，𝑏[3]，…，𝑏[𝐿−1]，𝑏[𝐿]）
以下函数，将所有参数初始化为零。
这种方法效果不好，因为它无法“打破对称”，使用 np.zeros((…,…)) 函数，并使用正确的形状

# 参数：
#   layer_dims -- 包含每个层大小的Python数组（列表）
# 返回：
#   parameters -- 包含参数 "W1", "b1", ..., "WL", "bL" 的Python字典：
#   W1 -- 形状为 (layers_dims[1], layers_dims[0]) 的权重矩阵
#   b1 -- 形状为 (layers_dims[1], 1) 的偏置向量
#   WL -- 形状为 (layers_dims[L], layers_dims[L-1]) 的权重矩阵
#   bL -- 形状为 (layers_dims[L], 1) 的偏置向量

def initialize_parameters_zeros(layers_dims):
    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 = initialize_parameters_zeros([3,2,1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

在15000次迭代中训练模型

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)

性能非常糟糕，成本并没有真正降低，算法表现不如随机猜测
下面代码可见预测结果和决策边界的详细信息

print("predictions_train = " + str(predictions_train))
print("predictions_test = " + str(predictions_test))
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)

结果：
1、模型对每个样本都预测为0，将所有权重初始化为零会导致网络无法打破对称性。
2、这意味着每一层的每个神经元都会学习相同的内容，你可以将每一层的神经元数量设为1，这时网络的能力不会超过一个线性分类器，例如逻辑回归
记住：
权重 𝑊[𝑙] 应该随机初始化以打破对称性，将偏置 𝑏[𝑙] 初始化为零是可以的。
只要 𝑊[𝑙] 被随机初始化，对称性仍然会被打破

3、随机初始化

1、为了打破对称性，随机初始化权重，在随机初始化后，每个神经元可以学习其输入的不同函数
2、将权重初始化为大的随机值（乘以10），将偏置初始化为零。
3、使用 np.random.randn(…,…) * 10 来生成权重，使用 np.zeros((…, …)) 来生成偏置
4、使用一个固定的 np.random.seed(…) 来确保“随机”权重匹配，参数的初始值总是相同的

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)

def initialize_parameters_random(layers_dims):
    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])*10
        parameters['b' + str(l)] = np.zeros((layers_dims[l],1))
    return parameters
parameters = initialize_parameters_random([3, 2, 1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

迭代15000次

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)

如果在第0次迭代后看到成本为"inf"，这是由于数值舍入导致的；更加数值上精确的实现可以修复这个问题。
无论如何，看起来已经打破了对称性，这比之前的结果要好。模型不再输出全为0的结果了

print (predictions_train)
print (predictions_test)
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)

观察结果：成本初始非常高。
这是因为使用大的随机权重时，最后的激活函数（sigmoid）对某些样本输出非常接近0或1的结果，当它对该样本的预测错误时，会产生非常高的损失。确实，当 log(𝑎[3])=log(0) 时，损失变为无穷大。糟糕的初始化可能导致梯度消失/梯度爆炸，这也会减慢优化算法的速度。如果你继续训练这个网络，你会看到更好的结果，但使用过大的随机数进行初始化会减慢优化过程。
总结：将权重初始化为非常大的随机值效果不好—希望使用小的随机值进行初始化会有更好的效果

4、He初始化

def initialize_parameters_he(layers_dims):
    np.random.seed(3)
    parameters = {}
    L = len(layers_dims) - 1

    for l in range(1, L + 1):
        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))
    return parameters
parameters = initialize_parameters_he([2, 4, 1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

15000次迭代

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)
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)

观察结果：使用He初始化的模型在很少的迭代次数内很好地将蓝色和红色的点分开

5、总结

二、正则化

问题陈述

你刚刚被法国足球协会聘为人工智能专家。他们希望你推荐法国守门员应该将球踢到哪个位置，以便法国队的球员可以用头顶球。

1 函数包

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 数据集分析

train_X, train_Y, test_X, test_Y = load_2D_dataset()

1. 阐述：每个点对应足球场上的一个位置，法国守门员从足球场的左侧射门后，足球运动员用头顶球的位置。

• 如果点是蓝色的，意味着法国球员成功用头顶球。
• 如果点是红色的，意味着对方球队的球员用头顶球。

2. 目标：使用深度学习模型找到守门员应该踢球的位置。
3. 数据集分析：这个数据集有一些噪声，但看起来一个将上左半部分（蓝色）与下右半部分（红色）分开的对角线会非常有效。

首先尝试一个非正则化的模型。然后将学习如何对其进行正则化，并决定选择哪个模型来解决法国足球协会的问题。

3 没有正则化的模型

1. 在正则化模式下：通过将输入的 lambd 设置为非零值使用 “lambd” 而不是 “lambda”，因为 “lambda” 是 Python 中的保留关键字
2. 在随机失活模式下：通过将 keep_prob 设置为小于1的值。
   首先尝试没有任何正则化的模型。然后将实现：
3. L2正则化——函数：“compute_cost_with_regularization()” 和 “backward_propagation_with_regularization()”
4. 随机失活——函数：“forward_propagation_with_dropout()” 和 “backward_propagation_with_dropout()”

# 实现一个三层神经网络：线性->ReLU->线性->ReLU->线性->Sigmoid。
# 参数：
#   X -- 输入数据，形状为（输入大小，样本数）
#   Y -- 真实的标签向量（蓝点为1 / 红点为0），形状为（输出大小，样本数）
#   learning_rate -- 优化的学习率
#   num_iterations -- 优化循环的迭代次数
#   print_cost -- 如果为True，每10000次迭代打印成本
#   lambd -- 正则化超参数，标量
#   keep_prob -- 随机失活期间保持神经元活跃的概率，标量
# 返回：
#   parameters -- 模型学习到的参数。然后可以用它们来进行预测。

def model(X, Y, learning_rate=0.3, num_iterations=30000, print_cost=True, lambd=0, keep_prob=1):
    grads = {}
    costs = []
    m = X.shape[1]
    layers_dims = [X.shape[0], 20, 3, 1]
    # 初始化参数字典
    parameters = initialize_parameters(layers_dims)
    # 梯度下降循环

    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)

总结：训练准确率为94.8%，测试准确率为91.5%。这是基准模型（你将观察正则化对该模型的影响）
运行以下代码来绘制模型的决策边界

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正则化技术

# 参数：
#   A3 -- 经过激活函数的输出，前向传播的输出，形状为（输出大小，样本数）
#   Y -- "真实"标签向量，形状为（输出大小，样本数）
#   parameters -- 包含模型参数的Python字典
# 返回：
#   cost - 正则化损失函数的值（公式（2））

def compute_cost_with_regularization(A3, Y, parameters, lambd):
    m = Y.shape[1]
    W1 = parameters["W1"]
    W2 = parameters["W2"]
    W3 = parameters["W3"]

    cross_entropy_cost = compute_cost(A3, Y)

    L2_regularization_cost = (1./m*lambd/2)*(np.sum(np.square(W1)) + np.sum(np.square(W2)) + np.sum(np.square(W3)))
    cost = cross_entropy_cost + L2_regularization_cost
    return cost

A3, Y_assess, parameters = compute_cost_with_regularization_test_case()
print("cost = " + str(compute_cost_with_regularization(A3, Y_assess, parameters, lambd = 0.1)))

因为改变了成本，所以也需要改变反向传播，所有的梯度必须相对于这个新的成本函数进行计算
练习：实现反向传播中需要的变化，以考虑正则化，变化只涉及dW1,dW2，dW3

def backward_propagation_with_regularization(X, Y, cache, lambd):
    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/m * W3
    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/m * W2
    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/m * W1
    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

X_assess, Y_assess, cache = backward_propagation_with_regularization_test_case()

grads = backward_propagation_with_regularization(X_assess, Y_assess, cache, lambd = 0.7)
print ("dW1 = "+ str(grads["dW1"]))
print ("dW2 = "+ str(grads["dW2"]))
print ("dW3 = "+ str(grads["dW3"]))

现在使用L2正则化（𝜆=0.7）运行模型。模型()函数将调用：
compute_cost_with_regularization 代替 compute_cost
backward_propagation_with_regularization 代替 backward_propagation

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

观察结果：
1、𝜆的值是一个超参数，你可以使用开发集进行调整。
2、L2正则化使得决策边界更加平滑。如果𝜆太大，也可能出现“过度平滑”的情况，导致模型具有高偏差。
L2正则化基于这样的假设：具有小权重的模型比具有大权重的模型更简单。
因此，通过在成本函数中对权重的平方值进行惩罚，可以将所有权重推向较小的值。成本函数中具有大权重变得过于昂贵！这导致模型更加平滑，在输入变化时输出变化更加缓慢。
你应该记住的事情 – L2正则化对以下方面的影响：- 成本计算：- 成本中添加了正则化项； - 反向传播函数：- 梯度中有额外的项与权重矩阵相关；- 权重变小（“权重衰减”）：- 权重被推向较小的值

3、Dropout

随机失活是一种广泛使用的深度学习特定的正则化技术。它在每次迭代中随机关闭一些神经元。当你关闭一些神经元时，实际上是修改了你的模型。随机失活的理念是，在每次迭代中，你训练一个只使用部分神经元的不同模型。通过随机失活，你的神经元对于其他特定神经元的激活变得不太敏感，因为其他神经元可能在任何时候被关闭。

(1)使用随机失活进行前向传播

实现带有随机失活的前向传播。使用一个3层神经网络，并将随机失活应用于第一和第二隐藏层。不会对输入层或输出层应用随机失活。
操作步骤：您想要关闭第一和第二层的一些神经元。为此，您将执行以下4个步骤：
1、我们讨论了创建一个与𝑎[1]形状相同的变量𝑑[1]，使用np.random.rand()在0和1之间随机获取数值。
使用矢量化实现，因此创建一个与𝐴[1]相同维度的随机矩阵𝐷[1] = [𝑑1 𝑑1 … 𝑑1]。
2、将𝐷[1]的每个元素根据概率(1-keep_prob)设置为0或概率keep_prob设置为1，通过适当设置𝐷[1]中的值进行阈值处理。
提示：要将矩阵X的所有元素设置为0（如果元素小于0.5）或1（如果元素大于0.5），可以执行以下操作：X = (X < 0.5)。注意，0和1分别等同于False和True。
3、将𝐴[1]设置为𝐴[1]*𝐷[1]。（您正在关闭一些神经元）。您可以将𝐷[1]视为一个掩码，当它与另一个矩阵相乘时，会关闭一些值。
4、将𝐴[1]除以keep_prob。通过这样做，您确保成本的结果仍具有与没有随机失活时相同的期望值。（这种技术也称为反向失活）。

# 实现前向传播：LINEAR -> RELU + DROPOUT -> LINEAR -> RELU + DROPOUT -> LINEAR -> SIGMOID。
# 参数：
#   X -- 输入数据集，形状为（2，示例数量）
#   parameters -- 包含参数 "W1"，"b1"，"W2"，"b2"，"W3"，"b3" 的 Python 字典：
#   W1 -- 形状为（20，2）的权重矩阵
#   b1 -- 形状为（20，1）的偏置向量
#   W2 -- 形状为（3，20）的权重矩阵
#   b2 -- 形状为（3，1）的偏置向量
#   W3 -- 形状为（1，3）的权重矩阵
#   b3 -- 形状为（1，1）的偏置向量
#   keep_prob - 在随机失活期间保持神经元活动的概率，标量
# 返回值：
#   A3 -- 最后的激活值，前向传播的输出，形状为（1，1）
#   cache -- 元组，用于计算反向传播的存储信

def forward_propagation_with_dropout(X, parameters, keep_prob = 0.5):
    np.random.seed(1)

    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    W3 = parameters["W3"]
    b3 = parameters["b3"]

    # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID
    Z1 = np.dot(W1, X) + b1
    A1 = relu(Z1)
    # 下面的步骤1-4对应于上面描述的步骤1-4
    D1 = np.random.rand(A1.shape[0],A1.shape[1])     # Step 1: 初始化矩阵 D1 = np.random.rand(..., ...)
    D1 = D1 < keep_prob                              # Step 2: 将 D1 的元素转换为 0 或 1（使用 keep_prob 作为阈值）。
    A1 = A1 * D1                                     # Step 3: 关闭 A1 的一些神经元
    A1 = A1 / keep_prob                              # Step 4: 对那些没有被关闭的神经元进行缩放

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

    D2 = np.random.rand(A2.shape[0],A2.shape[1])     # Step 1: 初始化矩阵 D2 = np.random.rand(..., ...)
    D2 = D2 < keep_prob                              # Step 2: 将 D2 的元素转换为 0 或 1（使用 keep_prob 作为阈值）。
    A2 = A2 * D2                                     # Step 3: 关闭 A2 的一些神经元
    A2 = A2 / keep_prob                              # Step 4: 对那些没有被关闭的神经元进行缩放

    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
X_assess, parameters = forward_propagation_with_dropout_test_case()

A3, cache = forward_propagation_with_dropout(X_assess, parameters, keep_prob = 0.7)
print ("A3 = " + str(A3))

(2) 使用随机失活实现反向传播

练习：实现带有随机失活的反向传播。训练一个3层网络。在第一和第二隐藏层中添加随机失活，使用存储在缓存中的掩码 𝐷[1] 和 𝐷[2]。
指导说明：使用随机失活的反向传播实际上非常简单。您需要执行2个步骤：
1、在前向传播期间，通过将掩码 𝐷[1] 应用于 A1 关闭了一些神经元。在反向传播中，您将通过再次将相同的掩码 𝐷[1] 应用于 dA1 关闭相同的神经元。在前向传播期间，您将 A1 除以 keep_prob。
2、在反向传播需要将 dA1 再次除以 keep_prob（计算的解释是如果 𝐴[1] 被 keep_prob 缩放，那么它的导数 𝑑𝐴[1] 也将以相同的 keep_prob 缩放）

def backward_propagation_with_dropout(X, Y, cache, keep_prob):
    m = X.shape[1]
    (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3) = cache

    dZ3 = A3 - Y
    dW3 = 1./m * np.dot(dZ3, A2.T)
    db3 = 1./m * np.sum(dZ3, axis=1, keepdims = True)
    dA2 = np.dot(W3.T, dZ3)

    dA2 = dA2 * D2              # 步骤1：使用掩码 D2 关闭与前向传播期间相同的神经元。
    dA2 = dA2 / keep_prob       # 步骤2：缩放那些没有被关闭的神经元的值。

    dZ2 = np.multiply(dA2, np.int64(A2 > 0))
    dW2 = 1./m * np.dot(dZ2, A1.T)
    db2 = 1./m * np.sum(dZ2, axis=1, keepdims = True)

    dA1 = np.dot(W2.T, dZ2)

    dA1 = dA1 * D1               # 步骤1：使用掩码 D1 关闭与前向传播期间相同的神经元。
    dA1 = dA1 / keep_prob        #步骤2：缩放那些没有被关闭的神经元的值。

    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
X_assess, Y_assess, cache = backward_propagation_with_dropout_test_case()
gradients = backward_propagation_with_dropout(X_assess, Y_assess, cache, keep_prob = 0.8)
print ("dA1 = " + str(gradients["dA1"]))
print ("dA2 = " + str(gradients["dA2"]))

使用随机失活（keep_prob = 0.86）运行模型。这意味着在每次迭代中，以24%的概率关闭第1层和第2层的每个神经元。函数 model() 现在会调用：
forward_propagation_with_dropout 而不是 forward_propagation。
backward_propagation_with_dropout 而不是 backward_propagation。

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)
# 随机失活效果很好！测试准确率再次提高（达到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)

注意事项：
1、使用随机失活的常见错误是在训练和测试中都使用它。您应该只在训练中使用随机失活（随机消除节点）。
2、像TensorFlow、PaddlePaddle、Keras或Caffe这样的深度学习框架都带有随机失活层的实现。
关于随机失活的要记住的事项：
1、随机失活是一种正则化技术。
2、只在训练过程中使用随机失活。在测试时不要使用随机失活（随机消除节点）。
3、在前向传播和后向传播中都应用随机失活。
4、在训练过程中，将每个随机失活层除 keep_prob，以保持激活的期望值不变。例如，如果 keep_prob 是 0.5，则平均关闭一半的节点，因此输出会被缩放为 0.5，因为只有剩余的一半节点对解决方案有贡献。除以 0.5 等效于乘以 2。
5、因此，输出现在具有相同的期望值。您可以验证这一点，即使 keep_prob 是除了 0.5 之外的其他值也适用。

4、总结

3、梯度检查

问题阐述

您是一个团队的一员，负责使全球范围内的移动支付可用，并被要求构建一个深度学习模型来检测欺诈行为。每当有人进行支付时，您希望检查支付是否可能存在欺诈行为，例如用户的账户是否被黑客接管。但是，反向传播的实现相当具有挑战性，并且有时会出现错误。由于这是一个关键任务，您公司的首席执行官希望非常确信您的反向传播实现是正确的。您的首席执行官说：“给我一个证明，证明您的反向传播确实有效！”为了提供这种保证，您将使用“梯度检查”。

函数包

import numpy as np
from testCases import *
from gc_utils import sigmoid, relu, dictionary_to_vector, vector_to_dictionary, gradients_to_vector

1、梯度检查如何工作

2、一维梯度检查

前向传播：

# 实现线性前向传播
# 参数：
#   x -- 实值输入
#   theta -- 我们的参数，也是一个实数
# 返回值：
#    J -- 函数 J 的值，使用公式 J(theta) = theta * x 计算得到

def forward_propagation(x, theta):
    J = theta * x
    return J
x, theta = 2, 4
J = forward_propagation(x, theta)
print ("J = " + str(J))

输出结果为J=8

后向传播：

# dtheta -- 相对于 theta 的代价函数的梯度
def backward_propagation(x, theta):
    dtheta = x
    return dtheta
x, theta = 2, 4
dtheta = backward_propagation(x, theta)
print ("dtheta = " + str(dtheta))

输出结果：dtheta=2

梯度检查：

# 参数：
#   x -- 实值输入
#   theta -- 我们的参数，也是一个实数
#   epsilon -- 输入的微小变化，用于使用公式（1）计算近似梯度
# 返回值：
#   difference -- 近似梯度和反向传播梯度之间的差异（2）

def gradient_check(x, theta, epsilon = 1e-7):
# 使用公式计算 gradapprox。epsilon 足够小，您不需要担心极限问题。

    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

# 检查 gradapprox 是否足够接近 backward_propagation() 的输出。
    grad = backward_propagation(x, theta)

    numerator = np.linalg.norm(grad - gradapprox)                       # Step 1'
    denominator = np.linalg.norm(grad) + np.linalg.norm(gradapprox)     # Step 2'
    difference = numerator / denominator                               # Step 3'

    if difference < 1e-7:
        print ("The gradient is correct!")
    else:
        print ("The gradient is wrong!")

    return difference
x, theta = 2, 4
difference = gradient_check(x, theta)
print("difference = " + str(difference))

3、N维梯度检查

def forward_propagation_n(X, Y, parameters):
    # 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):
    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

梯度检查如何工作：

# 检查 backward_propagation_n 是否正确计算了由 forward_propagation_n 输出的代价函数的梯度。
# 参数：
#   parameters -- 包含参数 "W1"、"b1"、"W2"、"b2"、"W3"、"b3" 的 Python 字典
#   grad -- backward_propagation_n 的输出，包含相对于参数的代价函数的梯度
#   x -- 输入数据点，形状为 (输入大小, 1)
#   y -- 真实 "标签"
#   epsilon -- 输入的微小变化，用于使用公式（1）计算近似梯度
# 返回值：
#   difference -- 近似梯度和反向传播梯度之间的差异（2）

def gradient_check_n(parameters, gradients, X, Y, epsilon = 1e-7):
    # 设置变量
    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))

    # 计算gradapprox
    for i in range(num_parameters):

        # 计算 J_plus[i]。输入为 "parameters_values, epsilon"。输出为 "J_plus[i]"。
        # "_" 被使用是因为该函数有两个输出参数，但我们只关心第一个参数。
        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

        # Compute J_minus[i]. Inputs: "parameters_values, epsilon". Output = "J_minus[i]".
        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

        # Compute gradapprox[i]
        gradapprox[i] = (J_plus[i] - J_minus[i]) / (2.* epsilon)

    # Compare gradapprox to backward propagation gradients by computing difference.
    numerator = np.linalg.norm(grad - gradapprox)                                 # Step 1'
    denominator = np.linalg.norm(grad) + np.linalg.norm(gradapprox)               # Step 2'
    difference = numerator / denominator                                          # Step 3'

    if difference > 1e-7:
        print ("\033[93m" + "在反向传播中存在错误！difference = " + str(difference) + "\033[0m")
    else:
        print ("\033[92m" + "你的反向传播工作的很好！difference = " + str(difference) + "\033[0m")

    return difference
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)

已经实现了梯度检查，返回到 backward_propagation，尝试找到/修正错误（提示：检查 dW2 和 db1）。当认为已经修复时，重新运行梯度检查。请记住，如果修改了代码，需要重新执行定义 backward_propagation_n() 的单元格。
注意：
梯度检查很慢！使用 ∂𝐽∂𝜃≈𝐽(𝜃+𝜀)−𝐽(𝜃−𝜀)2𝜀 近似梯度在计算上是代价高昂的。因此，我们不会在每次迭代训练中运行梯度检查，只会偶尔检查梯度是否正确。
至少按照我们提供的方式，梯度检查无法与随机失活一起使用。通常，您会在没有随机失活的情况下运行梯度检查算法，以确保反向传播正确，然后再添加随机失活。
记住：
1、梯度检查验证反向传播的梯度与数值近似梯度（使用前向传播计算）之间的接近程度。
2、梯度检查很慢，因此我们不会在每次训练迭代中都运行它。通常只在确保代码正确后运行一次，然后关闭梯度检查并使用反向传播进行实际学习过程。