深度学习中的bp反向传播链式法则：原理剖析与实现细节

1次阅读

没有评论

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

神经网络训练的核心目标是找到一组参数（权重和偏置），使得模型在给定数据上的预测误差最小化。这个过程通常通过梯度下降法来实现，而反向传播（Backpropagation，简称 BP）则是计算这些梯度的关键算法。

为什么需要反向传播？直接计算每个参数的梯度在深层网络中计算量巨大，反向传播通过链式法则高效地分解了梯度计算过程，使得训练深层网络成为可能。

链式法则是微积分中的一个基本定理，用于计算复合函数的导数。在神经网络中，损失函数是多个嵌套函数的复合，链式法则允许我们将梯度计算分解为局部梯度的乘积。

数学表达式如下：

[\frac{\partial L}{\partial w} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial w} ]

其中，(L) 是损失函数，(y) 是网络的输出，(w) 是权重参数。

反向传播算法可以分为两个主要步骤：前向传播和反向传播。

前向传播 ：输入数据通过网络的每一层，计算每一层的输出，直到得到最终的预测值。
反向传播 ：从输出层开始，计算损失函数对每一层参数的梯度，利用链式法则将梯度从后向前传递。

具体步骤如下：

计算输出层的梯度：(\delta^L = \nabla_a L \odot \sigma'(z^L) )
对于每一层 (l)，从后向前计算梯度：(\delta^l = ((w^{l+1})^T \delta^{l+1}) \odot \sigma'(z^l) )
计算权重和偏置的梯度：(\nabla_{w^l} L = \delta^l (a^{l-1})^T ), (\nabla_{b^l} L = \delta^l )

下面是一个简单的两层神经网络的反向传播实现：

import numpy as np

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

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

# 定义网络结构
input_size = 3
hidden_size = 4
output_size = 1

# 初始化权重和偏置
w1 = np.random.randn(input_size, hidden_size)
b1 = np.random.randn(hidden_size)
w2 = np.random.randn(hidden_size, output_size)
b2 = np.random.randn(output_size)

# 前向传播
def forward(X):
    z1 = np.dot(X, w1) + b1
    a1 = sigmoid(z1)
    z2 = np.dot(a1, w2) + b2
    a2 = sigmoid(z2)
    return a1, a2

# 反向传播
def backward(X, y, a1, a2, learning_rate=0.1):
    # 计算输出层误差
    error = a2 - y
    delta2 = error * sigmoid_derivative(a2)

    # 计算隐藏层误差
    error_hidden = np.dot(delta2, w2.T)
    delta1 = error_hidden * sigmoid_derivative(a1)

    # 更新权重和偏置
    w2 -= learning_rate * np.dot(a1.T, delta2)
    b2 -= learning_rate * np.sum(delta2, axis=0)
    w1 -= learning_rate * np.dot(X.T, delta1)
    b1 -= learning_rate * np.sum(delta1, axis=0)

# 训练过程
X = np.array([[0, 0, 1], [0, 1, 1], [1, 0, 1], [1, 1, 1]])
y = np.array([[0], [1], [1], [0]])

for epoch in range(10000):
    a1, a2 = forward(X)
    backward(X, y, a1, a2)

    if epoch % 1000 == 0:
        print(f'Epoch {epoch}, Loss: {np.mean(np.square(a2 - y))}')

反向传播的计算复杂度主要取决于网络的结构和输入数据的维度。对于一个具有 (L) 层、每层 (n) 个神经元的网络，计算复杂度大致为 (O(L \cdot n^2) )。

为了优化性能，可以采用以下方法：