深度学习基础：2.1.5前向传播与反向传播算法原理与实现详解

1次阅读

共计 2500 个字符，预计需要花费 7 分钟才能阅读完成。

在开始前向传播和反向传播的讨论之前，我们需要了解神经网络的基本结构。一个典型的神经网络由输入层、隐藏层和输出层组成。每一层都由多个神经元（或称为节点）构成，相邻层之间的神经元通过权重连接。激活函数则用于引入非线性，使神经网络能够拟合复杂的函数。

前向传播是神经网络进行预测的过程。给定输入数据，信号从输入层通过隐藏层传递到输出层。具体步骤如下：

输入层接收原始数据，作为第一层的输入。
每一层的输出是上一层的输出与权重矩阵的点积，加上偏置项，然后通过激活函数。

数学表达式为：

$$ a^{(l)} = f(W^{(l)} a^{(l-1)} + b^{(l)}) $$

其中，$a^{(l)}$ 表示第 $l$ 层的激活值，$W^{(l)}$ 是连接第 $l-1$ 层和第 $l$ 层的权重矩阵，$b^{(l)}$ 是偏置向量，$f$ 是激活函数（如 ReLU、sigmoid 等）。

反向传播算法用于计算损失函数对网络参数的梯度，以便通过梯度下降更新权重。其核心是链式法则，步骤如下：

计算输出层的误差项：

$$ \delta^{(L)} = \frac{\partial J}{\partial a^{(L)}} \odot f'(z^{(L)}) $$

其中，$J$ 是损失函数，$z^{(L)} = W^{(L)} a^{(L-1)} + b^{(L)}$，$\odot$ 表示逐元素乘法。

反向传播误差到前一层：

$$ \delta^{(l)} = (W^{(l+1)})^T \delta^{(l+1)} \odot f'(z^{(l)}) $$

计算权重和偏置的梯度：

$$ \frac{\partial J}{\partial W^{(l)}} = \delta^{(l)} (a^{(l-1)})^T $$

$$ \frac{\partial J}{\partial b^{(l)}} = \delta^{(l)} $$

下面是一个使用 NumPy 实现前向传播和反向传播的示例代码：

import numpy as np

# 定义激活函数及其导数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return sigmoid(x) * (1 - sigmoid(x))

# 初始化参数
def initialize_parameters(layer_dims):
    parameters = {}
    L = len(layer_dims)
    for l in range(1, L):
        parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) * 0.01
        parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))
    return parameters

# 前向传播
def forward_propagation(X, parameters):
    caches = []
    A = X
    L = len(parameters) // 2
    for l in range(1, L + 1):
        A_prev = A
        W = parameters['W' + str(l)]
        b = parameters['b' + str(l)]
        Z = np.dot(W, A_prev) + b
        A = sigmoid(Z)
        caches.append((A_prev, W, b, Z))
    return A, caches

# 反向传播
def backward_propagation(AL, Y, caches):
    grads = {}
    L = len(caches)
    m = AL.shape[1]
    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
    current_cache = caches[L-1]
    A_prev, W, b, Z = current_cache
    dZ = dAL * sigmoid_derivative(Z)
    dW = np.dot(dZ, A_prev.T) / m
    db = np.sum(dZ, axis=1, keepdims=True) / m
    grads['dW' + str(L)] = dW
    grads['db' + str(L)] = db
    for l in reversed(range(L-1)):
        current_cache = caches[l]
        A_prev, W, b, Z = current_cache
        dA_prev = np.dot(W.T, dZ)
        dZ = dA_prev * sigmoid_derivative(Z)
        dW = np.dot(dZ, A_prev.T) / m
        db = np.sum(dZ, axis=1, keepdims=True) / m
        grads['dW' + str(l + 1)] = dW
        grads['db' + str(l + 1)] = db
    return grads

前向传播和反向传播的时间复杂度主要取决于矩阵乘法的操作。对于每一层，矩阵乘法的时间复杂度为 $O(n^{[l]} \times n^{[l-1]} \times m)$，其中 $n^{[l]}$ 是第 $l$ 层的神经元数量，$m$ 是样本数量。因此，整个网络的时间复杂度为各层时间复杂度的总和。

批量计算可以显著提高效率，因为现代深度学习框架（如 TensorFlow、PyTorch）能够利用 GPU 的并行计算能力加速矩阵运算。

在实现前向传播和反向传播时，容易遇到以下问题：