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()
- 阐述:每个点对应足球场上的一个位置,法国守门员从足球场的左侧射门后,足球运动员用头顶球的位置。
- 如果点是蓝色的,意味着法国球员成功用头顶球。
- 如果点是红色的,意味着对方球队的球员用头顶球。
- 目标:使用深度学习模型找到守门员应该踢球的位置。
- 数据集分析:这个数据集有一些噪声,但看起来一个将上左半部分(蓝色)与下右半部分(红色)分开的对角线会非常有效。
首先尝试一个非正则化的模型。然后将学习如何对其进行正则化,并决定选择哪个模型来解决法国足球协会的问题。
3 没有正则化的模型
- 在正则化模式下:通过将输入的 lambd 设置为非零值使用 “lambd” 而不是 “lambda”,因为 “lambda” 是 Python 中的保留关键字
- 在随机失活模式下:通过将 keep_prob 设置为小于1的值。
首先尝试没有任何正则化的模型。然后将实现: - L2正则化——函数:“compute_cost_with_regularization()” 和 “backward_propagation_with_regularization()”
- 随机失活——函数:“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、梯度检查很慢,因此我们不会在每次训练迭代中都运行它。通常只在确保代码正确后运行一次,然后关闭梯度检查并使用反向传播进行实际学习过程。