DeepLOB: Pembelajaran Mendalam pada Limit Order Book

Limit order book ialah struktur data pusat bagi pasaran elektronik moden. Setiap bid, setiap ask, setiap pembatalan — kesemuanya hidup dalam LOB. Selama berdekad-dekad, penyelidik kuantitatif telah membina ciri secara manual daripada data ini: nisbah ketidakseimbangan order, harga tengah berwajaran, isyarat kedudukan baris gilir. DeepLOB mengambil laluan yang berbeza — ia mempelajari ciri-ciri ini secara langsung daripada snapshot order book mentah menggunakan seni bina hibrid CNN-LSTM.

Diterbitkan oleh Zhang, Zohren, dan Roberts di Oxford-Man Institute pada tahun 2019, DeepLOB menunjukkan bahawa satu rangkaian mendalam tunggal, dilatih hujung-ke-hujung pada data book mentah, adalah berdaya saing dengan atau lebih baik daripada garis dasar klasik yang kukuh dalam peramalan pergerakan harga tengah. Walau bagaimanapun, kita perlu tepat tentang bukti tersebut. Set data penanda aras FI-2010 ialah yang paling banyak dipetik oleh kebanyakan kertas kerja, tetapi penulisnya sendiri memanggilnya tidak mencukupi — "terlalu pendek, dikecilkan sampelnya dan diambil daripada pasaran yang kurang cair" — dan membentangkan penilaian kedua yang jauh lebih besar pada data London Stock Exchange (LSE) sebagai hasil mereka yang lebih kukuh. Kajian LSE itu merangkumi kira-kira satu tahun bagi lima saham latihan dan lima saham ujian, dalam susunan 100M+ sampel, dan menunjukkan transfer learning: model yang dilatih pada satu set saham masih meramal pada saham yang tidak pernah dilihat. Hasil pemindahan itu, bukan papan pendahulu FI-2010, ialah tajuk sebenar kertas kerja tersebut. Catatan ini membedah seni bina, matematik, angka sebenar, dan pelaksanaan semula PyTorch yang berfungsi.

Limit Order Book sebagai Struktur Data

Sebuah limit order book mengekalkan dua senarai terisih — bid (order beli) dan ask (order jual) — masing-masing diatur mengikut aras harga. Pada setiap aras, book merekodkan harga dan volum agregat order yang menunggu.

Bagi order book dengan $L$ aras, satu snapshot tunggal pada masa $t$ ialah vektor bernilai $4L$:

di mana $p_i^{a}$ dan $v_i^{a}$ ialah harga dan volum ask pada aras $i$, dan $p_i^{b}$, $v_i^{b}$ ialah nilai sepadan di sebelah bid. Aras 1 memegang bid terbaik dan ask terbaik (BBO); perbezaan antara keduanya ialah spread bid-ask.

Dalam set data penanda aras FI-2010, $L = 10$, memberikan 40 ciri setiap snapshot. FI-2010 dibina daripada kira-kira 4 juta mesej limit-order mentah daripada lima ekuiti Finland di NASDAQ Nordic (Kesko, Outokumpu, Sampo, Rautaruukki, Wartsila) sepanjang sepuluh hari dagangan berturut-turut, 1-14 Jun 2010. Yang penting, DeepLOB tidak dilatih pada 4M snapshot: penanda aras mengecilkan sampel mesej tersebut (setiap 10 peristiwa) menjadi perwakilan ternormal sebanyak 394,337 sampel. Bentuk yang dikecilkan sampelnya dan ternormal itulah yang sebenarnya dilihat oleh model — salah satu sebab penulis memberi amaran terhadap melayan FI-2010 sebagai kata muktamad.

Harga Tengah dan Pergerakannya

Harga tengah pada masa $t$ ialah purata bagi bid terbaik dan ask terbaik:

DeepLOB meramalkan arah pergerakan harga tengah sepanjang ufuk masa hadapan sebanyak $k$ peristiwa. Label ialah pulangan yang dilicinkan, tetapi sedarilah bahawa terdapat dua konvensyen pelicinan dalam literatur, dan keduanya tidak boleh ditukar ganti:

• Min masa hadapan berbanding harga semasa (Tsantekidis et al.): bandingkan purata harga tengah sepanjang $k$ peristiwa seterusnya dengan harga tengah semasa yang mentah.
• Min masa hadapan berbanding min sebelumnya (Ntakaris et al., label kanonik FI-2010, juga yang digunakan DeepLOB untuk data LSE-nya): kedua-dua rujukan dan sasaran dilicinkan.

Melicinkan rujukan (bukan hanya masa hadapan) mengurangkan bunyi label dengan ketara daripada turun naik tick tunggal, itulah sebabnya bentuk min-sebelumnya/seterusnya lebih disukai. Apa-apa pun yang anda gunakan, pulangan selanjar didiskretkan menjadi tiga kelas — naik, turun, pegun — menggunakan ambang tetap $\pm\alpha$:

Set data FI-2010 menyediakan label untuk lima ufuk ramalan: $k \in \{10, 20, 30, 50, 100\}$ peristiwa.

Ciri LOB Tradisional

Sebelum pembelajaran mendalam, penyelidik bergantung pada ciri yang dibina secara manual. Memahami ciri-ciri ini adalah penting, kerana DeepLOB sengaja distrukturkan supaya menyerupai banyak daripadanya — seni binanya dimotivasikan oleh kuantiti-kuantiti ini walaupun ia tidak menghasilkannya semula dengan tepat.

Order Book Imbalance (OBI)

Isyarat mikrostruktur yang paling banyak digunakan. Di puncak book:

Lebih banyak volum bid berbanding volum ask mencadangkan tekanan menaik. Ketidakseimbangan pelbagai aras mengagregat merentas $L$ aras:

Harga Tengah Berwajaran Volum

Harga tengah piawai mewajarkan kedua-dua belah sama rata. Harga tengah berwajaran volum (juga dipanggil weighted mid, atau VAMP) condong ke arah sebelah book yang lebih berat. Dengan menulis ketidakseimbangan puncak book sebagai $I = v_1^{b}/(v_1^{b}+v_1^{a})$, ia ialah purata berwajaran ketidakseimbangan bagi kedua-dua harga:

Perhatikan pewajaran silang: harga ask diwajarkan oleh volum bid dan sebaliknya. Apabila volum bid mendominasi ($I \to 1$), weighted mid beralih ke arah ask — mencerminkan jangkaan bahawa book yang tidak seimbang akan diselesaikan dengan bergerak ke arah sebelah yang lebih berat.

Satu kata berhati-hati tentang penamaan. Weighted mid berwajaran volum yang statik ini bukan microprice Stoikov. Micro-price Stoikov (2018) ialah penganggar terlaras martingale $M_t + g(I, S)$ yang diperoleh daripada pembetulan rekursif tentang bagaimana spread dan ketidakseimbangan berkembang — keseluruhan hujahnya ialah weighted mid yang naif itu berat sebelah dan bukan martingale. Keduanya merupakan dua objek yang berbeza; kita menggunakan weighted mid di sini kerana kesederhanaannya, bukan sebagai pengganti microprice.

Ketidakseimbangan Kedalaman

Mengukur bentuk book di luar BBO:

Spread dan Spread Relatif

Ciri-ciri ini berkuasa tetapi terhad. Ia memerlukan kepakaran domain untuk direka bentuk, tidak menangkap interaksi tak linear yang kompleks, dan mengabaikan dinamik temporal merentas snapshot berturut-turut. DeepLOB menangani ketiga-tiga batasan tersebut.

Seni Bina DeepLOB

Seni bina ini mempunyai tiga blok, setiap satu dengan peranan yang tersendiri:

1. Blok konvolusi — mengekstrak ciri spatial daripada snapshot order book
2. Modul inception — menangkap corak temporal berbilang skala
3. Blok LSTM — memodelkan kebergantungan berjujukan merentas masa

Input kepada rangkaian ialah tensor berbentuk $(T, L \times 4)$, di mana $T$ ialah tetingkap lihat-belakang (100 langkah masa dalam kertas kerja) dan $L \times 4 = 40$ untuk 10 aras harga dan volum di kedua-dua belah.

Blok 1: Pengekstrakan Ciri Konvolusi

Lapisan konvolusi pertama beroperasi sepanjang dimensi ciri untuk mempelajari interaksi antara harga dan volum pada setiap aras.

Lapisan 1: Satu konvolusi dengan saiz penapis $1 \times 2$ dan stride $(1, 2)$ digunakan pada setiap pasangan harga-volum. Ini meringkaskan setiap pasangan $(p_i, v_i)$ menjadi satu ciri tunggal — seakan-akan mengira "interaksi harga-volum" pada setiap aras. Lebar mengecut daripada 40 kepada 20.

Lapisan 2: Satu konvolusi $1 \times 2$, stride $(1, 2)$ yang beroperasi merentas pasangan bid-ask yang sepadan pada aras yang sama. Ini menangkap maklumat spread dan ketidakseimbangan setiap aras. Lebar mengecut daripada 20 kepada 10.

Lapisan 3: Satu konvolusi $1 \times 10$ yang menyepadu merentas kesemua 10 aras, meruntuhkan dimensi kedalaman kepada lebar 1. Ini menghasilkan satu ciri agregat tunggal setiap langkah masa yang mengekod profil kedalaman penuh.

Setiap langkah $1 \times 2$ / $1 \times 10$ diikuti oleh dua konvolusi $(4, 1)$ sepanjang paksi masa, masing-masing dengan pengaktifan LeakyReLU dan normalisasi kelompok. Perhatikan bahawa konvolusi $(4, 1)$ ini dengan padding=(1, 0) tidak mengekalkan dimensi masa: setiap satu memendekkannya sebanyak satu langkah ($T_{\text{out}} = T_{\text{in}} - 1$). Merentas enam lapisan sebegini dalam blok 1-3, paksi masa mengecut daripada 100 kepada 94 sebelum modul inception — sesuatu yang dinyatakan dengan jelas oleh komen bentuk dalam kod di bawah.

Reka bentuk ini sengaja mengelakkan penapis spatial yang besar. Penapis $1 \times 2$ menghormati struktur berpasangan semula jadi data LOB — harga dengan volum, bid dengan ask. Bias induktif ini amat penting: penapis $3 \times 3$ akan mencampurkan aras dan belah yang bersebelahan dengan cara yang tiada makna kewangan.

Blok 2: Modul Inception

Selepas blok konvolusi mengurangkan 40 ciri kepada perwakilan spatial yang padat (lebar 1), modul inception beroperasi sepanjang dimensi masa untuk menangkap corak pada pelbagai skala temporal secara serentak.

Modul inception DeepLOB mempunyai empat laluan selari, setiap satu menghasilkan 32 saluran, kesemuanya digabungkan:

• Bottleneck $1 \times 1$ $\to$ konvolusi temporal $3 \times 1$: corak temporal jangka pendek (3 langkah masa)
• Bottleneck $1 \times 1$ $\to$ konvolusi temporal $5 \times 1$: corak temporal jangka sederhana (5 langkah masa)
• Max-pool $3 \times 1$ $\to$ konvolusi $1 \times 1$: laluan pengumpulan yang mengekalkan pandangan yang dilicinkan dan dikecilkan sampelnya
• (pengurangan $1 \times 1$ bertindak sebagai bottleneck titik-dalam-masa sebelum konvolusi temporal)

Setiap laluan temporal menggunakan padding simetri supaya dimensi masa dikekalkan dalam blok inception (tidak seperti blok konvolusi di atas). Output digabungkan sepanjang dimensi saluran, memberikan rangkaian akses kepada ciri temporal berbilang skala secara serentak.

Ini diilhamkan oleh seni bina inception GoogLeNet, tetapi disesuaikan untuk data temporal 1D dan bukannya imej 2D. Pandangan utamanya ialah dinamik LOB beroperasi pada pelbagai skala masa: bunyi tick demi tick, momentum jangka pendek, dan pengembalian min ufuk lebih panjang kesemuanya wujud bersama.

Pelaksanaan semula PyTorch di bawah membentangkan varian tiga-laluan yang dipermudahkan (dua konvolusi temporal serta laluan $1\times1$) supaya kod kekal mudah dibaca; ia meninggalkan laluan max-pool. Kami menyatakan ini dengan jelas kerana ia merupakan penyimpangan daripada kertas kerja, bukan modul asal.

Blok 3: Pemodelan Jujukan LSTM

Output modul inception disuap ke dalam lapisan LSTM yang memproses keseluruhan jujukan sepanjang $T$. LSTM menangkap kebergantungan temporal jarak jauh yang akan terlepas oleh konvolusi semata-mata — perubahan rejim, kesan waktu-hari, dan keadaan pasaran yang berkembang.

Keadaan tersembunyi akhir LSTM dilalukan melalui lapisan bersambung sepenuhnya dengan pengaktifan softmax untuk menghasilkan taburan kebarangkalian merentas tiga kelas (naik, turun, pegun).

Fungsi Kerugian

Model dilatih dengan entropi silang berkategori:

di mana $y_{i,c}$ ialah label sebenar terkod satu-panas dan $\hat{y}_{i,c}$ ialah kebarangkalian yang diramalkan bagi kelas $c$.

Pelaksanaan Semula PyTorch

DeepLOB asal dibina dalam Keras pada backend TensorFlow; repositori penulis (zcakhaa) kemudiannya menambah port PyTorch. Kod di bawah ialah pelaksanaan semula PyTorch ilustratif kami sendiri, bukan yang rasmi. Ia menyimpang daripada kertas kerja dalam dua cara yang kami tandakan secara sebaris: ia meninggalkan laluan max-pool inception (tiga laluan dan bukan empat), dan ia menskalakan kiraan saluran ke atas. Kertas kerja menggunakan 16 penapis sepanjang blok konvolusi dan 32 penapis setiap laluan inception (input LSTM $3 \times 32 = 96$), memberikan model padat dengan kira-kira 60k parameter. Cebisan di bawah menggunakan 32 penapis konvolusi / 64 penapis inception (input LSTM 192) — konsisten secara dalaman dan boleh dijalankan, tetapi lebih berat daripada yang asal. Untuk memadankan kertas kerja, tetapkan saluran konvolusi kepada 16, saluran inception kepada 32, dan input_size=96.

import torch
import torch.nn as nn


class DeepLOB(nn.Module):
    """
    DeepLOB-style CNN-Inception-LSTM for limit order books.
    Reimplementation inspired by Zhang, Zohren, Roberts (2019),
    IEEE Transactions on Signal Processing, arXiv:1808.03668.

    NOTE: this is an illustrative reimplementation, NOT the official model.
    Differences from the paper:
      - inception has 3 paths here vs 4 in the paper (max-pool path omitted);
      - channel counts are scaled up (paper: 16 conv / 32 inception, input 96).

    Input shape: (batch_size, 1, T, 40)
        T = lookback window (e.g. 100)
        40 = 10 levels x 4 features (ask_price, ask_vol, bid_price, bid_vol)
    """

    def __init__(self, num_classes: int = 3, T: int = 100):
        super().__init__()
        self.num_classes = num_classes

        self.conv1 = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=(1, 2), stride=(1, 2)),
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(32),
            nn.Conv2d(32, 32, kernel_size=(4, 1), padding=(1, 0)),  # time -1
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(32),
            nn.Conv2d(32, 32, kernel_size=(4, 1), padding=(1, 0)),  # time -1
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(32),
        )

        self.conv2 = nn.Sequential(
            nn.Conv2d(32, 32, kernel_size=(1, 2), stride=(1, 2)),
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(32),
            nn.Conv2d(32, 32, kernel_size=(4, 1), padding=(1, 0)),  # time -1
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(32),
            nn.Conv2d(32, 32, kernel_size=(4, 1), padding=(1, 0)),  # time -1
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(32),
        )

        self.conv3 = nn.Sequential(
            nn.Conv2d(32, 32, kernel_size=(1, 10)),
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(32),
            nn.Conv2d(32, 32, kernel_size=(4, 1), padding=(1, 0)),  # time -1
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(32),
            nn.Conv2d(32, 32, kernel_size=(4, 1), padding=(1, 0)),  # time -1
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(32),
        )

        self.inp1 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=(1, 1), padding=(0, 0)),
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(64),
        )
        self.inp2 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=(1, 1), padding=(0, 0)),
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(64),
            nn.Conv2d(64, 64, kernel_size=(3, 1), padding=(1, 0)),
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(64),
        )
        self.inp3 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=(1, 1), padding=(0, 0)),
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(64),
            nn.Conv2d(64, 64, kernel_size=(5, 1), padding=(2, 0)),
            nn.LeakyReLU(negative_slope=0.01),
            nn.BatchNorm2d(64),
        )

        self.lstm = nn.LSTM(
            input_size=192,  # 64 * 3 paths from the simplified inception
            hidden_size=64,
            num_layers=1,
            batch_first=True,
        )

        self.fc = nn.Linear(64, num_classes)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        Args:
            x: Tensor of shape (batch, 1, T, 40)
        Returns:
            Tensor of shape (batch, num_classes)
        """
        h = self.conv1(x)   # (batch, 32, T-2, 20)
        h = self.conv2(h)   # (batch, 32, T-4, 10)
        h = self.conv3(h)   # (batch, 32, T-6, 1)   e.g. T=100 -> 94

        h_inp1 = self.inp1(h)  # (batch, 64, T-6, 1)
        h_inp2 = self.inp2(h)  # (batch, 64, T-6, 1)
        h_inp3 = self.inp3(h)  # (batch, 64, T-6, 1)
        h = torch.cat([h_inp1, h_inp2, h_inp3], dim=1)  # (batch, 192, T-6, 1)

        h = h.squeeze(-1)          # (batch, 192, T-6)
        h = h.permute(0, 2, 1)     # (batch, T-6, 192)

        h, _ = self.lstm(h)
        h = h[:, -1, :]  # take last hidden state

        out = self.fc(h)
        return out

Prapemprosesan Data

Set data FI-2010 dihantar dengan dinormalkan secara z-score. Untuk data order book langsung, anda perlu menormalkan dengan cara yang serupa:

import numpy as np
from torch.utils.data import Dataset


class LOBDataset(Dataset):
    """Dataset for limit order book snapshots."""

    def __init__(
        self,
        data: np.ndarray,
        labels: np.ndarray,
        T: int = 100,
    ):
        """
        Args:
            data: shape (num_snapshots, 40), raw LOB features
            labels: shape (num_snapshots,), class labels {0, 1, 2}
            T: lookback window length
        """
        self.data = data
        self.labels = labels
        self.T = T

        self.mean = data[:len(data) // 2].mean(axis=0)
        self.std = data[:len(data) // 2].std(axis=0)
        self.std[self.std == 0] = 1.0
        self.data = (self.data - self.mean) / self.std

    def __len__(self) -> int:
        return len(self.data) - self.T

    def __getitem__(self, idx: int):
        x = self.data[idx : idx + self.T].reshape(1, self.T, 40)
        y = self.labels[idx + self.T - 1]
        return torch.tensor(x, dtype=torch.float32), torch.tensor(
            y, dtype=torch.long
        )

Gelung Latihan

def train_deeplob(
    model: DeepLOB,
    train_loader,
    val_loader,
    epochs: int = 50,
    lr: float = 0.01,
    device: str = "cuda",
):
    model = model.to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=lr, eps=1)

    best_val_f1 = 0.0
    for epoch in range(epochs):
        model.train()
        train_loss = 0.0
        for x_batch, y_batch in train_loader:
            x_batch = x_batch.to(device)
            y_batch = y_batch.to(device)

            optimizer.zero_grad()
            logits = model(x_batch)
            loss = criterion(logits, y_batch)
            loss.backward()
            optimizer.step()
            train_loss += loss.item()

        model.eval()
        all_preds, all_labels = [], []
        with torch.no_grad():
            for x_val, y_val in val_loader:
                x_val = x_val.to(device)
                preds = model(x_val).argmax(dim=1).cpu()
                all_preds.extend(preds.numpy())
                all_labels.extend(y_val.numpy())

        from sklearn.metrics import f1_score
        val_f1 = f1_score(all_labels, all_preds, average="weighted")

        print(
            f"Epoch {epoch+1}/{epochs} | "
            f"Train Loss: {train_loss/len(train_loader):.4f} | "
            f"Val F1: {val_f1:.4f}"
        )

        if val_f1 > best_val_f1:
            best_val_f1 = val_f1
            torch.save(model.state_dict(), "deeplob_best.pt")

Hiperparameter latihan utama daripada kertas kerja asal:

• Pengoptimum: Adam dengan $\epsilon = 1$ (luar biasa besar — membantu menstabilkan kemas kini pada data kewangan yang berbunyi)
• Kadar pembelajaran: 0.01
• Saiz kelompok: 32
• Tetingkap lihat-belakang: $T = 100$ langkah masa

Kami menjejaki F1 berwajaran dan bukannya ketepatan dalam pengesahan, kerana ketiga-tiga kelas tidak seimbang — dan, seperti yang ditunjukkan oleh bahagian seterusnya, F1 ialah metrik yang ditekankan oleh kertas kerja asal atas sebab itu jua.

Apa yang DeepLOB Direka untuk Tangkap

Satu aspek menarik DeepLOB ialah betapa rapatnya blok-bloknya dimotivasikan oleh ciri yang dibina secara manual di atas. Kita mahu berhati-hati di sini: kertas kerja membentangkan ini sebagai gerak hati reka bentuk, bukan sebagai sifat yang terbukti bagi rangkaian yang terlatih. Ia tidak menerbitkan visualisasi penapis, korelasi ketidakseimbangan-pengaktifan, atau analisis tentang apa yang ditumpukan oleh LSTM. Jadi bacalah yang berikut sebagai niat seni bina, bukan penemuan yang terukur.

Blok konvolusi pertama. Penapis $1 \times 2$ memasangkan harga dengan volum pada setiap aras. Secara struktur, ini ialah operasi yang sama yang membentuk harga berwajaran volum — kertas kerja memotivasikan lapisan pertama dengan menyatakan bahawa peta cirinya membentuk kuantiti seakan micro-price. Rangkaian dibina untuk memulihkan sesuatu dalam keluarga itu; kami tidak mendakwa ia membuktikan penemuan semula mana-mana penganggar tertentu.

Blok konvolusi kedua. Dengan beroperasi merentas pasangan bid-ask, penapis ini diletakkan untuk mempelajari ciri seakan ketidakseimbangan pada pelbagai aras — sekali lagi, melalui binaan dan bukan melalui korelasi yang ditunjukkan.

Modul inception. Konvolusi temporal berbilang skala bertujuan untuk menangkap momentum pada frekuensi yang berbeza: laluan $1\times1$ bertindak balas terhadap struktur titik-dalam-masa, laluan $3\times1$ terhadap trend jangka pendek, laluan $5\times1$ terhadap trend yang sedikit lebih panjang, dan (dalam modul penuh) laluan max-pool terhadap pandangan yang dilicinkan.

Lapisan LSTM. Komponen rekuren menambah memori kebergantungan jarak jauh yang tidak boleh diwakili oleh konvolusi — peralihan rejim dan kesan waktu-hari. Kami mengelakkan dakwaan yang lebih kuat (seperti LSTM melaksanakan "perhatian adaptif" yang menimbang semula data terkini dalam rejim turun naik); kertas kerja tidak menunjukkan ini.

Prestasi pada FI-2010

Kertas kerja asal menilai dua protokol. Setup 1 menggunakan pembahagian normalisasi awal set data; Setup 2 ialah penyediaan pembelajaran mendalam yang paling banyak dibandingkan oleh kerja seterusnya. Kerana FI-2010 tidak seimbang dari segi kelas, kertas kerja menekankan F1, bukan ketepatan, dan melaporkan angka berasaskan precision/recall bagi garis dasar bukan-neural (SVM, MLP). Berikut ialah angka Setup 2 yang sebenar (F1, %):

Pada $k = 10$, DeepLOB juga melaporkan ketepatan 84.47% bersama F1 83.40-nya. Setup 2 melaporkan hanya $k \in \{10, 20, 50\}$ — tiada baris $k = 100$ di sini. (Setup 1 memang melaporkan $k \in \{10, 50, 100\}$, dengan F1 DeepLOB masing-masing 77.66 / 74.96 / 76.58.) Tanda sengkang di atas menandakan sel garis dasar yang tidak dijadualkan oleh kertas kerja pada ufuk tersebut dalam protokol ini.

Beberapa pemerhatian menonjol:

1. DeepLOB mengalahkan garis dasar dengan jurang yang besar pada ufuk pendek. Pada $k = 10$ F1-nya (83.40) jauh lebih tinggi daripada LSTM (66.33), CNN-I (55.21), MLP (48.27), dan SVM (35.88). Tertib kualitatif — model rekuren-konvolusi mendalam mengatasi CNN biasa, MLP, dan SVM — ialah kesimpulan yang teguh.
2. Trend ufuk adalah tak monoton, bukan "lebih panjang lebih mudah". Merentas Setup 2, F1 DeepLOB pergi $83.40 \to 72.82 \to 80.35$ apabila $k$ pergi $10 \to 20 \to 50$ — corak berbentuk U, dengan $k=20$ yang paling sukar, bukan barisan menaik yang kemas. Sama ada sesuatu ufuk itu "lebih mudah" sangat bergantung pada penyediaan, ambang $\alpha$, dan skema pelicinan label; kita tidak sepatutnya membaca undang-undang universal ke dalam angka-angka ini.
3. DeepLOB tidak mendominasi setiap kaedah klasik pada setiap sel. Terhadap garis dasar kukuh seperti C(TABL) jurangnya menyempit pada beberapa ufuk, jadi "mengatasi semua pendekatan klasik di mana-mana" melebih-lebihkan keadaan. Dakwaan yang boleh dipertahankan ialah ia berdaya saing hingga terbaik, dan jelas terbaik pada ufuk pendek.

Dan sekali lagi: pandangan kertas kerja itu sendiri ialah FI-2010 terlalu kecil dan terlalu dikecilkan sampelnya untuk menyelesaikan persoalan ini. Buktinya yang lebih kukuh ialah kajian LSE, di mana DeepLOB berlatih pada satu set saham dan masih meramal pada saham yang dipegang keluar — hasil transfer learning yang tidak dapat ditunjukkan oleh FI-2010.

LOBFrame dan Krisis Replikasi

Rangka kerja penanda aras LOBFrame (Briola, Bartolucci, Aste, 2024) menyediakan pelengkap yang menyedarkan kepada hasil-hasil ini. Walaupun seni bina DeepLOB adalah kukuh, rangka kerja tersebut menonjolkan beberapa kaveat penting:

Kebergantungan mikrostruktur. Prestasi model berbeza dengan ketara merentas saham dengan ciri mikrostruktur yang berbeza. Saham cair bertick-besar lebih mudah diramal berbanding instrumen tak cair bertick-kecil. Model yang kelihatan kukuh pada satu saham boleh merosot dengan banyak pada saham yang lain.

Ramalan berbanding keuntungan. Ketepatan pengelasan yang tinggi tidak secara automatik diterjemahkan kepada keuntungan dagangan. LOBFrame menekankan metrik yang terikat kepada sama ada pergerakan yang diramalkan cukup besar untuk melepasi spread bid-ask. Sesuatu model perlu betul cukup kerap, dan pada pergerakan yang cukup besar, untuk mengatasi spread — dan bagi saham berspread ketat, palang itu adalah tinggi.

Kepekaan label. Pilihan ambang $\alpha$ dan ufuk $k$ secara dramatik mempengaruhi kedua-dua ketepatan yang dilaporkan dan nilai praktikal ramalan. Label yang terlalu ketat menghasilkan sasaran yang berbunyi; label yang terlalu lebar menghasilkan ramalan yang "tepat" secara remeh tetapi tidak berguna.

Melangkaui DeepLOB: Landskap Semasa

Sejak penerbitan DeepLOB, beberapa lanjutan telah muncul:

Transformer untuk limit order book (Wallbridge, 2020). Sering dirujuk secara longgar sebagai "TransLOB" dalam literatur kemudian, model itu sendiri ialah pengekstrak ciri konvolusi sebab-akibat/dilatasi diikuti oleh perhatian-kendiri berbilang-kepala bertopeng — bukan sekadar DeepLOB dengan LSTM ditukar kepada Transformer; ia tidak menggunakan semula timbunan inception+konvolusi. Ia melaporkan keadaan terkini FI-2010 yang baharu pada zamannya.

Varian domain kripto. Beberapa kumpulan menerapkan seni bina bergaya DeepLOB kepada pasaran mata wang kripto, di mana dinamik order book berbeza dengan ketara daripada ekuiti — spread lebih lebar, dagangan 24/7, dan campuran peserta yang berbeza yang kesemuanya menuntut latihan semula.

Varian dipertingkat-perhatian. Satu jalur kerja menyisipkan perhatian berbilang-kepala antara blok inception dan LSTM, membenarkan rangkaian menumpu pada aras atau langkah masa yang paling bermaklumat untuk ramalan semasa.

LOB-Bench (Nagy, Frey, Li, Sarkar, Vyetrenko, Zohren, Calinescu, Foerster, 2025). Penanda aras ini mengalihkan perhatian daripada ramalan kepada penjanaan, menjaringkan betapa realistiknya model generatif data order book — relevan untuk backtesting dan latihan agen dan bukannya peramalan arah.

Pertimbangan Praktikal untuk Pengeluaran

Jika anda mempertimbangkan untuk menggunakan model bergaya DeepLOB dalam sistem dagangan langsung, beberapa kebimbangan kejuruteraan timbul:

Latensi

Model mesti menghasilkan ramalan dalam belanjawan latensi sistem dagangan anda. Bagi sistem HFT yang beroperasi pada latensi sub-milisaat, walaupun inferens PyTorch yang dioptimumkan boleh menjadi terlalu lambat. Pilihan termasuk:

• Eksport ONNX dengan pengoptimuman TensorRT
• Pengkuantuman kepada INT8
• Penggunaan FPGA untuk aplikasi yang paling sensitif kepada latensi

Saluran Paip Data

Model menjangkakan snapshot order book yang ternormal dan sejajar pada frekuensi tetap. Dalam amalan, kemas kini LOB tiba secara tak segerak. Anda memerlukan:

• Enjin pembinaan semula snapshot yang mengekalkan keadaan book semasa
• Pensampel frekuensi-tetap yang menghasilkan tensor input $(T, 40)$
• Normalisasi dalam talian menggunakan statistik bergolek

Kestabilan Ciri

Parameter normalisasi z-score yang dikira pada data latihan hanyut sepanjang masa. Harga berubah, rejim turun naik beralih, struktur pasaran berkembang. Sistem pengeluaran memerlukan:

• Tetingkap normalisasi bergolek (cth., kira semula statistik setiap hari)
• Pengesanan rejim untuk mencetuskan latihan semula model
• Pemantauan untuk peralihan taburan input

Lebih Suai pada Mikrostruktur

Corak LOB adalah khusus tempat dan khusus instrumen. Model yang dilatih pada ekuiti NASDAQ tidak akan berfungsi pada Binance BTC/USDT tanpa latihan semula. Walaupun dalam tempat yang sama, model boleh lebih suai pada:

• Rejim saiz tick (saham bertick-besar berbanding bertick-kecil)
• Corak waktu-hari (lelongan pembukaan, lengai tengah hari, silang penutupan)
• Tingkah laku market maker yang berubah sepanjang masa

Kesimpulan

DeepLOB mewakili penerapan pembelajaran mendalam yang bersih dan bermotivasi baik kepada mikrostruktur pasaran. Seni bina tiga-bloknya — CNN untuk ciri spatial, inception untuk corak temporal berbilang skala, LSTM untuk kebergantungan berjujukan — memetakan secara semula jadi kepada struktur data limit order book.

Pandangan utamanya bukan sekadar bahawa model mendalam boleh memadankan atau mengalahkan ciri yang dibina secara manual, tetapi bahawa bias induktif seni bina — penapis $1 \times 2$, keselarian inception, memori rekuren — mengekod pengetahuan domain yang tulen tentang bagaimana order book berfungsi. Ini bukan rangkaian mendalam generik yang dibaling kepada data kewangan; ia ialah seni bina yang direka di sekeliling geometri khusus limit order book. Dan buktinya yang paling meyakinkan bukanlah papan pendahulu FI-2010 yang penulis sendiri tidak percayai, tetapi hasil transfer learning pada setahun data LSE.

Bagi pengamal, DeepLOB ialah garis dasar yang kukuh dan blok binaan yang berguna. Bagi penyelidik, ia menunjukkan bahawa reka bentuk seni bina yang teliti — bukan sekadar skala model — memacu prestasi pada data kewangan berstruktur. Cuma ingatlah untuk memetik angka yang sebenar, perhatikan skema label, dan layan ketepatan pengelasan sebagai jauh ketinggalan daripada keuntungan dagangan.

Rujukan

1. Zhang, Z., Zohren, S., & Roberts, S. (2019). DeepLOB: Deep Convolutional Neural Networks for Limit Order Books. IEEE Transactions on Signal Processing, 67(11), 3001-3012. arXiv:1808.03668

2. Ntakaris, A., Magris, M., Kanniainen, J., Gabbouj, M., & Iosifidis, A. (2018). Benchmark Dataset for Mid-Price Forecasting of Limit Order Book Data with Machine Learning Methods. Journal of Forecasting, 37(8), 852-866. arXiv:1705.03233

3. Briola, A., Bartolucci, S., & Aste, T. (2024). Deep Limit Order Book Forecasting (LOBFrame). arXiv:2403.09267

4. Wallbridge, J. (2020). Transformers for Limit Order Books. arXiv:2003.00130

5. Cont, R., Kukanov, A., & Stoikov, S. (2014). The Price Impact of Order Book Events. Journal of Financial Econometrics, 12(1), 47-88.

6. Stoikov, S. (2018). The Micro-Price: A High-Frequency Estimator of Future Prices. Quantitative Finance, 18(12), 1959-1966.

7. Nagy, P., Frey, S., Li, K., Sarkar, B., Vyetrenko, S., Zohren, S., Calinescu, A., & Foerster, J. (2025). LOB-Bench: Benchmarking Generative AI for Finance — an Application to Limit Order Book Data. ICML 2025. arXiv:2502.09172

8. DeepLOB code (original in Keras/TensorFlow; the repository also provides a PyTorch port): github.com/zcakhaa/DeepLOB-Deep-Convolutional-Neural-Networks-for-Limit-Order-Books