在深度学习中，循环神经网络（RNN）与Transformer是处理序列数据的主流工具。它们在中等长度序列任务中表现优异，如机器翻译和摘要生成。然而，当输入序列从数百扩展至数万甚至数十万时，这些经典模型暴露出难以克服的根本性缺陷。这不仅是算力瓶颈，更是其内在结构设计的局限。唯有深入理解这些问题，才能明白为何必须为长序列专门设计新模型。

序列增长引发的核心矛盾

序列建模的本质在于捕捉有序数据中的依赖关系：位置顺序、时间先后以及远距离关联都蕴含关键语义。短序列下，这些关系尚可有效建模；但随着长度呈指数级增加，三个结构性难题逐渐显现。

计算资源的非线性膨胀首当其冲。以标准RNN为例，每个时间步必须依赖前一状态，导致整个过程无法并行化，只能逐次推进。而Transformer采用自注意力机制，需对每一对位置计算相关性，带来O(L²)的内存与计算开销。当序列长度达到十万量级时，即使使用顶级硬件，注意力矩阵也无法装入显存。

长期依赖的梯度衰减是另一个深层障碍。尽管LSTM和GRU引入门控机制缓解了这一问题，但在超过千步的序列中，反向传播时梯度仍会因链式法则而迅速消失或爆炸。这如同信息传递经过多轮转述后失真严重，使得模型难以记住早期的关键信息。

信号传播质量下降则更为隐蔽。虽然自注意力提供了全局视野，但长序列下注意力分布趋于平滑——所有位置都被赋予相似权重，导致局部细节被稀释。这种现象在长文档分析、高分辨率图像建模中尤为显著，模型反而忽略了真正重要的上下文片段。

传统架构的数学本质限制

以标准Transformer的注意力模块为例：

import torch
import torch.nn as nn

class StandardAttention(nn.Module):
    def __init__(self, d_model, seq_len):
        super().__init__()
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.seq_len = seq_len

    def forward(self, x):
        Q = self.W_q(x)  # (B, L, D)
        K = self.W_k(x)
        V = self.W_v(x)

        attn_scores = torch.einsum('bld,bmd->blm', Q, K) / (K.size(-1) ** 0.5)
        attn_weights = torch.softmax(attn_scores, dim=-1)
        output = torch.einsum('blm,bmd->bld', attn_weights, V)
        return output

该实现中，attn_scores 的维度为 (B, L, L)，若 L=100000，仅此矩阵就需约40GB显存（float32）。更糟的是后续softmax与加权求和也需大量中间存储。平方复杂度使其在长序列场景下彻底失效。

相比之下，传统RNN的串行结构更难优化。其核心逻辑如下：

class SimpleRNNCell(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        self.h = nn.Parameter(torch.zeros(1, hidden_dim))
        self.W_ih = nn.Linear(input_dim, hidden_dim)
        self.W_hh = nn.Linear(hidden_dim, hidden_dim)

    def forward(self, x):
        batch_size, seq_len, _ = x.shape
        h = self.h.expand(batch_size, -1)
        outputs = []

        for t in range(seq_len):
            h = torch.tanh(self.W_ih(x[:, t]) + self.W_hh(h))
            outputs.append(h)

        return torch.stack(outputs, dim=1)

由于每一步输出依赖前一步隐藏状态，整个过程必须串行执行。即便拥有数千个计算核心，也无法加速时间维度上的推进。因此，训练超长序列模型可能耗时数天乃至数周。

新型架构的突破路径

面对上述困境，研究者从不同角度重构序列建模范式，不再局限于"全连接+注意力"的旧框架。

状态空间模型（SSM）源自控制理论，用微分方程描述系统演化。如Mamba系列模型引入可学习的选择机制，使状态转移矩阵能根据输入动态调整。其核心思想是维护一个压缩的隐状态流，而非存储完整历史。这个状态随新输入不断更新，形成对上下文的持续摘要。计算与存储成本仅取决于隐状态维度，与序列长度无关，从而支持百万级序列处理。

线性注意力机制则通过代数重排打破平方复杂度。传统注意力需构建完整的注意力矩阵，而线性注意力将计算顺序重构为先聚合键值乘积，再与查询结合：

class LinearAttention(nn.Module):
    def __init__(self, d_model, feature_dim=64):
        super().__init__()
        self.proj_q = nn.Linear(d_model, feature_dim)
        self.proj_k = nn.Linear(d_model, feature_dim)
        self.proj_v = nn.Linear(d_model, d_model)
        self.feature_dim = feature_dim

    def forward(self, x):
        Q = F.elu(self.proj_q(x)) + 1  # 非负保证
        K = F.elu(self.proj_k(x)) + 1
        V = self.proj_v(x)

        # 先计算 KV: (B, F, D)
        KV = torch.einsum('bld,bmd->bfd', K, V)

        # K 求和: (B, F)
        K_sum = K.sum(dim=1)

        # 分子: Q @ KV
        numerator = torch.einsum('bld,bfd->bld', Q, KV)

        # 分母: Q @ K_sum
        denominator = torch.einsum('bld,bf->bl', Q, K_sum)

        # 输出: 分子 / 分母
        output = numerator / (denominator.unsqueeze(-1) + 1e-8)
        return output

此设计避免了显式构造 L×L 矩阵，中间结果仅需 (B, F, D) 形状，其中 F 远小于 L。因此，空间复杂度由 O(L²) 降至 O(L)，代价是轻微表达能力损失，但在多数长序列任务中可接受。

混合架构提供务实折衷方案。例如，在局部窗口内使用标准注意力保持精细感知，同时引入全局摘要记忆层处理远距离依赖。这种设计模仿人类阅读习惯：精读当前段落，脑中保留整体印象。

实际应用中的权衡策略

选择何种模型需结合具体场景。若序列长度在几千以内且精度要求极高，标准Transformer配合梯度检查点仍具竞争力。但对于金融高频数据、生理信号、基因组序列等动辄数万步的场景，状态空间模型或线性注意力更具优势。

工程层面也有诸多优化手段：混合精度训练减少显存占用；序列分块（chunking）允许分段处理，梯度跨块累积；梯度检查点牺牲部分计算换取显存节省。

评估模型是否具备真实长距离建模能力同样重要。可通过设计测试：在序列起始插入特殊标记，要求模型在末尾做出依赖该标记的决策。若模型能跨越数千步准确响应，则表明其已掌握真正的长程依赖。

结语

长序列建模呼唤新架构的根本原因在于：传统方法在计算复杂度、信息传播效率与状态表示能力之间存在不可调和的矛盾。Transformer的平方开销让长序列物理上不可行，RNN的串行结构制约并行潜力，两者在远距离建模中均出现性能退化。

新一代模型——包括状态空间模型、线性注意力与混合结构——都在探索同一个目标：以线性代价维持对全局结构的感知能力。这不是简单的工程改进，而是对序列建模基本范式的重新定义。

对于从业者而言，掌握这些新架构的原理与适用边界，将有助于在日益增长的数据规模面前做出更科学的技术选型。序列建模的边界正被持续拓展，而这场变革才刚刚启程。