01. 神经网络和深度学习 —— week4 深层神经网络 （编程作业）

初始化：

def initialize_parameters_deep(layers_dims): 
	  """
      参数：
	      layers_dims: 包含网络中每个图层的节点数量的列表
	  返回：
	      parameters: 包含参数“W1”,"b1",...,"WL","bL"的字典
	      “Wl”：权重矩阵，维度为[layers_dims[l], layers_dims[l-1]]
	      "bl"：偏置向量，维度为[layers_dims[l], 1]
      """

前向传播 :

def linear_forward(A,W,b):
   """
   实现前向传播的线性部分
   参数：
       A：来自上一层（或输入数据）的激活，维度为(上一层的节点数量，示例的数量）
       W：权重矩阵，numpy数组，维度为（当前图层的节点数量，前一图层的节点数量）
       b：偏向量，numpy向量，维度为（当前图层节点数量，1）
   返回：
       Z：激活函数的输入，也称为预激活参数
       cache：一个包含“A”，“W”和“b”的字典，存储这些变量以有效地计算后向传递
   """
   
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”("A","W","b")和“activation_cache”("Z")的字典，我们需要存储它以有效地计算后向传递
   """

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）
   """

计算成本：

def compute_cost(AL,Y):
    """
    计算成本函数。
    参数：
        AL： 与标签预测相对应的概率向量，维度为（1，示例数量）
        Y：标签向量（例如：如果不是猫，则为0，如果是猫则为1），维度为（1，数量）
    返回：
        cost - 交叉熵成本
    """

反向传播 ：

def linear_backward(dZ,cache):
    """
    为单层实现反向传播的线性部分（第L层）
    参数：
         dZ： 相对于（当前第l层的）线性输出的成本梯度
         cache： 来自当前层前向传播的值的元组（A_prev，W，b）
    返回：
         dA_prev: 相对于激活（前一层l-1）的成本梯度，与A_prev维度相同
         dW: 相对于W（当前层l）的成本梯度，与W的维度相同
         db: 相对于b（当前层l）的成本梯度，与b维度相同
    """

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的维度相同
    """

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-1)] = ...
            grads [“dW”+ str(l)] = ...
            grads [“db”+ str(l)] = ...
    """

更新参数 ：

def update_parameters(parameters, grads, learning_rate):
    """
    使用梯度下降更新参数
    参数：
     parameters：包含你的参数的字典
     grads：包含梯度值的字典，是L_model_backward的输出
    返回：
     parameters：包含更新参数的字典
                 参数[“W”+ str（l）] = ...
                 参数[“b”+ str（l）] = ...
    """

搭建多层神经网络：

def L_layer_model(X, Y, layers_dims, learning_rate=0.0075, num_iterations=3000, print_cost=False,isPlot=True):
    """
    实现一个L层神经网络：[LINEAR-> RELU] *（L-1） - > LINEAR-> SIGMOID。
    参数：
        X： 输入的数据，维度为(n_x，例子数)
        Y： 标签，向量，0为非猫，1为猫，维度为(1,数量)
        layers_dims： 层数的向量，维度为(n_y,n_h,···,n_h,n_y)
        learning_rate: 学习率
        num_iterations: 迭代的次数
        print_cost: 是否打印成本值，每100次打印一次
        isPlot: 是否绘制出误差值的图谱
    返回：
     parameters: 模型学习的参数, 然后他们可以用来预测。
    """

预测函数：

def predict(X, y, parameters):
    """
    该函数用于预测L层神经网络的结果，也包含两层
    参数：
     X: 测试集
     y: 标签
     parameters: 训练模型的参数
    返回：
     p: 给定数据集X的预测
    """

参考自：
[1] 中文版：https://blog.youkuaiyun.com/u013733326/article/details/79767169
[2] 英文版：https://blog.youkuaiyun.com/koala_tree/article/details/78092337

代码照着写了一遍，还是没理解好。过几天再看一遍吧。