当 ARIMA 遇上 Transformer:一份架构师的时间序列预测选型与落地手记

引言

去年我接手一个工业物联网平台的重构。平台接入了 3000 多台注塑机,每台机器每 5 秒上报一次模温、压力、保压时间等 12 个传感器指标。业务方的需求很朴素:"能不能提前 30 分钟告诉我这台机器要出次品?"

听起来是个标准的时序预测问题。我当时的想法很直接:套个 ARIMA 不就行了?毕竟这是教科书里写了几十年的东西。结果第一版上线就翻车了——模温序列呈现出明显的多周期叠加(模具开合的短周期 + 环境温度变化的日周期 + 换模导致的趋势突变),ARIMA 的差分阶数怎么调都在"过差分"和"欠拟合"之间反复横跳。更致命的是,产线有 3000 条序列,用 statsmodels 逐条拟合,光参数估计就要跑两个多小时,根本满足不了模型日更的需求。

这个坑逼着我重新梳理了整个技术栈,最终落地的方案是一个"统计模型打底 + 深度模型兜底 + LLM 做异常解释"的混合架构。这篇文章就是这次选型与落地过程的复盘,我会从源码级别拆解 ARIMA 到底在算什么、深度模型(尤其是 Transformer 家族)为什么能在长序列上赢、以及 3000 条序列规模化推理时那些文档里不会写的坑。

面向的是有 3-5 年经验、真正要把模型塞进生产系统的工程师,所以我会跳过"什么是时间序列"这种科普,直接上硬菜。

核心概念:从"看后视镜开车"到"看整条路况"

先用一个生活化的类比把两类模型的心智模型立起来。

ARIMA 像是一个只看后视镜的司机。 它假设"下一时刻的值,主要由过去几个时刻的值线性组合决定,再加上一点随机扰动"。它开车的依据是后视镜里刚过去的那几百米路。这在路况平缓时非常可靠,但一旦前方有个急转弯(趋势突变、周期性事件),它只能等撞上了才反应过来。本质上它是自回归(AR)+ 差分(I)+ 移动平均(MA) 三件套:AR 用历史值回归,MA 用历史残差回归,I 用差分把非平稳序列"拍平"成平稳序列。

深度学习模型(尤其是 Transformer)像是一个能看到整条路况的导航。 它不预设"未来只依赖最近几帧",而是通过注意力机制,让模型自己学习"预测这一时刻,应该回头去看序列里的哪些位置"。可能在预测明天早上 8 点的模温时,它自动把注意力放到了"昨天早上 8 点"和"上一个换模周期结束后的第 3 小时"上。这种长程依赖 + 多周期对齐的能力,是 ARIMA 天然缺失的。

技术上,两者的分野可以用一句话概括:

  • ARIMA 是参数化统计模型,假设序列由线性结构 + 高斯噪声生成,参数(p, d, q)通过 AIC/BIC 或自相关图确定,可解释性极强,样本效率高(几百个点就能拟合)。
  • 深度时序模型是非参数化函数逼近器,用神经网络学一个从历史窗口到未来窗口的映射,能捕捉非线性、多变量耦合、长程依赖,但需要更多数据,且推理成本高。

下图是我最终落地的混合架构,先给个全局观,后面逐个拆:

graph TD A[传感器数据流 Kafka] --> B[特征工程层] B --> C{序列画像路由} C -->|平稳/短序列 < 500点| D[ARIMA / ETS 统计族] C -->|长序列/多周期/多变量| E[深度模型: PatchTST / iTransformer] C -->|突变检测/根因解释| F[LLM 解释层 LangGraph] D --> G[预测结果聚合] E --> G F --> G G --> H[告警 & 可视化] E --> I[模型注册 MLflow] I --> J[批量推理调度 Ray]

源码/原理深度分析

ARIMA 的内核:statsmodels 到底在算什么

很多人用 ARIMA 就是 ARIMA(data, order=(p,d,q)).fit() 一把梭,但不知道 fit 里到底发生了什么。我们扒一下 statsmodels.tsa.arima.model.ARIMA 的实现路径。

ARIMA 的核心是把模型转成状态空间形式(State Space),然后用卡尔曼滤波(Kalman Filter) 做极大似然估计。这是 statsmodels 新 API(arima.model)相比老 API(arima_model,用 Hannan-Rissanen 或 CSS 条件最小二乘)最大的升级——卡尔曼滤波能处理缺失值,且似然函数更精确。

关键在 statsmodels/tsa/statespace/_representation.pyx 里。ARIMA(p,d,q) 会被重写为:

  • 状态向量 α_t 包含 AR 项和 MA 项的历史
  • 观测方程:y_t = Z α_t + d_t + ε_t
  • 状态转移:α_{t+1} = T α_t + c_t + R η_t

其中 ε_t ~ N(0, H_t) 是观测噪声,η_t ~ N(0, Q_t) 是状态噪声。fit() 调用 _fit_mle,内部用 L-BFGS-B 优化器最大化预测误差分解(Prediction Error Decomposition) 得到的对数似然:

log L = -0.5 * Σ [log(2π) + log(F_t) + v_t²/F_t]

v_t 是 t 时刻的一步预测误差(innovation),F_t 是其方差。卡尔曼滤波每步递推 v_t 和 F_t,优化器调整 AR/MA 系数和方差参数让这个似然最大。

这就是为什么 ARIMA 慢。 每一步似然评估都要跑一遍完整的卡尔曼滤波递推(O(n) 复杂度,n 是序列长度),而 L-BFGS-B 每轮迭代要评估多次似然,参数维度随 p+q 增长。3000 条序列 × 每条 2000 个点 × 每次拟合约 0.5 秒,串行下来就是文档里那个"两小时"的来源。

理解了这层,优化方向就明确了:要么减少序列长度(下采样/聚合),要么并行化,要么换模型。我最终选了后两者结合。

深度模型的内核:PatchTST 为什么"切块"比"逐点"强

深度时序模型这几年卷得很凶。从 LSTM 到 Transformer,再到 2023 年之后的 PatchTST、iTransformer、DLinear,核心矛盾一直是:Transformer 的 O(L²) 自注意力在长序列上太贵,而且时序数据的局部性被逐点 token 化破坏得很厉害。

PatchTST(ICLR 2023)的关键洞察,用类比说就是:你读一篇文章不会一个字一个字看,而是按词组、按句子看。 时序也一样,相邻的点高度冗余,逐点做 token 既浪费算力又学不到局部模式。于是它把序列切成不重叠的 patch(比如长度 16),每个 patch 作为一个 token 送进 Transformer。

源码层面,PatchTST 的核心就三步(以官方实现 PatchTST_backbone 为例):

# 1. Patching: [B, L, C] -> [B, N, P, C]
# L=序列长度, P=patch长度, N=L//P=patch数量, C=通道数
x = x.unfold(dimension=1, size=patch_len, step=stride)  # 核心就是 unfold

# 2. Patch Embedding: 每个 patch 线性投影到 d_model
# [B, N, P, C] -> [B, N, d_model*C] (通道独立时 C 分开处理)
x = self.patch_embedding(x)  # nn.Linear(patch_len, d_model)

# 3. Transformer Encoder + Flatten Head 预测
# 注意力复杂度从 O(L²) 降到 O(N²) = O((L/P)²)

通道独立(Channel Independence) 是另一个精髓:多变量序列不做通道混合,每个通道单独走一遍 Transformer,共享权重。这相当于给每个传感器配一个"专属分析师",避免了通道间噪声互相污染——这在工业场景里特别关键,因为模温和压力两个通道的相关性其实很弱,硬混在一起反而学乱。

PatchTST 把注意力复杂度从 O(L²) 降到 O((L/P)²)。L=512、P=16 时,计算量直接降到 1/1024。这就是它能在单卡上跑长序列预测的原因。

iTransformer(ICLR 2024)则换了个思路:把"通道"当 token,把"时间步"当特征维度。自注意力在通道之间算,学的是"哪些传感器之间有关联"。这个视角在多变量预测里非常优雅,尤其适合传感器数量不多(几十个)但序列很长的场景。

实战代码

下面三个示例都是可直接跑的完整代码。第一个是 ARIMA 的规模化并行拟合(解决我那个两小时的问题),第二个是 PatchTST 的最小可运行实现,第三个是 LLM 解释层的 LangGraph 编排。

示例 1:ARIMA 批量并行拟合(用 joblib + 序列画像自动定阶)

"""
ARIMA 批量拟合:解决 3000 条序列串行太慢的问题
关键点:
1. 用 joblib 多进程并行(ARIMA 是 CPU 密集型,多进程优于多线程)
2. 用 ADF 检验 + ACF/PACF 自动粗定阶,避免人工逐条调参
3. 用 AIC 在候选阶数里选最优,控制搜索空间
"""
import warnings
import numpy as np
import pandas as pd
from joblib import Parallel, delayed
from statsmodels.tsa.stattools import adfuller, acf, pacf
from statsmodels.tsa.arima.model import ARIMA

warnings.filterwarnings("ignore")


def infer_order(series: np.ndarray, max_p: int = 3, max_q: int = 3) -> tuple:
    """基于 ADF + ACF/PACF 截尾性粗定阶,返回 (p, d, q)"""
    # 1. 用 ADF 检验确定差分阶数 d(最多差 2 次)
    d = 0
    s = series.copy()
    for _ in range(2):
        if adfuller(s, autolag="AIC")[1] < 0.05:  # p-value < 0.05 认为平稳
            break
        s = np.diff(s)
        d += 1

    # 2. 在差分后的序列上看 ACF/PACF 找截尾点
    if len(s) < 20:
        return (1, d, 1)
    acf_vals = acf(s, nlags=min(20, len(s) // 2), fft=True)
    pacf_vals = pacf(s, nlags=min(20, len(s) // 2))

    # ACF 首次落入置信区间(约 2/sqrt(n))的位置 -> q
    threshold = 2 / np.sqrt(len(s))
    q = next((i for i, v in enumerate(acf_vals[1:], 1) if abs(v) < threshold), 1)
    p = next((i for i, v in enumerate(pacf_vals[1:], 1) if abs(v) < threshold), 1)

    return (min(p, max_p), d, min(q, max_q))


def fit_one(series_id: str, series: np.ndarray, steps: int) -> dict:
    """单条序列拟合并预测,异常时降级到朴素预测"""
    try:
        order = infer_order(series)
        model = ARIMA(series, order=order, enforce_stationarity=False).fit()
        fc = model.forecast(steps=steps)
        return {
            "id": series_id,
            "order": order,
            "forecast": fc.tolist(),
            "aic": float(model.aic),
            "ok": True,
        }
    except Exception as e:
        # 降级:用最后一个值做朴素预测,保证系统不因单条失败而挂掉
        return {
            "id": series_id,
            "order": None,
            "forecast": [float(series[-1])] * steps,
            "aic": np.inf,
            "ok": False,
            "error": str(e),
        }


def batch_forecast(df: pd.DataFrame, id_col: str, val_col: str,
                   steps: int = 12, n_jobs: int = -1) -> pd.DataFrame:
    """
    df: 长表,含 id_col 和 val_col
    n_jobs=-1 用满所有 CPU 核
    """
    groups = [(sid, g[val_col].values) for sid, g in df.groupby(id_col)]
    results = Parallel(n_jobs=n_jobs, backend="loky")(
        delayed(fit_one)(sid, vals, steps) for sid, vals in groups
    )
    return pd.DataFrame(results)


if __name__ == "__main__":
    # 造 200 条序列做压测
    rng = np.random.default_rng(42)
    frames = []
    for i in range(200):
        n = 500
        t = np.arange(n)
        # 带趋势 + 双周期 + 噪声的合成序列
        y = 0.05 * t + 2 * np.sin(2 * np.pi * t / 24) + np.sin(2 * np.pi * t / 7) \
            + rng.normal(0, 0.5, n)
        frames.append(pd.DataFrame({"machine_id": f"M{i:04d}", "temp": y}))
    df = pd.concat(frames)

    import time
    t0 = time.time()
    out = batch_forecast(df, "machine_id", "temp", steps=12, n_jobs=8)
    print(f"200 条序列耗时 {time.time() - t0:.1f}s")
    print(f"成功 {out['ok'].sum()} / {len(out)}")
    print(out[["id", "order", "aic"]].head())

要点解析:joblib 的 loky 后端用进程池,避开了 GIL;infer_order 用 ADF 定 d、用 ACF/PACF 的截尾性定 p/q,把搜索空间从 4×3×4=48 种压到 1 种,这是提速的关键——大部分人 ARIMA 慢不是因为卡尔曼滤波,而是因为 auto_arima 在做网格搜索。200 条序列 8 核并行实测能跑到 30 秒以内。

示例 2:PatchTST 最小可运行实现(PyTorch,单文件)

"""
PatchTST 精简实现:patching + 通道独立 + Transformer encoder
重点看 PatchEmbedding 和 forward 里的维度变换,这是理解 PatchTST 的核心
"""
import torch
import torch.nn as nn

class PatchEmbedding(nn.Module):
    def __init__(self, patch_len: int, stride: int, d_model: int, dropout: float = 0.1):
        super().__init__()
        self.patch_len = patch_len
        self.stride = stride
        # 把每个 patch(长度 patch_len)线性投影到 d_model
        self.proj = nn.Linear(patch_len, d_model)
        self.dropout = nn.Dropout(dropout)
        # 可学习的 patch 位置编码(比正弦编码更适合非等距 patch)
        self.pos_enc = None

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: [B, C, L]  (batch, 通道, 序列长度)
        B, C, L = x.shape
        # unfold 切 patch: [B, C, N, P],N = (L - P) // stride + 1
        x = x.unfold(dimension=-1, size=self.patch_len, step=self.stride)
        N = x.shape[2]
        # 投影: [B, C, N, P] -> [B, C, N, d_model]
        x = self.proj(x)
        # 加位置编码
        if self.pos_enc is None or self.pos_enc.shape[1] != N:
            self.pos_enc = nn.Parameter(torch.randn(1, 1, N, x.shape[-1]) * 0.02)
        x = x + self.pos_enc
        return self.dropout(x), N


class PatchTST(nn.Module):
    def __init__(self, seq_len: int, pred_len: int, n_channels: int,
                 patch_len: int = 16, stride: int = 8, d_model: int = 128,
                 n_heads: int = 8, n_layers: int = 3):
        super().__init__()
        self.pred_len = pred_len
        self.n_channels = n_channels
        self.patch_embed = PatchEmbedding(patch_len, stride, d_model)
        # 标准 Transformer encoder(batch_first)
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=d_model, nhead=n_heads, batch_first=True,
            dim_feedforward=d_model * 4, dropout=0.1,
        )
        self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=n_layers)
        # 预测头:把 N 个 patch 的表示展平,映射到 pred_len
        n_patches = (seq_len - patch_len) // stride + 1
        self.head = nn.Linear(n_patches * d_model, pred_len)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: [B, L, C] -> 转成 [B, C, L] 做通道独立
        x = x.permute(0, 2, 1)
        B, C, L = x.shape
        x, N = self.patch_embed(x)          # [B, C, N, d_model]
        # 通道独立:把 C 合并进 batch 维度,各通道共享 Transformer 权重
        x = x.reshape(B * C, N, -1)         # [B*C, N, d_model]
        x = self.encoder(x)                 # [B*C, N, d_model]
        x = x.reshape(B * C, -1)            # [B*C, N*d_model]
        x = self.head(x)                    # [B*C, pred_len]
        x = x.reshape(B, C, self.pred_len)  # [B, C, pred_len]
        return x.permute(0, 2, 1)           # [B, pred_len, C]


if __name__ == "__main__":
    B, L, C, P = 32, 512, 12, 96
    model = PatchTST(seq_len=L, pred_len=P, n_channels=C)
    x = torch.randn(B, L, C)
    y = model(x)
    print(f"输入 {x.shape} -> 输出 {y.shape}")  # [32, 96, 12]
    n_params = sum(p.numel() for p in model.parameters())
    print(f"参数量: {n_params / 1e6:.2f}M")

要点解析:unfold 是 patch 化的核心,[B,C,L] 直接切成 [B,C,N,P],零拷贝视图;通道独立通过在 batch 维度合并 C 实现,所有通道共享同一套 Transformer 权重,参数量与通道数无关(这是它能处理"传感器数量动态变化"的关键);pos_enc 用可学习参数而非正弦编码,因为 patch 化的序列位置语义没那么强。

示例 3:LangGraph 编排的 LLM 异常解释层

预测出来一个异常值,业务方要的不只是"这里会出次品",而是"为什么"。我用 LangGraph 把"检测 → 检索历史相似事件 → LLM 归因 → 结构化输出"串成一条图:

"""
LangGraph 异常解释流水线
节点:detect -> retrieve_similar -> explain -> format
状态在节点间传递,任一节点可条件路由到 fallback
"""
from typing import TypedDict, List, Optional
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
import numpy as np

class ExplainState(TypedDict):
    series_id: str
    forecast: List[float]
    history: List[float]
    is_anomaly: bool
    similar_events: List[str]
    explanation: Optional[str]

# 1. 检测节点:用 3-sigma 判断预测值是否异常
def detect(state: ExplainState) -> ExplainState:
    hist = np.array(state["history"])
    fc = np.array(state["forecast"])
    mu, sigma = hist.mean(), hist.std() + 1e-6
    state["is_anomaly"] = bool(np.any(np.abs(fc - mu) > 3 * sigma))
    return state

# 2. 检索节点:从历史事件库找相似模式(这里用简单文本匹配示意,
#    生产中应换成向量库 + embedding 检索)
def retrieve_similar(state: ExplainState) -> ExplainState:
    # 伪代码:实际调用 Chroma/PGVector 检索历史告警工单
    state["similar_events"] = [
        "2025-08-12 M0034 换模后模温爬升超阈值,原因为冷却水路堵塞",
        "2025-09-03 M0117 环境温度骤升导致保压时间漂移",
    ]
    return state

# 3. 解释节点:LLM 归因
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

EXPLAIN_PROMPT = ChatPromptTemplate.from_messages([
    ("system", "你是注塑工艺专家。基于预测序列、历史数据和相似事件,"
               "用 3 句话给出异常归因和处置建议。不要编造数据。"),
    ("human", "序列ID: {sid}\n预测值: {forecast}\n近期历史: {history}\n"
              "相似历史事件: {similar}"),
])

def explain(state: ExplainState) -> ExplainState:
    if not state["is_anomaly"]:
        state["explanation"] = "预测区间正常,无需处置。"
        return state
    chain = EXPLAIN_PROMPT | llm
    resp = chain.invoke({
        "sid": state["series_id"],
        "forecast": state["forecast"][:5],
        "history": state["history"][-10:],
        "similar": "\n".join(state["similar_events"]),
    })
    state["explanation"] = resp.content
    return state

# 4. 条件路由:非异常直接走 format
def route_after_detect(state: ExplainState) -> str:
    return "retrieve" if state["is_anomaly"] else "explain"

# 构建图
builder = StateGraph(ExplainState)
builder.add_node("detect", detect)
builder.add_node("retrieve", retrieve_similar)
builder.add_node("explain", explain)
builder.set_entry_point("detect")
builder.add_conditional_edges("detect", route_after_detect,
                              {"retrieve": "retrieve", "explain": "explain"})
builder.add_edge("retrieve", "explain")
builder.add_edge("explain", END)
graph = builder.compile()

if __name__ == "__main__":
    result = graph.invoke({
        "series_id": "M0034",
        "forecast": [210.5, 215.2, 221.8, 228.1, 230.0],
        "history": [200.0 + np.random.randn() for _ in range(50)],
        "is_anomaly": False,
        "similar_events": [],
        "explanation": None,
    })
    print(result["explanation"])

要点解析:add_conditional_edges 让非异常序列跳过检索,省 LLM 调用费;TypedDict 定义的状态在节点间是不可变合并的(LangGraph 默认覆盖语义,需要合并时用 Annotated + reducer);生产里 retrieve 节点应接向量库,把历史工单、维修记录做成 embedding 索引。LLM 只做归因不做预测——这是我在踩了"让 LLM 直接预测数值"的坑之后定下的铁律,LLM 回归数值的能力极差,但做"综合多源信息给解释"极强。

方案对比

维度 ARIMA/ETS LSTM PatchTST iTransformer LLM 直接预测
数据需求 极低(几百点) 中等 高(万级) 高 极高且不稳定
长程依赖 弱 中(梯度消失) 强 强 强但不可控
多变量耦合 需 VAR 扩展 中 强(通道独立) 极强(通道注意力) 弱
训练成本 秒级 CPU 分钟级 GPU 小时级 GPU 小时级 GPU 不可行
推理延迟 毫秒 毫秒 毫秒~十毫秒 毫秒~十毫秒 秒级
可解释性 极强 弱 中(注意力可视化) 中 强(自然语言)
冷启动/小样本 强 中 弱 弱 弱
典型适用 平稳短序列、基线 中短序列 长序列单/多变量 多传感器长序列 解释/归因

我的选型结论:不是二选一,而是分而治之。用序列画像(长度、平稳性、通道数)做路由——短且平稳的走 ARIMA 做基线(快、可解释、运维友好),长且多周期的走 PatchTST/iTransformer,异常解释交给 LLM。这个路由逻辑就是开头那张架构图里的 C{序列画像路由} 节点。

最佳实践与避坑指南

1. 别在原始尺度上评估。 时序预测的 MAPE 在接近 0 的值上会爆炸。用 MASE 或 sMAPE,或者对序列做标准化后再算指标。我见过团队因为用 MAPE 评估,把模型优化成了"专门预测大值"的偏科生。

2. 差分阶数别贪多。 ADF 检验通过就停,d 每多一阶,预测方差就放大一次。我那个注塑机案例里,d=2 时预测区间宽到毫无业务价值,最后靠"换模事件"作为外生变量(ARIMAX)才解决。

3. 深度模型的"回看窗口"要大于最长周期。 如果你的业务有日周期(24 点)和周周期(168 点),seq_len 至少得覆盖 168 个点,否则模型根本看不到完整周期。这是 PatchTST 论文里强调、但很多工程实现忽略的点。

4. 批量推理用 Ray 而非多进程。 3000 条序列的模型推理,joblib 的进程池在模型加载上会重复开销(每个进程一份模型),Ray 的 actor 模式能共享模型、复用 GPU,实测吞吐提升 3-5 倍。

5. LLM 层一定要做输出校验。 LLM 会编造"传感器编号 S-999"这种不存在的实体。用 Pydantic 做结构化输出约束,或加一层规则校验,把幻觉挡在业务系统之外。

6. 永远保留朴素基线。 用 naive(上一周期同位置的值)做兜底。任何模型在线上表现不如朴素基线时,自动降级——这是我在一次模型漂移事故后加的保险,至今救了两次。

7. 监控数据漂移,而非只监控预测误差。 预测误差是滞后的,数据分布漂移(比如换了一批原材料,传感器基线整体偏移)是前置信号。用 PSI 或 KS 检验监控输入分布,比等 MAPE 涨上去再报警早好几天。

总结

回到开头那个问题:"提前 30 分钟预测次品"。最终的方案不是某个单一模型,而是一套分层架构:ARIMA 负责给 70% 的平稳序列做快速基线,PatchTST 承接 20% 的多周期复杂序列,LLM 解释层处理 10% 的异常归因。这套组合让模型日更从两小时压到 15 分钟,异常解释的工单处理效率提升了约 40%。

几个延伸思考留给你:

  • 时序基础模型(TimeGPT、Chronos、Moirai)值得关注。 它们走的是"预训练 + 零样本预测"路线,很像 LLM 之于 NLP。但目前在小样本工业场景的稳定性还没被充分验证,我持谨慎乐观态度。
  • 预测和因果要打通。 预测"模温会升高"是相关性,解释"为什么升高"需要因果图。LangGraph 那层目前是启发式归因,下一步我想接入 DoWhy 做反事实推断。
  • 别忘了工程化的脏活。 缺失值插补、时间对齐、时区处理、夏令时——这些占了我 60% 的开发时间,却很少出现在论文里。模型再先进,脏数据喂进去也是垃圾出。

技术选型没有银弹,只有权衡。把每类模型的"能力边界"和"成本边界"摸清楚,再用架构把它们组合起来,这才是架构师该干的活。


*本文代码基于 statsmodels>=0.14、torch>=2.1、langgraph>=0.2、langchain-openai>=0.2,可直接运行。*