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

1次阅读

没有评论

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

对于机器学习初学者来说，实现 BP 神经网络时往往会遇到一些常见问题。理解这些问题并找到解决方案，是掌握神经网络的关键一步。

梯度消失问题：当网络层数较多时，梯度在反向传播过程中会逐渐变小，导致浅层权重几乎不更新。
局部最优陷阱：损失函数可能存在多个局部最小值，导致模型收敛到次优解。
过拟合：模型在训练集上表现很好，但在测试集上表现不佳，缺乏泛化能力。
参数调整困难：学习率、网络结构等超参数的选择对模型性能影响很大，但缺乏系统性的调参方法。
计算效率低：实现不当的神经网络训练速度慢，难以应用于实际问题。

BP 神经网络的核心在于前向传播和反向传播两个过程。下面我们通过数学公式来理解这两个过程。

前向传播是数据从输入层流向输出层的过程。对于第 l 层的第 j 个神经元，其输出为：

$$a_j^{(l)} = f(z_j^{(l)})$$

其中，

$$z_j^{(l)} = \sum_{i} w_{ji}^{(l)}a_i^{(l-1)} + b_j^{(l)}$$

f(·)是激活函数，常用的有 sigmoid、tanh 等。

常用的损失函数是均方误差（MSE）：

$$J = \frac{1}{2m}\sum_{i=1}^m (y_i – a_i^{(L)})^2$$

其中 m 是样本数量，L 是输出层。

反向传播通过链式法则计算损失函数对各层参数的梯度。对于输出层：

$$\delta_j^{(L)} = (a_j^{(L)} – y_j)f'(z_j^{(L)})$$

对于隐藏层：

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

然后更新权重和偏置：

$$w_{ji}^{(l)} = w_{ji}^{(l)} – \alpha \frac{\partial J}{\partial w_{ji}^{(l)}} = w_{ji}^{(l)} – \alpha a_i^{(l-1)}\delta_j^{(l)}$$

$$b_j^{(l)} = b_j^{(l)} – \alpha \frac{\partial J}{\partial b_j^{(l)}} = b_j^{(l)} – \alpha \delta_j^{(l)}$$

下面我们使用 Python 和 numpy 实现一个简单的 BP 神经网络。

import numpy as np

class NeuralNetwork:
    def __init__(self, layers):
        """
        初始化神经网络
        :param layers: 各层神经元数量，如 [2,3,1] 表示输入层 2 个，隐藏层 3 个，输出层 1 个
        """
        self.layers = layers
        self.weights = []
        self.biases = []

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

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

    def sigmoid_derivative(self, z):
        s = self.sigmoid(z)
        return s * (1 - s)

    def tanh(self, z):
        return np.tanh(z)

    def tanh_derivative(self, z):
        return 1 - np.tanh(z)**2

    def forward(self, X):
        """
        前向传播
        :param X: 输入数据，shape (n_features, n_samples)
        :return: 网络输出
        """
        self.activations = [X]
        self.zs = []

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

        return self.activations[-1]

    def backward(self, X, y, learning_rate):
        """
        反向传播
        :param X: 输入数据
        :param y: 真实标签
        :param learning_rate: 学习率
        """
        m = X.shape[1]  # 样本数量

        # 计算输出层误差
        delta = (self.activations[-1] - y) * self.sigmoid_derivative(self.zs[-1])

        # 更新最后一层的权重和偏置
        self.weights[-1] -= learning_rate * np.dot(delta, self.activations[-2].T) / m
        self.biases[-1] -= learning_rate * np.mean(delta, axis=1, keepdims=True)

        # 反向传播误差
        for l in range(len(self.weights)-2, -1, -1):
            delta = np.dot(self.weights[l+1].T, delta) * self.sigmoid_derivative(self.zs[l])
            self.weights[l] -= learning_rate * np.dot(delta, self.activations[l].T) / m
            self.biases[l] -= learning_rate * np.mean(delta, axis=1, keepdims=True)

    def train(self, X, y, epochs, learning_rate, verbose=True):
        """
        训练网络
        :param X: 训练数据
        :param y: 标签
        :param epochs: 迭代次数
        :param learning_rate: 学习率
        :param verbose: 是否打印训练信息
        """
        losses = []

        for epoch in range(epochs):
            # 前向传播
            output = self.forward(X)

            # 计算损失
            loss = np.mean((output - y)**2) / 2
            losses.append(loss)

            # 反向传播
            self.backward(X, y, learning_rate)

            if verbose and epoch % 100 == 0:
                print(f"Epoch {epoch}, Loss: {loss}")

        return losses

import matplotlib.pyplot as plt

# 创建网络
nn = NeuralNetwork([2, 4, 1])

# 生成训练数据
X = np.random.rand(2, 1000)
y = (X[0,:] > X[1,:]).reshape(1, -1).astype(float)

# 训练网络
losses = nn.train(X, y, epochs=1000, learning_rate=0.1)

# 绘制损失曲线
plt.plot(losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss Curve')
plt.show()

在实际实现 BP 神经网络时，初学者常会遇到以下问题：