PSO-LSTM粒子群算法优化LSTM超参数，提升时间序列预测精度

简介：基于粒子群算法优化长短期记忆神经网络的时间序列预测完整项目，包含可直接运行的源程序与配套数据集，面向计算机、电子信息、数学等专业学生，适用于课程设计、期末大作业、毕业设计等场景，也适合刚接触深度学习的入门者研究智能优化与神经网络结合的方法。压缩包内共包含三个文件，其中一个程序文件、两个数据文件，整体体积很小，仅有49KB，下载和运行都非常方便，也便于用文本编辑器查看代码与数据。程序代码基于TensorFlow框架编写，并可在Anaconda与PyCharm等常用集成开发环境中运行；采用参数化编程方式，所有关键参数均可灵活调整，同时每行都配有详尽注释，完整展示了数据预处理、粒子群算法优化长短期记忆网络的超参数、模型训练及最终时间序列预测的整个流程，即便没有深厚深度学习基础的读者也能按注释逐步理解。目前已有550人学习下载，资料中提供了完整数据和结构清晰的代码，既能直接运行查看预测效果，也可以作为二次开发与算法改进的可靠参考，尤其适合作为相关课程设计与毕业设计的起点。

1. 为什么时间序列预测要用PSO-LSTM粒子群算法

同一个LSTM模型，别人预测误差是你的一半，差别往往不在神经元数量，而在超参数怎么来的。手写网格搜索调batch_size、学习率、隐藏层单元，一轮就是半小时。时间序列预测项目里，最耗时间的往往不是建模，而是反复试参数。

PSO-LSTM的做法是用粒子群算法自动搜索长短期记忆网络的关键超参数：每个粒子是一组候选参数，粒子群通过个体最优和全局最优迭代更新位置，让模型逼近合适的网络配置。下面按原理、源码、参数寻优、训练验证和落地技巧展开，适合已经会跑LSTM但手动调参调不动，或者想再推高时间序列预测精度的Python工程师。

2. PSO-LSTM原理：粒子群算法如何为长短期记忆网络搜索超参数

2.1 粒子群优化的数学基础与粒子编码

PSO（粒子群优化）把每个超参数组合看成一个粒子。假设要优化 4 个参数——LSTM 隐藏单元数 units、学习率 lr、批大小 batch_size、Dropout 比率 dropout——粒子位置就是一个 4 维向量 x = (units, lr, batch_size, dropout)，取值范围由你给定。速度向量 v 控制粒子在这个超参数空间里的移动步长和方向。标准 PSO 按下面两式更新：

v = w * v + c1 * r1 * (pbest - x) + c2 * r2 * (gbest - x) x = x + v

其中 w 是惯性权重，c1、c2 是加速常数，r1、r2 是 [0,1] 之间的随机数，pbest 是个体历史最优位置，gbest 是群体最优位置。看起来简单的两行公式，落进 LSTM 场景有两个细节必须处理：整数型参数（units、batch_size）在每代更新后要取整，否则会带出小数层的网络；lr 和 dropout 这类连续参数要做边界截断，不然粒子飞到取值区间外，Keras 在 build 模型时直接抛异常。

初始化位置的方式常见有均匀随机和拉丁超立方两种，粒子数通常取 10～30，迭代次数取 20～50。下面是一段浓缩的粒子状态初始化与边界处理代码，保留了 PSO 里最容易写错的取整和截断步骤。

import numpy as np n_particles = 15 n_dims = 4 # units, lr, batch_size, dropout bounds = np.array([ [32, 128], # units: 隐藏单元数 [1e-4, 1e-2], # lr: 学习率 [16, 64], # batch_size: 批大小 [0.0, 0.4] # dropout: 丢弃比例 ]) # 随机初始化位置和速度 x = np.random.uniform(low=bounds[:, 0], high=bounds[:, 1], size=(n_particles, n_dims)) v = np.random.uniform(low=-1, high=1, size=(n_particles, n_dims)) def clip_position(pos, b): """把越界粒子拉回边界，整数参数取整""" pos = np.clip(pos, b[:, 0], b[:, 1]) pos[:, 0] = np.round(pos[:, 0]).astype(int) # units 取整 pos[:, 2] = np.round(pos[:, 2]).astype(int) # batch_size 取整 return pos x = clip_position(x, bounds)

np.random.uniform生成粒子位置，速度初始化为较小的随机值，避免第一代就飞过最优区域。clip_position在每一轮速度更新后都要调用：np.clip把连续参数限制在边界内，units 和 batch_size 用round转成整数。如果少了取整，后续build_lstm里出现units=64.7这种值会直接报错；如果少了截断，lr 可能变成负数，Adam 优化器会拒绝执行。

2.2 为什么LSTM超参数适合交给粒子群而不是网格搜索

LSTM 时间序列预测的超参数空间有几个特点：维度不高但范围宽，参数之间存在强耦合。learning_rate 偏大时 units 多了反而过拟合，batch_size 小的时候 dropout 的影响会被放大。网格搜索要覆盖这种耦合，只能把每个维度切细，组合数呈指数上涨。一个 4 参数、每参数 5 档的网格就是 625 组，LSTM 单次训练按 90 秒算，光跑一遍就是 15 个小时以上；PSO 用 15 个粒子迭代 20 次，实际最多 300 次模型训练，而且粒子会往效果好的区域聚集，不像网格那样在无效区间浪费算力。

随机搜索能救回一部分问题，但它是完全盲探，每一代之间没有信息传递。PSO 的优势在 pbest 和 gbest 两个记忆项：粒子飞过的好位置会被保留，下一轮的速度更新里，c2r2(gbest - x) 会引导群体往当前最优解移动，c1r1(pbest - x) 则保留每个粒子自己找到的局部好位置。对于代价函数不光滑、评估成本又高的 LSTM 训练场景，这种带记忆的搜索比无记忆采样更划算。三种方式在同等 300 次训练预算下的差异如下表：

这个表不是为了证明 PSO 永远比随机搜索强，而是说明在预算有限的条件下，PSO 的后期收敛更有价值。随机搜索的 sklearn 实现很容易跑，但它不会告诉你“下一次往哪个方向试”；PSO 给出的 gbest 本身就是一组可直接拿去训练的超参数。把 pbest 的历史曲线画出来，还能观察粒子是不是在后期震荡幅度变大，如果明显，说明粒子数偏少或者惯性权重 w 偏大。

2.3 从粒子位置到LSTM损失评估的闭环

PSO 本身不关心模型内部结构，它只负责生成超参数组并收集损失值。完整闭环是：粒子位置解码成 Keras 模型参数 → 构建 LSTM → 在训练集上训练固定 epoch → 在验证集上算 loss → 把 loss 返回给 PSO 作为适应度。这里的 loss 不能用训练集 loss，否则粒子会全部涌向过拟合的解，常见做法是用验证集上的均方误差或平均绝对误差。

把闭环写成伪代码，能更清楚看到每一轮发生了什么：

for current_iter in range(max_iter): for i in range(n_particles): units, lr, batch_size, dropout = decode(x[i]) val_loss = train_lstm(units, lr, batch_size, dropout) # 评估一个粒子 if val_loss < fitness_pbest[i]: fitness_pbest[i] = val_loss pbest[i] = x[i].copy() best_idx = np.argmin(fitness_pbest) gbest = pbest[best_idx].copy() v = inertia * v + c1 * r1 * (pbest - x) + c2 * r2 * (gbest - x) x = x + v x = clip_position(x, bounds)

这里刻意没有直接用 pyswarm 或 scikit-opt 这类现成库。原因有两个：一是 LSTM 训练耗时太长，通用 PSO 库的回调机制和终止条件在这个场景里不够灵活，比如没法在验证集 loss 连续 5 代不降时提前停；二是把主循环写在自己手里，每一轮都能打印当前粒子的超参数和 loss，排查问题比黑盒库方便得多。pyswarm 内部默认按函数评估次数终止，和“训练一个 LSTM 模型”这种重量级评估的节奏并不匹配。

3. Python实现：PSO-LSTM数据预处理与构建源码

3.1 时间序列数据集构造：滑动窗口与归一化

PSO-LSTM 的第一道坎不在模型，在数据格式。LSTM 输入要求是 (samples, time_steps, features) 三维张量，所以原始一维序列要先切成固定长度的窗口。以预测下一个时间点为例，设窗口长度 time_steps=12，那前 12 个点组成输入，第 13 个点作为标签，窗口每次滑动一步；窗口太长会把早期噪声也学进模型，太短又捕捉不到周期。数据来源如果是爬虫抓取的批量接口，时间戳经常有缺失，切分之前先做连续性检查，否则窗口会发生错位。

数据归一化在 PSO 场景里比普通 LSTM 更讲究。粒子群会在不同参数下反复训练模型，如果训练集和验证集分布不一致，适应度评估就失去可比性。常见做法是 MinMaxScaler 只在训练集上 fit，再用同一个 scaler transform 验证集和测试集。下面这段是完整的数据预处理代码，含窗口切分和反归一化工具函数。

import numpy as np import pandas as pd from sklearn.preprocessing import MinMaxScaler def split_sequence(seq, time_steps, pred_len=1): X, y = [], [] for i in range(len(seq) - time_steps - pred_len + 1): X.append(seq[i:i + time_steps]) y.append(seq[i + time_steps:i + time_steps + pred_len]) return np.array(X), np.array(y) df = pd.read_csv('data.csv', parse_dates=['date'], index_col='date') values = df['value'].values.reshape(-1, 1) train_size = int(len(values) * 0.8) train_raw, test_raw = values[:train_size], values[train_size:] scaler = MinMaxScaler(feature_range=(0, 1)) train_scaled = scaler.fit_transform(train_raw) test_scaled = scaler.transform(test_raw) # 只用训练集的 min/max time_steps = 12 X_train, y_train = split_sequence(train_scaled.flatten(), time_steps, pred_len=1) X_test, y_test = split_sequence(test_scaled.flatten(), time_steps, pred_len=1) X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1)) X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1)) def inverse_scale(predicted, scaler): return scaler.inverse_transform(predicted.reshape(-1, 1))

三个容易踩的坑。第一，train_test_split默认会乱序切分，时间序列必须按时间顺序切，否则验证集里混着未来数据，PSO 选出的 gbest 在真实预测时严重失真。第二，fit_transform只能用在训练集上，测试集必须复用同一个 scaler，单独对测试集 fit 等于把未来信息泄漏给每一轮的粒子评估，最终指标会虚高。第三，split_sequence的 y 默认是单步预测值，改 pred_len 后 y 会变成二维，后面的 Dense 输出层也要跟着改成对应维度。

窗口长度直接决定训练样本数量和模型看到的时间范围，实际项目里可以参考下表起步：

提示：PSO 每代都要比较 pbest 和 gbest，训练集、验证集必须保持同分布。时间序列里“同分布”的前提就是严格按时间切分，不要用 sklearn 默认的 shuffle。

3.2 可被粒子群调用的LSTM构建函数

PSO 每一轮都要构建一个新模型，模型创建函数必须设计成“纯参数输入、模型输出”，不依赖全局状态。这里的build_lstm接收 4 个超参数，两层 LSTM 中间加 Dropout，第二层不设置return_sequences，让输出维度对齐最后的 Dense 层。用 Keras 的 Sequential 接口写起来最直接：

from tensorflow.keras.models import Sequential from tensorflow.keras.layers import LSTM, Dense, Dropout from tensorflow.keras.optimizers import Adam def build_lstm(units, learning_rate, dropout, n_features=1): model = Sequential([ LSTM(units, activation='tanh', return_sequences=True, input_shape=(time_steps, n_features)), Dropout(dropout), LSTM(units // 2, activation='tanh', return_sequences=False), Dropout(dropout), Dense(1) ]) model.compile( optimizer=Adam(learning_rate=learning_rate), loss='mse', metrics=['mae'] ) return model

units // 2是刻意做的参数量控制：第二层单元数减半，小粒子比如 units=32 时第二层只有 16 个单元，模型依然可训练。Adam 的 learning_rate 由粒子的 lr 维直接传入，每次模型重新编译，保证超参数真正生效，而不是在 fit 之后再修改优化器状态。return_sequences=True的第一层输出完整时间步给第二层，第二层return_sequences=False只保留最后一步，最后落到 Dense(1) 上做单值回归。

units 的选择直接决定参数量和训练耗时，表格里按 time_steps=12、n_features=1 估算：

参数量的量级会影响 PSO 的整体节奏：粒子数 15、迭代 20 次等于要训练几十个模型，单模型参数翻 4 倍，总耗时差不多也翻 4 倍。显存吃紧时优先调小第一层 units，而不是动 dropout；dropout 在粒子群搜索中承担的是正则强度，过早压小会让 gbest 偏向过拟合解。

3.3 PSO-LSTM完整主循环源码

主循环把数据准备和模型构建串起来，核心评估函数train_and_evaluate完成构建模型、训练、验证集 loss 计算三件事。早停在这里不仅是为了节省时间，更是为了粒子对比的公平：所有粒子都用同一套 epoch 上限和 patience，谁先触发早停只取决于验证集 loss 是否还在下降，而不是人为给定不同的训练轮数。

from tensorflow.keras.callbacks import EarlyStopping def train_and_evaluate(params, X_tr, y_tr, X_val, y_val, epochs=30): units, lr, batch_size, dropout = params model = build_lstm(int(units), float(lr), float(dropout)) es = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True) history = model.fit( X_tr, y_tr, validation_data=(X_val, y_val), epochs=epochs, batch_size=int(batch_size), callbacks=[es], verbose=0 ) val_loss = min(history.history['val_loss']) return val_loss, model pbest = x.copy() gbest = x[0].copy() fitness_pbest = np.full(n_particles, np.inf) fitness_gbest = np.inf for it in range(max_iter): for i in range(n_particles): loss, _ = train_and_evaluate(x[i], X_train, y_train, X_test, y_test) if loss < fitness_pbest[i]: fitness_pbest[i] = loss pbest[i] = x[i].copy() best_i = np.argmin(fitness_pbest) if fitness_pbest[best_i] < fitness_gbest: fitness_gbest = fitness_pbest[best_i] gbest = pbest[best_i].copy() w = 0.9 - 0.5 * (it / max_iter) r1, r2 = np.random.rand(2) v = w * v + 1.5 * r1 * (pbest - x) + 1.5 * r2 * (gbest - x) x = clip_position(x + v, bounds) print(f'iter {it+1}/{max_iter}, best_val_loss={fitness_gbest:.6f}, gbest={gbest}')

代码里把验证集放在 X_test 上，是预算有限时的工程妥协：粒子评估阶段需要一块不参与训练的数据，等 PSO 结束后再用独立测试集做最终检验。如果数据量超过 5 万条，建议把序列切成 train 60%、val 20%、test 20%，train_and_evaluate 只认 val 段。w的线性衰减是让粒子前期大步探索、后期收敛的关键，0.9 到 0.4 是文献里最常见的区间，小于 0.3 时粒子会太早停滞，大于 1.0 时容易震荡。

注意：显存不足时，先把 batch_size 搜索范围从 [16,64] 改到 [16,32]，units 从 [32,128] 改到 [32,64]，粒子数降到 10。搜索空间变小后，代数可以不变，收敛速度反而更快。

4. 训练预算控制与时间序列预测结果验证

4.1 训练预算：epoch、早停和粒子评估成本的三角约束

PSO-LSTM 的工程量不在算法本身，在“一次实验到底跑多久”。假设粒子数 15、迭代 20 次，最多 300 次模型训练，每次跑满 100 个 epoch 的话，即使数据只有几千条，也够在普通电脑上跑一夜。所以必须把单次评估成本压下来：epoch=30、patience=5，让早停在验证集连续 5 次不下降时提前结束。这样大部分粒子十几个 epoch 就会停下，整体耗时能压到全量训练的三分之一。

这里给一组我常用的预算参数：

c1、c2 取 1.5 不是拍脑袋，粒子群早期的实验里 1.5～2.0 区间表现都比较稳定。c1 调大会让粒子更偏向局部探索，适合超参数空间峰谷多的情况，但会拖慢整体收敛；c2 调大会让群体太快聚到当前 gbest，容易错过附近的更优解。工程上先用 c1=c2=1.5 跑通，再看 pbest 曲线决定要不要调。

4.2 粒子群进化曲线与最优超参数解读

训练结束后，把每代的 fitness_gbest 画成曲线，能直接判断搜索是否收敛。正常曲线是前 5 代快速下降，后面缓慢趋平；如果曲线一直在锯齿状震荡，先检查每个粒子训练时是否用了相同的随机种子。LSTM 初始权重随机，同一组超参数在不同 seed 下 val_loss 会有波动，PSO 会把这种噪声当成适应度的一部分，导致 gbest 不稳定。最简单的控制办法是在脚本开头固定tf.random.set_seed(42)和np.random.seed(42)，再跑一次 PSO 对比两次 gbest；差距超过 15% 就要加大 epochs 或者对验证集 loss 做多次平均。

下面是一次实际运行的收敛示意，数据为某流量序列，features=1，time_steps=12：

这组数据反映一个常见规律：迭代后期学习率明显下降，dropout 反而上升。PSO 在后期发现小 lr 配大 dropout 能让验证集 loss 更低，实际上是在搜索空间里找到了一个更平滑的损失盆地。如果 gbest 里的 batch_size 一直顶在 64 边界不回头，说明搜索区间设窄了，把 bounds 里 batch_size 改成 [16,128] 再跑一次；如果 lr 一直在下限附近，说明这个数据集用 Adam 已经接近极限，可以考虑换成 SGD with momentum 再让 PSO 去搜它的 lr。

4.3 测试集预测与误差指标计算

拿到 gbest 后要用完整训练集重新训练一次，epoch 加到 100，这个模型才算真正可用的最终模型，粒子评估阶段那个 30 epoch 的模型只是适应度探测器。计算 MAE 和 MAPE 时必须用反归一化后的真实值，直接在 0～1 区间上算 MAPE，分母接近 0 时会产生极端异常值。

from sklearn.metrics import mean_absolute_error, mean_squared_error best_units, best_lr, best_batch, best_dropout = tuple(gbest) final_model = build_lstm(int(best_units), float(best_lr), float(best_dropout)) final_model.fit(X_train, y_train, epochs=100, batch_size=int(best_batch), validation_split=0.1, verbose=1) pred_scaled = final_model.predict(X_test) pred = inverse_scale(pred_scaled, scaler) y_test_inv = inverse_scale(y_test, scaler) mae = mean_absolute_error(y_test_inv, pred) rmse = np.sqrt(mean_squared_error(y_test_inv, pred)) mape = np.mean(np.abs((y_test_inv - pred) / (y_test_inv + 1e-8))) * 100 print(f"MAE={mae:.4f}, RMSE={rmse:.4f}, MAPE={mape:.4f}%") plt.plot(y_test_inv, label='true') plt.plot(pred, label='pred') plt.legend()

最终训练里加了validation_split=0.1，是从训练集再切 10% 做验证监控，不影响 PSO 已验证过的最优参数。画图时预测序列很长的话，横坐标会挤成一团，一般用plt.xticks(np.arange(0, len(y_test_inv), step), rotation=45)按固定步长抽刻度，或者把前 50 个点单独画一张局部对比图。拟合曲线上最容易暴露两个问题：峰值相位偏移说明 time_steps 太短，模型看不到完整周期；整体值域被压缩说明测试集的实际范围超出了训练集，这时要回头检查数据切分的比例。

5. 让PSO-LSTM在长序列上更稳的3个实战技巧

5.1 用多特征组合保留季节分量

很多教程在预处理阶段对原始序列直接做一阶差分，然后丢给 LSTM。在 PSO 寻优时，差分会改变序列的方差结构，粒子在短训练里可能学不到完整的季节性。常见做法是一次性差分后，把差分结果和历史同期值拼成多特征输入，比如预测今天 14:00 的值时，把昨天 14:00 的值作为第 2 个特征。实现时在 split_sequence 之前构造一个 (n, 2) 的矩阵，features 变成 2，记得同步修改 build_lstm 的 n_features 参数，否则输入维度对不上会直接报错。

5.2 多步预测用滚动窗口，别让输出层一口气吐全序列

如果要预测未来 24 个点，直接把输出层改成 Dense(24)，误差会沿时间步累加，PSO 的验证指标也被最后几步带偏。更稳的做法是递归滚动预测：模型保持 Dense(1) 单步输出，预测一步后把结果拼到输入窗口尾部，丢掉最老的一个点，继续预测下一步。这样 PSO 的 val_loss 反映的是单步误差，最终应用时再用滚动方式合成多步，两个口径不冲突。滚动方式的另一个好处是兼容增量预测场景，新数据到了不用重建模型。

5.3 对 gbest 做小邻域复评，过滤随机种子噪声

LSTM 训练随机性会污染适应度比较，同一个粒子可能因为一次运气好被选成 gbest。在数据量允许的前提下，把 train_and_evaluate 里的 val_loss 改成同一个粒子跑 3 个不同随机种子取平均，结果更稳；但代价是训练次数变成 3 倍。更划算的方案是只对 gbest 做复评：PSO 跑完后，在 gbest 每个维度上乘以 0.95、1.0、1.05 生成小邻域候选，每个候选训练 3 次取平均 loss，再挑最终最优。

import itertools noise = [0.95, 1.0, 1.05] candidates = [] for nu, nl, nd in itertools.product(noise, noise, noise): cand = np.array([gbest[0]*nu, gbest[1]*nl, gbest[2]*1.0, gbest[3]*nd]) candidates.append(clip_position(cand.reshape(1, -1), bounds)[0]) final_best = min(candidates, key=lambda c: np.mean([ train_and_evaluate(c, X_train, y_train, X_test, y_test)[0] for _ in range(3) ]))

复评时 batch_size 保持 gbest 原值不变，因为它是离散整数且对 loss 影响相对平缓，只对 units、lr、dropout 三个维度做 1% 级别的扰动就够了。最终拿到的这一组参数，既保留了粒子群全局搜索的结果，又剔除了单次训练带来的随机偏差。后续上线时把 final_best 存成 json，训练脚本和推理脚本共用同一份配置，避免两边参数不一致。

本文还有配套的精品资源，点击获取