BP神经网络预测

\[ \frac{\partial E}{\partial W^{(l)}} = \frac{1}{N} \sum_{k=1}^{N} \delta_k^{(l)} (a_k^{(l-1)})^T, \quad \frac{\partial E}{\partial b^{(l)}} = \frac{1}{N} \sum_{k=1}^{N} \delta_k^{(l)} \]

梯度下降更新：

\[ W^{(l)} \leftarrow W^{(l)} - \eta \frac{\partial E}{\partial W^{(l)}}, \quad b^{(l)} \leftarrow b^{(l)} - \eta \frac{\partial E}{\partial b^{(l)}} \]

其中 \( \eta \) 为学习率。

网络设计

合理的网络结构是取得良好预测效果的关键，需在拟合能力与泛化能力之间取得平衡。

隐藏层数选择

层数	适用场景	特点
1层	简单非线性映射	万能逼近定理保证可逼近任意连续函数
2层	复杂非线性关系	可逼近任意函数
3层+	深度学习场景	需大量数据，易过拟合

数学建模中的预测任务，通常1-2层隐藏层即可满足需求。

隐藏层节点数经验公式

\[ h = \sqrt{n + m} + a \quad (a \in [1, 10]), \quad h = 2n + 1, \quad h = \log_2 n \]

实践中推荐交叉验证确定最优节点数。

学习率选择

推荐范围：\( \eta \in [0.001, 0.1] \)
过大导致不稳定甚至发散，过小收敛慢且易陷入局部最优
推荐使用Adam等自适应学习率优化器

数据预处理

神经网络对输入数据尺度敏感，归一化处理必不可少。

Min-Max归一化

\[ x’ = \frac{x - x_{\min}}{x_{\max} - x_{\min}}, \quad \text{反归一化：} \quad x = x’(x_{\max} - x_{\min}) + x_{\min} \]

Z-score标准化

\[ x’ = \frac{x - \mu}{\sigma} \]

注意事项

训练集和测试集使用相同的归一化参数
输出变量同样需要归一化（特别是使用Sigmoid时）
预测结果需要反归一化回原始尺度

实际案例分析

以时间序列预测为例，展示BP神经网络的完整建模过程。

问题描述

某地区12个月的月均气温（摄氏度）：

月份	1	2	3	4	5	6	7	8	9	10	11	12
气温	2.0	4.5	10.2	16.8	22.3	27.1	30.5	29.8	24.6	17.4	9.8	3.6

目标：用前3个月气温预测下一个月气温。

步骤一：构造滑动窗口样本

样本	输入 \( (x_1, x_2, x_3) \)	输出 \( y \)
1	(2.0, 4.5, 10.2)	16.8
2	(4.5, 10.2, 16.8)	22.3
3	(10.2, 16.8, 22.3)	27.1
4	(16.8, 22.3, 27.1)	30.5
5	(22.3, 27.1, 30.5)	29.8
6	(27.1, 30.5, 29.8)	24.6
7	(30.5, 29.8, 24.6)	17.4
8	(29.8, 24.6, 17.4)	9.8
9	(24.6, 17.4, 9.8)	3.6

前7组为训练集，后2组为测试集。

步骤二：数据归一化

\( x_{\min} = 2.0 \)，\( x_{\max} = 30.5 \)，归一化：\( x’ = \frac{x - 2.0}{28.5} \)

归一化后部分数据：

样本	输入	输出
1	(0.000, 0.088, 0.288)	0.519
2	(0.088, 0.288, 0.519)	0.712
3	(0.288, 0.519, 0.712)	0.881

步骤三：网络设计

结构：\([3, 5, 1]\)（输入3，隐藏5，输出1）
隐藏层激活：Sigmoid；输出层：线性
学习率 \( \eta = 0.1 \)

步骤四：前向传播示例

设 \( W^{(1)} \)（5x3）、\( b^{(1)} \)（5x1）为随机初始化权重，输入样本1 \( x = (0, 0.088, 0.288)^T \)：

\[ z^{(1)} = W^{(1)} x + b^{(1)}, \quad a^{(1)} = \sigma(z^{(1)}) \]

例如 \( z_1^{(1)} = 0.2 \times 0 + (-0.3) \times 0.088 + 0.4 \times 0.288 + 0.1 = 0.189 \)

\[ a_1^{(1)} = \sigma(0.189) = \frac{1}{1+e^{-0.189}} \approx 0.547 \]

输出层：\( \hat{y} = W^{(2)} a^{(1)} + b^{(2)} = 0.225 \)

步骤五：反向传播

目标 \( y = 0.519 \)，输出层误差：\( \delta^{(2)} = 0.225 - 0.519 = -0.294 \)

隐藏层误差：

\[ \delta_j^{(1)} = W_j^{(2)} \cdot \delta^{(2)} \cdot a_j^{(1)}(1 - a_j^{(1)}) \]

权重更新示例：

\[ W^{(2)}_1 = 0.3 - 0.1 \times (-0.294) \times 0.547 = 0.316 \]

import numpy as np
from sklearn.neural_network import MLPRegressor
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error
import matplotlib.pyplot as plt

# 原始数据
data = np.array([2.0, 4.5, 10.2, 16.8, 22.3, 27.1, 30.5, 29.8, 24.6, 17.4, 9.8, 3.6])

# 构造滑动窗口样本
def create_samples(data, window_size=3):
    X, y = [], []
    for i in range(len(data) - window_size):
        X.append(data[i:i+window_size])
        y.append(data[i+window_size])
    return np.array(X), np.array(y)

window_size = 3
X, y = create_samples(data, window_size)

# 划分训练集和测试集
X_train, X_test = X[:7], X[7:]
y_train, y_test = y[:7], y[7:]

# 数据归一化
scaler_X = MinMaxScaler()
scaler_y = MinMaxScaler()
X_train_scaled = scaler_X.fit_transform(X_train)
X_test_scaled = scaler_X.transform(X_test)
y_train_scaled = scaler_y.fit_transform(y_train.reshape(-1, 1)).ravel()

# 构建BP神经网络
model = MLPRegressor(
    hidden_layer_sizes=(5,),
    activation='relu',
    solver='adam',
    learning_rate_init=0.01,
    max_iter=2000,
    tol=1e-6,
    random_state=42,
    early_stopping=True,
    validation_fraction=0.2
)
model.fit(X_train_scaled, y_train_scaled)

# 预测与评价
y_pred_scaled = model.predict(X_test_scaled)
y_pred = scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1)).ravel()

mse = mean_squared_error(y_test, y_pred)
mae = mean_absolute_error(y_test, y_pred)
print(f"测试集MSE: {mse:.4f}, MAE: {mae:.4f}")
print(f"真实值: {y_test}, 预测值: {y_pred}")

# 可视化
plt.figure(figsize=(10, 5))
plt.plot(range(1, 13), data, 'bo-', label='实际气温')
plt.plot([11, 12], y_pred, 'r^--', label='预测气温')
plt.xlabel('月份')
plt.ylabel('气温 (°C)')
plt.title('BP神经网络气温预测')
plt.legend()
plt.grid(True)
plt.show()

方法二：手写BP神经网络

import numpy as np

class BPNeuralNetwork:
    """手写BP神经网络（回归预测）"""

    def __init__(self, layers, learning_rate=0.01, epochs=1000, tol=1e-6):
        self.layers = layers
        self.lr = learning_rate
        self.epochs = epochs
        self.tol = tol
        self.weights = []
        self.biases = []
        self.loss_history = []

        # Xavier初始化
        np.random.seed(42)
        for i in range(len(layers) - 1):
            limit = np.sqrt(6.0 / (layers[i] + layers[i+1]))
            w = np.random.uniform(-limit, limit, (layers[i+1], layers[i]))
            b = np.zeros((layers[i+1], 1))
            self.weights.append(w)
            self.biases.append(b)

    def sigmoid(self, z):
        z = np.clip(z, -500, 500)
        return 1.0 / (1.0 + np.exp(-z))

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

    def forward(self, X):
        self.activations = [X]
        self.z_values = []
        a = X
        # 隐藏层：Sigmoid激活
        for i in range(len(self.weights) - 1):
            z = self.weights[i] @ a + self.biases[i]
            self.z_values.append(z)
            a = self.sigmoid(z)
            self.activations.append(a)
        # 输出层：线性激活
        z = self.weights[-1] @ a + self.biases[-1]
        self.z_values.append(z)
        self.activations.append(z)
        return z

    def backward(self, y):
        m = y.shape[1]
        deltas = [None] * len(self.weights)
        # 输出层误差
        deltas[-1] = self.activations[-1] - y
        # 隐藏层误差
        for i in range(len(self.weights) - 2, -1, -1):
            a = self.activations[i+1]
            deltas[i] = (self.weights[i+1].T @ deltas[i+1]) * self.sigmoid_derivative(a)
        # 更新参数
        for i in range(len(self.weights)):
            dW = (1.0 / m) * deltas[i] @ self.activations[i].T
            db = (1.0 / m) * np.sum(deltas[i], axis=1, keepdims=True)
            self.weights[i] -= self.lr * dW
            self.biases[i] -= self.lr * db

    def fit(self, X_train, y_train):
        for epoch in range(self.epochs):
            y_pred = self.forward(X_train)
            loss = (1.0 / (2 * y_train.shape[1])) * np.sum((y_pred - y_train)**2)
            self.loss_history.append(loss)
            if loss < self.tol:
                print(f"第 {epoch+1} 轮收敛，损失: {loss:.8f}")
                break
            self.backward(y_train)
            if (epoch + 1) % 500 == 0:
                print(f"轮次 {epoch+1}/{self.epochs}, 损失: {loss:.6f}")

    def predict(self, X):
        return self.forward(X)


# ========== 气温预测 ==========
data = np.array([2.0, 4.5, 10.2, 16.8, 22.3, 27.1, 30.5, 29.8, 24.6, 17.4, 9.8, 3.6])
window_size = 3
X, y = [], []
for i in range(len(data) - window_size):
    X.append(data[i:i+window_size])
    y.append(data[i+window_size])
X, y = np.array(X), np.array(y).reshape(-1, 1)

X_train, X_test = X[:7], X[7:]
y_train, y_test = y[:7], y[7:]

# 归一化
X_min, X_max = X_train.min(), X_train.max()
y_min, y_max = y_train.min(), y_train.max()
X_train_norm = (X_train - X_min) / (X_max - X_min)
X_test_norm = (X_test - X_min) / (X_max - X_min)
y_train_norm = (y_train - y_min) / (y_max - y_min)

# 训练（数据转置为 特征数 x 样本数）
nn = BPNeuralNetwork(layers=[3, 5, 1], learning_rate=0.5, epochs=5000, tol=1e-6)
nn.fit(X_train_norm.T, y_train_norm.T)

# 预测与反归一化
y_pred_norm = nn.predict(X_test_norm.T)
y_pred = y_pred_norm.T * (y_max - y_min) + y_min
print(f"真实值: {y_test.ravel()}")
print(f"预测值: {y_pred.ravel()}")

多步滚动预测

def multi_step_predict(model, scaler_X, scaler_y, last_window, steps=3):
    """多步滚动预测"""
    predictions = []
    current_window = last_window.copy()
    for _ in range(steps):
        window_scaled = scaler_X.transform(current_window.reshape(1, -1))
        pred_scaled = model.predict(window_scaled)
        pred = scaler_y.inverse_transform(pred_scaled.reshape(-1, 1)).ravel()[0]
        predictions.append(pred)
        current_window = np.append(current_window[1:], pred)
    return np.array(predictions)

last_window = data[-3:]
future_preds = multi_step_predict(model, scaler_X, scaler_y, last_window, steps=3)
print(f"未来3个月预测: {future_preds}")

应用注意事项与局限性

BP神经网络具有强大的非线性拟合能力，但实际应用中需注意诸多问题。

关键注意事项

1. 数据量要求

\[ N_{\min} \geq 5 \sim 10 \times W \]

其中 \( W \) 为网络总参数数。\([3,5,1]\) 网络有 \( W = 3\times5+5+5\times1+1 = 26 \) 个参数，至少需130个样本。

2. 过拟合防止

早停法（Early Stopping）：验证误差上升时停止训练
L2正则化：\( E_{\text{reg}} = E + \frac{\lambda}{2} \sum_l |W^{(l)}|_F^2 \)
Dropout：训练时随机丢弃部分神经元

3. 局部最优问题

多次随机初始化取最优
动量法：\( \Delta W(t) = -\eta \frac{\partial E}{\partial W} + \alpha \Delta W(t-1) \)，\( \alpha \in [0.8, 0.95] \)

4. 梯度消失与爆炸

使用ReLU替代Sigmoid
Batch Normalization
Xavier/He权重初始化

5. 超参数调优

超参数	推荐范围	调优方法
学习率	0.001 ~ 0.1	网格搜索 / 学习率衰减
隐藏节点数	经验公式 + CV	逐步增加至验证误差不降
迭代次数	1000 ~ 10000	结合早停法
批大小	16 ~ 128	通常32或64

局限性

理论层面：

缺乏严格理论指导结构选择
黑箱模型，可解释性差
不保证全局最优

实践层面：

超参数敏感，调参工作量大
小样本易过拟合
时间序列长期依赖捕捉能力有限（不如LSTM）

与其他方法对比

方法	优势	劣势
BP神经网络	非线性拟合能力强	黑箱、需大量数据
线性回归	可解释性强、快速	无法处理非线性
支持向量回归	小样本表现好	大规模数据慢
随机森林	鲁棒、不易过拟合	外推能力弱
LSTM	擅长长序列依赖	结构复杂、训练慢

数学建模竞赛建议

优先简单模型：线性模型能解决则无需神经网络
合理划分数据：训练:验证:测试 = 7:1.5:1.5
多模型对比：BP网络与传统方法对比体现选择合理性
充分可视化：预测曲线、误差分布、损失曲线
参数敏感性分析：讨论不同设置对结果的影响
多指标评价：

\[ R^2 = 1 - \frac{\sum_{i=1}^N (y_i - \hat{y}i)^2}{\sum{i=1}^N (y_i - \bar{y})^2}, \quad \text{MAPE} = \frac{1}{N} \sum_{i=1}^N \left| \frac{y_i - \hat{y}_i}{y_i} \right| \times 100% \]

总结

BP神经网络是数学建模中处理非线性预测问题的有力工具。正确使用的关键在于：合理的数据预处理、恰当的网络结构设计、有效的训练策略以及充分的结果验证。在实际建模中，应当将其与其他方法配合使用，取长补短，获得最佳预测效果。

数学建模指南

BP神经网络预测

网络结构

基本结构

数学表示

常用激活函数

前向传播

损失函数

反向传播与权重更新

误差项计算

梯度与参数更新