简介:这是一份面向Python初学者的LSTM时间序列预测项目资源,特别适合课程设计、期末大作业等场景。代码逻辑直观、注释详尽,并附带使用说明手册,即使不熟悉循环神经网络也能按文档快速跑通项目。资源共27个文件,压缩包8.85MB,内部包含Python源码(模型定义、工具函数、主程序)、训练好的模型权重、Excel样例数据、PyCharm工程配置文件、界面/结果截图以及PDF操作手册等,从数据导入、训练到预测均有对应模块可查。其中两个xlsx文件提供可直接使用的示例数据,model权重文件省去重新训练的时间,png/jpg图片能直观展示预测效果,md与pdf则分别说明项目结构和操作步骤。目前已有666人学习下载,作为“简单又好用”的高分项目被许多学习者直接采用。通过该项目,读者能完整掌握LSTM时间序列预测的预处理、建模、训练与评估流程,也可以替换自己的数据实现定制化预测,是很适合毕业设计或课程设计的快速起点。

1. 先搞懂LSTM时间序列预测到底在预测什么

时间序列预测的核心是用历史观察值外推未来,而LSTM因为门控结构能保留长期信息,成为这类任务里最常用的神经网络方案。但新手在Python里跑LSTM时,最常见的困惑不是模型代码,而是为什么数据要变成三维、为什么预测值要先归一化再还原、为什么训练集不能随机打乱。这几点恰恰决定了脚本能不能从“能运行”变成“预测结果合理”。

这篇内容就是围绕一套可以直接复制运行的Python程序,讲清楚数据怎么预处理、LSTM模型怎么搭、参数怎么调,最后补上多步预测和模型部署时容易漏掉的细节。对5年以上工程师来说,后面关于滚动预测和回调函数的部分也值得对照自己的方案查缺补漏。

2. 搭建LSTM预测模型前必须先做好的三件事:数据形态、归一化和滑动窗口

2.1 把普通列变成有监督学习样本:滑动窗口原理

LSTM不能直接吃一维序列。它要求的输入形状是 (样本数, 时间步, 特征数) ,其中时间步就是模型每次向后看多长。假设你有一组按小时采样的流量数据 [a1, a2, a3, a4, a5] ,当时间步设为3时,就要把它切成这样:

X(模型输入) y(要预测的下一点)
[a1, a2, a3] a4
[a2, a3, a4] a5

每一行都是一个样本,窗口在序列上滑动一位。这个过程叫滑动窗口,是几乎所有LSTM序列监督化的基础。标准做法是用一个循环来实现,而不是用pandas的shift拼接,因为后者容易让人忽略序列的前后依赖。

import numpy as np

def create_sliding_window(data, time_steps):
    X, y = [], []
    for i in range(len(data) - time_steps):
        X.append(data[i:i + time_steps])
        y.append(data[i + time_steps])
    return np.array(X), np.array(y)

这个函数的逻辑很直接:从第 i 个位置切出 time_steps 个连续值作为输入,把紧跟其后的那一个值作为目标标签。注意 data 必须是一维数组,如果数据形状是 (n, 1) ,先调用 .flatten() 再传入。

在实际项目中,往往不只是单变量。比如水文径流预报可能同时包含上游流量和降雨量,这时候窗口内每个时间步都不止一个值,输入形状变成 (样本数, time_steps, 特征数) 。对这种情况,上面函数要稍微改一下:

def create_sliding_window_multivariate(data, time_steps, pred_col=0):
    X, y = [], []
    for i in range(len(data) - time_steps):
        X.append(data[i:i + time_steps])
        y.append(data[i + time_steps, pred_col])
    return np.array(X), np.array(y)

此时 data 是二维数组,每一列是一个特征, pred_col 表示要把哪一列作为预测目标。这个扩展在实际项目里很常见,也是把一个“看起来简单”的LSTM代码变成“高分项目”的常用加分项。注意输入里仍然包含其他特征,模型可以从这些特征中提取与目标相关的短期关系。

2.2 MinMaxScaler归一化的放置位置与预测后的还原

LSTM内部默认使用 tanh 激活函数,输出范围在 [-1, 1] 附近,而输入如果直接带入几万甚至更大的数值,梯度很容易被推入饱和区。所以几乎所有LSTM时间序列代码都会先做归一化。最常用的是 MinMaxScaler ,把数据压到 [0, 1] 区间。

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))
data_scaled = scaler.fit_transform(raw_values.reshape(-1, 1)).flatten()

这里有个关键点: fit_transform 只能用在训练集上,测试集必须调用 transform ,否则测试集的最大最小值会影响训练时的缩放,造成数据泄漏。这会让验证指标显得虚高,实际部署时却变差。正确的拆法是把原始序列先按时间切好,再做归一化。

train_raw = raw_values[:split_index]
test_raw = raw_values[split_index:]

train_scaled = scaler.fit_transform(train_raw.reshape(-1, 1)).flatten()
test_scaled = scaler.transform(test_raw.reshape(-1, 1)).flatten()

这样的另一个好处是,后续用 scaler.inverse_transform 还原预测值的时候,单位是测试集自己的尺度,误差计算才有意义。很多新手在画图时发现预测曲线和真实曲线不在一个数量级,多半就是忘了做这一步反向还原。

2.3 训练集/测试集的切分陷阱:不能用随机打乱

机器学习里的常规做法是随机划分数据集,也就是打乱样本顺序。但时间序列样本之间存在先后依赖,前一个样本的窗口末尾和后一个样本的窗口起始往往有重叠。如果随机打乱,模型在训练时就看到了“未来信息”,测试集误差会被严重低估。

所以切分必须保留时间顺序:

split_index = int(len(data_scaled) * 0.8)
train = data_scaled[:split_index]
test = data_scaled[split_index:]

train_X, train_y = create_sliding_window(train, TIME_STEPS)
test_X, test_y = create_sliding_window(test, TIME_STEPS)

注意这里构造测试集时, test_X 里的第一个样本完全来自 test 的开头部分, test_y 是它后面一个点。整个测试集没有跨越训练切分点,也就不会用到训练集中的数据。如果数据集存在明显趋势或周期,交叉验证更推荐的工具是 TimeSeriesSplit ,不过对课程设计和大多数业务场景,一次性按时间切分已经完全够用。

提示:不要在 create_sliding_window 之前对整个序列做随机 shuffle ,一定要在窗口化之前保持原始顺序。

3. 一套能直接跑通的LSTM时间序列预测Python最小代码

3.1 库的选择与随机种子

在Python生态里,LSTM最成熟的落地方式有两种:TensorFlow/Keras 和 PyTorch。从“简单又好用”的角度,Keras的 Sequential 接口是最短路径,几行就能把模型搭出来。下面这份代码面向的是环境里已经装好 tensorflow 、 numpy 、 sklearn 的情况。固定随机种子这一步很多人跳过,但项目要给别人复现时,这行代码能避免每次跑结果都不一样。

import numpy as np
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

np.random.seed(42)
tf.random.set_seed(42)

随机种子设成多少并不重要,重要的是它让后续实验具备可比较性。调参过程中如果不固定随机种子,你很难判断效果提升来自参数变化还是运气。

3.2 构造一个可复现的模拟数据

没有真实数据时,可以用三角函数加趋势和噪声来构造序列。这样能在分钟级跑通流程,便于调试。模拟数据的目的是验证整个管线是否正确,而不是得到多高精度。

t = np.arange(0, 1000)
raw = 10 * np.sin(t * 0.02) + t * 0.01 + np.random.normal(0, 0.2, len(t))

这段数据包含正弦波动、线性上升趋势和高斯噪声,对LSTM来说有足够信息量去学习。实际项目中你只需要把 raw 替换成自己的真实序列即可,后面代码完全不用动。

3.3 数据预处理与模型搭建

先做归一化,再构造滑动窗口,最后切分。TIME_STEPS这里设为20,含义是模型每次看过去20个点,然后预测第21个点。这个值不是固定的,第4章会详细讨论怎么选。

TIME_STEPS = 20
BATCH_SIZE = 64
EPOCHS = 20

scaler = MinMaxScaler(feature_range=(0, 1))
scaled = scaler.fit_transform(raw.reshape(-1, 1)).flatten()

X, y = [], []
for i in range(len(scaled) - TIME_STEPS):
    X.append(scaled[i:i + TIME_STEPS])
    y.append(scaled[i + TIME_STEPS])
X = np.array(X).reshape(-1, TIME_STEPS, 1)
y = np.array(y)

split = int(len(X) * 0.8)
train_X, train_y = X[:split], y[:split]
test_X, test_y = X[split:], y[split:]

X.reshape(-1, TIME_STEPS, 1) 中的最后一维1表示单变量特征。如果是多变量数据,构造X时直接传入二维片段,不需要reshape成3维,因为 np.array 会自动识别为 (样本数, time_steps, 特征数) 。

model = Sequential([
    LSTM(64, activation='tanh', return_sequences=True, input_shape=(TIME_STEPS, 1)),
    LSTM(32, activation='tanh'),
    Dense(1)
])
model.compile(optimizer='adam', loss='mse', metrics=['mae'])
model.summary()

第一个LSTM层加上 return_sequences=True ,是为了让第二个LSTM层能继续接收完整的时间步序列。如果只有一个LSTM层,这个参数可以省略。 Dense(1) 输出单个连续值,对应一步预测。loss使用mse,这是因为我们处理的是回归任务,而不是分类。

3.4 训练、预测与反归一化

训练时传入验证集,可以在每一个epoch结束时观察到模型在未见数据上的表现。预测完成后必须用 scaler.inverse_transform 将结果还原到原始数据单位。

history = model.fit(train_X, train_y,
                    validation_data=(test_X, test_y),
                    epochs=EPOCHS,
                    batch_size=BATCH_SIZE,
                    verbose=1)

pred_scaled = model.predict(test_X)
pred = scaler.inverse_transform(pred_scaled).flatten()
true = scaler.inverse_transform(test_y.reshape(-1, 1)).flatten()

这里 pred_scaled 的形状是 (样本数, 1) ,而 test_y 是 (样本数,) ,所以还原时要把 test_y reshape成 (-1, 1) 。预测值还原后,可以直接计算误差指标和绘图。下面这段绘图代码很适合放在项目报告里:

import matplotlib.pyplot as plt

plt.figure(figsize=(12, 4))
plt.plot(true, label='true')
plt.plot(pred, label='pred')
plt.legend()
plt.title('LSTM Time Series Prediction')
plt.show()

这段代码完成后,你已经有一条可运行的完整LSTM预测链路。接下来要思考的是怎么把预测效果从“能跑”提升到“准确”和“有说服力”。

4. LSTM参数调整的4个关键位置与常见错误

4.1 time_steps回看步数到底怎么定

time_steps是LSTM输入里最重要的参数,它决定了模型能观察多长的历史。选太小,模型看不到周期;选太大,样本量减少,训练时间变长,还容易过拟合。一个经验做法是先画自相关图,找到自相关系数明显衰减的滞后阶数,再把它作为time_steps的初值。

import pandas as pd
from pandas.plotting import autocorrelation_plot

autocorrelation_plot(pd.Series(raw))
plt.show()

如果数据存在周期性,比如一天96个15分钟点,time_steps至少覆盖一个完整周期,也就是96。如果没有明显周期,普通序列取20-50都可以。对于课程设计,20是常用默认值,从20开始调,观察验证集loss变化。

4.2 units、batch_size和epochs之间的平衡

units表示LSTM隐状态的维度,可以理解成“记忆容量”。但units过大不等于更好,参数数量会按4倍关系膨胀,因为每个LSTM单元内部有遗忘门、输入门、候选记忆和输出门。batch_size影响梯度稳定性:batch太小,loss震荡;batch太大,模型不易跳出局部极小点。一个能覆盖多数场景的组合是 units=64/32,batch_size=64,epochs先用20试探。

如果训练曲线稳定下降但最终验证loss偏高,优先增加units或加深层数。如果训练loss很低但验证loss高,说明过拟合,优先加Dropout,而不是继续加深网络。

4.3 遗忘门的输入是什么数据:理解LSTM内部的门控

很多人在搜LSTM原理时会看到“遗忘门的输入是什么数据”这个问题。答案是:遗忘门的输入是上一时刻的隐藏状态 h_{t-1} 和当前时刻的输入 x_t 拼接而成的向量。它通过sigmoid函数输出一个0到1之间的值,作用于上一时刻的记忆单元 c_{t-1} 。这个机制决定了LSTM是选择继承长期记忆还是丢弃部分上下文信息。

对应到代码,Keras的 LSTM 层内部已经封装了遗忘门,不需要手写门结构。但当你在调参时,需要知道 dropout 和 recurrent_dropout 是作用于不同位置的。前者随机屏蔽时间步输入,后者随机屏蔽循环连接,也就是 h_{t-1} 到当前单元的那条路径。加Dropout时通常写成:

model = Sequential([
    LSTM(64, return_sequences=True, dropout=0.2, recurrent_dropout=0.1, input_shape=(TIME_STEPS, 1)),
    LSTM(32, dropout=0.2),
    Dense(1)
])

recurrent_dropout 会显著拖慢训练速度,因为循环连接无法像普通层那样方便并行。所以实际项目中如果数据量不大,优先加 dropout=0.2 ,不要轻易加 recurrent_dropout 。

4.4 单步预测和多步预测容易搞混

第3章里的代码是单步预测:每预测一个点,实际输入里用的全部是真实的历史值。而项目需求往往是一口气预测未来24个点。这时如果还用单步模型,你需要把上一步的预测值当成输入喂回去,这种递归预测会随步长累积误差。

单步预测的评估结果看起来漂亮,但直接展示给最终用户会误导,因为真实业务中你不可能拿到未来真实值当作输入。所以高分项目里通常会在这一章做扩展:要么改成多步输出,要么展示滚动预测的误差增长曲线。这个差异被忽略的频率很高,也是答辩时最容易暴露的问题。

5. 让LSTM项目变“高分”的完整化:多步预测、指标与模型保存

5.1 多步预测的实现方式与选择

实现多步预测有两种主流方式。第一种是递归预测,把每一步输出接到窗口末尾,代码量小但误差累积。第二种是直接预测多个时间步,即在模型最后一层使用 Dense(horizon) ,同时输出未来多个点的值。训练时构造y的方式也随之变化。

def create_multi_output_window(data, time_steps, horizon):
    X, y = [], []
    for i in range(len(data) - time_steps - horizon + 1):
        X.append(data[i:i + time_steps])
        y.append(data[i + time_steps:i + time_steps + horizon])
    return np.array(X), np.array(y)

模型结构只改最后一个输出层:

HORIZON = 24
model = Sequential([
    LSTM(64, return_sequences=True, input_shape=(TIME_STEPS, 1)),
    LSTM(32),
    Dense(HORIZON)
])

训练时 y 的形状是 (样本数, HORIZON) ,loss仍然用mse。预测结果一次性拿出24个值,每个值之间的相关性由模型自己学习。相比递归预测,这种方法误差更均匀,但代价是模型需要更多数据才能学得稳。

两种方式的取舍可以参考下面这张表:

方式 训练损失 多步误差表现 适用情况
递归单步 最低 随步长快速增大 短周期、步数少
多输出 略高 稳定、不累积 中长期预测

5.2 用MAE、RMSE、R2给出可论证的量化效果

项目报告里只有一张预测曲线图是不够的。答辩老师会直接问“预测精度是多少”。所以在模型跑通之后,用sklearn评估指标打出一组数字是必须动作。

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

mae = mean_absolute_error(true, pred)
rmse = np.sqrt(mean_squared_error(true, pred))
r2 = r2_score(true, pred)

print(f'MAE: {mae:.4f}')
print(f'RMSE: {rmse:.4f}')
print(f'R2: {r2:.4f}')

MAE直观反映平均误差绝对值,RMSE对大误差更敏感。R2越接近1说明模型解释能力越强。注意这三个指标必须在原始数值尺度上算,也就是 inverse_transform 之后,而不是在归一化后的 [0, 1] 区间里算。否则RMSE看起来很小,但实际误差可能很大,指标失去比较意义。

如果项目需要对比多个模型,建议统一用RMSE作为主指标。因为RMSE带平方项,能放大“偶尔预测偏差很大”的情况,对时间序列这类连续预测来说更严格。

5.3 模型保存与部署时的一个隐藏坑

训练完成后用 model.save('lstm_ts.h5') 保存,预测时用 load_model 加载,这是Keras的标准流程。但很多刚接触的人只保存模型,忘了保存归一化器。模型保存的只是网络权重和结构,不包含scaler中的 min_ 和 scale_ 属性;部署时新来的数据如果不经过同一个scaler,预测结果会完全不同。

import joblib

model.save('lstm_ts.h5')
joblib.dump(scaler, 'scaler.pkl')

上线预测时,加载模型和scaler,然后按同样的顺序处理新数据:先reshape成 (-1, 1) ,再 transform ,接着构造三维输入,预测后再 inverse_transform 。每一步顺序都不能乱。业务系统里常见的问题是训练时的数据是批量传入,而线上预测是逐条传入,忘了给单个样本增加一个batch维,导致shape报错。排查时先打印 input_data.shape ,确保它是 (1, TIME_STEPS, 特征数) 。

6. 用 EarlyStopping 和 ReduceLROnPlateau 把调参时间压到最少

最后一章介绍一个实际项目里高频使用的技巧:回调函数。它能让模型在训练过程中自己判断什么时候停、什么时候降低学习率,从而减少你盯着loss曲线反复试探的次数。Keras里最常用的一对组合是 EarlyStopping 和 ReduceLROnPlateau 。

from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau

early_stop = EarlyStopping(
    monitor='val_loss',
    patience=10,
    restore_best_weights=True
)

reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.5,
    patience=5,
    min_lr=1e-5
)

history = model.fit(
    train_X, train_y,
    validation_data=(test_X, test_y),
    epochs=200,
    batch_size=64,
    callbacks=[early_stop, reduce_lr]
)

EarlyStopping 的 patience=10 表示验证集loss连续10个epoch没有改善就停止训练, restore_best_weights=True 会把模型参数回滚到验证集loss最低的那一个epoch,避免你保存到过拟合的权重。 ReduceLROnPlateau 的 factor=0.5 表示验证loss连续5个epoch不下降时,学习率减半,这样模型进入平台期后能更精细地收敛, min_lr 防止学习率降到无意义的程度。

使用回调后,epoch数可以大胆设到200,不需要你手动判断何时停。节约下来的时间用来做更重要的事:测试不同的TIME_STEPS和units组合。一个快速验证流程是先用数据量的10%跑3个epoch,确认数据形状、归一化还原、回调监控都没问题,再全量训练。这能把整体调参周期缩短一半以上。

另外,如果你发现验证集loss总是比训练集loss高一大截,先检查scaler是否只fit了训练集,再检查输入窗口是否跨越了切分点。这两类问题在LSTM时间序列预测里出现的频率远高于模型结构本身的问题。把这条检查路径记到自己的模板里,以后再做同类项目时,第一版就能收敛到可用状态。

本文还有配套的精品资源,点击获取 menu-r.4af5f7ec.gif

Logo

聚焦RDK与具身智能,汇集机器人开发教程、开源案例和技术交流

更多推荐