反向传播算法(BP)原理解析与实现：从数学推导到Python实战

1次阅读

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

在神经网络训练中，我们需要调整权重参数使得损失函数最小化。传统方法如有限差分法计算梯度时，每个参数都需要单独调整并重新计算损失，时间复杂度高达 O(n²)。对于百万级参数的现代网络，这种方法完全不可行。

反向传播算法通过链式法则高效计算所有参数的梯度，将复杂度降至 O(n)，解决了深层网络训练的核心瓶颈。

给定复合函数 f(g(x))，其导数为：

\frac{df}{dx} = \frac{df}{dg} \cdot \frac{dg}{dx}

设网络输出为：

a^{(3)} = f(W^{(2)}f(W^{(1)}x + b^{(1)}) + b^{(2)})

损失函数 L 对第二层权重的梯度：

\frac{\partial L}{\partial W^{(2)}} = \frac{\partial L}{\partial a^{(3)}} \cdot \frac{\partial a^{(3)}}{\partial z^{(3)}} \cdot \frac{\partial z^{(3)}}{\partial W^{(2)}}

其中 z 表示加权输入，a 表示激活输出。

import numpy as np

class NeuralNetwork:
    def __init__(self, layers):
        self.weights = [np.random.randn(y, x)*0.1 
                        for x, y in zip(layers[:-1], layers[1:])]
        self.biases = [np.zeros((y, 1)) for y in layers[1:]]

    def forward(self, x):
        for w, b in zip(self.weights, self.biases):
            x = sigmoid(np.dot(w, x) + b)
        return x

    def backward(self, x, y):
        # 初始化梯度容器
        grad_w = [np.zeros_like(w) for w in self.weights]
        grad_b = [np.zeros_like(b) for b in self.biases]

        # 前向传播缓存中间值
        activation = x
        activations = [x]
        zs = []

        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, activation) + b
            zs.append(z)
            activation = sigmoid(z)
            activations.append(activation)

        # 反向传播
        delta = (activations[-1] - y) * sigmoid_prime(zs[-1])
        grad_b[-1] = delta
        grad_w[-1] = np.dot(delta, activations[-2].T)

        for l in range(2, len(self.weights)+1):
            z = zs[-l]
            delta = np.dot(self.weights[-l+1].T, delta) * sigmoid_prime(z)
            grad_b[-l] = delta
            grad_w[-l] = np.dot(delta, activations[-l-1].T)

        return grad_w, grad_b

def sigmoid(x):
    return 1/(1+np.exp(-x))

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