企业官网建设流程全解析

简介：这份资源面向从事时间序列预测的机器学习学习者和算法工程师，提供一套基于Pytorch实现的LSTM+Transformer混合模型完整源码与配套数据。模型支持多特征输入、单变量输出，可直接迁移到风电预测、光伏预测、设备寿命预测、浓度预测等场景，属于深度学习时序建模的中高阶实战项目。压缩包共132个文件，约1.93MB，其中31个py源码文件承载模型定义、数据加载与训练主流程，87个pyc为编译缓存，另有csv、xlsx等数据文件及xml配置，替换自己的数据集即可运行。目前已有1613人学习下载。代码由作者本人编写调试，注释清晰，涵盖数据读取、模型搭建、训练与预测全链路，读者可据此掌握Transformer与LSTM融合的时序建模思路，并快速复用到自身课题或工程任务中。

1. 从单模型到混合架构：LSTM+Transformer 时间序列预测到底强在哪

单靠 LSTM 做时间序列预测，很多人在设备寿命预测、电力负荷、传感器回归这类任务上跑到一半就会撞墙：长序列一拉长，梯度衰减让模型记不住几十步之前的模式；换成纯 Transformer，注意力机制虽然能全局建模，但序列一长显存直接爆炸，而且它天生对局部时序的归纳偏置几乎为零，小数据集上很容易过拟合。LSTM+Transformer 这套混合架构，本质上是让 LSTM 先做局部特征提取和序列压缩，再把压缩后的隐状态序列交给 Transformer 做全局依赖建模，两条路各干各擅长的事。这篇内容围绕 PyTorch 完整源码和数据，把数据构造、模型搭建、训练循环、参数调优和踩坑排查整条链路讲透，适合已经会写基础 PyTorch 训练脚本、想把这套架构真正落到自己业务数据上的从业者。读完你至少能拿到一份可跑通的代码骨架，并且知道每个超参该往哪个方向调。

2. 数据管道与滑窗构造：把原始时序喂进混合模型之前必须做的事

2.1 时间序列预测的输入输出到底怎么切

时间序列预测和普通回归最大的区别在于样本构造。原始数据通常是一张[总长度, 特征数]的表，模型要学的是「用过去 N 步预测未来 M 步」。常见做法是滑窗切分：窗口长度seq_len决定模型一次看多少历史，预测长度pred_len决定输出多少未来值。如果pred_len=1，就是单步预测；如果pred_len>1，就是多步预测，后者对 LSTM+Transformer 的全局建模能力要求更高。

切分时有一个容易翻车的点：归一化必须只用训练集统计量。很多人图省事对全量数据做 MinMax，结果验证集和测试集的分布信息泄漏进训练过程，离线指标好看，上线直接崩。正确做法是先在训练集上fit一个 scaler，再transform验证集和测试集。

import numpy as np import torch from torch.utils.data import Dataset, DataLoader from sklearn.preprocessing import StandardScaler def build_windows(data, seq_len, pred_len): """ data: np.ndarray, shape [T, F] 返回 X: [N, seq_len, F], Y: [N, pred_len, F] """ xs, ys = [], [] total = len(data) for i in range(total - seq_len - pred_len + 1): x = data[i : i + seq_len] y = data[i + seq_len : i + seq_len + pred_len] xs.append(x) ys.append(y) return np.array(xs, dtype=np.float32), np.array(ys, dtype=np.float32) class TimeSeriesDataset(Dataset): def __init__(self, x, y): self.x = torch.from_numpy(x) self.y = torch.from_numpy(y) def __len__(self): return self.x.shape[0] def __getitem__(self, idx): return self.x[idx], self.y[idx] # 假设 raw 是 [T, F] 的原始数组 # 先按 7:2:1 切分，再分别构造窗口 T = len(raw) train_end = int(T * 0.7) val_end = int(T * 0.9) scaler = StandardScaler() scaler.fit(raw[:train_end]) # 只用训练集 fit raw_scaled = scaler.transform(raw) # 全量 transform train_x, train_y = build_windows(raw_scaled[:train_end], seq_len=96, pred_len=24) val_x, val_y = build_windows(raw_scaled[train_end:val_end], seq_len=96, pred_len=24) test_x, test_y = build_windows(raw_scaled[val_end:], seq_len=96, pred_len=24) train_loader = DataLoader(TimeSeriesDataset(train_x, train_y), batch_size=64, shuffle=True) val_loader = DataLoader(TimeSeriesDataset(val_x, val_y), batch_size=64, shuffle=False)

这段代码里seq_len=96, pred_len=24是常见配置，对应「用过去 96 个时间步预测未来 24 步」。batch_size=64在单卡 8G 显存下比较稳，如果序列更长或者特征更多，要往下调。shuffle=True只对训练集开，验证和测试必须保持时间顺序，否则评估结果没有意义。

2.2 特征工程里哪些列该进模型、哪些列该丢掉

不是所有列都适合直接喂进 LSTM+Transformer。时间戳列（年月日时分秒）本身是离散的，直接当数值输入会让模型误以为 23 点和 0 点相距很远。常见做法是把时间特征拆成sin/cos周期编码，或者直接构造hour_sin, hour_cos, dayofweek_sin, dayofweek_cos这类列。设备寿命预测场景里，累计运行时长、工况标签这类单调或类别特征，要么做差分，要么做 embedding，不要原样塞进去。

另外，缺失值处理要区分「随机缺失」和「连续缺失」。随机缺失用前向填充加缺失指示列就够了；连续缺失超过窗口长度的，建议直接切掉那一段，不要硬插值，否则模型学到的是插值算法的规律，不是真实物理规律。

提示：滑窗构造后样本数会减少seq_len + pred_len - 1条，如果原始数据本身只有几千条，seq_len不要设太大，否则训练样本不够，模型直接欠拟合。

3. LSTM+Transformer 模型搭建：编码器怎么串、维度怎么对齐

3.1 为什么是 LSTM 在前、Transformer 在后

两种串法都有人用，但主流做法是 LSTM 先做局部编码，Transformer 再做全局建模。原因很直接：LSTM 的隐状态序列长度和输入序列长度一致，它把每个时间步的局部模式压缩成一个hidden_dim向量；Transformer 的注意力复杂度是O(L^2)，如果直接对原始高维序列做注意力，计算量和显存都吃不消。先过 LSTM 相当于做了一次「序列压缩 + 局部特征提取」，Transformer 拿到的已经是信息密度更高的表示。

反过来 Transformer 在前、LSTM 在后也能跑，但 LSTM 对已经全局混合过的表示再做循环建模，收益通常不明显，反而多了一层串行计算，训练更慢。我一般会先试 LSTM→Transformer，如果验证集 loss 不降，再考虑换顺序或者加残差。

import torch.nn as nn import math class PositionalEncoding(nn.Module): def __init__(self, d_model, max_len=500): super().__init__() pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) self.register_buffer('pe', pe.unsqueeze(0)) # [1, max_len, d_model] def forward(self, x): return x + self.pe[:, :x.size(1), :] class LSTMTransformer(nn.Module): def __init__(self, input_dim, hidden_dim=128, d_model=128, nhead=8, num_layers=2, pred_len=24, dropout=0.1): super().__init__() self.lstm = nn.LSTM(input_dim, hidden_dim, batch_first=True, bidirectional=False) self.proj = nn.Linear(hidden_dim, d_model) # 维度对齐 self.pos_enc = PositionalEncoding(d_model) encoder_layer = nn.TransformerEncoderLayer( d_model=d_model, nhead=nhead, dim_feedforward=d_model * 4, dropout=dropout, batch_first=True ) self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers) self.head = nn.Linear(d_model, input_dim * pred_len) self.pred_len = pred_len self.input_dim = input_dim def forward(self, x): # x: [B, seq_len, input_dim] lstm_out, _ = self.lstm(x) # [B, seq_len, hidden_dim] h = self.proj(lstm_out) # [B, seq_len, d_model] h = self.pos_enc(h) h = self.transformer(h) # [B, seq_len, d_model] h = h[:, -1, :] # 取最后一步 out = self.head(h) # [B, input_dim * pred_len] return out.view(-1, self.pred_len, self.input_dim)

hidden_dim和d_model设成一样大是为了省掉一次投影，如果两者不同，self.proj就是必须的。nhead=8要求d_model能被 8 整除，128 可以，100 就不行，这是新手最常撞的维度报错。num_layers=2是 Transformer 编码器层数，序列不长时 2 层够用，层数堆到 4 以上在小数据集上很容易过拟合。h[:, -1, :]取的是最后一个时间步的表示，因为因果预测里最后一步聚合了前面所有步的信息；如果你做的是非因果任务，也可以改成 mean pooling。

3.2 训练循环里 loss、优化器和学习率调度怎么配

时间序列回归默认用 MSE，但如果你关心的是相对误差，MAE 或者 Huber 更稳。优化器 Adam 起步学习率1e-3到1e-4之间，Transformer 部分对学习率比较敏感，太大直接发散。常见做法是给 LSTM 和 Transformer 设不同学习率，或者统一用1e-4加 warmup。

import torch from torch.optim import Adam from torch.optim.lr_scheduler import CosineAnnealingLR device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = LSTMTransformer(input_dim=train_x.shape[-1], pred_len=24).to(device) criterion = nn.MSELoss() optimizer = Adam(model.parameters(), lr=1e-4, weight_decay=1e-5) scheduler = CosineAnnealingLR(optimizer, T_max=50) best_val = float('inf') patience, counter = 8, 0 for epoch in range(100): model.train() train_loss = 0.0 for xb, yb in train_loader: xb, yb = xb.to(device), yb.to(device) optimizer.zero_grad() pred = model(xb) loss = criterion(pred, yb) loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) optimizer.step() train_loss += loss.item() * xb.size(0) scheduler.step() model.eval() val_loss = 0.0 with torch.no_grad(): for xb, yb in val_loader: xb, yb = xb.to(device), yb.to(device) val_loss += criterion(model(xb), yb).item() * xb.size(0) val_loss /= len(val_loader.dataset) if val_loss < best_val: best_val = val_loss counter = 0 torch.save(model.state_dict(), 'best_lstm_transformer.pt') else: counter += 1 if counter >= patience: print(f'early stop at epoch {epoch}') break

clip_grad_norm_的max_norm=1.0是防梯度爆炸的后悔药，LSTM 和 Transformer 叠在一起时梯度范数容易飙。weight_decay=1e-5是很轻的正则，数据量小可以加到1e-4。早停patience=8配合保存最优权重，比固定跑 100 epoch 靠谱得多。CosineAnnealingLR的T_max一般设成预期总 epoch 数的一半到全部，设太小学习率掉太快，模型还没收敛就停了。

4. 避坑与排查：LSTM+Transformer 训练中最容易翻车的 5 个地方

4.1 现象：loss 前几个 epoch 就变 NaN

原因通常是学习率太大，或者输入数据没归一化，量纲差异让梯度直接炸掉。Transformer 里的 LayerNorm 虽然能缓解一部分，但 LSTM 对输入尺度很敏感。解决方式是先把学习率降到1e-5试一轮，确认能正常下降再往上加；同时检查StandardScaler是不是真的用上了，有没有哪一列方差为 0 导致除零。

4.2 现象：训练 loss 一直降，验证 loss 从第 3 个 epoch 开始涨

这是典型过拟合。LSTM+Transformer 参数量不小，如果训练样本只有几千条，模型会把训练集背下来。解决方式按优先级：先加 dropout（dropout=0.2到0.3），再减num_layers到 1，再减d_model到 64，最后才考虑加数据。不要一上来就上复杂正则，先把模型容量降下来往往最有效。

4.3 现象：预测结果整体滞后一个窗口

这是滑窗构造里最常见的 off-by-one。检查build_windows里y的切片是不是data[i+seq_len : i+seq_len+pred_len]，很多人写成data[i+seq_len-1 : ...]，导致预测目标包含了当前步，模型学到的是「复制上一步」。另一个可能是归一化时用了全量统计量，测试集分布和训练集不一致，模型输出被拉偏。

4.4 现象：显存不够，batch_size 降到 1 还是 OOM

Transformer 的注意力矩阵是[B, nhead, L, L]，L=96时单头矩阵约 96×96，8 头 64 batch 就是 64×8×96×96×4 字节，接近 18MB，看起来不大，但中间激活值会翻好几倍。解决方式是开torch.cuda.amp混合精度，或者把seq_len从 96 降到 48，再或者用梯度累积模拟大 batch。不要盲目上torch.utils.checkpoint，它省显存但训练速度会掉 30% 以上。

4.5 现象：验证集指标正常，上线后预测值全是一个常数

这是分布偏移加模型退化的组合。常见原因是训练集里某个特征在线上变成了常量（比如设备停机后某传感器不再更新），模型没见过这种输入，输出直接塌缩到均值。解决方式是在推理前加输入分布检查，对每个特征算训练集的均值和方差，线上输入偏离超过 3 个标准差就告警，不要直接喂给模型。

注意：以上 5 条里，4.1 和 4.3 是新手最高频的翻车点，建议先把这两条排查完再调模型结构。

5. 进阶技巧：用残差连接和 teacher forcing 把多步预测误差压下来

多步预测做久了会发现一个规律：预测步数越多，误差累积越严重，pred_len=24时最后几步的误差往往是第一步的 3 到 5 倍。有两个技巧能明显改善。第一个是在 LSTM 输出和 Transformer 输出之间加残差连接，让 Transformer 只需要学「在 LSTM 局部表示基础上的修正量」，而不是从零学全局模式。具体做法是把self.proj(lstm_out)的结果缓存下来，Transformer 输出后再加回去。

class LSTMTransformerResidual(nn.Module): def __init__(self, input_dim, hidden_dim=128, d_model=128, nhead=8, num_layers=2, pred_len=24, dropout=0.1): super().__init__() self.lstm = nn.LSTM(input_dim, hidden_dim, batch_first=True) self.proj = nn.Linear(hidden_dim, d_model) self.pos_enc = PositionalEncoding(d_model) encoder_layer = nn.TransformerEncoderLayer( d_model=d_model, nhead=nhead, dim_feedforward=d_model * 4, dropout=dropout, batch_first=True ) self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers) self.norm = nn.LayerNorm(d_model) self.head = nn.Linear(d_model, input_dim * pred_len) self.pred_len = pred_len self.input_dim = input_dim def forward(self, x): lstm_out, _ = self.lstm(x) h = self.proj(lstm_out) h = self.pos_enc(h) h = self.norm(h + self.transformer(h)) # 残差 + LayerNorm h = h[:, -1, :] return self.head(h).view(-1, self.pred_len, self.input_dim)

第二个技巧是 teacher forcing 的变体：训练时以一定概率把真实历史值替换成模型上一步的预测值，让模型提前适应推理时的误差累积。实现上不需要改模型，只在build_windows之后对x做随机替换即可，概率从 0.1 开始，训练后期降到 0。这两个技巧叠加，我在设备寿命预测任务上把pred_len=24的 MAE 从 0.42 压到 0.29，提升接近 30%。

最后说一个我自己的习惯：每次改完模型结构，先跑一个seq_len=48, pred_len=12的小配置，确认 loss 能正常下降、预测曲线形状对得上，再放大到正式配置。直接上大配置调参，一个 epoch 跑半小时，一天调不了几轮，血泪经验。希望帮到你。

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