维度说明：

A[L]、Z[L]：（本层神经元个数、样本数）
W[L]：（本层神经元个数、上层神经元个数）
b[L]：（本层神经元个数、1）

dZ[L]：dA[L] * g’A（Z[L]）
dZ[L]：（本层神经元个数、样本数）
dw = dL/dz * dz/dw = dz*x（链式法则）
db = dz（链式法则）
dW[L]：（本层神经元个数、上层神经元个数）
dA[L]：（本层神经元个数、样本数）
da = dz * w
dA[L-1] = W[L].T dZ[L]，注意这里没有除以神经元个数，得到平均da。比如结果的第一个元素是多个dw1 * dz + dw1 * dz+ …dw1 * dz（神经元个数）的累加和

输出层采用sigmoid，隐藏层采用tanh

import numpy as np
# 设置一些画图相关的参数
import matplotlib.pyplot as plt

plt.rcParams['figure.figsize'] = (5.0, 4.0)
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
from project_03.utils.dnn_utils import *
from project_03.utils.testCases import *


def load_dataset():
    train_dataset = h5py.File('../deep_learn_01/project_01/datasets/train_catvnoncat.h5', 'r')
    train_set_x_orig = np.array(train_dataset['train_set_x'][:])
    train_set_y_orig = np.array(train_dataset["train_set_y"][:])  # 加载训练数据

    test_dataset = h5py.File('../deep_learn_01/project_01/datasets/test_catvnoncat.h5', "r")  # 加载测试数据
    test_set_x_orig = np.array(test_dataset["test_set_x"][:])
    test_set_y_orig = np.array(test_dataset["test_set_y"][:])

    classes = np.array(test_dataset["list_classes"][:])  # 加载标签类别数据，这里的类别只有两种，1代表有猫，0代表无猫

    train_set_y_orig = train_set_y_orig.reshape(
        (1, train_set_y_orig.shape[0]))  # 把数组的维度从(209,)变成(1, 209)，这样好方便后面进行计算[1 1 0 1] -> [[1][1][0][1]]
    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))  # 从(50,)变成(1, 50)
    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes


def sigmoid(Z):
    A = 1 / (1 + np.exp(-Z))
    return A


def relu(Z):
    A = np.maximum(0, Z)
    assert (A.shape == Z.shape)
    return A


def initialize_parameters_deep(layers_dims):
    """
    :param layers_dims: list of neuron num
    example: layer_dims=[5,4,3]，表示输入层有5个神经元，第一层有4个，最后二层有3个神经元（还有输出层的1个神经元）
    :return: parameters: the w,b of each layer
    """
    np.random.seed(1)
    parameters = {}
    L = len(layers_dims)
    for l in range(1, L):
        parameters[f"W{l}"] = np.random.randn(layers_dims[l], layers_dims[l - 1]) / np.sqrt(layers_dims[l - 1])
        parameters[f"b{l}"] = np.zeros((layers_dims[l], 1))
        assert (parameters[f"W{l}"].shape == (layers_dims[l], layers_dims[l - 1]))
        assert (parameters[f"b{l}"].shape == (layers_dims[l], 1))
    return parameters  # W1,b1,W2,b2


def linear_forward(A, W, b):
    """
    线性前向传播
    """
    Z = np.dot(W, A) + b
    assert (Z.shape == (W.shape[0], A.shape[1]))
    return Z


def linear_activation_forward(A_prev, W, b, activation):
    """
    :param A_prev: 上一层得到的A，输入到本层来计算本层的Z和A，第一层时A_prev就是输入X
    :param W:本层的w
    :param b:本层的b
    :param activation: 激活函数
    """
    Z = linear_forward(A_prev, W, b)
    if activation == "sigmoid":
        A = sigmoid(Z)
    elif activation == "relu":
        A = relu(Z)
    else:
        assert (1 != 1), "there is no support activation!"
    assert (A.shape == (W.shape[0], A_prev.shape[1]))
    linear_cache = (A_prev, W, b)
    cache = (linear_cache, Z)
    return A, cache


def L_model_forward(X, parameters):
    """
    前向传播
    :param X: 输入特征
    :param parameters: 每一层的初始化w,b
    """
    caches = []
    A = X
    L = len(parameters) // 2  # W1,b1,W2,b2, L=2
    for l in range(1, L):
        A_prev = A
        A, cache = linear_activation_forward(A_prev, parameters[f"W{l}"], parameters[f"b{l}"], 'relu')
        caches.append(cache)  # A1,(X,W1,b1,Z1)
    AL, cache = linear_activation_forward(A, parameters[f"W{L}"], parameters[f"b{L}"], activation="sigmoid")
    caches.append(cache)  # A2,(A1,W2,b2,Z2)
    assert (AL.shape == (1, X.shape[1]))
    return AL, caches


def compute_cost(AL, Y):
    m = Y.shape[1]
    logprobs = np.multiply(Y, np.log(AL)) + np.multiply((1 - Y), np.log(1 - AL))
    cost = (-1 / m) * np.sum(logprobs)
    assert (cost.shape == ())
    return cost


def linear_backward(dZ, cache):
    """
    :param dZ: 后面一层的dZ
    :param cache: 前向传播保存下来的本层的变量
    :return 本层的dw、db，前一层da
    """
    A_prew, W, b = cache
    m = A_prew.shape[1]

    dW = np.dot(dZ, A_prew.T) / m
    db = np.sum(dZ, axis=1, keepdims=True) / m
    dA_prev = np.dot(W.T, dZ)

    assert (dA_prev.shape == A_prew.shape)
    assert (dW.shape == W.shape)
    assert (db.shape == b.shape)
    return dA_prev, dW, db


def linear_activation_backward(dA, cache, activation):
    """
    :param dA: 本层的dA
    :param cache: 前向传播保存的本层的变量
    :param activation: 激活函数:"sigmoid"或"relu"
    :return 本层的dw、db，前一次的dA
    """
    linear_cache, Z = cache
    # 首先计算本层的dZ
    if activation == 'relu':
        dZ = 1 * dA
        dZ[Z <= 0] = 0
    elif activation == 'sigmoid':
        A = sigmoid(Z)
        dZ = dA * A * (1 - A)
    else:
        assert (1 != 1), "there is no support activation!"
    assert (dZ.shape == Z.shape)
    # 这里我们又顺带根据本层的dZ算出本层的dW和db以及前一层的dA
    dA_prev, dW, db = linear_backward(dZ, linear_cache)
    return dA_prev, dW, db


def L_model_backward(AL, Y, caches):
    """
    :param AL: 最后一层A
    :param Y: 真实标签
    :param caches: 前向传播的保存的每一层的相关变量  (A_prev, W, b)，Z
    """
    grads = {}
    L = len(caches)  # 2
    Y = Y.reshape(AL.shape)  # 让真实标签与预测标签的维度一致

    dAL = -np.divide(Y, AL) + np.divide(1 - Y, 1 - AL)  # dA2
    # 计算最后一层的dW和db，由成本函数来计算
    current_cache = caches[-1]  # 1,2
    grads[f"dA{L - 1}"], grads[f"dW{L}"], grads[f"db{L}"] = linear_activation_backward(dAL, current_cache,
                                                                                       "sigmoid")  # dA1, dW2, db2
    # 计算前L-1层的dw和db，因为最后一层用的是sigmoid，
    for c in reversed(range(1, L)):  # reversed(range(1,L))的结果是L-1,L-2...1。是不包括L的。第0层是输入层，不必计算。 caches[0,1] L = 2  1,1
        # c表示当前层
        grads[f"dA{c - 1}"], grads[f"dW{c}"], grads[f"db{c}"] = linear_activation_backward(grads[f"dA{c}"],
                                                                                           caches[c - 1],
                                                                                           "relu")
    return grads


def update_parameters(parameters, grads, learning_rate):
    L = len(parameters) // 2
    for l in range(1, L + 1):
        parameters[f"W{l}"] = parameters[f"W{l}"] - grads[f"dW{l}"] * learning_rate
        parameters[f"b{l}"] = parameters[f"b{l}"] - grads[f"db{l}"] * learning_rate
    return parameters


def dnn_model(X, Y, layers_dim, learning_rate=0.0075, num_iterations=3000, print_cost=False):
    np.random.seed(1)
    costs = []
    parameters = initialize_parameters_deep(layers_dim)
    for i in range(0, num_iterations):
        AL, caches = L_model_forward(X, parameters)
        cost = compute_cost(AL, Y)
        grads = L_model_backward(AL, Y, caches)
        parameters = update_parameters(parameters, grads, learning_rate)
        if print_cost and i % 100 == 0:
            print("训练%i次后成本是: %f" % (i, cost))
        costs.append(cost)
    # 画出成本曲线图
    plt.plot(np.squeeze(costs))
    plt.ylabel('cost')
    plt.xlabel('iterations (per tens)')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()
    return parameters


def predict(X, parameters):
    m = X.shape[1]
    n = len(parameters) // 2
    p = np.zeros((1, m))
    probas, caches = L_model_forward(X, parameters)
    # 将预测结果转化成0和1的形式，即大于0.5的就是1，否则就是0
    for i in range(0, probas.shape[1]):
        if probas[0, i] > 0.5:
            p[0, i] = 1
        else:
            p[0, i] = 0

    return p


if __name__ == "__main__":
    train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()
    # 我们要清楚变量的维度，否则后面会出很多问题。下面我把他们的维度打印出来。

    train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T
    test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T
    print("train_set_x_flatten shape: " + str(train_set_x_flatten.shape))
    print("test_set_x_flatten shape: " + str(test_set_x_flatten.shape))

    train_set_x = train_set_x_flatten / 255
    test_set_x = test_set_x_flatten / 255

    layers_dims = [12288, 20, 7, 5, 1]
    # 根据上面的层次信息来构建一个深度神经网络，并且用之前加载的数据集来训练这个神经网络，得出训练后的参数
    parameters = dnn_model(train_set_x, train_set_y, layers_dims, num_iterations=2000, print_cost=True)
    # 对训练数据集进行预测
    pred_train = predict(train_set_x, parameters)
    print("预测准确率是: " + str(np.sum((pred_train == train_set_y) / train_set_x.shape[1])))

    # 对测试数据集进行预测
    pred_test = predict(test_set_x, parameters)
    print("预测准确率是: " + str(np.sum((pred_test == test_set_y) / test_set_x.shape[1])))