Deep Learning Specialization深度学习与神经网络入门

2. 激活函数

在神经网络中，激活函数扮演着重要的角色。它为神经网络添加了非线性因素，使得神经网络可以拟合更复杂的模型。在本章中，我们将详细介绍几种常见的激活函数及其特性。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

2.1 Sigmoid函数

Sigmoid函数是最早被使用在神经网络中的激活函数，表达式为：

它的特点是其输出在(0, 1)之间，因此可以被解释为概率。并且，当z趋向于正无穷，a趋近于1，而当z趋向于负无穷，a趋近于0。，因此在二分类问题中常常被用作输出层的激活函数，将输出解释为概率。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

Sigmoid函数在分类算法Logistic回归中被广泛使用，这个算法主要用于二分类问题。它的目标是找到一个模型，可以根据输入的特征预测出一个事件发生的概率。这个预测的概率就是Logistic回归模型的输出。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

然而，Sigmoid函数在输入值的绝对值较大时，函数的梯度接近于0，这将导致梯度消失，使得神经网络的训练变得困难。此外，Sigmoid函数的输出不是以0为中心的，这可能会导致训练过程中的收敛速度变慢。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

2.2 Tanh函数

Tanh函数可以看作是Sigmoid函数的扩展，它将输入压缩到(-1,1)。Tanh函数的表达式为：

由于Tanh函数的输出是以0为中心的，因此在实践中，Tanh函数通常比Sigmoid函数的表现要好。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

然而，Tanh函数仍然存在梯度消失的问题，当输入值的绝对值较大时，函数的梯度接近于0。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

2.3 ReLU函数(Rectified Linear Unit 、线性整流函数、修正线性单元)

ReLU函数是目前在神经网络中常用的激活函数。ReLU函数的表达式为：

ReLU函数在x>0时保持输入不变，在x<0时输出为0。由于ReLU函数在x>0时梯度为1，在x<0时梯度为0，因此ReLU函数在一定程度上缓解了梯度消失的问题。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

然而，ReLU函数在x<0时完全不激活，这可能会导致一些神经元死亡，即在训练过程中永远不会被激活。此外，ReLU函数的输出也不是以0为中心的。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

2.4 Leaky ReLU函数

为了解决ReLU函数在x<0时可能导致的神经元死亡问题，人们提出了Leaky ReLU函数。Leaky ReLU函数的表达式为：
与ReLU函数相比，Leaky ReLU函数在x<0时的斜率为0.01，这意味着Leaky ReLU函数在x<0时仍然有小的梯度，因此可以缓解神经元死亡的问题。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

激活函数是神经网络中的重要组成部分，理解不同激活函数的性质和适用场景，可以帮助我们更好地设计和优化神经网络。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

3. 前向传播

在深度学习中，前向传播（Forward Propagation）是一种非常基础且关键的过程。前向传播涉及将输入数据传递通过神经网络并计算出结果。本章将详细阐述前向传播的过程，并给出一些相关的数学细节。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

3.1 前向传播的概念

首先，我们来理解什么是前向传播。在神经网络中，每一层的节点都是由前一层的节点通过某种计算得来的，这个计算的过程就是前向传播。具体地说，对于每一层，我们都会首先计算一个线性组合（即，对输入进行加权求和），然后再通过一个激活函数进行非线性变换。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

在数学上，对于第层的每个节点，其线性组合可以写作，其中是连接第层的第个节点和第层的第个节点的权重，是第层的第个节点的激活值，是第层的第个节点的偏置。接下来，我们会将输入到一个激活函数中，得到该节点的激活值。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

3.2 线性部分的计算

为了更有效地处理多个节点和多个样本，我们通常使用矩阵和向量的形式来表示和计算线性部分。假设我们现在有个样本，那么我们可以将这些样本的输入表示为一个的矩阵，其中是输入的大小（即，第0层，也就是输入层的节点数），是样本的数量。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

对于第层，我们可以将其权重表示为一个的矩阵，将其偏置表示为一个的向量，其中是第层的节点数，是第层的节点数。这样，对于所有的样本，我们可以一次性计算第层所有节点的线性组合，即，其中是第层所有节点的激活值。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

3.3 非线性部分的计算

得到线性部分后，我们需要通过一个激活函数进行非线性变换。这里的激活函数可以是任何非线性函数，常见的有Sigmoid函数、tanh函数、ReLU函数、Leaky ReLU函数等。使用激活函数的目的是为了引入非线性，使得神经网络可以逼近任何函数。如果我们不使用激活函数，那么无论神经网络有多少层，其总是等价于一个线性模型，这大大限制了神经网络的表达能力。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

对于第层，我们将输入到激活函数中，得到激活值。同样，为了一次性处理所有的样本，我们可以将看作是一个的矩阵，其中每一列对应一个样本，每一行对应一个节点。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

3.4 结果的计算

当我们计算到最后一层，也就是输出层时，我们就得到了神经网络的输出结果。对于二分类问题，我们通常使用Sigmoid函数作为输出层的激活函数，这样得到的结果可以看作是正类的概率；对于多分类问题，我们通常使用softmax函数作为输出层的激活函数，这样得到的结果可以看作是每个类别的概率。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

在前向传播结束后，我们会计算损失函数，比较预测结果和真实标签的差距。然后在后向传播中，我们会根据这个差距来更新网络的参数，使得预测结果更接近真实标签。这就是神经网络的训练过程。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

以上就是前向传播的过程，虽然涉及到了一些线性代数和微积分的知识，但总的来说，前向传播只是一种将输入数据转换为输出结果的过程，而这个过程是完全确定的，只依赖于输入数据和网络参数。理解了前向传播，我们就理解了神经网络如何从输入得到输出，也就理解了神经网络的“前半部分”。接下来我们将讨论后向传播，也就是神经网络的“后半部分”。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/ai/53813.html

# 定义sigmoid函数
def sigmoid(Z):
    A = 1 / (1 + np.exp(-Z))
    cache = Z
    return A, cache

# 前向传播函数
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, cache = sigmoid(Z2)

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

    return A2, cache

# 计算CostFunction
def compute_cost(A2, Y):
    m = Y.shape[1]

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

    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 / m) * np.dot(dZ2, A1.T)
    db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)
    dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2))
    dW1 = (1 / m) * np.dot(dZ1, X.T)
    db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)

    grads = {"dW1": dW1,
             "db1": db1,
             "dW2": dW2,
             "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 optimize(parameters, X, Y, num_iterations=10000, learning_rate=1.2, print_cost=False):
    costs = []

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

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

    return parameters, costs

def model(X_train, Y_train, X_test, Y_test, n_h=4, num_iterations=10000, learning_rate=1.2, print_cost=True):
    np.random.seed(3)

    n_x = X_train.shape[0]
    n_y = Y_train.shape[0]

    parameters = initialize_parameters(n_x, n_h, n_y)
    parameters, costs = optimize(parameters, X_train, Y_train, num_iterations, learning_rate, print_cost)

    return parameters, costs