时间序列预测这件事，我最早是用ARIMA那一套做的，后来发现很多场景下线性模型确实不够用——比如传感器数据里那种又长又复杂的依赖关系，或者多条序列之间互相影响的耦合模式。深度学习进来之后，能做的事情一下子多了不少，但坑也跟着多了。这篇内容我打算把时间序列预测里深度学习这条路线从头到尾捋一遍，包括模型选型的逻辑、数据预处理的细节、训练过程中容易翻车的地方，以及我自己在几个模拟项目里踩过的坑。不管你是刚接触时序预测的新手，还是已经用过LSTM但效果不太理想的老手，应该都能从里面找到一些有用的东西。
1. 为什么传统方法不够用，深度学习到底补了什么
1.1 时序预测问题的本质拆解
时间序列预测说白了就是给定一段历史数据，预测未来一段时间的值。听起来简单，但实际场景里变数很多。我习惯把问题拆成三个维度来看：预测步长、序列数量、外部变量。
预测步长决定了你是做单步预测还是多步预测。单步预测就是每次只预测下一个时间点，多步预测则要一口气预测未来好几个点。这两者的难度完全不是一个量级——单步预测误差累积少，多步预测每一步的误差都会往后传，到后面可能偏得离谱。
序列数量决定了你是单变量还是多变量。单变量就是一条曲线，多变量就是多条曲线互相影响。比如一个模拟的工业设备监控场景，温度、压力、振动三条序列之间是有物理耦合的，你不能把它们割裂开来单独预测。
外部变量则是那些不在序列里但会影响序列的因素，比如节假日、天气、设备开关机状态等。这些变量在传统方法里很难自然地融进去，但深度学习模型可以比较方便地处理。
1.2 传统方法的三个硬伤
ARIMA、指数平滑这些经典方法我用过不少，它们在特定场景下确实好用，但有几个问题绕不过去。
第一个是线性假设。ARIMA本质上是线性模型，它假设未来的值是过去值的线性组合。但现实中的时序数据往往有非线性模式，比如突然的阶跃变化、周期性的幅度调制、长尾的衰减过程，这些线性模型都抓不住。
第二个是固定窗口。传统方法通常需要你手动指定滞后阶数，也就是看过去多少个点。这个窗口是固定的，但实际数据里不同时间尺度的依赖关系可能不一样——有时候需要看最近几个点，有时候需要看很久以前的某个模式。固定窗口没法自适应。
第三个是多变量扩展困难。虽然VAR模型可以处理多变量，但参数数量随变量数平方增长，变量一多就爆炸。而且VAR同样有线性假设的问题。
1.3 深度学习带来的三个关键能力
深度学习模型在时序预测上的优势，我总结为三点。
自动特征提取。卷积网络可以自动从原始序列里提取局部模式，循环网络可以自动学习时间依赖，注意力机制可以自动找到相关的时间点。你不需要手动设计特征，模型自己会学。
长程依赖建模。LSTM、GRU这些门控机制，以及后来的Transformer，都能在一定程度上捕捉长距离的时间依赖。虽然实际效果要看数据和调参，但至少理论上不受固定窗口的限制。
多变量联合建模。深度学习模型可以很自然地把多条序列作为输入，让它们在网络内部交互。比如用共享的编码器提取每条序列的特征，再用注意力机制让它们互相参考。
注意：深度学习不是万能的。如果数据量很小（比如只有几百个点），或者序列本身就很规则（比如纯周期信号），传统方法可能反而更稳。我一般建议先跑一个ARIMA作为baseline，如果深度学习模型连baseline都打不过，那就说明要么数据不够，要么模型没调好。
2. 数据预处理：决定成败的隐形战场
2.1 缺失值处理的几种策略
时序数据几乎没有不缺的。传感器故障、传输丢包、存储问题，都会导致缺失。处理方法我按场景分三类。
短缺口（连续缺失少于5个点）：直接用线性插值或者前向填充就行。线性插值适合变化平缓的序列，前向填充适合变化剧烈的序列。我一般先用线性插值，如果发现插值后的曲线在缺口处有明显的不自然拐点，再换前向填充。
长缺口（连续缺失超过5个点但少于序列长度的10%）：这时候插值就不太靠谱了，因为缺口太长，插出来的值基本是猜的。我通常的做法是把这个缺口标记出来，在训练时用一个mask告诉模型这些位置不可信。具体实现就是在损失函数里把这些位置的权重设为0。
超大缺口（缺失超过10%）：如果一条序列缺了这么多，我一般会考虑直接放弃这条序列，或者用其他相关序列来补。比如多条传感器序列之间有相关性，可以用其他序列做回归来填补。
import numpy as np import pandas as pd def handle_missing(series, short_gap=5, long_gap_ratio=0.1): """ series: 一维时间序列 short_gap: 短缺口阈值 long_gap_ratio: 长缺口占总长度比例阈值 """ s = series.copy() # 标记缺失 mask = s.isna() # 短缺口线性插值 s = s.interpolate(method='linear', limit=short_gap) # 剩余缺失用前向填充 s = s.fillna(method='ffill').fillna(method='bfill') # 返回处理后的序列和原始缺失mask return s, mask2.2 归一化：不是随便减个均值除个方差就完事
归一化在时序预测里特别重要，因为不同序列的量纲可能差好几个数量级。但直接做全局归一化有个问题：如果序列有明显的趋势，全局归一化之后趋势还在，模型还是得学趋势。我一般用滚动归一化或者差分+归一化。
滚动归一化就是用一个滑动窗口计算均值和方差，每个点用它所在窗口的统计量来归一化。这样趋势和周期都被去掉了，模型只需要学相对变化。缺点是推理时需要用最近的窗口统计量，如果窗口太短会不稳定。
差分+归一化是先做一阶差分去掉趋势，再做全局归一化。这个方法简单稳定，但差分会让序列丢失绝对水平信息，如果预测任务需要绝对水平（比如预测具体温度值），还得把差分逆回去。
def rolling_normalize(series, window=100): """滚动归一化""" mean = series.rolling(window=window, min_periods=1).mean() std = series.rolling(window=window, min_periods=1).std() std = std.replace(0, 1) # 防止除零 normalized = (series - mean) / std return normalized, mean, std def diff_normalize(series): """差分+全局归一化""" diff = series.diff().dropna() mean = diff.mean() std = diff.std() normalized = (diff - mean) / std return normalized, mean, std2.3 训练集/验证集/测试集的划分陷阱
时序数据的划分和普通机器学习不一样，绝对不能随机划分。因为时序数据有时间依赖，随机划分会导致未来信息泄露到训练集里。
正确的做法是按时间顺序切分。比如前70%做训练，中间15%做验证，最后15%做测试。但这里有个细节：验证集和测试集之间最好留一个gap，因为有些模型（比如用滑动窗口的）在边界处会有信息泄露。
我一般会留一个长度为预测步长的gap。比如预测未来24个点，那验证集和测试集之间就空24个点。这样能更真实地评估模型在完全未见数据上的表现。
提示：如果你的数据有明显的周期性（比如日周期、周周期），划分时要保证每个集合都包含完整的周期。否则模型可能在训练集里没见过某个周期模式，测试时直接懵掉。
3. 模型选型：从LSTM到Transformer的实战对比
3.1 LSTM和GRU：经典但不过时
LSTM和GRU是时序预测里最常用的两个循环网络。LSTM有三个门（输入门、遗忘门、输出门），GRU有两个门（重置门、更新门）。GRU参数少一些，训练快一些，但LSTM在长序列上通常更稳。
我在实际项目里的经验是：如果序列长度在100以内，GRU和LSTM差别不大；如果序列长度超过200，LSTM的优势会明显一些。但这不是绝对的，还要看数据的具体特性。
用LSTM做时序预测的基本结构是：输入序列经过LSTM层，取最后一个时间步的隐藏状态，接一个全连接层输出预测值。如果是多步预测，可以接一个长度为预测步长的全连接层，或者用seq2seq的结构。
import torch import torch.nn as nn class LSTMPredictor(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim, num_layers=2, dropout=0.2): super().__init__() self.lstm = nn.LSTM( input_dim, hidden_dim, num_layers, batch_first=True, dropout=dropout ) self.fc = nn.Linear(hidden_dim, output_dim) def forward(self, x): # x: (batch, seq_len, input_dim) lstm_out, (h_n, c_n) = self.lstm(x) # 取最后一个时间步 last_hidden = lstm_out[:, -1, :] out = self.fc(last_hidden) return out3.2 Temporal Convolutional Network：被低估的选手
TCN（时间卷积网络）是我个人比较喜欢的一个结构。它用因果卷积保证不看到未来信息，用膨胀卷积扩大感受野，用残差连接防止梯度消失。相比LSTM，TCN的训练更稳定，并行度更高，而且感受野可以精确控制。
TCN的关键参数是膨胀因子和卷积核大小。膨胀因子通常按2的幂次增长（1, 2, 4, 8, ...），这样感受野是指数增长的。卷积核大小一般取3或5。感受野的计算公式是：1 + 2 * (kernel_size - 1) * (2^num_layers - 1)。
比如kernel_size=3，num_layers=4，感受野就是1 + 2*2*(16-1) = 61。也就是说每个输出点能看到过去61个点的信息。这个感受野是精确可控的，不像LSTM那样模糊。
class TCNBlock(nn.Module): def __init__(self, in_channels, out_channels, kernel_size, dilation, dropout=0.2): super().__init__() padding = (kernel_size - 1) * dilation self.conv = nn.Conv1d( in_channels, out_channels, kernel_size, padding=padding, dilation=dilation ) self.chomp = nn.ConstantPad1d((0, -padding), 0) # 去掉未来信息 self.relu = nn.ReLU() self.dropout = nn.Dropout(dropout) self.downsample = nn.Conv1d(in_channels, out_channels, 1) if in_channels != out_channels else None def forward(self, x): out = self.conv(x) out = self.chomp(out) out = self.relu(out) out = self.dropout(out) res = x if self.downsample is None else self.downsample(x) return self.relu(out + res)3.3 Transformer系：注意力机制的威力与代价
Transformer在时序预测上的应用这几年很火。核心思想是用自注意力机制让每个时间点都能直接看到其他所有时间点，不受距离限制。这对长序列特别有用。
但Transformer有几个坑。第一是计算复杂度是O(n^2)，序列一长就吃不消。第二是对位置编码很敏感，时序数据的位置信息很重要，但标准的位置编码不一定适合所有周期模式。第三是容易过拟合，尤其是数据量不大的时候。
我一般会在以下情况考虑Transformer：序列长度超过500，数据量足够大（至少几万条），而且有明显的长程依赖。否则TCN或者LSTM可能更划算。
class TransformerPredictor(nn.Module): def __init__(self, input_dim, d_model, nhead, num_layers, output_dim, dropout=0.1): super().__init__() self.input_proj = nn.Linear(input_dim, d_model) self.pos_encoder = nn.Parameter(torch.randn(1, 1000, d_model) * 0.02) encoder_layer = nn.TransformerEncoderLayer( d_model, nhead, dim_feedforward=d_model*4, dropout=dropout, batch_first=True ) self.transformer = nn.TransformerEncoder(encoder_layer, num_layers) self.fc = nn.Linear(d_model, output_dim) def forward(self, x): # x: (batch, seq_len, input_dim) x = self.input_proj(x) x = x + self.pos_encoder[:, :x.size(1), :] x = self.transformer(x) out = self.fc(x[:, -1, :]) return out3.4 模型选型的决策框架
我把选型逻辑整理成一个简单的决策表，供参考。
| 场景特征 | 推荐模型 | 理由 |
|---|---|---|
| 序列短（<100），数据量小 | GRU | 参数少，不易过拟合 |
| 序列中等（100-500），需要长程依赖 | LSTM或TCN | 平衡效果和训练成本 |
| 序列长（>500），数据量大 | Transformer | 自注意力捕捉长程依赖 |
| 多变量，变量间有复杂交互 | Transformer或TCN | 注意力/卷积便于跨变量建模 |
| 需要精确控制感受野 | TCN | 膨胀卷积感受野可计算 |
| 实时推理，延迟敏感 | GRU或TCN | 结构简单，推理快 |
注意：这个表只是起点，实际选型一定要做消融实验。我见过太多情况是理论上应该好的模型，在实际数据上就是不如简单模型。别迷信结构，数据说话。
4. 训练过程中的关键细节与调参经验
4.1 损失函数的选择：MSE不是唯一答案
大多数人做时序预测默认用MSE（均方误差）。MSE对异常值很敏感，一个大偏差就会主导梯度。如果你的数据里有尖峰或者异常点，MSE会让模型过度关注这些点，导致整体预测偏保守。
我常用的替代方案有：
MAE（平均绝对误差）：对异常值更鲁棒，梯度稳定。缺点是梯度在0附近不连续，收敛可能慢一些。
Huber损失：结合了MSE和MAE的优点，小误差时用MSE，大误差时用MAE。需要调一个阈值参数delta，我一般取数据标准差的1到2倍。
Quantile损失：如果你需要预测区间而不只是点预测，可以用分位数损失。比如同时预测0.1、0.5、0.9三个分位数，就得到了一个80%的预测区间。
def huber_loss(pred, target, delta=1.0): diff = torch.abs(pred - target) loss = torch.where( diff < delta, 0.5 * diff ** 2, delta * (diff - 0.5 * delta) ) return loss.mean() def quantile_loss(pred, target, quantiles=[0.1, 0.5, 0.9]): losses = [] for i, q in enumerate(quantiles): e = target - pred[:, i] losses.append(torch.max(q * e, (q - 1) * e)) return torch.stack(losses).mean()4.2 学习率调度：warmup和余弦退火
时序预测模型对学习率比较敏感。太大容易震荡，太小收敛慢。我一般用warmup + 余弦退火的组合。
warmup就是在训练初期让学习率从很小的值线性增加到初始学习率，避免一开始就大步长导致不稳定。余弦退火则是让学习率按余弦曲线慢慢降到接近0，帮助模型在后期精细调整。
具体参数：warmup步数一般取总步数的5%到10%，初始学习率取1e-3到1e-4，最终学习率取初始值的1%左右。
from torch.optim.lr_scheduler import LambdaLR import math def get_cosine_schedule_with_warmup(optimizer, warmup_steps, total_steps): def lr_lambda(step): if step < warmup_steps: return step / warmup_steps progress = (step - warmup_steps) / (total_steps - warmup_steps) return 0.5 * (1 + math.cos(math.pi * progress)) return LambdaLR(optimizer, lr_lambda)4.3 早停策略：别等到过拟合了才停
早停是防止过拟合的基本手段，但时序预测里的早停有个细节：验证集的损失可能因为序列的周期性而波动。比如验证集里包含一个高峰段，损失就会突然变大，但这不代表模型变差了。
我的做法是用平滑后的验证损失来做早停判断。具体就是对最近几个epoch的验证损失取移动平均，如果移动平均连续N个epoch没有下降就停。N一般取5到10。
另外，保存模型时不要只保存最后一个epoch的，要保存验证损失最低的那个。我一般会维护一个best_loss变量，每次验证损失创新低就保存模型。
4.4 梯度裁剪和权重初始化
时序预测模型，尤其是LSTM和Transformer，容易出现梯度爆炸。梯度裁剪是必备的，一般把梯度范数限制在1.0到5.0之间。
权重初始化也很重要。LSTM的权重我一般用正交初始化，Transformer用Xavier初始化。好的初始化能让训练稳定很多，收敛也更快。
# 梯度裁剪 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) # LSTM正交初始化 for name, param in model.named_parameters(): if 'weight_ih' in name: nn.init.xavier_uniform_(param) elif 'weight_hh' in name: nn.init.orthogonal_(param)5. 多步预测的策略与误差控制
5.1 直接多步 vs 递归多步 vs 多模型
多步预测有三种主流策略，各有优劣。
递归多步：训练一个单步预测模型，预测出下一步后把预测值当作输入，再预测下一步。优点是只需要一个模型，缺点是误差会累积，预测步长越长越不准。
直接多步：训练一个模型直接输出未来N步。优点是误差不累积，缺点是模型输出维度固定，换预测步长要重新训练。
多模型：为每个预测步长训练一个模型。优点是每个模型专注自己的步长，缺点是模型数量多，训练成本高。
我一般用直接多步，因为误差控制更好。如果预测步长变化频繁，会用递归多步加一个误差校正机制。
5.2 误差累积的量化与缓解
递归多步的误差累积可以用一个简单公式估算：如果单步误差是e，预测N步的误差大约是e乘以一个累积因子。这个因子取决于模型的稳定性和数据的可预测性。
缓解误差累积的方法有几个。一是用teacher forcing：训练时不用模型自己的预测值，而是用真实值作为下一步输入。但这样会导致训练和推理不一致，推理时误差还是累积。二是用scheduled sampling：训练时以一定概率用真实值，一定概率用预测值，逐步过渡到全用预测值。三是加一个误差校正网络：单独训练一个网络来预测并校正累积误差。
def scheduled_sampling_prob(epoch, total_epochs, start=0.0, end=1.0): """计算scheduled sampling中使用预测值的概率""" progress = min(epoch / total_epochs, 1.0) return start + (end - start) * progress5.3 预测区间的估计
点预测不够用的时候，需要给预测区间。方法有几种。
分位数回归：直接预测多个分位数，前面提过。优点是简单直接，缺点是分位数之间可能不单调（比如0.1分位数比0.5分位数还大），需要后处理。
蒙特卡洛Dropout：推理时保持Dropout开启，多次前向传播得到多个预测值，用这些值的分布估计区间。优点是实现简单，缺点是计算量大（要跑多次）。
深度集成：训练多个模型，用它们的预测方差估计区间。优点是效果好，缺点是训练成本高。
我一般用分位数回归，因为推理快，而且分位数可以直接控制区间的宽度。
6. 实战中踩过的坑与排查思路
6.1 验证集损失不下降但训练集损失在降
这是过拟合的典型表现，但时序预测里原因可能更复杂。
第一个可能：验证集和训练集的分布不一致。比如训练集包含某个季节，验证集包含另一个季节，模型在训练集上学的模式在验证集上不适用。排查方法是画一下训练集和验证集的统计量对比，看均值、方差、自相关有没有明显差异。
第二个可能：数据泄露。比如归一化时用了全局统计量，而全局统计量包含了验证集的信息。排查方法是检查所有预处理步骤，确保只用了训练集的统计量。
第三个可能：模型太复杂。减少层数、减小隐藏维度、增加Dropout，看验证损失是否改善。
6.2 预测值滞后于真实值
这是时序预测里最常见的问题之一。模型预测的曲线看起来跟真实曲线形状很像，但整体往右移了一点，也就是滞后了。
原因：模型学到的是"用过去预测现在"，而不是"用过去预测未来"。如果训练时输入和目标的划分有重叠，模型就会倾向于输出最近的值。
排查：检查数据划分。确保输入序列的最后一个点和目标序列的第一个点之间没有重叠。比如输入是[t-100, t-1]，目标应该是[t, t+23]，而不是[t-99, t+24]。
解决：调整数据划分，确保输入和目标之间有一个明确的边界。另外，可以在损失函数里加大远期预测的权重，让模型更关注远期。
6.3 多变量预测中某些变量预测特别差
多变量预测时，经常出现某些变量预测很准，某些变量预测很差的情况。
原因一：变量之间的尺度差异太大。比如一个变量范围是0到1，另一个是0到10000。归一化没做好的话，大尺度变量会主导损失。
解决：对每个变量单独归一化，或者用可学习的缩放参数。
原因二：变量之间的相关性太弱。如果某些变量跟其他变量没什么关系，模型很难利用其他变量的信息来帮它预测。
解决：做一下变量间的相关性分析，把不相关的变量去掉，或者给每个变量单独建一个预测头。
原因三：某些变量本身噪声太大。噪声大的变量预测误差天然就大，不一定是模型的问题。
解决：检查这些变量的信噪比，如果确实噪声大，考虑做平滑或者用更鲁棒的损失函数。
6.4 训练loss震荡严重
训练loss震荡通常有几个原因。
学习率太大：这是最常见的原因。降低学习率，或者加warmup。
batch size太小：小batch的梯度估计方差大，导致震荡。增大batch size，或者用梯度累积。
数据里有异常值：异常值会导致梯度突然变大。检查数据，处理异常值，或者用Huber损失。
模型初始化不好：重新初始化，或者换一种初始化方法。
我一般按这个顺序排查：先降学习率，再增batch size，再查数据，最后查初始化。
7. 模型评估与上线后的持续优化
7.1 时序预测的评估指标选择
MSE、MAE、RMSE这些是基础指标，但时序预测还需要看一些专门的指标。
MAPE（平均绝对百分比误差）：适合量纲不同的序列对比。但有个问题：当真实值接近0时，MAPE会爆炸。所以如果数据里有0或者接近0的值，MAPE不可靠。
sMAPE（对称MAPE）：解决了MAPE在0附近的问题，但定义有点反直觉，实际用的少。
MASE（平均绝对缩放误差）：用naive预测（比如预测值等于上一个值）的MAE做分母，得到一个相对误差。这个指标的好处是跟数据尺度无关，而且有明确的基准（MASE<1说明比naive好）。
我一般同时看MAE和MASE。MAE看绝对误差，MASE看相对基准的表现。
7.2 上线后的数据漂移检测
模型上线后，数据分布可能会变。比如设备老化导致传感器读数偏移，或者用户行为变化导致序列模式改变。数据漂移会导致模型效果下降。
检测方法：定期计算新数据的统计量（均值、方差、自相关），跟训练时的统计量对比。如果差异超过阈值，就触发告警。
我一般用**PSI（群体稳定性指标）**来量化漂移。PSI小于0.1说明分布稳定，0.1到0.25说明有轻微漂移，大于0.25说明漂移严重，需要重新训练。
def calculate_psi(expected, actual, buckets=10): """计算PSI""" def scale_range(data, buckets): min_val, max_val = data.min(), data.max() breakpoints = np.linspace(min_val, max_val, buckets + 1) return breakpoints breakpoints = scale_range(expected, buckets) expected_perc = np.histogram(expected, breakpoints)[0] / len(expected) actual_perc = np.histogram(actual, breakpoints)[0] / len(actual) # 避免除零 expected_perc = np.where(expected_perc == 0, 0.0001, expected_perc) actual_perc = np.where(actual_perc == 0, 0.0001, actual_perc) psi = np.sum((actual_perc - expected_perc) * np.log(actual_perc / expected_perc)) return psi7.3 在线学习和增量更新
如果数据漂移是渐进的，可以考虑在线学习或者增量更新。方法有几种。
滑动窗口重训练：定期用最近的数据重新训练模型。简单可靠，但计算成本高。
增量学习：用新数据微调模型，只更新部分参数。计算成本低，但可能遗忘旧知识。
集成更新：维护多个模型，新模型用新数据训练，旧模型保留，预测时加权平均。平衡新旧知识。
我一般用滑动窗口重训练，因为最稳。窗口大小取训练数据量的1到2倍，重训练频率根据数据变化速度定，一般一周到一个月一次。
7.4 一个完整的排查案例
说一个我实际遇到的案例。一个模拟的能耗预测项目，模型上线后第一周效果很好，第二周开始MAE逐渐上升，第三周MAE翻了一倍。
排查过程：
第一步：检查数据质量。发现数据没有缺失，也没有明显异常值。
第二步：计算PSI。发现PSI从0.05升到了0.3，说明数据分布确实漂移了。
第三步：分析漂移来源。画了一下新数据的分布，发现均值没怎么变，但方差变大了。进一步分析发现，是因为那段时间设备运行模式变了，出现了更多的启停操作，导致能耗波动变大。
第四步：解决方案。用最近一个月的数据重新训练了模型，并且在训练数据里增加了启停操作的样本权重。重新上线后MAE恢复到了正常水平。
经验总结：数据漂移不一定表现为均值变化，方差变化也是漂移。PSI能捕捉到这种变化，但需要结合具体分析才能找到原因。
提示：上线后的监控不只是看模型指标，还要看数据指标。我一般会同时监控MAE、PSI、预测值的分布、真实值的分布。任何一个异常都会触发排查。
8. 几个容易被忽略的工程细节
8.1 时间特征的编码方式
时间戳本身包含很多信息：小时、星期、月份、是否节假日等。这些特征怎么编码，对模型效果有影响。
周期性特征（小时、星期、月份）用sin/cos编码比用one-hot好。因为sin/cos能保留周期性，模型能学到"23点和0点很接近"这种关系，one-hot学不到。
非周期性特征（是否节假日、是否促销）用one-hot或者embedding。二值特征直接用0/1就行。
def encode_time_features(timestamps): """timestamps: pandas DatetimeIndex""" features = pd.DataFrame(index=timestamps) # 小时周期 features['hour_sin'] = np.sin(2 * np.pi * timestamps.hour / 24) features['hour_cos'] = np.cos(2 * np.pi * timestamps.hour / 24) # 星期周期 features['dow_sin'] = np.sin(2 * np.pi * timestamps.dayofweek / 7) features['dow_cos'] = np.cos(2 * np.pi * timestamps.dayofweek / 7) # 月份周期 features['month_sin'] = np.sin(2 * np.pi * timestamps.month / 12) features['month_cos'] = np.cos(2 * np.pi * timestamps.month / 12) return features8.2 序列长度的选择
输入序列长度（lookback）和预测长度（horizon）的比值，对模型效果有影响。
经验上，lookback至少要是horizon的2到3倍。比如预测未来24个点，输入至少要看过去48到72个点。如果lookback太短，模型没有足够的信息来预测；如果太长，计算成本高，而且可能引入噪声。
但这不是绝对的。如果序列的周期性很强，lookback至少要覆盖一个完整周期。比如日周期数据，lookback至少24小时；周周期数据，lookback至少168小时。
我一般会做几个不同lookback的对比实验，看验证集效果。通常效果会先升后降，取峰值对应的lookback。
8.3 批次大小的选择
batch size影响训练稳定性和速度。大batch训练快但可能泛化差，小batch泛化好但训练慢且不稳定。
时序预测里我一般用32到128的batch size。如果数据量很大（几十万条以上），可以用256或512。如果数据量小（几千条），用16或32。
另外，如果用了BatchNorm，batch size不能太小，否则统计量不准。时序预测里我一般用LayerNorm而不是BatchNorm，因为LayerNorm不依赖batch size，而且更适合序列数据。
8.4 随机种子的设置
时序预测模型对随机种子比较敏感，不同的初始化可能导致效果差很多。为了实验可复现，我一般会固定所有随机种子。
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但要注意，固定种子后如果效果不好，不要急着换种子。先检查数据和模型，种子只是最后的手段。我见过有人靠换种子刷指标，但实际上线后效果不稳定，因为换种子相当于在验证集上过拟合了。
8.5 模型保存和加载的坑
PyTorch保存模型有两种方式：保存整个模型和保存state_dict。我强烈建议只保存state_dict，因为保存整个模型会把模型结构也序列化进去，加载时如果代码变了可能加载失败。
另外，加载模型时要注意设备映射。如果训练时用GPU，推理时用CPU，需要指定map_location。
# 保存 torch.save(model.state_dict(), 'model.pth') # 加载 model = LSTMPredictor(input_dim=10, hidden_dim=64, output_dim=24) model.load_state_dict(torch.load('model.pth', map_location='cpu')) model.eval()还有一个细节：推理前一定要调model.eval()，否则Dropout和BatchNorm的行为跟训练时一样，会导致结果不稳定。这个坑我踩过好几次，明明训练时效果很好，推理时结果乱七八糟，最后发现是忘了调eval。
9. 从实验到上线的完整流程梳理
9.1 实验阶段的管理
实验阶段最容易乱。我一般用配置文件管理所有实验参数，每次实验保存一份配置和对应的结果。这样后面回溯的时候能知道哪个参数对应哪个效果。
配置文件用YAML或者JSON都行，我习惯用YAML，因为可读性好。
# config.yaml data: lookback: 168 horizon: 24 train_ratio: 0.7 val_ratio: 0.15 test_ratio: 0.15 gap: 24 model: type: TCN hidden_dim: 64 num_layers: 4 kernel_size: 3 dropout: 0.2 training: batch_size: 64 lr: 0.001 epochs: 100 patience: 10 loss: huber huber_delta: 1.09.2 推理服务的封装
上线时，推理服务需要处理几个事情：加载模型、预处理输入、推理、后处理输出。
预处理要注意：推理时的预处理必须跟训练时完全一致。归一化的统计量要用训练时保存的，不能用推理数据重新计算。这个坑很常见，训练时用全局统计量归一化，推理时用当前batch的统计量，结果完全不对。
后处理要注意：如果训练时做了差分，推理时要逆差分回去。逆差分的基准值要用输入序列的最后一个值。
class Predictor: def __init__(self, model_path, norm_stats, config): self.model = load_model(model_path, config) self.model.eval() self.norm_mean = norm_stats['mean'] self.norm_std = norm_stats['std'] def predict(self, input_series): # 归一化 normalized = (input_series - self.norm_mean) / self.norm_std # 转tensor x = torch.FloatTensor(normalized).unsqueeze(0) # 推理 with torch.no_grad(): pred = self.model(x) # 逆归一化 pred = pred.numpy() * self.norm_std + self.norm_mean return pred9.3 监控和告警
上线后需要监控的东西：预测误差、数据漂移、推理延迟、服务可用性。
预测误差需要真实值才能算，所以一般有延迟。我一般用两种监控：一种是延迟监控（等真实值到了算误差），一种是即时监控（看预测值的分布是否异常）。
即时监控的阈值怎么定？我一般用训练时验证集预测值的分布作为基准，计算上线后预测值的PSI。PSI超过0.25就告警。
推理延迟监控也很重要。如果延迟突然变大，可能是模型加载有问题，或者输入数据量变大了。我一般设一个延迟阈值，超过就告警。
9.4 模型更新的策略
模型更新有几种策略：定期更新、触发式更新、A/B测试。
定期更新：比如每周重新训练一次。简单，但可能更新不及时。
触发式更新：当监控指标超过阈值时触发更新。及时，但需要完善的监控。
A/B测试：新模型和旧模型同时跑，对比效果后再切换。稳妥，但需要流量支持。
我一般用定期更新加触发式更新的组合。定期更新保证模型不过时，触发式更新应对突发漂移。A/B测试在重要更新时用。
10. 一些个人体会
做时序预测这几年，最大的感受是：数据质量比模型结构重要得多。我见过太多人花大量时间调模型，但数据里的缺失值、异常值、泄露问题没处理好，最后效果怎么都上不去。反过来，数据干净的情况下，简单的LSTM甚至线性模型都能有不错的效果。
另一个感受是：别迷信SOTA。论文里的模型往往是在特定数据集上调过参的，直接搬到自己的数据上不一定好用。我一般会先跑一个简单的baseline（比如naive预测或者线性回归），然后逐步增加复杂度，每加一个组件都要验证是否真的有提升。没有提升就果断去掉，保持模型简单。
还有一个是：评估要全面。不能只看一个指标。MAE、MASE、预测区间覆盖率、不同时间段的误差，都要看。有时候整体MAE很好，但某个时间段的误差特别大，这种模型上线后可能会在特定场景下出问题。
最后说一个实际的小技巧：在损失函数里给近期预测更高的权重。因为实际业务中，近期的预测往往比远期的更重要。比如预测未来24小时，前6小时的误差可能比后6小时更关键。可以在损失函数里加一个指数衰减的权重，让模型更关注近期。
def weighted_loss(pred, target, decay=0.9): """给近期预测更高权重""" horizon = pred.size(1) weights = torch.FloatTensor([decay ** i for i in range(horizon)]) weights = weights / weights.sum() loss = (pred - target) ** 2 weighted_loss = (loss * weights.unsqueeze(0)).mean() return weighted_loss这个技巧在多个项目里都帮我提升了近期预测的准确率，而且实现简单，推荐试试。
