限价订单簿建模：DeepLOB与Transformer及数据管线实战

第一次把 Level-2 行情导进 DataFrame 的人，往往会对着几十列数字愣一会儿：买一到买十的价格和挂单量、卖一到卖十的价格和挂单量，逐笔更新，一天下来几百万行。这些数字排得整整齐齐，看起来很像一张表，实际上是一张实时变形的供需地图。限价订单簿（Limit Order Book，LOB）建模要做的，就是从这张地图的连续快照里，判断接下来几百毫秒到几秒，价格更可能往哪边走。

这件事听起来像是“把数据丢进神经网络”，但真正做过一轮的人都会发现，模型结构反而是最不费劲的部分。DeepLOB 的结构网上一搜就有，Transformer 的 encoder 更是调包即用，真正耗时间的是另外三件事：快照怎么对齐、特征怎么归一化、标签怎么定义。这三个环节里任何一个出错，你都能训出一个 loss 曲线漂亮、验证集准确率不低、但一放进模拟撮合就完全失效的模型。

所以这篇文章不打算做成“DeepLOB 与 Transformer 结构对比表”。我更想讲清楚一件事：LOB 建模的核心难点不在选哪个网络，而在于你如何把一张高频变化的订单簿，翻译成模型能学的张量，以及你如何诚实地评估它。 DeepLOB 和 Transformer 只是这条流水线末端的两个不同选择，前者是一个极强的、至今绕不开的基线，后者带来的是长程依赖和多尺度注意力的可能性，但也同时引入了样本量、位置编码和过拟合的新问题。

下面按“任务定义 → 基线拆解 → Transformer 变体 → 数据管线 → 评估口径 → 落地路径”的顺序展开，中间会给出可运行的 PyTorch 结构示意、关键参数解释和一套排查顺序。

1. 先把这个任务说清楚：LOB 建模到底在预测什么

在写第一行模型代码之前，必须先把“预测什么”钉死。这一步没想清楚，后面所有的实验都是在给一个模糊的目标做优化，指标再好看也没有意义。

1.1 一条快照里的 40 个数字，其实是一张供需地图

最常见的 LOB 表示是“10 档 × 2 侧 × 2 字段”，也就是买一至买十的价格与挂单量、卖一至卖十的价格与挂单量，合计 40 维。FI-2010 这个被引用到烂的数据集用的就是这个形式，100 个时间步 × 40 维，构成一个 100 × 40 的矩阵。

但要知道这 40 维里信息密度是完全不同的。

直接把这 40 列原始数值喂给网络，会遇到两个隐蔽的问题。第一，价格是绝对水平，不同标的、不同时间段差异巨大，模型很容易学到“今天的价格区间”而不是“订单簿形状”。第二，量纲差异悬殊，挂单量可能是价格的几千倍，不做处理的话梯度会被量的维度主导。

常见的处理方式是构造相对特征而不是绝对特征：某一档价格减去中间价，某一档挂单量除以该侧总量或过去一段时间的均值。这样处理之后，模型看到的才是“形状”而不是“水平”。这一步看起来平平无奇，但它是后面所有模型能不能收敛的前提。

另一个常被忽略的点是中间价（mid-price）的定义。最常见的写法是 (best_bid + best_ask) / 2，但在价差较大、一档挂单很薄的时候，这个值会剧烈跳动。有些实践会改用加权中间价，或者用微价格（micro-price），即按买卖一档的挂单量对报价做加权。用哪种口径，会直接影响你后面标签的平滑程度和噪声水平，必须和团队统一定义，不能一个脚本一个说法。

1.2 三种建模视角，决定了你后面所有工程选择

同一份订单簿数据，至少有三种把它变成张量的方式，每种方式对应一类模型家族，也对应不同的工程成本。

第一种，图像视角。 把 时间 × 特征 当成一张灰度图，用二维卷积去扫。DeepLOB 走的就是这条路。好处是卷积天然擅长捕捉局部模式，比如“买一量突然放大同时卖一量收缩”这种横跨相邻档位的形态；坏处是时间维和特征维被同等对待，而它们的物理含义完全不同。

第二种，序列视角。 把每个时间步的 40 维向量当成一个 token，整段历史就是一个长度为 T 的序列，用 RNN 或 Transformer 建模。好处是模型可以显式处理任意长的时间依赖；坏处是每一帧内部的结构信息被压平了，模型需要自己重新学出“买一和卖一是相邻的”。

第三种，事件视角。 不看快照，只看逐笔的委托、成交、撤单消息，把订单簿当成一个由事件驱动的点过程。这条路最贴近真实市场机制，也最难工程化，需要对消息做完整重放。

新手最容易犯的错，是看到某个方案在论文里效果好就直接照搬，却没意识到论文用的是 FI-2010 那种已经预处理好的矩阵，而自己手上是原始逐笔消息，中间隔着一整套重建订单簿的工程量。

1.3 标签怎么定义，比模型选哪个更影响结果

这是我认为最该被强调、却最常被一笔带过的环节。

LOB 模型的输出通常是三分类：价格上涨、下跌、基本不变。这个“不变”的门槛怎么定，直接决定了任务难度。门槛设得太窄，绝大部分样本都会落进“不变”类，模型只要全预测这一类就能拿到很高的准确率，但毫无用处；门槛设得太宽，三类样本均衡了，但可预测性大幅下降。

常见的做法是：取未来 k 步的中间价均值，与当前中间价比较，涨跌超过阈值 α 记为涨/跌，否则记为不变。FI-2010 用的就是这种平滑标签，k 通常取 10 左右，α 与价格的最小变动单位挂钩。

这里有几个必须自己决定的细节：

• k 取多大。k 太小，标签基本是噪声，人的肉眼都看不出规律；k 太大，中间经历了太多不可观测的信息，模型学到的其实是长期趋势而不是订单簿的即时影响。实践里可以先从“几十毫秒到几秒”对应的步数开始试。
• α 怎么定。一种思路是绑定最小报价单位，另一种思路是按历史波动率设定动态阈值。前者简单但不同标的不通用，后者更合理但会引入额外参数。
• 是否用未来信息做归一化。如果你用全样本的均值和方差做标准化，实际上已经把未来信息泄漏进了训练集。这一点在 4.3 节会详细展开。

注意：标签定义一旦定下来，整个项目的所有实验都必须用同一套口径。中途改一次标签，之前所有的对比实验结果就全部作废，因为它们优化的根本不是同一个目标。

2. DeepLOB 为什么到今天还是一个绕不开的基线

如果把 LOB 建模的论文按引用量排个序，DeepLOB 大概率在前几名。它发表于 2019 年，结构并不复杂，但它的价值不在于“最强”，而在于它把一条完整的、可复现的流水线固定了下来：什么样的输入表示、什么样的卷积堆叠、什么样的输出头。后来者要证明自己的方案更好，最自然的做法就是先把它跑通作为参照。

2.1 拆开结构看，它做的事比名字朴素

DeepLOB 的整体结构可以概括为：三个卷积块负责把 100 × 40 的输入压缩，中间插入 Inception 模块做多尺度特征提取，然后接 LSTM，最后全连接加 softmax 输出三分类。

下面是一份简化后的结构示意，目的是让形状变化看得清楚，不追求与原论文逐层对齐：

python复制import torch
import torch.nn as nn

class InceptionBlock(nn.Module):
    """多尺度并行卷积，四路输出拼接"""
    def __init__(self, in_ch, out_ch=16):
        super().__init__()
        self.b1 = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, kernel_size=(1, 1)), nn.LeakyReLU(0.01))
        self.b2 = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, kernel_size=(1, 3), padding=(0, 1)), nn.LeakyReLU(0.01),
            nn.Conv2d(out_ch, out_ch, kernel_size=(3, 1), padding=(1, 0)), nn.LeakyReLU(0.01))
        self.b3 = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, kernel_size=(1, 5), padding=(0, 2)), nn.LeakyReLU(0.01),
            nn.Conv2d(out_ch, out_ch, kernel_size=(5, 1), padding=(2, 0)), nn.LeakyReLU(0.01))
        self.b4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.Conv2d(in_ch, out_ch, kernel_size=(1, 1)), nn.LeakyReLU(0.01))

    def forward(self, x):
        return torch.cat([self.b1(x), self.b2(x), self.b3(x), self.b4(x)], dim=1)


class DeepLOBSketch(nn.Module):
    def __init__(self, seq_len=100, n_feat=40, n_classes=3):
        super().__init__()
        # 输入: (B, 1, T, F)
        self.block1 = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=(1, 2), stride=(1, 2)), nn.LeakyReLU(0.01),
            nn.Conv2d(16, 16, kernel_size=(4, 1)), nn.LeakyReLU(0.01),
            nn.Conv2d(16, 16, kernel_size=(4, 1)), nn.LeakyReLU(0.01),
            InceptionBlock(16),
        )
        self.block2 = nn.Sequential(
            nn.Conv2d(64, 32, kernel_size=(4, 1)), nn.LeakyReLU(0.01),
            nn.Conv2d(32, 32, kernel_size=(4, 1)), nn.LeakyReLU(0.01),
            InceptionBlock(32),
        )
        self.lstm = nn.LSTM(input_size=128, hidden_size=64,
                            num_layers=1, batch_first=True)
        self.head = nn.Sequential(
            nn.Linear(64, 3), nn.Softmax(dim=-1))

    def forward(self, x):
        x = self.block2(self.block1(x))   # (B, C, T', F')
        x = x.permute(0, 3, 1, 2)         # (B, F', C, T')
        b, f, c, t = x.shape
        x = x.reshape(b, f, c * t)        # 以剩余档位为序列长度
        x, _ = self.lstm(x)
        return self.head(x[:, -1, :])

这段代码里最值得停下来看的一行是 permute(0, 3, 1, 2)。经过卷积之后，时间维已经被反复压缩，而重排之后的张量，序列长度对应的是剩余的价格档位，不是时间步。也就是说，在这个结构里，LSTM 是沿着“从买一到买十”的方向扫描的，时间维的信息已经被卷积编码进了特征维。

很多人复现时把这一步理解成“按时间做 LSTM”，结果形状对不上或者语义完全跑偏。这个细节恰恰说明了 DeepLOB 的设计取向：它认为订单簿的空间结构（档位之间的相对关系）比纯粹的时间顺序更值得用循环结构去刻画，时间上的局部形态则由前面的卷积负责。

2.2 卷积 + LSTM 的组合吃到了什么，又丢了什么

从工程角度看，这个组合有几个很实际的优点。

第一，参数量小。卷积的权重共享加上 LeakyReLU 这种轻量激活，整个模型通常在几十万参数级别。这意味着在只有几个月高频数据的场景下，它不容易立刻过拟合。

第二，对输入长度不敏感。因为是卷积先压缩，你可以把 T 从 100 改成 50 或者 200，只要调整最后的 reshape 逻辑，模型照样能跑。相比之下，纯 Transformer 对序列长度更敏感，位置编码需要重新设计。

第三，训练稳定。卷积加 LSTM 的组合收敛行为已经很成熟，学习率、批大小这些超参的容错空间比 Transformer 大。

但它也有明确的短板。卷积的感受野是局部的，即使堆叠多层，它能看到的“历史跨度”也是有限的。如果某类模式需要跨越几十上百个时间步才能显现（比如某个大挂单被逐步吃掉的过程），卷积加短 LSTM 很难完整捕捉。Transformer 的动机正是从这里来的：与其靠堆叠扩大感受野，不如直接让任意两个位置之间都能建立联系。

还有一点容易被忽略：DeepLOB 的输出是 softmax 三分类，它在优化的是交叉熵，而交易关心的往往是“预测正确时的收益能否覆盖预测错误时的损失”。这两件事并不等价，后面 5.2 节会展开。

2.3 复现时最容易翻车的三个地方

即便结构照抄，复现结果和论文对不上也是常态。按经验，问题通常集中在这三处。

第一处，输入缩放。 原论文对输入做了一个把数值压到 [-1, 1] 再乘以缩放因子的处理，很多人直接跳过这一步，用 StandardScaler 处理完就喂进去。问题在于 LOB 特征里有大量长尾分布（挂单量），标准化之后仍然会有极值，LeakyReLU 前面的卷积层很容易被这些极值带偏。更稳的做法是先做分位数截断（比如按 0.5% 和 99.5% 裁剪），再做标准化。

第二处，滑窗构造。 T=100 意味着每个样本要用 100 个连续快照。如果数据里有缺失的时间段（停牌、行情中断），简单的 rolling 会把断裂处两边的数据拼在一起，造出根本不存在的连续序列。正确做法是先按交易时段切分，在每个连续段内部做滑窗，跨段的地方丢弃。

第三处，样本划分。 这一点在下一节会展开，但先给结论：绝对不能用随机打乱的方式划分训练集和测试集。相邻样本之间有 99 个时间步是重叠的，随机划分等于把测试集的信息泄漏进训练集，准确率会虚高得离谱。

注意：如果看到某个复现报告的准确率明显高于同类工作，第一件该怀疑的事不是“他调参调得好”，而是“他的训练集和测试集是不是有重叠”。

3. Transformer 进入 LOB 的三种姿势，不要只会替换 LSTM

把 LSTM 换成 Transformer encoder 是最直觉的改法，但它不是唯一做法，也未必是最适合 LOB 的做法。目前能看到的三条技术路线，思路差别很大，选错了方向会比用 DeepLOB 更差。

3.1 把时间步当 token：最直接的改法

这是最容易被想到的方案：每个时间步的 40 维特征经过一个线性层投影成 d_model 维的向量，加上位置编码，送进标准的 Transformer encoder，最后取某个位置或做池化得到分类结果。

这条路线的代表作是 TransLOB 一类的方案。它的关键设计不在于 Transformer 本身，而在于卷积下采样 + 因果约束这两点。

为什么要先做卷积下采样？因为原始序列长度可能是几百甚至上千，标准注意力的计算量是序列长度的平方，直接全部送进去成本太高。用一维因果卷积先把序列压缩几倍，既降低了长度，又保留了局部形态的提取能力。

为什么必须强调因果？这是 LOB 建模里最容易出大错的地方。标准 Transformer encoder 的自注意力是双向的，每个位置都能看到序列中所有其他位置。在自然语言里这没问题，因为一句话是完整的；但在时间序列预测里，如果位置 t 能看到位置 t+5 的信息，而标签又是由 t 之后的价格决定的，那就是彻头彻尾的未来信息泄漏。模型在训练集上会表现得像开了挂，实盘一上就原形毕露。

所以正确做法是使用因果掩码（causal mask），保证位置 t 只能关注 t 及之前的位置。这个约束会让训练变慢、准确率变低，但它是必须付的代价。

python复制import math

def causal_mask(seq_len, device):
    """上三角为 -inf，保证位置 t 只能看到 <= t 的位置"""
    mask = torch.triu(torch.ones(seq_len, seq_len, device=device), diagonal=1)
    return mask.masked_fill(mask == 1, float('-inf'))


class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=2048):
        super().__init__()
        pe = torch.zeros(max_len, d_model)
        pos = torch.arange(0, max_len).unsqueeze(1).float()
        div = torch.exp(torch.arange(0, d_model, 2).float()
                        * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(pos * div)
        pe[:, 1::2] = torch.cos(pos * div)
        self.register_buffer('pe', pe.unsqueeze(0))

    def forward(self, x):
        return x + self.pe[:, :x.size(1)]

这段位置编码是标准正弦形式。在 LOB 场景下还有一个额外考虑：时间步之间的间隔并不均匀。行情活跃时一秒可能有几十条更新，清淡时可能几秒才一条。如果直接用步数做位置编码，模型会误以为两个相邻步之间的时间距离是一样的。更严谨的做法是把真实时间差作为额外特征，或者用可学习的时间衰减。

3.2 把价格档位当 token：分档注意力与轴向注意力

这条路线更有意思，也更贴合 LOB 的数据结构。

既然订单簿天生是二维的（时间 × 档位），那为什么不用二维的注意力？轴向注意力（axial attention）的思路是：先沿着时间维做一次注意力，再沿着档位维做一次注意力，把二维注意力的 O((T·F)²) 复杂度降到 O(T²·F + F²·T)。在 T=100, F=40 这种规模下，这个降幅是数量级的。

Axial-LOB 这类工作正是基于这个想法，把订单簿当作图像处理，但用轴向注意力替代卷积，从而在保持参数量的同时获得全局感受野。

这条路线的优势在于，它显式承认了“时间”和“档位”是两个语义不同的维度。你可以给时间维加因果掩码，而档位维不加——因为买一和卖十之间不存在时间先后，它们在同一时刻同时可见。这种维度级别的差异化处理，是纯序列模型做不到的。

代价是实现复杂度上升。你需要自己管理两种掩码、两种位置编码，调试成本明显高于直接套用 nn.TransformerEncoder。

3.3 把整张簿当图像：patch 化的代价

第三条是 ViT 式的做法：把 100 × 40 的矩阵切成若干 patch，每个 patch 展平后投影成 token，走标准 Transformer。

这种做法在计算机视觉里很成功，但搬到 LOB 上要谨慎。视觉图像里相邻像素的语义是连续的，而 LOB 矩阵里“时间相邻”和“档位相邻”的语义差别很大。如果按正方形切 patch，一个 patch 里可能同时包含时间上前后的信息和档位上下的信息，语义被混在一起。

更合理的切法是长条 patch：沿时间维切成长度为 p 、宽度覆盖全部档位的条带，这样每个 token 代表一个时间段内的完整订单簿形态。这样切出来的序列长度是 T/p，既保留了每个时刻的完整横截面，又缩短了序列。

三选一没有标准答案。如果数据量只有几个月、算力有限，我更建议从“时间步 token + 因果卷积下采样”起步，因为它最接近成熟方案，出问题时也最容易定位。轴向注意力留给数据量充足、且已经确认瓶颈在“档位间长程关系”的场景。

4. 数据管线才是分水岭：对齐、归一化、切分

前面三节讨论的都是模型，但实际项目里，模型代码可能只占全部工作量的两成。剩下八成里，数据管线的坑最深，而且一旦出错，往往不会报错，只会让你的实验结果莫名其妙地好或者莫名其妙地差。

4.1 时间戳对齐里藏着的泄漏

LOB 数据通常有两种时间戳：交易所撮合时间（exchange timestamp）和本地接收时间（local timestamp）。两者之间可能有几十毫秒的差，在网络抖动的时候差异更大。

用哪个？如果目标是研究“订单簿形态与未来价格的关系”，用撮合时间是合理的；如果目标是评估“我在本地能看到信息之后能赚多少”，必须用本地接收时间，因为撮合时间在实盘里是不可提前获得的。

这个选择听起来只是换一列，但它直接决定了你的模型是否在用未来信息。更隐蔽的问题是快照重建。如果你的数据源给的是逐笔消息，需要自己重放出每个时间点的订单簿状态，那么重放逻辑必须严格按消息序号处理，不能按时间戳排序后处理——同一毫秒内可能有多条消息，顺序错了，订单簿状态就错了。

一个实用的检查方法：随机抽若干个时间点，用重放出来的订单簿和交易所公布的快照做比对，如果买卖一档对不上，说明重放逻辑有问题。这个校验步骤值得写进流水线，每次数据更新都跑一遍。

4.2 归一化不是可选项，而是模型能不能收敛的前提

前面提过分位数截断加标准化的组合，这里展开讲讲为什么。

LOB 特征的分布是典型的重尾分布。挂单量在绝大多数时刻集中在某个区间，但偶尔会出现一个比均值大几百倍的巨单。如果直接做 z-score 标准化，这个巨单会把该维度的标准差撑大，导致其余 99% 的样本标准化后全部挤在 0 附近，模型的梯度几乎不动。

处理顺序建议是：

1. 按训练集统计分位数阈值（比如 0.5% 和 99.5%），对全部数据做截断。
2. 用截断后的训练集统计均值和标准差。
3. 对训练、验证、测试集应用同一组参数。

第三步是关键。统计量必须只来自训练集。如果用了全样本的统计量，测试集的分布信息就泄漏进去了，虽然影响比标签泄漏小，但在高频数据上依然会让指标虚高。

还有一个细节：价格类特征和数量类特征的归一化方式应该不同。价格更适合用“相对中间价的差值”，数量更适合用“对数变换后再标准化”。把两者混在一起用同一套处理，模型很难学好。

4.3 训练/验证/测试怎么切才算诚实

这是我认为整个项目里最需要坚持原则的地方。

高频数据的时间相关性极强。相邻两个样本的输入窗口有 99 个时间步重叠，标签也高度相关。如果随机划分，训练集里的样本和测试集里的样本几乎是同一段行情的不同切片，模型只要记住这段行情的特征就能拿高分。

正确的做法是按时间顺序切分：用前面的时间段训练，中间一段验证，最后一段测试。而且要留出隔离带（embargo），即在训练集结束和验证集开始之间丢弃一段数据，长度至少等于标签的前视窗口，避免训练集最后一个样本的标签用到了验证集开头的信息。

python复制def time_split(n_samples, train_ratio=0.6, val_ratio=0.2, embargo=50):
    """按时间顺序切分，并在段与段之间留隔离带"""
    train_end = int(n_samples * train_ratio)
    val_end = int(n_samples * (train_ratio + val_ratio))
    train_idx = range(0, train_end)
    val_idx = range(train_end + embargo, val_end)
    test_idx = range(val_end + embargo, n_samples)
    return list(train_idx), list(val_idx), list(test_idx)

注意隔离带要加两次，训练/验证之间一次，验证/测试之间一次。embargo 的取值应该大于等于标签所用的前视步数，保守一点可以取它的两三倍。

比单次划分更严谨的做法是滚动前推验证（walk-forward validation）：用第 1 个月训练、第 2 个月验证，再用第 1-2 个月训练、第 3 个月验证，依次类推。这样能看出模型在不同市场环境下的稳定性，也能暴露“只在某一段行情里有效”的问题。

注意：如果换了切分方式之后模型效果从“很好”掉到“一般”，不要急着怀疑模型。更可能是之前的切分方式在作弊，现在的结果才是真实水平。

5. 训练和评估：指标好看和能不能用是两件事

模型能跑通只是第一步。真正决定这个方案有没有价值的，是你能不能诚实地评估它，以及你能不能解释它的失败。

5.1 损失函数与类别不平衡

三分类任务在 LOB 上几乎必然遇到类别不平衡。“不变”类通常占大头，尤其是在阈值设得比较窄的时候。用标准交叉熵训练，模型会倾向于把大部分样本判成多数类。

几种常见的应对方式，各有代价：

• 类别加权：给少数类更大的损失权重。实现简单，但权重过大会让模型对噪声过度敏感，把随机波动判成涨跌。
• 重采样：对少数类过采样。在时间序列上要小心，简单的随机复制会加剧过拟合，因为复制出来的样本和原样本在时间上完全重叠。
• 调整阈值：训练时不改损失，推理时根据验证集调整判定阈值。这种方式最灵活，也最贴近实际使用，因为实盘里你本来就可以选择只在置信度高的时候出手。

我更推荐第三种。原因很实际：交易决策本身就是一个带阈值的动作，模型输出概率，你决定在什么概率以上才行动。把这个阈值当成一个可调参数，比强行让模型输出均衡的三分类更有意义。

5.2 评估口径：从准确率走到经济含义

准确率是最容易看、也最容易骗人的指标。一个把所有样本判成“不变”的模型，在 70% 样本属于不变类时能拿到 70% 的准确率，但它一分钱也赚不到。

更有参考价值的指标有几个层次：

第一层，混淆矩阵和每一类的精确率/召回率。 特别要看“涨”和“跌”两类的召回率，如果其中一类接近 0，说明模型根本没学会区分方向。

第二层，马修斯相关系数（MCC）。 它对类别不平衡不敏感，取值在 -1 到 1 之间，0 表示和随机猜没区别。在多分类不平衡场景下，它比准确率和 F1 都更可靠。

第三层，经济指标。 把模型信号转成简单的持仓规则：预测涨则持多，预测跌则持空或空仓，扣除一个合理的手续费和滑点假设，看累计收益和最大回撤。这一步不需要多精确，目的是检验信号是否还有残余价值。

这里必须说清楚边界：回测结果不等于实盘结果。高频场景下的滑点、排队位置、撮合概率，都是回测里难以准确建模的。任何回测数字都应该被当作“上界估计”，而不是“预期收益”。

5.3 一个容易被忽略的对照实验

在把模型效果归因于“Transformer 比 LSTM 强”之前，至少要做三个对照：

1. 随机标签对照：把训练集的标签随机打乱后重新训练。如果模型在测试集上仍然表现不错，说明数据管线有泄漏。
2. 打乱时间顺序对照：把输入序列的时间顺序随机打乱，如果效果没明显下降，说明模型根本没在利用时间结构。
3. 只用一档特征对照：只保留买一卖一的价格和量，看效果下降多少。如果几乎不降，说明后面九档的信息在你这个任务上基本没用，可以大幅简化模型。

这三个实验花不了多少时间，但能帮你排除掉绝大部分“假阳性”结果。尤其是第一个，它是检验数据泄漏最直接的手段。

6. 一条可执行的落地路径和它的边界

讲到这里，方法论已经铺开了。最后给一条从零开始的路径，以及它的适用边界。

6.1 最小可行实验：三天内能跑通什么

我建议的顺序是“先窄后宽”，不要一上来就拼多模型集成。

第一步，搭一条最小数据管线。 取一个标的、一段连续行情，重放出 10 档订单簿快照，构造相对特征，做分位数截断和标准化。产物是一个 (N, T, 40) 的数组和对应的标签。这一步的目标不是完美，而是可复现——同样的输入，跑两次得到同样的输出。

第二步，跑通 DeepLOB 基线。 用前面的结构示意，先把 T=100、三分类跑通。不要调参，就用默认设置，看 loss 是否下降、验证集 MCC 是否明显大于 0。如果 MCC 接近 0，先回去检查数据管线，不要改模型。

第三步，做一次诚实的切分。 换成按时间切分加隔离带，重新训练。这时候指标大概率会下降，这是正常的，下降后的数字才是基准线。

第四步，再上 Transformer。 用因果卷积下采样加因果掩码 encoder，其余设置保持一致。只有在同一套数据、同一套切分、同一套评估下，两者的对比才有意义。

python复制# 最小实验的主循环骨架
for epoch in range(num_epochs):
    model.train()
    for xb, yb in train_loader:          # xb: (B, 1, T, 40)
        xb, yb = xb.to(device), yb.to(device)
        logits = model(xb)
        loss = criterion(logits, yb)
        optimizer.zero_grad()
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()

    model.eval()
    with torch.no_grad():
        val_metrics = evaluate(model, val_loader)
    # 以 MCC 而非 accuracy 作为早停依据
    if val_metrics['mcc'] > best_mcc:
        best_mcc = val_metrics['mcc']
        torch.save(model.state_dict(), 'best.pt')

这段骨架里有两个值得注意的细节：梯度裁剪，因为 LOB 输入里偶尔会有极端值导致梯度爆炸；以及以 MCC 而非 accuracy 做早停，理由前面说过了。

6.2 排查链路：结果不对时按这个顺序看

模型表现异常时，按下面的顺序排查，能省掉大量盲目调参的时间。

这张表不是万能的，但覆盖了大部分常见情况。核心思路是：先排除数据问题，再怀疑模型问题。经验上，十次“模型效果不好”里有六到七次根子在数据。

6.3 这套方案的适用边界

最后必须说清楚，这套方法能做什么、不能做什么。

适合的场景：有稳定的 Level-2 数据源、能自己重放订单簿、研究目标明确（比如做短周期方向判断或者作为多因子体系里的一个信号源）、有足够的算力做滚动验证。

不适合的场景：数据只有日频或分钟频 K 线（信息量根本不够，硬套 LOB 模型没有意义）；没有能力做严格的时间切分和泄漏检查；期望模型直接给出交易指令而不经过任何人工审核。

需要额外补的工程能力：如果要把这套东西长期跑下去，至少还需要补上模型版本管理、特征计算的一致性校验（训练和推理必须用同一份代码）、异常输入的保护（行情中断、数据源切换）、以及模型退化监控（在线 MCC 或命中率持续下降时告警）。

还有一点值得单独强调：这类模型学到的往往是统计相关性，不是市场机制。它可能在特定流动性环境下表现良好，但在市场结构发生变化（比如某类参与者退出、交易规则调整）后迅速失效。所以滚动重训和持续监控不是可选项，而是这个方案能长期存活的前提。

如果只能记住一句话，我希望是这句：LOB 建模的胜负手，不在 DeepLOB 还是 Transformer，而在你有没有一条能被反复验证、不会偷偷泄漏未来信息的数据管线。 模型结构可以换，超参可以调，但一条不诚实的数据管线，会让你所有的努力都建立在流沙上。先把切分做对，把归一化做对，把标签定义钉死，再去比较那两个网络——顺序反了，比较出来的结论也站不住。