企业官网建设流程全解析

简介：面向时间序列预测与毕业设计场景，这份资源提供了基于长短时记忆网络LSTM、Transformer架构以及自定义线性模型实现ETTh1数据集预测的完整Python源码与项目说明。压缩包共39个文件，以34个py脚本为核心，覆盖数据加载、模型构建、实验执行等模块；另含2个shell启动脚本、2个Markdown说明文档，以及1个内置的项目代码压缩包，整体大小仅64KB。

代码结构清晰：data_provider模块负责数据读取与预处理，exp模块管理实验流程，layers模块提供Transformer的自注意力等子模块，models目录则分别实现了LSTM、Transformer和自定义线性模型三个可切换版本。通过调整run_longExp.py中的模型名称、序列长度等超参数，即可对比不同架构在ETTh1上的预测效果。

目前已有1428人学习下载。资源内代码均经过测试运行成功，适合计算机相关专业学生作为课程设计、毕业设计或入门进阶材料，也便于在其基础上二次开发，深入理解时间序列预测模型的实现差异。

1. ETTh1 时间序列预测为什么值得用三种模型各跑一遍

时间序列预测在工业界和学术圈有个很尴尬的现状：论文里指标一个比一个漂亮，换到自己的数据集上却经常“水土不服”。ETTh1 作为 Transformer 类模型被反复引用的标准基准，包含 7 个电力负荷相关变量、1 小时采样粒度，其可复现性远超普通业务数据，但也正因为标准，很多人跑完只是记住了几个数字，没搞明白模型到底吃透了什么规律。LSTM、Transformers、自定义模型三者恰好代表了序列建模的三条路线：递归归纳、全局注意力、面向特定任务的手工归纳偏置。把这三个模型在同一份 ETTh1 上从数据处理、训练调参到预测评估完整做一遍，才能真正理解“不同架构对同一组序列的建模差异”落在哪里——哪些是数据本身的周期贡献，哪些是模型结构带来的增益。这篇内容不抄任何现成源码，只按一线工程做法把三套方案完整落地，给出能直接运行的命令、参数表和排错点，适合已经会用 Python 处理数据、但没系统对比过这几个架构的算法工程师和研究生。

2. 数据预处理与评估协议：ETTh1 的坑提前排掉

2.1 ETTh1 数据字段与 7 个变量的含义

ETTh1 是 ETT（Electricity Transformer Temperature）数据集中的小时级变体，来源于两台电力变压器在两年间的运行记录，每条样本包含 7 个特征：油温（OT）、6 个不同位置的负荷值（HUFL、HULL、MUFL、MULL、LUFL、LULL）。目标变量通常选油温 OT 做单变量预测，也可以把 6 个负荷变量全部作为外生特征做多变量预测。多变量版本的输入形状是[batch, seq_len, 7]，单变量版本是[batch, seq_len, 1]。

数据本身已经按时间排序，不需要 shuffle。训练集、验证集、测试集的划分比例一般取 6:2:2 或 7:2:1，但有一条硬性约束：必须按时间顺序切分，不能随机打乱后分层抽样，否则验证集和测试集会包含训练集之后的信息，评估结果会虚高。常见的做法是：

import pandas as pd from sklearn.preprocessing import StandardScaler df = pd.read_csv('ETTh1.csv') # 按时间顺序划分：前 60% 训练，20% 验证，20% 测试 train_size = int(len(df) * 0.6) val_size = int(len(df) * 0.2) train_df = df.iloc[:train_size] val_df = df.iloc[train_size:train_size + val_size] test_df = df.iloc[train_size + val_size:] # 只对训练集拟合 scaler，避免信息泄露 scaler = StandardScaler() train_scaled = scaler.fit_transform(train_df[feature_cols]) val_scaled = scaler.transform(val_df[feature_cols]) test_scaled = scaler.transform(test_df[feature_cols])

feature_cols按你的预测目标决定：只预测油温就取['OT']，把负荷也作为输入特征就取全部 7 列。这里StandardScaler只在训练集上fit，验证集和测试集直接transform，这是很多初学实现会忽略的细节——一旦对整个数据集做标准化再切分，测试集的均值方差就泄露给了训练过程，测试指标会偏乐观。

2.2 滑窗采样原理与 lookback、horizon 参数选择

时间序列预测的样本构造方式不是按行取，而是用滑动窗口从连续序列里切出(X, y)对。X是过去lookback个时间步的特征，y是未来horizon个时间步的目标值。ETTh1 是小时级数据，如果做短期预测，lookback=96（过去 4 天）、horizon=24（预测未来 1 天）是 Informer、Autoformer 论文里的标准组合；如果想做长期预测，horizon可以提到 168（一周）。

滑窗采样时要注意步长。无重叠滑窗会浪费样本，步长为 1 的滑窗会让相邻样本高度相关，训练时模型容易记住“上一条样本的答案”。工程上常用步长stride=24，相当于每隔一天取一个窗口，在样本数量和独立性之间取平衡。生成样本的代码如下：

import numpy as np def create_sequences(data, feature_cols, target_idx, lookback, horizon, stride=24): X_list, y_list = [], [] for i in range(0, len(data) - lookback - horizon + 1, stride): X_list.append(data[i:i + lookback, :]) y_list.append(data[i + lookback:i + lookback + horizon, target_idx]) return np.array(X_list), np.array(y_list) # 假设 train_scaled 形状是 [N, 7] X_train, y_train = create_sequences(train_scaled, feature_cols, target_idx=6, lookback=96, horizon=24) # y_train 形状: [样本数, 24]，x_train 形状: [样本数, 96, 7]

target_idx=6对应 OT 列在多变量输入中的索引，如果你的feature_cols只选了['OT']，target_idx 就设 0。y的形状设计成[样本数, horizon]而不是[样本数, horizon, 1]，这样在计算 MSE 时可以直接和模型输出做比较，少一次维度压缩操作。滑窗代码看起来简单，但边界条件容易错：range的终点必须是len(data) - lookback - horizon + 1，否则最后一个窗口会越界，导致数组维度不一致而报错。

2.3 评估指标：MSE、MAE 为什么比准确率更合适

分类任务看准确率，回归任务看误差。时间序列预测是回归问题，标准评估指标是MSE（均方误差）、MAE（平均绝对误差），以及论文里常配的MAPE（平均百分比误差）。MSE 对大误差敏感，能放大模型的极端失误；MAE 反映平均偏差水平；MAPE 给出相对误差百分比，便于直观理解。

注意：MAPE 在目标值接近 0 时会爆炸，ETTh1 的油温数据经过标准化后有负值，直接计算 MAPE 会得到无意义的巨大数字。工程上要么对反标准化后的原始值计算 MAPE，要么干脆只报 MSE 和 MAE。

在测试集上统一用同一套评估函数，才能公平对比三个模型。评估代码：

from sklearn.metrics import mean_squared_error, mean_absolute_error def evaluate_model(y_true, y_pred, scaler, target_idx=6): # y_true, y_pred 形状都是 [样本数, horizon] # 反标准化回原始尺度再计算指标，结果更可读 y_true_inv = scaler.inverse_transform( np.concatenate([np.zeros((len(y_true), target_idx)), y_true, np.zeros((len(y_true), len(feature_cols) - target_idx - 1))], axis=1) )[:, target_idx] # 对 y_pred 做同样的反变换... mse = mean_squared_error(y_true_inv, y_pred_inv) mae = mean_absolute_error(y_true_inv, y_pred_inv) return mse, mae

这段代码的要点是反标准化：scaler是在 7 维特征上训练的，要把预测的 1 维结果放回 7 维空间里才能正确inverse_transform。直接对一维数组做反变换会报形状不匹配的错误。inverse_transform之后再取出目标列，得到的就是真实温度尺度下的误差值，可以直接和论文里的公开指标做横向比较。

3. LSTM 实现：回归任务的递归建模与训练细节

3.1 LSTM 处理回归预测的输入输出结构

LSTM 的核心是按时间步递归处理输入序列。每个时间步，LSTM 单元接收当前时刻的特征向量和上一时刻的隐藏状态，输出新的隐藏状态和细胞状态。对于 ETTh1 的输入[batch, 96, 7]，LSTM 会依次处理 96 个时间步，每个时间步输入一个[batch, 7]的向量。最后一个时间步输出的隐状态h_n浓缩了整个序列的信息，再接一个全连接层把它映射到horizon维的预测输出。

这里要区分两种预测方式：单步递归预测和直接多步预测。单步递归是模型只预测下一个时间步，把预测值拼接回输入，再预测下一个；直接多步是模型一次性输出未来 24 个值。工程实现上直接用后者，训练更稳定，推理也更快。PyTorch 的nn.LSTM返回的 output 包含所有时间步的隐状态，取output[:, -1, :]就是最后一个时间步的隐状态：

import torch import torch.nn as nn class LSTMPredictor(nn.Module): def __init__(self, input_size, hidden_size, num_layers, output_size, dropout=0.1): super().__init__() self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True, dropout=dropout) self.fc = nn.Linear(hidden_size, output_size) def forward(self, x): # x: [batch, seq_len, input_size] out, _ = self.lstm(x) # out: [batch, seq_len, hidden_size] last_hidden = out[:, -1, :] # 取最后一个时间步 return self.fc(last_hidden) # [batch, horizon]

batch_first=True让输入输出形状更符合直觉，num_layers控制 LSTM 层数。层数不是越多越好：2 层在 ETTh1 上基本够用，3 层以上在小规模数据上容易过拟合，而且训练时间翻倍。hidden_size一般取 32~128 之间，ETTh1 数据量不大，取 64 起步就行。

3.2 训练超参数：学习率、batch size、早停与梯度裁剪

LSTM 的梯度在长序列上容易爆炸或消失，这是循环结构的天生问题。虽然 ETTh1 的 lookback 只有 96，不算特别长，但训练时仍然要加梯度裁剪。常用做法是设置max_grad_norm=1.0，在反向传播后、优化器更新前执行：

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-5) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( optimizer, mode='min', factor=0.5, patience=3 ) for epoch in range(100): model.train() train_loss = 0.0 for X_batch, y_batch in train_loader: optimizer.zero_grad() y_pred = model(X_batch) loss = nn.MSELoss()(y_pred, y_batch) loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) optimizer.step() train_loss += loss.item() # 验证集上评估，触发学习率衰减 val_loss = validate(model, val_loader) scheduler.step(val_loss)

学习率初始 1e-3 是 Adam 的常用起点，ReduceLROnPlateau在验证集 loss 3 个 epoch 不降时把学习率减半。weight_decay加 L2 正则防止过拟合。训练轮数不要固定跑满 100，建议结合早停——验证集 loss 连续 10 个 epoch 不下降就终止训练，保存验证集上最优的模型权重：

best_val_loss = float('inf') patience_counter = 0 for epoch in range(100): # ...训练代码... if val_loss < best_val_loss: best_val_loss = val_loss torch.save(model.state_dict(), 'lstm_best.pt') patience_counter = 0 else: patience_counter += 1 if patience_counter >= 10: print(f'Early stop at epoch {epoch}') break

早停的关键在于只保存验证集最优时的权重，而不是最后 1 个 epoch 的权重。由于验证集 loss 后期可能震荡，最后一步的模型反而不如中间某一步的泛化好。

3.3 训练曲线诊断：loss 不降 / 震荡 / 过拟合的判别

训练曲线是排查问题最直接的工具。LSTM 在 ETTh1 上训练时常见的三种异常现象：

训练 loss 不降或下降极慢。通常是学习率太小或模型容量不足。先检查数据是否标准化——ETTh1 原始 OT 值在几十度量级，不标准化会让 loss 数值巨大，梯度更新不稳定。再检查是不是输入输出形状不匹配，y_pred和y_batch维度不一致时 MSE 会报错或产生无意义数值。

验证 loss 持续震荡。往往与学习率偏大或 batch size 太小有关。试试把学习率降到 3e-4，或把 batch size 从 32 提到 64。ETTh1 的训练样本量在 2 万左右，batch size 32 时每个 epoch 的更新次数约 600，样本随机性带来的梯度噪声偏大，容易在小幅度震荡。

训练 loss 降、验证 loss 升，这是典型过拟合。优先降低hidden_size或num_layers，其次加大dropout到 0.2~0.3，最后才是加weight_decay。不要一上来就堆正则，先把模型容量降下来试一轮。记录每个 epoch 的训练和验证 loss 曲线，能直接看出模型是欠拟合还是过拟合，这比反复试参数快得多。

4. Transformers 实现：多头注意力与位置编码的关键取舍

4.1 自注意力机制为什么适合长序列，但对 ETTh1 的挑战在哪

Transformer 的核心是自注意力机制：每个时间步的表示通过计算它与其他所有时间步的相关性来更新，直接从全局捕获依赖关系。这对长序列有天然优势——LSTM 需要把信息一步步传过来，路径长度等于序列长度，而 Transformer 的信息传递路径是 O(1) 的，任意两个时间步之间直接相连。

但 Transformer 在 ETTh1 这种小时级数据上有一个关键劣势：计算复杂度是序列长度的平方。lookback=96 时计算量还不明显，但 Transformer 的归纳偏置不如循环网络强。时间序列的规律是局部的——今天的温度更接近昨天的温度，而不是三个月前的同一天。自注意力会被迫把权重分配给所有位置，如果数据量不够大，模型学出来的注意力分布可能偏向噪声。

另一个问题是注意力机制本身对位置信息不敏感：在纯 self-attention 中，把序列倒序输入，输出的表示完全一样。位置编码就是来解决这个问题的。

4.2 位置编码的两种方案：正弦编码 vs 可学习编码

Transformer 原文使用正弦位置编码，公式是：

def sinusoidal_positional_encoding(seq_len, d_model): pe = torch.zeros(seq_len, d_model) position = torch.arange(0, seq_len, dtype=torch.float).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-np.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) return pe.unsqueeze(0) # [1, seq_len, d_model]

正弦编码的优点是不需要训练、长度外推性相对好；可学习编码则让模型自己决定位置信息的表达方式。ETTh1 这类小时级数据，周期性规律清晰，建议直接用可学习位置编码，因为它的自由度更高，模型可以自适应地调整“每小时”这个位置的向量表达。实现时把位置编码作为模型的nn.Parameter：

class TransformerPredictor(nn.Module): def __init__(self, input_size, d_model, nhead, num_layers, output_size, dropout=0.1): super().__init__() self.input_proj = nn.Linear(input_size, d_model) self.pos_encoder = nn.Parameter(torch.zeros(1, 96, d_model)) encoder_layer = nn.TransformerEncoderLayer( d_model=d_model, nhead=nhead, dim_feedforward=d_model * 4, dropout=dropout, batch_first=True ) self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers) self.fc = nn.Linear(d_model, output_size) def forward(self, x): x = self.input_proj(x) + self.pos_encoder out = self.transformer_encoder(x) return self.fc(out[:, -1, :])

输入先经过线性投影把 7 维映射到d_model维，加上位置编码后进入 TransformerEncoder。out[:, -1, :]是最后一个位置的输出表示，类似 LSTM 取最后一个时间步的隐状态，但语义不同——Transformer 的这个位置表示已经通过注意力汇聚了整个序列的信息。

4.3 参数设定：d_model、nhead、层数与学习率的对应关系

Transformer 各参数之间相互制约，不能单独调。核心经验是：d_model必须能被nhead整除，否则多头注意力的维度拆分会报错。ETTh1 数据规模小，推荐从d_model=128,nhead=4,num_layers=2起步，这是在小数据上不容易过拟合的配置。

学习率是 Transformer 训练的敏感项。由于注意力层的梯度量级变化大，固定学习率容易震荡，工程上常用Warmup + 线性衰减（Transformer 原文的调度方式）：

optimizer = torch.optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.98)) def lr_lambda(step): warmup_steps = 4000 if step < warmup_steps: return float(step) / float(max(1, warmup_steps)) return warmup_steps ** 0.5 * step ** -0.5 scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)

warmup_steps在 ETTh1 上设 4000 意味着前 4000 步学习率从 0 线性升到峰值，之后按反平方根衰减。这个调度比固定学习率稳定得多，注意力层对学习率波动的容忍度极低，固定学习率很容易在训练初期就发散。训练轮数建议 20~30，Transformer 在小数据集上的收敛比 LSTM 快，因为全局注意力一次就能看到整个序列的信息，不需要像 LSTM 那样逐步传递。

4.4 与 LSTM 的对比实验：同一份数据的公平对照方法

做对比实验时最容易犯的错是“不同模型用了不同的预处理或评估方式”，导致结果差异无法归因于模型本身。公平对照必须保证四点：同一份train_scaled、val_scaled、test_scaled；同一个滑窗参数lookback=96, horizon=24, stride=24；同一个数据加载器或 batch size；同一套 MSE/MAE 评估函数。唯一可以不同的是模型内部结构和学习率调度。

我把两个模型放进同一个训练脚本里，用argparse控制模型类型字段，这样能够避免手改训练循环引入其他变量：

model_configs = { 'lstm': {'model_type': 'lstm', 'hidden_size': 64, 'num_layers': 2, 'lr': 1e-3}, 'transformer': {'model_type': 'transformer', 'd_model': 128, 'nhead': 4, 'num_layers': 2, 'lr': 1e-3, 'warmup_steps': 4000} }

对比实验的观察重点不是谁更高一点，而是结合训练曲线看：Transformer 是否收敛更快、验证集 loss 更低、但测试集和验证集之间的差距更大。ETTh1 数据量有限，Transformer 在测试集上未必一定超过 LSTM，这种“预期之外的平局”本身就是信息，说明该数据集的序列长度和复杂度还没有到需要全局注意力的程度。

5. 自定义模型实战：从零搭建轻量预测网络

5.1 为什么要自定义模型：针对单变量 ETTh1 的精简设计

标准化框架只能给兜底方案。ETTh1 的序列带明显的日周期和温度惯性，这种规律性强的数据未必需要堆叠复杂结构。自定义模型的目标是用最简结构达到接近 LSTM 和 Transformer 的效果，从而验证数据本身的可预测性到底有多强。

我的做法是从 LSTM 中拆出最关键的组件：门控循环单元（GRU）+ 注意力池化。GRU 比 LSTM 少一个门，参数更少、训练更快；注意力池化替代“取最后一个时间步”的操作，让模型从所有时间步中按相关性加权聚合特征。这个组合在 ETTh1 上是一个合理的轻量基线，参数量不到 LSTM 的一半：

class LightweightSeqNet(nn.Module): def __init__(self, input_size, hidden_size, output_size, dropout=0.1): super().__init__() self.gru = nn.GRU(input_size, hidden_size, batch_first=True) self.attention = nn.Sequential( nn.Linear(hidden_size, hidden_size // 2), nn.Tanh(), nn.Linear(hidden_size // 2, 1) ) self.dropout = nn.Dropout(dropout) self.fc = nn.Linear(hidden_size, output_size) def forward(self, x): out, _ = self.gru(x) # [batch, seq_len, hidden_size] # 计算每个时间步的注意力权重 attn_weights = torch.softmax(self.attention(out), dim=1) # [batch, seq_len, 1] # 加权求和得到序列表示 context = torch.sum(out * attn_weights, dim=1) # [batch, hidden_size] context = self.dropout(context) return self.fc(context)

attention子模块把每个时间步的隐状态映射成一个标量分数，softmax在时间步维度上归一化，得到权重分布。这里dim=1对应序列长度维，因为batch_first=True时输出形状是[batch, seq_len, hidden_size]。加权求和把 96 个时间步的信息聚合成一个向量，比单纯取最后一个时间步更灵活——如果某个中间时间点的状态对预测更有用，注意力机制能自动分配更高权重。

5.2 训练细节对比：收敛速度、参数量与内存占用

自定义模型在训练时的第一感受是内存占用显著下降。GRU 只有 2 个门（LSTM 有 3 个），隐状态数量减半，反向传播时的中间变量更少。在 batch size=64、lookback=96 的条件下，LSTM 的显存占用约是自定义模型的 1.5 倍。这个差异在单卡训练时影响不大，但如果后续要把模型部署到边缘设备或嵌入式环境，参数量的差距就很关键了。

Transformer 的参数量是自定义模型的近 30 倍，但在 ETTh1 这种单变量预测任务上，它未必能换来等比例的精度提升。参数量大意味着需要更多数据才能充分拟合；ETTh1 训练集约 1.2 万条样本，对 50 万参数的模型来说偏少。自定义模型训练收敛更快，一般 15 个 epoch 左右就能达到稳定验证损失。

5.3 对自定义模型做误差分析：到底比基线强在哪

模型跑完不是结束，还需要回答“自定义模型相对于基线模型强在哪里”。误差分析按时间步展开是最高效的做法。将测试集的预测值和真实值按 horizon 的每个位置（第 1 小时、第 2 小时……第 24 小时）分别计算 MAE，绘制成曲线，能直观看到模型在短期和长期预测上的能力差异：

import matplotlib.pyplot as plt y_test = np.array(测试集真实值) # [样本数, 24] y_pred_custom = np.array(模型预测值) # [样本数, 24] mae_by_step = np.mean(np.abs(y_test - y_pred_custom), axis=0) plt.plot(range(1, 25), mae_by_step, marker='o') plt.xlabel('预测步长 (小时)') plt.ylabel('MAE') plt.title('不同预测时长的误差分布')

通常观察到的规律是：预测步长越远，误差越大。第 1 小时预测误差最小，因为其信息几乎全部来自当前时刻的油温和负荷；第 12 小时以后误差开始显著上升，进入日周期的“相位不确定区”——模型知道温度会在某个区间波动，但不确定具体峰值出现在几点。如果自定义模型在短步长上逼近 LSTM、在长步长上略逊，说明注意力池化对短时依赖建模充分，但对长程模式捕捉不如 LSTM 的隐状态传递。

误差分布曲线还能帮你发现模型是否在某些时段系统性偏大，比如每天 8 点到 10 点的用电高峰。这个信息比单纯比较 MSE 数字更有工程价值，能指引下一轮特征工程的方向，例如是否要加入“小时序号”作为周期特征。

6. 模型对比与推理部署：测试集评估和可视化输出

三个模型在测试集上的评估要统一操作。加载各自训练好的最优权重，在同一个test_loader上循环推理，收集全部预测结果后计算 MSE 和 MAE。注意model.eval()和torch.no_grad()是测试的标准流程，前者关闭 dropout 和 batch norm 的训练行为，后者禁止梯度计算，减少内存占用：

def inference(model, test_loader, device): model.eval() preds, trues = [], [] with torch.no_grad(): for X_batch, y_batch in test_loader: X_batch = X_batch.to(device) y_pred = model(X_batch).cpu().numpy() preds.append(y_pred) trues.append(y_batch.numpy()) return np.concatenate(preds, axis=0), np.concatenate(trues, axis=0) # 对三个模型分别调用，得到 pred_lstm, pred_transformer, pred_custom

推理阶段的核心性能指标是吞吐量：单条样本的预测延迟（p99）和每秒处理的样本数。ETTh1 测试集样本约 4000 条，三个模型的推理总时间都在 1 秒以内，但这个数字在实时预测场景会放大——假设生产环境需要每分钟预测一次未来 24 小时，LSTM 和自定义模型都能轻松满足；Transformer 虽然绝对延迟也可接受，但 GPU 内存占用更高，部署成本更大。

可视化推荐画 24 小时预测对比曲线：取测试集最后一条样本，画出真实值、LSTM 预测、Transformer 预测、自定义模型预测四条曲线，保存为 PNG。这一步的工程意义在于：指标数字只告诉你“差多少”，曲线才能告诉你“差在形状上还是幅值上”。如果预测曲线整体滞后真实曲线半个周期，那不是模型精度问题，而是输入信息的相位偏差问题。

最后把模型导出为生产可用的格式。PyTorch 模型用torch.jit.script或torch.onnx.export导出，前者保持 PyTorch 生态兼容性，后者可以转换到 TensorRT 或 ONNX Runtime 做 CPU/GPU 推理加速：

dummy_input = torch.randn(1, 96, 7) traced_model = torch.jit.trace(model.cpu(), dummy_input) traced_model.save('lstm_etth1.pt')

导出的模型输入输出维度和训练时完全一致，部署时不再需要加载 PyTorch 模型定义，直接torch.jit.load就能跑。把lookback=96, horizon=24, stride=24这些参数和标准化 scaler 一起打包进一个配置 JSON，放进model/目录，整个项目就能脱离训练脚本独立运行，这也是源码交付时最实用的组织方式。

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