DeepLearning - Part1 Week 2（2）

本文为吴恩达DeepLearning课程的学习笔记。

关于神经网络的基本表示概念不再赘述。这里记录下有关激活函数的一些知识点，这里曾经在我刚开始接触机器学习的时候比较迷惑。代码实现了一层隐藏层的神经网络。

1.激活函数
激活函数的作用：对线性输入引入非线性因素，提高神经网络对模型的表达能力，从而更好的拟合不同的非线性函数。

2.常用激活函数优缺点对比

sigmoid激活函数，除非用在二分类问题的输出层，否则一般情况下不使用。
优点：sigmoid函数的输出映射在（0，1）之间，优化稳定，容易求导。
缺点：计算成本高，容易出现梯度消失。因为不是以0为中心，收敛速度较慢。

sigmoid
tanh激活函数，该激活函数十分通用，几乎在所有场合都更优越。
优点：将sigmoid函数改变为以0为中心，导数范围变大。梯度消失问题有所缓解。
缺点：幂运算，计算成本高。仍存在梯度消失问题。

tanh
ReLU激活函数，是最常用的默认激活函数。
优点：收敛速度快，极大的改善了梯度消失问题。运算速度更快。
缺点：对参数初始化和学习率十分敏感，存在神经元死亡。

ReLU

3.代码实现

layer_size ：获取训练集X的shape和Y的shape，用来构建神经网络的输入层和输出层。
initialize_parameters ：初始化参数，使用随机数初始化神经网络参数。
forward_propagation：正向传播，隐藏层使用tanh作为激活函数，输出层使用sigmoid作为激活函数（二分类问题）。
compute_cost：计算预测值和真实值之间的cost。
backward_propagation：反向传播，计算参数的梯度，用于更新参数。
update_parameters：更新参数，使用梯度下降算法。
nn_model ：神经网络的训练流程。
predict：预测。

流程图

def layer_size(X, Y):
    n_x = X.shape[0]
    n_y = Y.shape[0]

    return (n_x, n_y)


def initialize_parameters(n_x, n_h, n_y):
    np.random.seed(2)
    W1 = np.random.randn(n_h, n_x)
    b1 = np.zeros((n_h, 1))
    W2 = np.random.randn(n_y, n_h)
    b2 = np.zeros((n_y, 1))

    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2
                  }
    return parameters


def forward_propagation(X, parameters):
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]

    Z1 = np.dot(W1, X) + b1
    A1 = np.tanh(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = sigmoid(Z2)

    cache = {"Z1": Z1,
             "A1": A1,
             "Z2": Z2,
             "A2": A2}

    return A2, cache


def compute_cost(A2, Y, parameters):
    m = Y.shape[1]

    logprobs = np.multiply(np.log(A2), Y) + np.multiply(np.log(1 - A2), (1 - Y))
    cost = -1.0 / m * np.sum(logprobs)

    cost = np.squeeze(cost)
    return cost


def backward_propagation(parameters, cache, X, Y):
    m = X.shape[1]

    W1 = parameters['W1']
    W2 = parameters['W2']

    A1 = cache['A1']
    A2 = cache['A2']

    dZ2 = A2 - Y
    dW2 = 1.0 / m * np.dot(dZ2, A1.T)
    db2 = 1.0 / m * np.sum(dZ2, axis=1, keepdims=True)
    dZ1 = np.dot(W2.T, dZ2) * (1 - np.power(A1, 2))
    dW1 = 1.0 / m * np.dot(dZ1, X.T)
    db1 = 1.0 / m * np.sum(dZ1, axis=1, keepdims=True)

    grads = {"dW1": dW1,
             "dW2": dW2,
             "db1": db1,
             "db2": db2}
    return grads


def update_parameters(parameters, grads, learning_rate=1.2):
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]

    dW1 = grads["dW1"]
    db1 = grads["db1"]
    dW2 = grads["dW2"]
    db2 = grads["db2"]

    W1 = W1 - learning_rate * dW1
    b1 = b1 - learning_rate * db1
    W2 = W2 - learning_rate * dW2
    b2 = b2 - learning_rate * db2

    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}

    return parameters


def nn_model(X, Y, n_h, num_iterations=10000, print_cost=False):
    np.random.seed(3)
    n_x = layer_size(X, Y)[0]
    n_y = layer_size(X, Y)[1]

    parameters = initialize_parameters(n_x, n_h, n_y)

    for i in range(num_iterations):
        A2, cache = forward_propagation(X, parameters)
        cost = compute_cost(A2, Y, parameters)
        grads = backward_propagation(parameters, cache, X, Y)
        parameters = update_parameters(parameters, grads, learning_rate=1.2)

        if print_cost and i % 1000 == 0:
            print("Cost after iteration %i: %f" % (i, cost))

    return parameters


def predict(parameters, X):
    A2, cache = forward_propagation(X,parameters)
    predictions = (A2 > 0.5)
    return predictions