LSTM+Attention时序预测实战：架构、调参、避坑指南

1. 从"预测"这件事说起：为什么LSTM+Attention是绕不开的组合

做时间序列预测的人，大概率都经历过这样一个过程：一开始用ARIMA，发现线性假设太强，稍微复杂点的数据就拟合不动；然后换XGBoost或者LightGBM，把历史窗口拉成特征，效果确实好了一截，但总感觉少了点什么——模型对"哪些历史时刻更重要"这件事没有概念，所有时间步被一视同仁地塞进特征里。再往后走，自然就会碰到LSTM，碰到Attention，碰到这两者组合起来的经典架构。

"LSTM+Attention+Prediction"这个标题看起来简单，三个词就把整个技术栈概括完了，但它背后牵扯的东西其实相当多。LSTM解决的是"长序列中梯度消失、长期依赖难以捕捉"的问题，Attention解决的是"不同时间步对当前预测的贡献应该不同"的问题，Prediction则是最终要落地的目标——不管是股价走势、销量预测、设备剩余寿命估计，还是气象时序建模，本质上都是在做同一件事：给定过去一段时间的观测序列，推断未来某个时刻或某段时间的取值。

这套组合之所以成为时序预测领域的事实标准之一，核心原因在于它同时处理了两个维度的信息压缩。LSTM通过门控机制把变长序列压缩成一个固定维度的隐状态，Attention则在这个压缩过程中动态地分配权重，让模型自己学会"回头看"。你可以把它想象成一个人在读一份长报告：LSTM是他逐页阅读并记住关键信息的能力，Attention则是他在回答某个具体问题时，知道该翻回哪几页去重点看。

这篇文章面向的读者是已经有一定深度学习基础、准备把LSTM+Attention落地到实际预测任务中的从业者。我会从架构设计的思路讲起，拆解每个模块的选型理由，然后给出完整的实操流程和参数配置，最后把我在实际项目中踩过的坑和排查经验整理出来。代码以PyTorch为主，因为它在自定义模型结构上更灵活，适合做Attention这种非标准层的实现。

2. 架构设计：LSTM和Attention到底怎么拼在一起

2.1 两种主流拼接方式的取舍

LSTM和Attention的组合方式不是唯一的，实际项目中最常见的有两种结构，选择哪种取决于你的预测任务对信息粒度的要求。

第一种是LSTM编码 + Attention池化 + 全连接输出。这种结构里，LSTM先把整个输入序列编码成一串隐状态 $h_1, h_2, ..., h_T$，然后Attention机制对这串隐状态做加权求和，得到一个上下文向量 $c$，最后把 $c$ 送进全连接层做预测。这种方式的优点是结构清晰、计算量可控，适合大多数单步预测或多步直接预测的场景。

第二种是Encoder-Decoder + Attention。编码器LSTM把输入序列编码成隐状态序列，解码器LSTM在每一步生成预测时，通过Attention去查询编码器的所有隐状态，动态决定当前步应该关注输入的哪些部分。这种结构更适合序列到序列的预测任务，比如输入过去7天预测未来3天，而且未来每一步的预测都依赖于前一步的输出。

我个人的经验是：如果你的预测目标是一个点或者一个固定长度的向量（比如用过去24小时预测未来1小时的值），第一种结构足够用，而且训练更稳定。如果你的预测目标是一个变长序列，或者未来每一步之间存在强依赖关系，那就得上第二种。很多人在项目初期就上Encoder-Decoder，结果发现训练慢、调参难，其实完全没必要。

2.2 为什么是LSTM而不是Transformer

这两年Transformer在时序预测领域确实很火，不少论文宣称用纯Attention结构就能打败LSTM。但我在实际项目中反复对比过，至少在中小规模数据集（几万到几十万条样本）上，LSTM+Attention的组合仍然有它的优势。

原因在于归纳偏置。LSTM的结构天然适合处理有序序列，门控机制对时间步的顺序敏感，而Transformer的Self-Attention是排列不变的，需要额外的位置编码来注入顺序信息。在数据量不够大的时候，LSTM的这种先验知识反而成了优势——它不需要从数据里重新学习"顺序很重要"这件事。

另一个实际考量是计算资源。Self-Attention的复杂度是 $O(T^2)$，当你的序列长度到几百甚至上千时，显存占用会急剧上升。LSTM的复杂度是 $O(T)$，在长序列场景下更友好。当然，如果你的序列长度只有几十，而且数据量足够大，Transformer确实值得一试。

注意：这里说的LSTM优势是在中小规模数据和中短序列场景下。如果你的数据量在百万级别以上，序列长度超过500，那Transformer或者其变体（如Informer、Autoformer）可能更合适。技术选型永远要看具体场景，没有银弹。

2.3 Attention机制的具体形式选择

Attention本身也有很多变体，在时序预测中最常用的是加性Attention（Bahdanau Attention）和点积Attention（Luong Attention）。

加性Attention的计算方式是：

$$e_t = v^T \tanh(W_h h_t + W_s s + b)$$

其中 $h_t$ 是编码器在第 $t$ 步的隐状态，$s$ 是解码器当前状态（如果是自注意力池化，$s$ 可以省略或者用一个可学习的查询向量代替），$v$、$W_h$、$W_s$、$b$ 都是可学习参数。

点积Attention则是：

$$e_t = h_t^T W s$$

两者在效果上差异不大，但加性Attention在隐状态维度较高时更稳定，点积Attention计算更快。我在时序预测任务中通常默认用加性Attention，因为它的参数量稍多，在小数据集上反而更不容易过拟合——这听起来有点反直觉，但实际跑下来确实如此，可能是因为加性Attention的tanh非线性提供了更强的表达能力。

还有一个细节是是否要对Attention权重做温度缩放。在点积Attention中，通常会除以 $\sqrt{d_k}$ 来防止softmax饱和。在加性Attention中这个问题不那么突出，但如果你发现训练初期Attention权重几乎均匀分布，可以考虑在softmax前加一个可学习的温度系数。

3. 数据准备与特征工程：预测任务的隐形胜负手

3.1 时序数据的窗口构造

LSTM+Attention模型的输入是一个三维张量，形状为(batch_size, seq_len, input_dim)。其中seq_len是你回看的历史窗口长度，input_dim是每个时间步的特征维度。构造这个张量的过程，就是把原始时序数据切成一个个滑动窗口。

假设你有一条长度为 $N$ 的单变量时序 $x_1, x_2, ..., x_N$，回看窗口为 $L$，预测步长为 $H$，那么第 $i$ 个样本的输入是 $[x_i, x_{i+1}, ..., x_{i+L-1}]$，标签是 $[x_{i+L}, ..., x_{i+L+H-1}]$。样本数量为 $N - L - H + 1$。

窗口长度 $L$ 的选择非常关键。太短，模型看不到足够的上下文；太长，不仅计算量增加，还可能引入过多噪声。我的经验法则是：先看数据的自相关函数（ACF），找到自相关性显著衰减到零附近的滞后阶数，把它作为 $L$ 的初始值。比如日频销量数据，ACF通常在7、14、21这些滞后点上有峰值，那 $L$ 至少应该覆盖两个完整周期，也就是14以上。

对于多变量输入，每个时间步的特征维度 $input_dim$ 可能包含多个传感器的读数、多个统计量等。这时候要注意不同特征的量纲差异，标准化是必须的。

3.2 标准化与差分：别让量纲毁了模型

时序预测中，标准化方式的选择直接影响模型收敛速度和最终精度。常见的做法有三种：

我通常的做法是：先做一阶差分（如果ADF检验显示非平稳），再做Z-Score标准化。差分的目的是去除趋势，让模型专注于学习短期波动模式。但要注意，差分后的序列长度会减少1，而且预测出来的值需要做逆差分才能还原到原始尺度。

实操心得：标准化参数（均值、标准差）一定要在训练集上计算，然后应用到验证集和测试集。我见过太多人直接在全部数据上算均值和标准差，导致验证集指标虚高，上线后效果大打折扣。这是时序预测中最常见的数据泄漏形式之一。

3.3 特征工程的几个实用方向

除了原始的时序值，以下几类特征在时序预测中往往能带来显著提升：

时间特征：小时、星期几、月份、是否节假日等。这些特征可以帮助模型捕捉周期性模式。对于日频数据，星期几的one-hot编码几乎是必备的。

滚动统计量：过去7天均值、过去14天标准差、过去3天最大值等。这些特征相当于给模型提供了不同时间尺度的"摘要"，减轻了LSTM的记忆负担。

滞后特征：$x_{t-1}, x_{t-2}, ..., x_{t-k}$ 直接作为额外输入。虽然LSTM理论上能自己学到滞后关系，但显式提供滞后特征可以加速收敛。

外部变量：如果预测销量，可以加入促销标记、价格信息；如果预测设备寿命，可以加入工况参数。这些外部变量往往比历史时序本身更有预测力。

需要注意的是，特征不是越多越好。我做过一组对比实验，在某个销量预测任务中，把特征从15个增加到40个，验证集RMSE反而上升了8%。原因是过多特征引入了噪声，而且增加了过拟合风险。建议的做法是：先用领域知识筛选一批候选特征，然后用特征重要性分析（比如训练一个LightGBM看feature importance）做二次筛选，最后把精选的特征喂给LSTM+Attention。

4. 模型实现：从零搭建LSTM+Attention预测网络

4.1 LSTM编码器的实现细节

PyTorch中LSTM的实现很直接，但有几个参数需要仔细考虑：

import torch import torch.nn as nn class LSTMEncoder(nn.Module): def __init__(self, input_dim, hidden_dim, num_layers, dropout=0.2, bidirectional=False): super().__init__() self.hidden_dim = hidden_dim self.num_layers = num_layers self.bidirectional = bidirectional self.num_directions = 2 if bidirectional else 1 self.lstm = nn.LSTM( input_size=input_dim, hidden_size=hidden_dim, num_layers=num_layers, batch_first=True, dropout=dropout if num_layers > 1 else 0, bidirectional=bidirectional ) def forward(self, x): # x: (batch, seq_len, input_dim) outputs, (h_n, c_n) = self.lstm(x) # outputs: (batch, seq_len, hidden_dim * num_directions) return outputs, (h_n, c_n)

几个关键参数的选择逻辑：

hidden_dim：通常取64到256之间。太小，模型容量不足；太大，容易过拟合且训练慢。我的经验是从128开始试，如果验证集loss下降不够快就加到256，如果过拟合就减到64。

num_layers：1到3层足够。超过3层的LSTM在时序预测中很少带来提升，反而梯度问题更严重。如果确实需要更深的结构，建议用残差连接。

dropout：在多层LSTM中，dropout加在层与层之间。单层LSTM的话，dropout加在LSTM输出之后。0.1到0.3是常见范围。

bidirectional：双向LSTM能同时利用过去和未来的信息，在编码阶段确实更强。但要注意，如果你的预测任务是在线的（只能看到历史数据），那双向LSTM在推理时会有问题——它需要完整的序列才能计算。这种情况下只能用单向。

4.2 Attention层的实现与调优

下面是一个加性Attention池化的实现：

class AttentionPooling(nn.Module): def __init__(self, hidden_dim): super().__init__() self.query = nn.Linear(hidden_dim, hidden_dim, bias=False) self.key = nn.Linear(hidden_dim, hidden_dim, bias=False) self.energy = nn.Linear(hidden_dim, 1, bias=False) def forward(self, lstm_outputs, mask=None): # lstm_outputs: (batch, seq_len, hidden_dim) query = self.query(lstm_outputs) # (batch, seq_len, hidden_dim) key = self.key(lstm_outputs) # (batch, seq_len, hidden_dim) # 加性attention energy = self.energy(torch.tanh(query + key)) # (batch, seq_len, 1) energy = energy.squeeze(-1) # (batch, seq_len) if mask is not None: energy = energy.masked_fill(mask == 0, -1e9) weights = torch.softmax(energy, dim=1) # (batch, seq_len) context = torch.bmm(weights.unsqueeze(1), lstm_outputs) # (batch, 1, hidden_dim) context = context.squeeze(1) # (batch, hidden_dim) return context, weights

这里有几个实现细节值得展开：

mask的处理：如果你的batch中序列长度不一致（比如用padding对齐），必须传入mask，否则Attention会把padding位置也纳入计算，导致结果偏差。mask的形状是(batch, seq_len)，padding位置为0，有效位置为1。

query和key的设计：在上面的实现中，query和key都来自LSTM输出，这是一种自注意力形式。你也可以用一个可学习的全局query向量来代替，这样参数量更少：

self.global_query = nn.Parameter(torch.randn(hidden_dim))

两种方式效果差异不大，全局query更轻量，自注意力更灵活。

Attention权重的可视化：训练完成后，把Attention权重画出来，看看模型在预测时主要关注哪些历史时刻。这个分析非常有价值——如果模型关注的时刻和你的领域知识一致，说明模型学到了合理的模式；如果不一致，可能需要检查数据或调整架构。

4.3 输出层的设计与损失函数选择

输出层的形式取决于你的预测目标：

单步预测：一个线性层把context向量映射到标量或向量。

self.output_layer = nn.Linear(hidden_dim, output_dim)

多步直接预测：一个线性层映射到H * output_dim，然后reshape。

self.output_layer = nn.Linear(hidden_dim, horizon * output_dim)

自回归多步预测：需要一个解码器LSTM，每一步的输出作为下一步的输入。

损失函数方面，MSE是最常用的，但它对异常值敏感。如果你的数据中有较多异常值，可以考虑Huber损失或者分位数损失。我在实际项目中发现，Huber损失（delta=1.0）在大多数时序预测任务中比MSE更稳健，尤其是当数据中存在突发波动时。

另外，如果你做的是多步预测，可以考虑给不同步长的预测赋予不同权重。通常近期预测更重要，可以给近期步长更高的权重。这个权重可以通过验证集调优确定。

5. 训练策略与调参实战

5.1 学习率调度与早停

LSTM+Attention模型的训练对学习率比较敏感。我通常用Adam优化器，初始学习率设1e-3，然后配合ReduceLROnPlateau调度器：

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=5, min_lr=1e-6 )

早停的patience通常设10到15个epoch。如果验证集loss在连续这么多轮内没有下降，就停止训练并恢复到最佳模型。

实操心得：weight_decay（L2正则化）在LSTM+Attention中很重要，因为Attention层的参数量虽然不大，但很容易过拟合。1e-5到1e-4是常用范围。如果发现训练loss和验证loss差距很大，先加大weight_decay试试。

5.2 梯度裁剪：LSTM训练的必备操作

LSTM的梯度在反向传播时容易爆炸，尤其是序列较长的时候。梯度裁剪是必须的：

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

max_norm设1.0是常见选择。如果发现训练不稳定（loss剧烈波动），可以降到0.5；如果训练太慢，可以升到2.0。

5.3 Batch Size与序列长度的权衡

Batch size的选择受显存限制，但也影响训练动态。较大的batch size（64、128）训练更稳定，但可能陷入局部最优；较小的batch size（16、32）有正则化效果，但训练更慢。

我的建议是：在显存允许的前提下，优先用较大的batch size，然后通过调整学习率和weight_decay来控制过拟合。如果显存不够，可以用梯度累积来模拟大batch。

序列长度方面，如果原始序列很长（比如上千），可以考虑在训练时随机截取子序列，这样既有数据增强的效果，又能控制显存占用。但要注意，截取后的子序列必须仍然包含完整的周期信息。

5.4 多步预测的训练技巧

多步预测有两种训练策略：直接多步和自回归多步。

直接多步是让模型一次性输出所有步长的预测，损失函数是所有步长损失的总和。这种方式训练稳定，但各步长之间的依赖关系没有被显式建模。

自回归多步是让模型逐步生成预测，每一步的输出作为下一步的输入。这种方式更灵活，但训练时存在"曝光偏差"问题——训练时用的是真实值作为下一步输入，推理时用的是模型自己的预测，两者分布不一致。

解决曝光偏差的常用方法是计划采样（Scheduled Sampling）：在训练初期用真实值，随着训练进行逐渐增加使用模型预测的比例。PyTorch中可以通过自定义训练循环实现。

6. 常见问题与排查技巧实录

6.1 模型不收敛或loss震荡

这是最常见的问题，排查顺序如下：

我遇到过一次典型情况：模型训练loss正常下降，但验证loss从第3个epoch开始就持续上升。排查后发现是weight_decay设得太小（1e-6），Attention层严重过拟合。把weight_decay调到1e-4后问题解决。

6.2 预测结果滞后于真实值

这是时序预测中的经典问题——模型预测的曲线形状对了，但总是比真实值"慢半拍"。根本原因是模型倾向于输出历史值的平滑版本，而不是捕捉突变。

解决方案有几个方向：

加入差分特征：让模型学习变化量而不是绝对值。预测出变化量后再累加回原始尺度。

使用方向损失：除了MSE，额外加一个惩罚预测方向错误的损失项。比如如果真实值上升但模型预测下降，就加大惩罚。

调整损失函数：MSE倾向于预测条件均值，会导致平滑效应。改用分位数损失或者增加对极端值的权重可以缓解。

引入外部变量：如果突变是由外部事件引起的，把这些事件作为特征输入，模型就能提前"知道"要发生变化。

6.3 Attention权重均匀分布

如果训练完成后发现Attention权重几乎均匀分布，说明Attention机制没有学到有意义的模式。可能的原因和对策：

• hidden_dim太小：Attention的表达能力不足，增大hidden_dim试试。
• 序列太短：如果seq_len只有5到10，Attention的意义不大，模型可能退化成平均池化。
• 训练不充分：Attention层的参数可能需要更多轮次才能学到有意义的权重，增加训练epoch。
• 数据本身无时序模式：如果数据是白噪声，Attention确实学不到东西。先检查数据的自相关性。

6.4 过拟合的识别与处理

LSTM+Attention模型的参数量通常在几十万到几百万之间，在中小数据集上容易过拟合。识别过拟合的信号：训练loss持续下降但验证loss开始上升，两者差距越来越大。

处理手段按优先级排列：

1. 增加dropout：LSTM层间dropout和Attention输出dropout都可以加，0.2到0.5之间调。
2. 加大weight_decay：1e-5到1e-3之间调。
3. 减少模型容量：减小hidden_dim或num_layers。
4. 数据增强：对训练数据加噪声、做时间扭曲、随机缩放等。
5. 早停：最直接有效的手段，patience设小一点。

实操心得：不要一次性把所有正则化手段都用上，否则模型会欠拟合。我的做法是先加dropout，如果还不够就加weight_decay，最后才考虑减小模型容量。每次只调一个参数，观察验证集效果。

6.5 推理速度优化

如果模型需要在线推理，速度是关键。几个优化方向：

减小hidden_dim：推理时间与hidden_dim近似线性相关。如果128够用，就不要用256。

用ONNX导出：PyTorch模型导出为ONNX后，推理速度通常能提升20%到50%。

量化：把float32量化到int8，速度提升明显，但精度可能下降1%到3%。需要根据业务容忍度决定。

缓存LSTM隐状态：如果是流式推理，可以缓存上一步的隐状态，避免重复计算历史序列。但这要求推理时逐步输入，不能批量处理。

7. 一个完整的实战案例：多变量时序预测

7.1 任务定义与数据说明

假设我们有一个模拟的工业设备传感器数据集，包含温度、压力、振动三个维度的时序读数，采样频率为每小时一次，共收集了180天的数据（约4320条记录）。目标是：用过去48小时的三维传感器读数，预测未来12小时的温度值。

这是一个典型的多变量输入、单变量输出、多步预测任务。输入维度input_dim=3，回看窗口seq_len=48，预测步长horizon=12，输出维度output_dim=1。

7.2 完整模型定义

class LSTMAttentionPredictor(nn.Module): def __init__(self, input_dim, hidden_dim, horizon, num_layers=2, dropout=0.3): super().__init__() self.hidden_dim = hidden_dim self.horizon = horizon self.lstm = nn.LSTM( input_size=input_dim, hidden_size=hidden_dim, num_layers=num_layers, batch_first=True, dropout=dropout if num_layers > 1 else 0 ) self.attention = nn.Sequential( nn.Linear(hidden_dim, hidden_dim), nn.Tanh(), nn.Linear(hidden_dim, 1) ) self.dropout = nn.Dropout(dropout) self.output_layer = nn.Linear(hidden_dim, horizon) def forward(self, x): # x: (batch, seq_len, input_dim) lstm_out, _ = self.lstm(x) # (batch, seq_len, hidden_dim) # Attention attn_scores = self.attention(lstm_out) # (batch, seq_len, 1) attn_weights = torch.softmax(attn_scores, dim=1) # (batch, seq_len, 1) context = torch.sum(lstm_out * attn_weights, dim=1) # (batch, hidden_dim) context = self.dropout(context) output = self.output_layer(context) # (batch, horizon) return output, attn_weights.squeeze(-1)

7.3 训练循环与评估

def train_epoch(model, dataloader, optimizer, criterion, clip=1.0): model.train() total_loss = 0 for x_batch, y_batch in dataloader: optimizer.zero_grad() pred, _ = model(x_batch) loss = criterion(pred, y_batch) loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), clip) optimizer.step() total_loss += loss.item() return total_loss / len(dataloader) def evaluate(model, dataloader, criterion): model.eval() total_loss = 0 with torch.no_grad(): for x_batch, y_batch in dataloader: pred, _ = model(x_batch) loss = criterion(pred, y_batch) total_loss += loss.item() return total_loss / len(dataloader)

评估指标除了MSE，建议同时看MAE和MAPE。MSE对大误差敏感，MAE更直观，MAPE是百分比误差便于跨任务比较。但MAPE在真实值接近零时会爆炸，这时候用sMAPE（对称MAPE）更合适。

7.4 实验结果与分析

在模拟数据集上，我对比了几组配置：

从结果可以看出：Attention的加入带来了约11%的MAE下降（配置B vs E），这是最显著的提升。hidden_dim从128增加到256带来的提升有限（约2%），但训练时间增加了近一倍。3层LSTM反而比2层差，说明过深的LSTM在这个任务上过拟合了。

Attention权重的可视化显示，模型在预测未来12小时温度时，主要关注过去48小时中最近6到12小时的读数，以及大约24小时前的读数（对应日周期）。这个模式和领域知识一致——温度变化既有短期惯性，也有日周期规律。

8. 几个容易被忽视的工程细节

8.1 随机种子的设置

时序预测实验的可复现性很重要。PyTorch中需要设置以下种子：

import random import numpy as np import torch def set_seed(seed=42): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False

注意cudnn.deterministic = True会降低训练速度，但保证结果可复现。在最终跑实验时开启，日常调试时可以关掉。

8.2 模型保存与加载的最佳实践

不要只保存state_dict，还要保存模型配置和标准化参数：

checkpoint = { 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'model_config': {'input_dim': 3, 'hidden_dim': 128, 'horizon': 12}, 'scaler_mean': scaler.mean_, 'scaler_std': scaler.scale_, 'epoch': epoch, 'best_val_loss': best_val_loss } torch.save(checkpoint, 'best_model.pth')

这样在推理时可以直接从checkpoint重建模型，不需要手动记录超参数。我见过太多人只保存了state_dict，结果部署时忘了模型结构，只能翻训练代码重新确认。

8.3 推理时的批处理与实时性

如果推理请求是单条来的，逐条推理效率很低。可以维护一个缓冲区，积累到一定数量后批量推理，再把结果分发给各个请求。这种"微批处理"策略在延迟和吞吐之间取得了平衡。

另外，推理时一定要调用model.eval()，并且用torch.no_grad()包裹，否则会浪费显存和计算资源。

8.4 监控与持续改进

模型上线后不是终点。建议监控以下指标：

• 预测误差的滚动统计：如果误差均值或方差发生显著变化，说明数据分布可能漂移了。
• Attention权重的分布：如果权重突然变得均匀，可能是输入数据出了问题。
• 推理延迟：如果延迟突然增加，可能是输入序列变长了或者有内存泄漏。

当监控指标触发告警时，可以考虑用最近的数据对模型做增量微调，或者重新训练。增量微调的学习率要设小一点（1e-4或更低），避免破坏已经学到的模式。

9. 扩展方向：从基础架构到进阶方案

9.1 多尺度Attention

基础的Attention只在LSTM输出的隐状态序列上做一次加权。多尺度Attention则是在不同时间尺度上分别做Attention，然后把多个尺度的上下文向量拼接起来。比如同时在原始序列、2倍下采样序列、4倍下采样序列上做Attention，这样模型能同时捕捉短期波动和长期趋势。

实现上可以用不同大小的池化窗口对LSTM输出做下采样，然后分别过Attention层。代价是参数量和计算量增加，但在复杂时序上效果提升明显。

9.2 概率预测与不确定性量化

点预测只给出一个值，但很多业务场景需要知道预测的不确定性。可以把输出层改成预测均值和方差，用负对数似然作为损失函数：

class ProbabilisticOutput(nn.Module): def __init__(self, hidden_dim, horizon): super().__init__() self.mean_layer = nn.Linear(hidden_dim, horizon) self.log_var_layer = nn.Linear(hidden_dim, horizon) def forward(self, context): mean = self.mean_layer(context) log_var = self.log_var_layer(context) return mean, log_var

损失函数为：

$$\mathcal{L} = \frac{1}{2} \sum_{t} \left( \frac{(y_t - \mu_t)^2}{\sigma_t^2} + \log \sigma_t^2 \right)$$

这样模型不仅给出预测值，还给出置信区间，对决策支持更有价值。

9.3 在线学习与概念漂移适应

时序数据的分布可能随时间变化，固定模型会逐渐失效。在线学习的基本思路是：维护一个滑动窗口的训练集，定期用最新数据微调模型。微调时只更新部分参数（比如只更新输出层和Attention层），冻结LSTM层，这样既能适应新数据，又不会遗忘旧模式。

另一种方案是集成多个在不同时间段训练的模型，推理时根据当前数据与各模型训练数据的相似度动态加权。这种方案更稳健，但维护成本更高。

10. 我踩过的几个坑和对应的解决方案

第一个坑是数据泄漏。早期做销量预测时，我在构造滚动统计量特征时用了center=True的滚动窗口，导致每个时间步的统计量包含了未来信息。模型在验证集上表现极好，上线后一塌糊涂。后来改成center=False，并且严格确保所有特征只使用当前时刻及之前的数据。

第二个坑是序列长度与batch size的乘积超过显存。LSTM的显存占用与batch_size * seq_len * hidden_dim成正比。我一开始用batch_size=128, seq_len=168（一周的小时数），结果显存直接爆了。后来改成batch_size=32，配合梯度累积（每4个batch更新一次参数），效果和batch_size=128差不多，但显存占用只有四分之一。

第三个坑是Attention mask的维度不匹配。在处理变长序列时，mask的形状是(batch, seq_len)，但Attention scores的形状是(batch, seq_len, 1)，直接masked_fill会广播错误。正确的做法是把mask扩展成(batch, seq_len, 1)或者把scores squeeze成(batch, seq_len)后再mask。

第四个坑是逆标准化时用错了参数。如果训练时对目标值做了标准化，推理时预测出的值需要逆标准化才能还原到原始尺度。我一开始用了输入特征的均值和标准差去逆标准化输出，结果完全不对。后来在代码里明确区分了input_scaler和target_scaler，问题解决。

第五个坑是早停时保存的是最后一个epoch的模型而不是最佳模型。这个错误很隐蔽，因为训练loss一直在降，但验证loss可能在第20个epoch达到最优后就开始上升。如果保存的是最后一个epoch的模型，实际上保存的是过拟合的版本。正确的做法是在每个epoch结束后检查验证loss，如果优于历史最佳就保存checkpoint。

这些坑看起来都是小问题，但在实际项目中每一个都可能让你多花好几天去排查。希望这些经验能帮你少走弯路。