BP神经网络流程图解析：从数学原理到Python实现

1次阅读

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

在手动实现神经网络时，很多开发者会遇到梯度计算混乱和维度不匹配的问题。特别是当网络层数增加时，反向传播的链式求导很容易出错。我曾经在一个项目中尝试手动实现 3 层神经网络，就因为梯度计算错误导致模型无法收敛，浪费了大量调试时间。

另一个常见问题是维度不匹配。比如在全连接层中，权重的维度需要严格遵循 (W_{i,j}) 其中 i 是当前层神经元数量，j 是下一层神经元数量。一个简单的转置错误就可能让整个前向传播崩溃。

对比维度	手动实现 BP	使用框架(如 PyTorch)
开发效率	低，需要手动推导和实现所有公式	高，自动求导和优化器内置
理解深度	深入理解算法细节	可能成为 ” 调包侠 ”
调试难度	高，需要自己检查梯度计算	低，框架会自动验证
性能优化	需要手动优化矩阵运算	内置高效 CUDA 实现
灵活性	完全可控，可定制任何细节	受限于框架 API

flowchart TD
    A[输入层] --> B[隐藏层 1]
    B --> C[隐藏层 2]
    C --> D[输出层]
    D --> E[损失计算]
    E --> F[反向传播]
    F --> B
    F --> C

前向传播：

对于第 l 层，计算为：
$$z^l = W^l a^{l-1} + b^l$$
$$a^l = \sigma(z^l)$$

其中 $\sigma$ 是激活函数(如 Sigmoid)。

损失计算：

采用均方误差：
$$L = \frac{1}{2N}\sum_{i=1}^N(y_i – a^L_i)^2$$

反向传播：

输出层误差：
$$\delta^L = (a^L – y) \odot \sigma'(z^L)$$

隐藏层误差：
$$\delta^l = (W^{l+1})^T \delta^{l+1} \odot \sigma'(z^l)$$

梯度计算：
$$\frac{\partial L}{\partial W^l} = \delta^l (a^{l-1})^T$$
$$\frac{\partial L}{\partial b^l} = \delta^l$$

import numpy as np

class BPNetwork:
    def __init__(self, layers):
        """
        初始化网络
        :param layers: 每层神经元数量，如 [4,5,3] 表示 3 层网络
        """
        self.weights = [np.random.randn(y, x)*0.1 
                        for x, y in zip(layers[:-1], layers[1:])]
        self.biases = [np.random.randn(y, 1)*0.1 
                       for y in layers[1:]]

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

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

    def forward(self, x):
        """前向传播"""
        a = x
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, a) + b
            a = self.sigmoid(z)
        return a

    def train(self, X, y, epochs=1000, lr=0.1):
        """训练网络"""
        for _ in range(epochs):
            # 随机选择一个样本
            i = np.random.randint(len(X))
            x = X[i].reshape(-1,1)
            target = y[i].reshape(-1,1)

            # 前向传播
            activations = [x]
            zs = []
            for w, b in zip(self.weights, self.biases):
                z = np.dot(w, activations[-1]) + b
                zs.append(z)
                activations.append(self.sigmoid(z))

            # 反向传播
            delta = (activations[-1] - target) * self.sigmoid_prime(zs[-1])
            nabla_w = [np.zeros_like(w) for w in self.weights]
            nabla_b = [np.zeros_like(b) 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.weights)+1):
                delta = np.dot(self.weights[-l+1].T, delta) * self.sigmoid_prime(zs[-l])
                nabla_w[-l] = np.dot(delta, activations[-l-1].T)
                nabla_b[-l] = delta

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