BP神经网络推导：从数学原理到Python实现

1次阅读

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

BP 神经网络（Backpropagation Neural Network）是一种多层前馈神经网络，通过误差反向传播算法来训练网络权重。它的核心思想是通过比较网络输出与真实标签之间的误差，逐层反向调整权重参数，最终使得网络输出尽可能接近真实值。

BP 神经网络通常由三部分组成：

输入层：接收原始特征数据
隐藏层：进行特征变换和非线性映射
输出层：产生最终预测结果

前向传播是指数据从输入层经过隐藏层最终到达输出层的过程。对于第 l 层的第 j 个神经元，其输出可以表示为：

$$
a_j^l = f\left(\sum_{i} w_{ji}^l a_i^{l-1} + b_j^l\right)
$$

其中：
– $w_{ji}^l$ 表示第 l - 1 层第 i 个神经元到第 l 层第 j 个神经元的连接权重
– $b_j^l$ 表示第 l 层第 j 个神经元的偏置
– $f(\cdot)$ 是激活函数

反向传播算法的核心是通过链式法则计算损失函数对各个参数的梯度。定义第 l 层第 j 个神经元的误差项为：

$$
\delta_j^l = \frac{\partial L}{\partial z_j^l}
$$

其中 $z_j^l$ 是第 l 层第 j 个神经元的加权输入。

对于输出层（假设为第 L 层），误差项为：

$$
\delta_j^L = \frac{\partial L}{\partial a_j^L} f'(z_j^L)
$$

对于隐藏层，误差反向传播公式为：

$$
\delta_j^l = \left(\sum_k w_{kj}^{l+1} \delta_k^{l+1}\right) f'(z_j^l)
$$

最终，权重和偏置的梯度为：

$$
\frac{\partial L}{\partial w_{ji}^l} = a_i^{l-1} \delta_j^l \
\frac{\partial b_{j}^l} = \delta_j^l
$$

import numpy as np

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

    def sigmoid(self, z):
        return 1.0 / (1.0 + np.exp(-z))

    def sigmoid_prime(self, z):
        return self.sigmoid(z) * (1 - self.sigmoid(z))

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

    def train(self, X, y, epochs, learning_rate):
        for _ in range(epochs):
            for x, target in zip(X, y):
                # 前向传播
                activation = x
                activations = [x]
                zs = []
                for w, b in zip(self.weights, self.biases):
                    z = np.dot(w, activation) + b
                    zs.append(z)
                    activation = self.sigmoid(z)
                    activations.append(activation)

                # 反向传播
                delta = (activations[-1] - target) * \
                        self.sigmoid_prime(zs[-1])
                nabla_w = [np.zeros(w.shape) for w in self.weights]
                nabla_b = [np.zeros(b.shape) for b in self.biases]
                nabla_w[-1] = np.dot(delta, activations[-2].T)
                nabla_b[-1] = delta

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

                # 更新权重
                self.weights = [w - learning_rate * nw 
                                for w, nw in zip(self.weights, nabla_w)]
                self.biases = [b - learning_rate * nb 
                               for b, nb in zip(self.biases, nabla_b)]

梯度消失问题通常发生在深层网络中，由于激活函数的导数小于 1，导致误差在反向传播过程中指数级衰减。解决方案包括：