BP神经网络框架图解析：从理论到高效实现

1次阅读

没有评论

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

BP 神经网络作为经典的监督学习模型，在实际应用中常面临两个核心问题：训练效率低下和梯度消失现象。训练效率问题主要体现在大规模数据集上迭代速度慢，而梯度消失则导致深层网络难以有效学习底层特征。这两个问题直接影响模型的收敛速度和最终性能。

SGD（随机梯度下降）：基础优化算法，实现简单但收敛速度慢，容易陷入局部最优
Momentum：加入动量项，加速收敛并减少震荡
Adam：结合自适应学习率和动量，在大多数场景下表现优异

通过对比实验发现，在 BP 神经网络中，Adam 通常能达到比 SGD 快 2 - 3 倍的收敛速度，特别是在处理稀疏数据时优势更明显。

BP 神经网络的计算密集型部分可通过矩阵运算大幅优化：

前向传播：
```
Z = XW + b
A = σ(Z)
```
其中 σ 为激活函数
反向传播：
```
dZ = dA * σ'(Z)
dW = X.T @ dZ / m
db = np.sum(dZ, axis=0) / m
```
这种向量化实现可比循环实现快 10 倍以上

import numpy as np

class BPNeuralNetwork:
    def __init__(self, layer_dims):
        # 初始化权重和偏置
        self.parameters = {}
        for l in range(1, len(layer_dims)):
            self.parameters[f'W{l}'] = np.random.randn(layer_dims[l], layer_dims[l-1]) * 0.01
            self.parameters[f'b{l}'] = np.zeros((layer_dims[l], 1))

    def forward(self, X):
        # 前向传播实现
        caches = []
        A = X
        L = len(self.parameters) // 2

        for l in range(1, L):
            A_prev = A
            Z = np.dot(self.parameters[f'W{l}'], A_prev) + self.parameters[f'b{l}']
            A = self.relu(Z)
            caches.append((A_prev, Z))

        # 输出层使用 sigmoid
        ZL = np.dot(self.parameters[f'W{L}'], A) + self.parameters[f'b{L}']
        AL = self.sigmoid(ZL)
        caches.append((A, ZL))

        return AL, caches

    def backward(self, 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]
        grads[f'dZ{L}'] = dAL * self.sigmoid_derivative(current_cache[1])
        grads[f'dW{L}'] = np.dot(grads[f'dZ{L}'], current_cache[0].T) / m
        grads[f'db{L}'] = np.sum(grads[f'dZ{L}'], axis=1, keepdims=True) / m

        for l in reversed(range(L-1)):
            current_cache = caches[l]
            dA_prev = np.dot(self.parameters[f'W{l+2}'].T, grads[f'dZ{l+2}'])
            dZ = dA_prev * self.relu_derivative(current_cache[1])
            grads[f'dW{l+1}'] = np.dot(dZ, current_cache[0].T) / m
            grads[f'db{l+1}'] = np.sum(dZ, axis=1, keepdims=True) / m
            grads[f'dZ{l+1}'] = dZ

        return grads

在 MNIST 数据集上的测试结果显示：