吴恩达，神经⽹络优化课后作业总结版标题接着上⼀篇，猫脸脸识别4层神经⽹络。
1.我们将在原代码的基础上进⾏添加各类优化设置。（即添加剂）
1. 正则 、droput、动量梯度下降、adam
2. 第⼀步，导⼊数据
from lr_utils import load_datat
import numpy as np
import matplotlib.pyplot as plt
import h5py
train_t_x_orig , train_t_y , test_t_x_orig , test_t_y , class = load_datat()
m_train = train_t_y.shape[1]#训练集⾥图⽚的数量。
m_test = test_t_y.shape[1]#测试集⾥图⽚的数量。
num_px = train_t_x_orig.shape[1]#训练、测试集⾥⾯的图⽚的宽度和⾼度（均为64x64）。
#将训练集的维度降低并转置。
train_t_x_flatten = train_t_shape(train_t_x_orig.shape[0],-1).T
#将测试集的维度降低并转置。
test_t_x_flatten = test_t_shape(test_t_x_orig.shape[0],-1).T
train_x = train_t_x_flatten /255
test_x = test_t_x_flatten /255
利⽤he⽅法，进⾏初始化参数，若是不明⽩he初始化，可以去我上⼀篇查看。
def initialize_parameters_deep(layer_dims):
'''
参数：
layer_dims:⽹络每⼀层的单元数
返回：
parameters：初始化后的参数字典形式
"W1", "b1", ..., "WL", "bL":
Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])
bl -- bias vector of shape (layer_dims[l], 1)
'''
np.random.ed(1)
parameters ={}
L =len(layer_dims)# 神经⽹络层数+1 包括输⼊层
for l in range(1, L):
parameters['W'+str(l)]= np.random.randn(layer_dims[l], layer_dims[l -1])* np.sqrt(2./ layer_dims[l -1])# *0.01 parameters['b'+str(l)]= np.zeros((layer_dims[l],1))
asrt(parameters['W'+str(l)].shape ==(layer_dims[l], layer_dims[l -1]))
asrt(parameters['b'+str(l)].shape ==(layer_dims[l],1))
return parameters
编写⽆添加剂向前传播过程：注意，这是主要给测试集使⽤的
def linear_forward(A, W, b):
'''
隐层/输出层前向传播的线性组合部分
参数：
A：上⼀层的激活函数输出初始值是样本特征矩阵X
W：当前层的权重参数矩阵
b: 当前层的偏置参数向量
返回：
Z：当前层的线性组合输出
cache：元组形式 (A,W,b)
'''
Z = np.dot(W, A)+ b
asrt(Z.shape ==(W.shape[0], A.shape[1]))
cache =(A, W, b)
return Z, cache
def sigmoid(Z):
'''
2分类，输出层采⽤sigmoid激活函数
输出层前向传播的激活函数部分
参数：
Z：当前层（输出层）的线性组合输出
返回：观南上域
A：当前层（输出层）的激活输出
cache: Z
'''
A =1./(1+ np.exp(-Z))
岁月静安
cache = Z
asrt(A.shape == Z.shape)
return A, cache
def relu(Z):
'''延期申请书范文
隐层统⼀采⽤relu激活函数
参数：
Z：当前层(隐层)的线性组合输出
返回：
A：当前层(隐层)的激活输出
cache: Z
'''
A = np.maximum(0, Z)
cache = Z
asrt(A.shape == Z.shape)
return A, cache
def linear_activation_forward(A_prev, W, b, activation):
'''
隐层(输出层）的前向传播操作，包括线性组合和激活函数两部分
参数：
A_perv：上⼀层的激活函数输出初始值是样本特征矩阵X
W：上⼀层和当前层之间的权重参数矩阵
b: 上⼀层和当前层之间的偏置参数向量
activation：使⽤的激活函数类型⼀般所有隐层的激活函数是⼀样的输出层如果作2分类使⽤sigmoid 返回：
A: 当前层的激活函数输出
cache：存储重要的中间结果，⽅便运算。元组形式(linear_cache,activation_cache)=((A_prev,W,b),Z) '''
if activation =='sigmoid':
Z, linear_cache = linear_forward(A_prev, W, b)# 线性单元
Z, linear_cache = linear_forward(A_prev, W, b)# 线性单元
A, activation_cache = sigmoid(Z)# 激活单元
elif activation =='relu':
Z, linear_cache = linear_forward(A_prev, W, b)# 线性单元
A, activation_cache = relu(Z)# 激活单元
asrt(A.shape ==(W.shape[0], A_prev.shape[1]))
cache =(linear_cache, activation_cache)
return A, cache
def L_model_forward(X, parameters):
'''
L层神经⽹络整体的前向传播调⽤之前写好的每层的前向传播⽤for循环迭代
参数：
X：数据集的特征矩阵 (n_x,m)
parameters：模型参数
返回：
AL：模型最后的输出
caches：列表形式，存储每⼀层前向传播的cache=(linear_cache,activation_cache)
=((A_prev,W,b),Z)
对于linear_relu_forward()有L-1项cache 下标0～L-2
对于linear_sigmoid_forward()有1项cache 下标L-1
'''
caches =[]
A = X # A0 前向传播初始项
L =len(parameters)//2# 神经⽹络层数（不包含输⼊层）
# 前向传播通项
# 隐层和输出层激活函数不同 for循环迭代隐层前向传播输出层前向传播单独算放工
# 隐层
for l in range(1, L):# l: 1~L-1
A_prev = A
A, cache = linear_activation_forward(A_prev, parameters['W'+str(l)],parameters['b'+str(l)],'relu')
caches.append(cache)
# 输出层
AL, cache = linear_activation_forward(A, parameters['W'+str(L)],parameters['b'+str(L)],'sigmoid')
caches.append(cache)
return AL, caches
编写损失函数
def compute_cost(AL, Y):
'''
实现cost函数，计算代价
参数：
AL：输出层的激活输出模型最终输出 (1,m)
Y：样本的真实标签 0/1 (1,m)
返回：
cost: 交叉熵代价
'''
cost = np.mean(-Y * np.log(AL)-(1- Y)* np.log(1- AL))
cost = np.squeeze(cost)# Y和AL都是⽤2维数组表⽰的向量 cost算出来是[[cost]]，利⽤squeeze把它变成cost asrt(cost.shape ==())
return cost
⽆添加剂更新梯度
def update_parameters(parameters, grads, learning_rate):
'''
使⽤梯度下降法更新模型参数
参数：
parameters：模型参数
grads：计算的参数梯度字典形式
learning_rate：学习率
返回：
parameters：更新后的参数字典形式
parameters["W" + str(l)] = ...
parameters["b" + str(l)] = ...
'''
L =len(parameters)//2# 神经⽹络层数（输⼊层是第0层不算输⼊层）
# ⼀次梯度下降迭代更新参数
for l in range(L):# l 0~L-1
parameters['W'+str(l +1)]= parameters['W'+str(l +1)]- learning_rate * grads['dW'+str(l +1)]
parameters['b'+str(l +1)]= parameters['b'+str(l +1)]- learning_rate * grads['db'+str(l +1)]
return parameters
⼀，重要步骤：添加正则（损失函数）
#损失函数加正则
def compute_cost_with_regularization(AL, Y,parameters, lambd):
W1 = parameters['W1']
W2 = parameters['W2']
W3 = parameters['W3']
W4 = parameters['W4']
m = AL.shape[1]
cross_entropy_cost = compute_cost(AL, Y)
L2_reglarization_cost =1./ m * lambd /2*(
np.sum(np.square(W1))+ np.sum(np.square(W2))+ np.sum(np.square(W3)+ np.sum(np.square(W4)))) cost = L2_reglarization_cost + cross_entropy_cost
return cost
反向传播加⼊正则
def sigmoid_backward(dA, cache):
'''
sigmoid激活单元(输出层)的反向传播
参数：
dA：当前层(输出层)激活输出AL的梯度
cache：存储当前层(输出层)的线性组合输出Z,⽅便激活单元反向传播的计算
练瑜伽的好处返回：
dZ：当前层(输出层)线性组合输出Z的梯度
'''
Z = cache
s =1./(1+ np.exp(-Z))
# dZ=dA*(A对Z求导) A=sigmoid(Z) A对Z的导数=A(1-A)
粉后
女孩主题dZ = dA * s *(1- s)
asrt(dZ.shape == Z.shape)
消失的古文明return dZ
def relu_backward(dA, cache):
'''
隐层统⼀使⽤relu激活函数
relu激活单元(隐层)的反向传播
参数：
dA：当前层(隐层)激活输出Al的梯度
cache：存储当前层(隐层)的线性组合输出Z,⽅便激活单元反向传播的计算
返回：
dZ：当前层(隐层)线性组合输出Z的梯度
'''
Z = cache
# dZ=dA*(A对Z求导) 当Z>0时 A对Z求导=1 否则为0
dZ = np.array(dA, copy=True)
dZ[Z <=0]=0
asrt(dZ.shape == Z.shape)
return dZ
def linear_backward(dZ, cache,lambd):#加⼊正则项
'''
输出层/隐层线性单元的反向传播
参数：
dZ：当前层组合输出Z的梯度
cache：存储当前层前向传播的线性单元参数 (A_prev,W,b),⽅便线性单元反向传播的计算 lambd: 正则参数
返回：
dA_prev：前⼀层激活输出的梯度
dW：当前层权重参数矩阵的梯度
db：当前层偏置参数向量的梯度
'''
A_prev, W, b = cache
m = A_prev.shape[1]# 样本数
#W 正则求导剩余项
dW =1./ m * np.dot(dZ, A_prev.T)+ lambd / m * W # m个样本的平均梯度
db =1./ m * np.mean(dZ, axis=1, keepdims=True)
dA_prev = np.dot(W.T, dZ)
asrt(dW.shape == W.shape)
