BP神经网络预测入门实战：从数学原理到Python实现

1次阅读

没有评论

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

对于刚接触 BP 神经网络的初学者来说，在实现过程中经常会遇到以下几个典型问题：

梯度消失：在深层网络中，梯度在反向传播时会逐渐变小，导致浅层权重难以更新
局部最优：损失函数的非凸性使得优化容易陷入局部最小值而非全局最优
过拟合：模型在训练集上表现很好但在测试集上泛化能力差

这些问题的根源往往在于网络结构设计不当、超参数设置不合理或训练方法选择错误。接下来我们将从数学原理入手，逐步构建一个稳健的 BP 神经网络预测模型。

对于具有 L 层的神经网络，第 l 层的输出可以表示为：

$$a^{(l)} = f(z^{(l)}) = f(W^{(l)}a^{(l-1)} + b^{(l)})$$

其中 $f(·)$ 是激活函数，常用 Sigmoid 或 tanh。

采用均方误差 (MSE) 作为损失函数：

$$J(W,b) = \frac{1}{2m}\sum_{i=1}^m||h_W(x^{(i)}) – y^{(i)}||^2$$

关键是通过链式法则计算梯度：

输出层误差：
$$\delta^{(L)} = (a^{(L)} – y) \odot f'(z^{(L)})$$
隐藏层误差：
$$\delta^{(l)} = ((W^{(l+1)})^T\delta^{(l+1)}) \odot f'(z^{(l)})$$
参数梯度：
$$\nabla_{W^{(l)}}J = \delta^{(l)}(a^{(l-1)})^T$$
$$\nabla_{b^{(l)}}J = \delta^{(l)}$$

下面是用 numpy 实现的完整代码：

import numpy as np
import matplotlib.pyplot as plt

class NeuralNetwork:
    def __init__(self, layers):
        # 初始化权重和偏置
        self.weights = [np.random.randn(y, x)/np.sqrt(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/(1+np.exp(-z))

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

    def feedforward(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=1000, lr=0.1):
        loss_history = []
        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.weights)+1):
                    z = zs[-l]
                    delta = np.dot(self.weights[-l+1].T, delta) * self.sigmoid_prime(z)
                    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)]

            # 计算当前损失
            current_loss = np.mean((self.feedforward(X.T) - y.T)**2)
            loss_history.append(current_loss)

        # 绘制损失曲线
        plt.plot(loss_history)
        plt.xlabel('Epoch')
        plt.ylabel('Loss')
        plt.show()

# 示例使用
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([[0], [1], [1], [0]])

nn = NeuralNetwork([2,4,1])
nn.train(X, y, epochs=1000, lr=0.1)