def initialize_parameters(n_x,n_h,n_y):

W1 = np.random.randn(n_h, n_x) * 0.01

b1 = np.zeros((n_h, 1))

W2 = np.random.randn(n_y, n_h) * 0.01

b2 = np.zeros((n_y, 1))

#使用断言确保我的数据格式是正确的

assert(W1.shape == (n_h, n_x))

assert(b1.shape == (n_h, 1))

assert(W2.shape == (n_y, n_h))

assert(b2.shape == (n_y, 1))

parameters = {"W1": W1,

"b1": b1,

"W2": W2,

"b2": b2}

return parameters

def initialize_parameters_deep(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]) / np.sqrt(layers_dims[l - 1])

parameters["b" + str(l)] = np.zeros((layers_dims[l], 1))

#确保我要的数据的格式是正确的

assert(parameters["W" + str(l)].shape == (layers_dims[l], layers_dims[l-1]))

assert(parameters["b" + str(l)].shape == (layers_dims[l], 1))

return parameters

def linear_forward(A_prev,W,b):

"""

实现前向传播的线性部分。

参数：

A_prev - 来自上一层（或输入数据）的激活，维度为(上一层的节点数量，示例的数量）

W - 权重矩阵，numpy数组，维度为（当前图层的节点数量，前一图层的节点数量）

b - 偏向量，numpy向量，维度为（当前图层节点数量，1）

返回：

Z - 激活功能的输入，也称为预激活参数

cache - 一个包含“A”，“W”和“b”的字典，存储这些变量以有效地计算后向传递

"""

#Please do something

return Z,linear_cache

def linear_activation_forward(A_prev,W,b,activation):

"""

实现LINEAR-> ACTIVATION 这一层的前向传播

参数：

A_prev - 来自上一层（或输入层）的激活，维度为(上一层的节点数量，示例数）

W - 权重矩阵，numpy数组，维度为（当前层的节点数量，前一层的大小）

b - 偏向量，numpy阵列，维度为（当前层的节点数量，1）

activation - 选择在此层中使用的激活函数名，字符串类型，【"sigmoid" | "relu"】

返回：

A - 激活函数的输出，也称为激活后的值

cache - 一个包含“linear_cache”和“activation_cache”的字典，我们需要存储它以有效地计算后向传递

"""

#Please do something

return A,cache

def L_model_forward(X,parameters):

"""

实现[LINEAR-> RELU] *（L-1） - > LINEAR-> SIGMOID计算前向传播，也就是多层网络的前向传播，为后面每一层都执行LINEAR和ACTIVATION

参数：

X - 数据，numpy数组，维度为（输入节点数量，示例数）

parameters - initialize_parameters_deep（）的输出

返回：

AL - 最后的激活值

caches - 包含以下内容的缓存列表：

linear_relu_forward（）的每个cache（有L-1个，索引为从0到L-2）

linear_sigmoid_forward（）的cache（只有一个，索引为L-1）

"""

#Please do something

return AL,caches

def compute_cost(AL,Y):

"""

交叉熵误差函数，定义成本函数。

参数：

AL - 与标签预测相对应的概率向量，维度为（1，示例数量）

Y - 标签向量（例如：如果不是猫，则为0，如果是猫则为1），维度为（1，数量）

返回：

cost - 交叉熵成本

"""

#Please do something

return cost

def linear_backward(dZ,linear_cache):

"""

为单层实现反向传播的线性部分（第L层）

参数：

dZ - 相对于（当前第l层的）线性输出的成本梯度

cache - 来自当前层前向传播的值的元组（A_prev，W，b）

返回：

dA_prev - 相对于激活（前一层l-1）的成本梯度，与A_prev维度相同

dW - 相对于W（当前层l）的成本梯度，与W的维度相同

db - 相对于b（当前层l）的成本梯度，与b维度相同

"""

#Please do something

return dA_prev, dW, db

def linear_activation_backward(dA,cache,activation="relu"):
    """
    实现LINEAR-> ACTIVATION层的后向传播。
    
    参数：
         dA - 当前层l的激活后的梯度值
         cache - 我们存储的用于有效计算反向传播的值的元组（值为linear_cache，activation_cache）
         activation - 要在此层中使用的激活函数名，字符串类型，【"sigmoid" | "relu"】
    返回：
         dA_prev - 相对于激活（前一层l-1）的成本梯度值，与A_prev维度相同
         dW - 相对于W（当前层l）的成本梯度值，与W的维度相同
         db - 相对于b（当前层l）的成本梯度值，与b的维度相同
    """
    #Please do something
    
    return dA_prev,dW,db

def L_model_backward(AL,Y,caches):

"""

对[LINEAR-> RELU] *（L-1） - > LINEAR - > SIGMOID组执行反向传播，就是多层网络的向后传播

参数：

AL - 概率向量，正向传播的输出（L_model_forward（））

Y - 标签向量（例如：如果不是猫，则为0，如果是猫则为1），维度为（1，数量）

caches - 包含以下内容的cache列表：

linear_activation_forward（"relu"）的cache，不包含输出层

linear_activation_forward（"sigmoid"）的cache

返回：

grads - 具有梯度值的字典

grads [“dA”+ str（l）] = ...

grads [“dW”+ str（l）] = ...

grads [“db”+ str（l）] = ...

"""

#Please do something

return grads

def update_parameters(parameters, grads, learning_rate):
    L = len(parameters) // 2 #整除
    for l in range(L):
        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