Model Pruning for Low-Latency Trading Inference

我們的 DeepLOB 文章在部署一節結尾列出了三個要點——ONNX 加 TensorRT、INT8 量化、FPGA——卻沒有處理其中任何一項。本文要補上的，是這三者背後共同的第一個問題：模型比實際需要的更大。神經網路剪枝會移除冗餘參數，而文獻中真正有趣的主張並不是它能節省記憶體，而是只保留 10–20% 權重的子網路，仍可能達到密集模型的準確率。

延遲是否重要，本博客已經做過論證——訊息傳遞路徑上的 ZigBolt，以及用盈虧平衡算式說明的 IPC 稅——而價差建模也已經處理了快但略差與慢但更好的取捨，其中還有一張包含推論延遲欄位的梯度提升與深度學習比較表。但它們都沒有說明如何縮小一個既定模型。在報價迴圈的各個階段中，模型推論是我們完全能控制的一環；傳輸路徑則已在演算法交易的資料通訊中以可重現的 p50/p95/p99 數字處理。

**本文是什麼：**將幅度剪枝、結構化剪枝、迭代幅度剪枝、移動剪枝、知識蒸餾和 NVIDIA 2:4 半結構化稀疏性應用於交易 MLP 的數學與可執行程式碼。

**本文不是什麼：**已測量的結果。本博客的每篇實證文章都帶有溯源說明或配套儲存庫，而本文目前兩者皆無。下文的稀疏性—準確率—延遲曲線，是待執行的實驗，不是可以引用的表格。請把這裡的一切視為方法，數字則仍待取得。

剪枝能帶來什麼

限制因素首先是尺寸。考慮一個中頻模型——在訂單簿特徵上使用 4 層 MLP，每個隱藏層有 2048 個單元：

當 $d_{\text{in}} = 100$、$h = 2048$、$L = 4$、$d_{\text{out}} = 3$ 時，約有 1,260 萬個參數——以 float32 儲存約 48 MB。L2 通常只有 1–4 MB，因此權重放不進去；每次 forward pass 都必須從更遠的記憶體串流進來。剪掉其中 95% 後，約剩 630K 個有效參數、2.4 MB，這就能放入 L2。

這是否能轉化為實際時鐘時間，取決於核心運算是受記憶體限制還是受計算限制；這是算術強度問題，而不只是尺寸問題。回測引擎速度階梯透過一個測量案例演示了 Williams、Waterman 與 Patterson 的 roofline 模型，而不是武斷宣稱懲罰因子；這裡也適用同樣的框架和紀律：在宣稱加速之前，先測量搬移了多少位元組。

剪枝基礎

非結構化剪枝

最簡單的方法：依照幅度將單個權重設為零。給定權重矩陣 $\mathbf{W} \in \mathbb{R}^{m \times n}$，建立二元遮罩 $\mathbf{M} \in \{0, 1\}^{m \times n}$：

其中 $\tau$ 是為達到目標稀疏程度 $s$ 而選取的閾值：

剪枝後的矩陣是 $\mathbf{W}' = \mathbf{W} \odot \mathbf{M}$，其中 $\odot$ 表示 Hadamard 積。直覺上，接近零的權重對該層輸出的貢獻很小。

**把問題直白說清楚，因為稀疏數字很容易被誤讀：**非結構化稀疏性不會在標準硬體上轉化為加速。即使矩陣有 90% 的零，除非切換到稀疏核心或支援稀疏性的硬體，仍然會發出相同數量的乘加運算。當下方程式列印 Sparsity: 90.0% 時，那是零值的計數——不是任何 10 倍，更不是在密集 CPU GEMM 上的 1.01 倍。真正能節省時間的路徑是結構化剪枝（更小的矩陣）和 2:4 半結構化稀疏性（硬體支援），下文會介紹。

結構化剪枝

結構化剪枝會移除整個神經元、通道或注意力頭。對於線性層 $\mathbf{y} = \mathbf{W}\mathbf{x} + \mathbf{b}$，其中 $\mathbf{W} \in \mathbb{R}^{m \times n}$，移除神經元 $j$ 會將第 $j$ 行的 $\mathbf{W}$ 和第 $j$ 個元素的 $\mathbf{b}$ 歸零：

先移除 $\ell_2$ 範數最小的神經元。這是能產生真正更小矩陣的變體——但前提是你真的重建各層。把行歸零而保留原始張量形狀，不會改變 FLOP 數量；實作一節中的重建步驟，才會把遮罩轉換成 $512 \times n$ 矩陣。

對卷積層而言，對應做法是濾波器剪枝。給定 $\mathbf{W} \in \mathbb{R}^{C_{\text{out}} \times C_{\text{in}} \times k \times k}$，輸出濾波器 $i$ 的重要性為：

移除濾波器 $i$ 就會刪除整個輸出通道，按比例降低 FLOP。

彩票假說

2019 年，Frankle 和 Carbin 提出了彩票假說（Lottery Ticket Hypothesis，LTH）：隨機初始化的密集網路中存在一個稀疏子網路——一張「獲勝彩票」——從原始初始化開始訓練後，能在相近的迭代次數內達到完整網路的準確率。

形式化地說，考慮 $f(\mathbf{x}; \boldsymbol{\theta}_0)$，其初始化為 $\boldsymbol{\theta}_0 \sim \mathcal{D}_\theta$。訓練收斂後得到 $\boldsymbol{\theta}^*$，並推導出剪枝遮罩 $\mathbf{m}$。LTH 表示存在某個 $\mathbf{m}$，使得：

且 $\|\mathbf{m}\|_0 \ll |\boldsymbol{\theta}_0|$。最初的實驗在 MNIST 和 CIFAR-10 上進行，獲勝彩票保留了 10–20% 的參數。這些結果不能在沒有假設的情況下轉移到訂單簿資料——LOB 特徵非平穩，標籤幾乎是噪聲；這與影像分類處於不同狀態，而這種差異恰好可能很重要。

迭代幅度剪枝（IMP）

透過 IMP 找到這張彩票：

1. 使用 $\boldsymbol{\theta}_0$ 初始化網路。
2. 訓練至收斂，得到 $\boldsymbol{\theta}^*$。
3. 剪掉幅度最小的 $p\%$ 權重，建立遮罩 $\mathbf{m}$。
4. 將倖存權重重設為它們在 $\boldsymbol{\theta}_0$ 中的值（回溯初始化）。
5. 從第 2 步開始，在帶遮罩的網路上重複。

每一輪剪掉比例為 $p$ 的權重（通常為 20%），因此 $n$ 輪後會保留 $(1-p)^n$ 的參數。當 $p = 0.2$、執行 10 輪後，大約還剩 10.7%。

關於交易模型的三個假說，沒有一個經過測試

很容易主張 LTH 應該特別適合市場資料。這類論證有三個；三者都是假說，把它們說成事實，正是本博客要避免的失效模式。

1. **金融訊號是稀疏的。**訂單簿快照的大部分是噪聲，因此稀疏子網路可能天然與稀疏訊號對齊。可測試：將 IMP 與相同稀疏度的隨機遮罩比較；如果真正起作用的是稀疏性本身，隨機遮罩不應落後太多。
2. **獲勝彩票能跨市場狀態泛化。**這是關於市場的實證主張，背後沒有引用，也是三者中最有趣的一個。可以直接用使用 HMM 進行市場狀態偵測的狀態標籤來測試：在狀態 A 找到彩票，在狀態 B 重新訓練，並與在 B 中原生找到的彩票比較。
3. **稀疏性具有正則化作用。**較低的有效容量可能減少對微觀結構噪聲的擬合——這應表現為剪枝模型的樣本外差距小於密集模型，而不只是相當。

實作：剪枝交易 MLP

基礎模型

import torch
import torch.nn as nn
import torch.nn.utils.prune as prune
from copy import deepcopy

class TradingMLP(nn.Module):
    """MLP for mid-price direction prediction from order book features."""
    def __init__(self, input_dim=100, hidden_dim=2048,
                 num_layers=4, output_dim=3):
        super().__init__()
        layers = []
        dims = [input_dim] + [hidden_dim] * (num_layers - 1) + [output_dim]
        for i in range(len(dims) - 1):
            layers.append(nn.Linear(dims[i], dims[i + 1]))
            if i < len(dims) - 2:
                layers.append(nn.BatchNorm1d(dims[i + 1]))
                layers.append(nn.ReLU())
                layers.append(nn.Dropout(0.1))
        self.network = nn.Sequential(*layers)

    def forward(self, x):
        return self.network(x)

    def count_parameters(self):
        return sum(p.numel() for p in self.parameters())

model = TradingMLP(input_dim=100, hidden_dim=2048,
                   num_layers=4, output_dim=3)
print(f"Total parameters: {model.count_parameters():,}")

非結構化幅度剪枝

def apply_unstructured_pruning(model, sparsity=0.9):
    """Apply global unstructured L1 pruning to all Linear layers."""
    parameters_to_prune = []
    for name, module in model.named_modules():
        if isinstance(module, nn.Linear):
            parameters_to_prune.append((module, 'weight'))

    prune.global_unstructured(
        parameters_to_prune,
        pruning_method=prune.L1Unstructured,
        amount=sparsity,
    )
    return model

def compute_sparsity(model):
    """Fraction of zero weights. Note: a *count*, not a speedup."""
    total, zeros = 0, 0
    for name, param in model.named_parameters():
        if 'weight' in name:
            total += param.numel()
            zeros += (param == 0).sum().item()
    return zeros / total if total > 0 else 0

pruned_model = apply_unstructured_pruning(deepcopy(model), sparsity=0.9)
print(f"Sparsity: {compute_sparsity(pruned_model):.1%}")

結構化剪枝，以及讓它真正生效的重建

遮罩行只是工作的一半。真正產生加速的另一半，是將每一層重建為縮小後的形狀——這意味著要把移除向前傳播：移除第 $j$ 行（屬於第 $i$ 層），也要移除第 $j$ 列（屬於第 $i+1$ 層），以及兩者之間任何 BatchNorm1d 的第 $j$ 個通道。

def apply_structured_pruning(model, fraction=0.75):
    """Mask entire neurons by L2-norm of their weight rows."""
    for name, module in model.named_modules():
        if isinstance(module, nn.Linear) and module.out_features > 10:
            prune.ln_structured(
                module, name='weight', amount=fraction, n=2, dim=0
            )
    return model

def rebuild_pruned_mlp(model):
    """
    Physically shrink a structurally pruned TradingMLP.

    Walks the Sequential once. For each Linear: drop the input columns
    the previous layer no longer emits, then drop its own dead output
    rows. BatchNorm1d channels follow the preceding Linear's survivors.
    """
    new_layers = []
    keep_in = None  # surviving output indices of the previous Linear

    for layer in model.network:
        if isinstance(layer, nn.Linear):
            if prune.is_pruned(layer):
                prune.remove(layer, 'weight')

            W, b = layer.weight.data, layer.bias.data
            keep_out = (W.norm(dim=1) > 0).nonzero(as_tuple=True)[0]
            W = W[keep_out]
            if keep_in is not None:
                W = W[:, keep_in]

            new = nn.Linear(W.shape[1], W.shape[0])
            new.weight.data = W.clone()
            new.bias.data = b[keep_out].clone()
            new_layers.append(new)
            keep_in = keep_out

        elif isinstance(layer, nn.BatchNorm1d):
            new = nn.BatchNorm1d(len(keep_in))
            new.weight.data = layer.weight.data[keep_in].clone()
            new.bias.data = layer.bias.data[keep_in].clone()
            new.running_mean = layer.running_mean[keep_in].clone()
            new.running_var = layer.running_var[keep_in].clone()
            new.num_batches_tracked = layer.num_batches_tracked.clone()
            new_layers.append(new)

        else:  # ReLU, Dropout -- shape-agnostic, reuse as is
            new_layers.append(layer)

    rebuilt = deepcopy(model)
    rebuilt.network = nn.Sequential(*new_layers)
    return rebuilt

在信任这段程式碼之前，按照本博客其餘部分所使用的等價性閘門精神，要檢查兩件事：

• 形狀。rebuilt 應顯示隱藏層維度為 $(1 - \text{fraction}) \cdot h$——當 fraction=0.75、$h = 2048$ 時為 512——參數數量則應呈二次下降，因為內部矩陣的兩個維度都縮小了。
• **輸出。**在 eval() 模式下，對同一批資料，rebuilt(x) 必須在浮點容差內匹配未重建的遮罩模型輸出。如果不匹配，表示列傳播有誤；之後的每個數字測量的都會是與你想像不同的模型。

行存活測試假設被遮罩的行恰好為零，而存活行不為零。對 ln_structured 的輸出而言這成立；如果其他程序產生了一個真正全零的存活神經元，則不會成立。因此，應針對要求的比例斷言存活數量，而不是盲目信任範數測試。

迭代幅度剪枝（彩票搜尋）

def lottery_ticket_search(model_cls, model_kwargs, train_fn, eval_fn,
                          rounds=10, prune_rate=0.2, device='cpu'):
    """
    Iterative Magnitude Pruning to find a winning ticket.

    Parameters
    ----------
    model_cls : class -- model constructor
    model_kwargs : dict -- constructor arguments
    train_fn : callable -- train_fn(model) trains the model in-place
    eval_fn : callable -- eval_fn(model) returns out-of-sample accuracy
    rounds : int -- number of pruning rounds
    prune_rate : float -- fraction of surviving weights pruned per round
    """
    model_init = model_cls(**model_kwargs).to(device)
    theta_0 = deepcopy(model_init.state_dict())

    mask = {}
    for name, param in model_init.named_parameters():
        if 'weight' in name:
            mask[name] = torch.ones_like(param, dtype=torch.bool)

    results = []

    for round_idx in range(rounds):
        model = model_cls(**model_kwargs).to(device)
        state = deepcopy(theta_0)
        for name in mask:
            state[name] = state[name] * mask[name].float()
        model.load_state_dict(state)

        train_fn(model)

        acc = eval_fn(model)
        surviving = sum(m.sum().item() for m in mask.values())
        total = sum(m.numel() for m in mask.values())
        sparsity = 1.0 - surviving / total

        results.append({
            'round': round_idx,
            'accuracy': acc,
            'sparsity': sparsity,
            'surviving_params': int(surviving)
        })
        print(f"Round {round_idx}: acc={acc:.4f}, "
              f"sparsity={sparsity:.1%}")

        all_weights = []
        for name, param in model.named_parameters():
            if name in mask:
                alive = param.data.abs()[mask[name]]
                all_weights.append(alive.flatten())

        all_weights = torch.cat(all_weights)
        k = int(len(all_weights) * prune_rate)
        if k == 0:
            break
        threshold = all_weights.kthvalue(k).values.item()

        for name, param in model.named_parameters():
            if name in mask:
                mask[name] = mask[name] & (
                    param.data.abs() >= threshold
                )

    return results, mask

results 是本文所欠缺的稀疏性—準確率曲線的原始材料。eval_fn 必須真正使用樣本外資料，並在清除重疊的切分上執行——在樣本內對 IMP 執行評分，會得到一條漂亮但毫無意義的曲線。

測量它

延遲使用與本博客其餘部分相同的測試工具慣例來測量——不計入 warmup，取 N 次中的最佳結果，報告 p50/p95/p99 而不是平均值；這套協定及其程式碼見Polars 對比 pandas。有三點是剪枝特有的：

• 基準測試應使用重建後的模型，而不是帶遮罩的模型。batch size 為 1 的帶遮罩模型，測量的仍是密集形狀。
• 報告 batch size。Batch 1（報價迴圈）與 batch 256（研究掃描）位於記憶體受限/計算受限分界線的不同側，剪枝對它們的幫助也不同。
• 在相同切分、相同 horizon 下，以明確的標籤定義報告準確率。沒有相應準確率欄位的延遲表，等同於主張乾脆刪掉整個模型。

進階技術

使用知識蒸餾剪枝

不要孤立地進行剪枝和微調，而應把原始密集模型當作教師。剪枝後的學生模型最小化任務損失與教師輸出分布的 KL 散度之和：

其中 $\mathbf{z}_t$ 和 $\mathbf{z}_s$ 分別是教師和學生的 logits，$T$ 是溫度，$\alpha$ 用來平衡兩個目標。$T^2$ 因子會重新縮放蒸餾梯度，否則梯度會按 $1/T^2$ 縮小。

def distillation_loss(student_logits, teacher_logits, labels,
                      temperature=3.0, alpha=0.5):
    """Combined task + distillation loss."""
    task_loss = nn.CrossEntropyLoss()(student_logits, labels)

    soft_student = nn.functional.log_softmax(
        student_logits / temperature, dim=-1
    )
    soft_teacher = nn.functional.softmax(
        teacher_logits / temperature, dim=-1
    )
    kd_loss = nn.functional.kl_div(
        soft_student, soft_teacher, reduction='batchmean'
    )

    return (1 - alpha) * task_loss + alpha * (temperature ** 2) * kd_loss

移動剪枝

移動剪枝不是按絕對幅度剪枝，而是剪掉訓練過程中正向零移動的權重（Sanh 等，2020）。重要性分數累積梯度與權重的乘積：

分數為負的權重會被剪掉。相較於幅度剪枝，它的論據專門針對微調：當你調整預訓練模型時，幅度分布已經受到預訓練任務塑造，因此幅度是過時的重要性訊號，而移動方向是更新鮮的訊號。對於在滾動窗口上重新訓練的交易模型，這比從頭訓練更常見。

NVIDIA 2:4 結構化稀疏性

Ampere 及其後續 NVIDIA GPU 在硬體中支援 2:4 結構化稀疏性：每 4 個連續權重中，恰好 2 個必須為零。

這是硬體真正會獎勵的唯一一種細粒度稀疏形式，因此它比非結構化剪枝中「90% 為零」的數字更重要。這個限制是局部而非全域的——它不在乎每四個權重中哪兩個存活——因此比固定一個全域遮罩弱得多，但 50% 是唯一可用的稀疏程度。

from torch.ao.pruning import WeightNormSparsifier

sparsifier = WeightNormSparsifier(
    sparsity_level=0.5,
    sparse_block_shape=(1, 4),
    zeros_per_block=2,
)

sparsifier.prepare(
    model, config=[{"tensor_fqn": "network.0.weight"}]
)
sparsifier.step()
sparsifier.squash_mask()

要實現加速，推論路徑必須使用稀疏張量核心——匯出 ONNX 再建立 TensorRT，或使用 torch.sparse.to_sparse_semi_structured。把 2:4 遮罩模型透過密集執行環境匯出，只會付出準確率代價，得不到任何收益。

生產部署

驗證

剪枝模型是一個新模型，而不是壓縮過的舊模型；它要像其他候選模型一樣，通過滾動前向最佳化所要求的滾動重訓練和樣本外重新驗證，並套用去膨脹夏普比率的選擇效應校正。這項校正不可省略——IMP 會生成一系列候選模型，因此在十輪中看起來最好的稀疏程度，是在搜尋過程中選出的，其夏普比率需要按有效試驗次數去膨脹。一條「夏普下降超過 5% 就拒絕」的平面規則經不起這種算術，這也是本文不會提出這種規則的原因。

量化堆疊

剪枝可以與量化組合。一個 90% 稀疏並量化至 INT8 的模型，其壓縮比為：

一個 48 MB 的模型會變成 1.2 MB。這只是儲存方面的主張，沒有更多含義。1.2 MB 模型是否做出相同決策，是另一個需要獨立回答的問題；GPU 精度陷阱正是我們必須提出這個問題的原因：在本博客中，fp32 已被證明會在一次看起來完全合理的回測計算中產生 211 的相對誤差。INT8 是比這更激進的縮減。只有在相對於 fp32 密集模型的量化一致性閘門有量化結果後，才應部署量化加剪枝模型——要看留出期間的決策一致率和 PnL 差異，而不是口頭保證。

監控

剪枝模型可能對分布漂移更敏感。值得監控的項目包括：

• 啟動稀疏性：如果存活神經元大多輸出零，有效模型比預期更小，而且可能正在退化。
• 重訓練期間的梯度範數：梯度爆炸表示存活子網路被要求過度補償已移除的部分。
• 預測熵：如果剪枝模型在噪聲很大的微觀結構資料上變得過度自信，很可能是在擬合訓練狀態。

結論

這些方法都已相當成熟；在掃描完成之前，本文只主張到這裡。非結構化剪枝給你一個稀疏數字，卻不帶來速度。結構化剪枝只有在重建各層、而不是只加遮罩時，才會帶來速度。彩票假說表示緊湊模型或許已存在於過度參數化模型中，但目前它只在影像基準上得到驗證，並未在訂單簿資料上驗證；上文提出的三個「應該」適用於市場資料的理由，也都是附帶實驗的假說，而非研究發現。

文獻給出的實務啟發法，是先訓練大型模型再逐步剪小，而不是一開始就設計小模型：大型模型能更有效探索損失景觀，剪枝則保留真正重要的路徑。這是否對交易模型成立、在什麼稀疏程度成立，以及要付出多少準確率代價，只差一次 IMP 掃描就能回答——而完成掃描、得到數字後，應該重新閱讀本文。