BP神经网络介绍：从数学原理到Python实战

1次阅读

没有评论

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

神经网络是一种模仿生物神经元连接方式的计算模型。一个典型的神经网络由输入层、隐藏层和输出层组成，每层包含若干神经元。神经元之间通过带有权重的连接传递信号，这些权重会在训练过程中不断调整。

BP（Back Propagation）神经网络是最经典的前馈神经网络之一，其核心思想是通过误差反向传播来调整网络参数。下面我们重点解析 BP 算法的数学原理。

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

$$a_j^l = \sigma(\sum_k w_{jk}^l a_k^{l-1} + b_j^l)$$

其中 $\sigma$ 是激活函数，常用 Sigmoid、ReLU 等。

为了衡量网络输出与真实值的差距，我们需要定义损失函数。对于分类问题，常用交叉熵损失：

$$L = -\frac{1}{N}\sum_{i=1}^N \sum_{j=1}^C y_{ij}\log(p_{ij})$$

反向传播的核心是链式法则。我们首先计算输出层的误差：

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

然后逐层反向传播误差：

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

最后计算权重和偏置的梯度：

$$\frac{\partial L}{\partial w_{jk}^l} = a_k^{l-1} \delta_j^l$$
$$\frac{\partial L}{\partial b_j^l} = \delta_j^l$$

使用梯度下降法更新参数：

$$w_{jk}^l = w_{jk}^l – \eta \frac{\partial L}{\partial w_{jk}^l}$$
$$b_j^l = b_j^l – \eta \frac{\partial L}{\partial b_j^l}$$

其中 $\eta$ 是学习率。

与线性回归相比：BP 神经网络可以学习非线性关系
与决策树相比：BP 神经网络更适合处理连续特征
与 SVM 相比：BP 神经网络在大数据集上表现更好
缺点：训练时间长，需要大量数据，解释性差

下面是使用 NumPy 实现的 BP 神经网络完整代码：

import numpy as np
from sklearn.datasets import load_digits
from sklearn.preprocessing import OneHotEncoder

class BPNeuralNetwork:
    def __init__(self, layers, learning_rate=0.1, epochs=1000):
        self.layers = layers  # 各层神经元数量，如 [64, 32, 10]
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.weights = []
        self.biases = []

        # 初始化权重和偏置
        for i in range(len(layers)-1):
            # Xavier 初始化
            w = np.random.randn(layers[i], layers[i+1]) * np.sqrt(2.0/layers[i])
            b = np.zeros((1, layers[i+1]))
            self.weights.append(w)
            self.biases.append(b)

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

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

    def softmax(self, x):
        exps = np.exp(x - np.max(x))
        return exps / np.sum(exps, axis=1, keepdims=True)

    def forward(self, X):
        self.activations = [X]
        self.zs = []

        for i in range(len(self.weights)):
            z = np.dot(self.activations[-1], self.weights[i]) + self.biases[i]
            self.zs.append(z)

            if i == len(self.weights)-1:
                a = self.softmax(z)  # 输出层用 softmax
            else:
                a = self.sigmoid(z)  # 隐藏层用 sigmoid

            self.activations.append(a)

        return self.activations[-1]

    def backward(self, X, y):
        deltas = [None] * len(self.weights)
        m = X.shape[0]

        # 输出层误差
        error = self.activations[-1] - y
        deltas[-1] = error

        # 反向传播误差
        for i in range(len(self.weights)-2, -1, -1):
            error = np.dot(deltas[i+1], self.weights[i+1].T) * self.sigmoid_derivative(self.activations[i+1])
            deltas[i] = error

        # 更新权重和偏置
        for i in range(len(self.weights)):
            dw = np.dot(self.activations[i].T, deltas[i]) / m
            db = np.sum(deltas[i], axis=0, keepdims=True) / m

            self.weights[i] -= self.learning_rate * dw
            self.biases[i] -= self.learning_rate * db

    def train(self, X, y):
        for epoch in range(self.epochs):
            output = self.forward(X)
            self.backward(X, y)

            if epoch % 100 == 0:
                loss = -np.mean(y * np.log(output + 1e-10))
                print(f"Epoch {epoch}, Loss: {loss:.4f}")

    def predict(self, X):
        output = self.forward(X)
        return np.argmax(output, axis=1)

# 加载 MNIST 数据
digits = load_digits()
X = digits.data / 16.0  # 归一化到 0 -1
encoder = OneHotEncoder(sparse=False)
y = encoder.fit_transform(digits.target.reshape(-1, 1))

# 创建网络
network = BPNeuralNetwork(layers=[64, 32, 10], learning_rate=0.1, epochs=1000)

# 训练
network.train(X, y)

# 预测
predictions = network.predict(X)
accuracy = np.mean(predictions == digits.target)
print(f"Accuracy: {accuracy:.4f}")

梯度消失问题常发生在使用 Sigmoid 激活函数的深层网络中，因为其导数最大值为 0.25，多次连乘会导致梯度指数级减小。解决方案：