DeepLOB: Limit Emir Defterlerinde Derin Öğrenme

Limit emir defteri, modern elektronik piyasaların merkezi veri yapısıdır. Her alış, her satış, her iptal — hepsi LOB içinde yaşar. Onlarca yıldır kantitatif araştırmacılar bu veriden elle özellikler üretti: emir dengesizliği oranları, ağırlıklı orta fiyatlar, kuyruk pozisyonu sinyalleri. DeepLOB farklı bir yol izledi — bu özellikleri, hibrit bir CNN-LSTM mimarisi kullanarak doğrudan ham emir defteri anlık görüntülerinden öğrenir.

Zhang, Zohren ve Roberts tarafından 2019'da Oxford-Man Institute'ta yayımlanan DeepLOB, ham defter verisi üzerinde uçtan uca eğitilen tek bir derin ağın, orta fiyat hareketi tahmininde güçlü klasik temel modellerle rekabet edebileceğini ve hatta onları geçebileceğini gösterdi. Ancak kanıt konusunda titiz olmalıyız. Çoğu makalenin atıf verdiği kıyaslama veri kümesi FI-2010'dur, fakat yazarların kendisi onu yetersiz olarak nitelendirir — "fazlasıyla kısa, alt örneklenmiş ve daha az likit bir piyasadan alınmış" — ve daha güçlü sonuçları olarak Londra Borsası (LSE) verisi üzerinde yapılan ikinci, çok daha büyük bir değerlendirme sunarlar. Bu LSE çalışması, beş eğitim hisse senedi ve beş test hisse senedinden yaklaşık bir yılı, 100M+ örnek mertebesinde kapsar ve transfer öğrenmeyi gösterir: bir hisse senedi kümesi üzerinde eğitilen bir model, görmediği hisse senetlerinde hâlâ tahmin yapabilir. Makalenin gerçek manşeti, FI-2010 lider tablosu değil, bu transfer sonucudur. Bu yazı mimariyi, matematiği, gerçek sayıları ve çalışan bir PyTorch yeniden uygulamasını ayrıntılı biçimde inceler.

Veri Yapısı Olarak Limit Emir Defteri

Bir limit emir defteri, her biri fiyat seviyesine göre düzenlenmiş iki sıralı liste tutar — alışlar (alım emirleri) ve satışlar (satım emirleri). Defter, her seviyede fiyatı ve bekleyen emirlerin toplam hacmini kaydeder.

$L$ seviyeli bir emir defteri için, $t$ anındaki tek bir anlık görüntü, $4L$ değerden oluşan bir vektördür:

Burada $p_i^{a}$ ve $v_i^{a}$, $i$ seviyesindeki satış fiyatı ve hacmidir; $p_i^{b}$, $v_i^{b}$ ise karşılık gelen alış tarafı değerleridir. Seviye 1, en iyi alış ile en iyi satışı (BBO) tutar; aralarındaki fark alış-satış spread'idir.

FI-2010 kıyaslama veri kümesinde $L = 10$ olup anlık görüntü başına 40 özellik elde edilir. FI-2010, NASDAQ Nordic üzerindeki beş Fin hisse senedinden (Kesko, Outokumpu, Sampo, Rautaruukki, Wartsila) 1-14 Haziran 2010 tarihleri arasındaki on ardışık işlem gününde toplanan yaklaşık 4 milyon ham limit emir mesajından oluşturulur. Önemlisi, DeepLOB 4M anlık görüntü üzerinde eğitilmez: kıyaslama bu mesajları (her 10 olayda bir) alt örnekleyerek 394.337 örnekten oluşan normalize edilmiş bir gösterime indirger. Modelin gerçekte gördüğü şey bu alt örneklenmiş, normalize edilmiş biçimdir — yazarların FI-2010'u son söz olarak ele almaya karşı uyarmasının nedenlerinden biri budur.

Orta Fiyat ve Hareketleri

$t$ anındaki orta fiyat, en iyi alış ile en iyi satışın ortalamasıdır:

DeepLOB, $k$ olay sonrası bir gelecek ufku boyunca orta fiyat hareketinin yönünü tahmin eder. Etiket, düzleştirilmiş bir getiridir; ancak literatürde iki düzleştirme geleneği bulunduğunu ve bunların birbirinin yerine kullanılamayacağını bilin:

• Gelecek ortalaması vs mevcut fiyat (Tsantekidis ve diğerleri): sonraki $k$ olay üzerindeki ortalama orta fiyatı ham mevcut orta fiyatla karşılaştırın.
• Gelecek ortalaması vs önceki ortalama (Ntakaris ve diğerleri, kanonik FI-2010 etiketi; ayrıca DeepLOB'un LSE verisi için kullandığı etiket): hem referans hem de hedef düzleştirilmiştir.

Yalnızca geleceği değil referansı da düzleştirmek, tek tik dalgalanmalarından kaynaklanan etiket gürültüsünü kayda değer ölçüde azaltır; önceki/sonraki ortalama biçiminin tercih edilmesinin nedeni budur. Hangisini kullanırsanız kullanın, sürekli getiri, sabit eşikler $\pm\alpha$ kullanılarak üç sınıfa ayrılır — yükseliş, düşüş, durağan:

FI-2010 veri kümesi, beş tahmin ufku için etiketler sağlar: $k \in \{10, 20, 30, 50, 100\}$ olay.

Geleneksel LOB Özellikleri

Derin öğrenmeden önce araştırmacılar elle üretilen özelliklere dayanıyordu. Bunları anlamak temeldir; çünkü DeepLOB, bilinçli olarak bunların çoğunu andıracak şekilde yapılandırılmıştır — mimarisi, tam olarak yeniden üretmediği yerlerde bile bu büyüklüklerden ilham alır.

Emir Defteri Dengesizliği (OBI)

En yaygın kullanılan mikroyapı sinyali. Defterin tepesinde:

Satış hacmine göre daha fazla alış hacmi, yukarı yönlü baskıya işaret eder. Çok seviyeli dengesizlik, $L$ seviye boyunca toplanır:

Hacim Ağırlıklı Orta Fiyat

Standart orta fiyat her iki tarafı eşit ağırlıklandırır. Hacim ağırlıklı orta fiyat (ağırlıklı orta ya da VAMP olarak da bilinir), defterin daha ağır tarafına doğru eğilir. Defter tepesi dengesizliğini $I = v_1^{b}/(v_1^{b}+v_1^{a})$ olarak yazarsak, bu, iki fiyatın dengesizlik ağırlıklı ortalamasıdır:

Çapraz ağırlıklandırmaya dikkat edin: satış fiyatı alış hacmiyle ağırlıklandırılır, tersi de geçerlidir. Alış hacmi baskın olduğunda ($I \to 1$), ağırlıklı orta satışa doğru kayar — dengesiz bir defterin daha ağır tarafa doğru hareket ederek çözüleceği beklentisini yansıtır.

İsimlendirme konusunda bir uyarı. Bu statik, hacim ağırlıklı orta, Stoikov'un microprice'ı değildir. Stoikov'un micro-price'ı (2018), spread ve dengesizliğin nasıl evrildiğine dair özyinelemeli bir düzeltmeden elde edilen martingal düzeltmeli bir tahmin edici $M_t + g(I, S)$'dir — onun bütün noktası, naif ağırlıklı ortanın yanlı olduğu ve bir martingal olmadığıdır. Bunlar iki ayrı nesnedir; burada ağırlıklı ortayı microprice'ın yerine değil, basitliği için kullanıyoruz.

Derinlik Dengesizliği

Defterin BBO ötesindeki şeklini ölçer:

Spread ve Göreli Spread

Bu özellikler güçlüdür ama sınırlıdır. Tasarlanmaları alan uzmanlığı gerektirir, karmaşık doğrusal olmayan etkileşimleri yakalamazlar ve ardışık anlık görüntüler arasındaki zamansal dinamikleri göz ardı ederler. DeepLOB bu üç sınırlamanın da üstesinden gelir.

DeepLOB Mimarisi

Mimari, her biri farklı bir role sahip üç bloktan oluşur:

1. Konvolüsyonel blok — emir defteri anlık görüntüsünden uzamsal özellikler çıkarır
2. Inception modülü — çok ölçekli zamansal kalıpları yakalar
3. LSTM bloğu — zaman boyunca ardışık bağımlılıkları modeller

Ağın girdisi, $(T, L \times 4)$ biçiminde bir tensördür; burada $T$ geriye bakış penceresidir (makalede 100 zaman adımı) ve her iki taraftaki 10 fiyat ve hacim seviyesi için $L \times 4 = 40$'tır.

Blok 1: Konvolüsyonel Özellik Çıkarımı

İlk konvolüsyonel katmanlar, her seviyedeki fiyat ile hacim arasındaki etkileşimleri öğrenmek için özellik boyutu boyunca çalışır.

Katman 1: Her fiyat-hacim çiftine uygulanan, filtre boyutu $1 \times 2$ ve adım $(1, 2)$ olan bir konvolüsyon. Bu, her $(p_i, v_i)$ çiftini tek bir özellikte özetler — her seviyede bir "fiyat-hacim etkileşimi" hesaplamaya benzer. Genişlik 40'tan 20'ye küçülür.

Katman 2: Aynı seviyedeki eşleşen alış-satış çiftleri arasında çalışan $1 \times 2$, adım $(1, 2)$ konvolüsyonu. Bu, seviye başına spread ve dengesizlik bilgisini yakalar. Genişlik 20'den 10'a küçülür.

Katman 3: Tüm 10 seviye boyunca bütünleştiren ve derinlik boyutunu genişlik 1'e çökerten bir $1 \times 10$ konvolüsyon. Bu, zaman adımı başına tüm derinlik profilini kodlayan tek bir toplam özellik üretir.

Her $1 \times 2$ / $1 \times 10$ adımını, zaman ekseni boyunca, her biri LeakyReLU aktivasyonu ve toplu normalleştirme içeren iki $(4, 1)$ konvolüsyon izler. Dikkat edin: padding=(1, 0) ile bu $(4, 1)$ konvolüsyonlar zaman boyutunu korumaz: her biri onu bir adım kısaltır ($T_{\text{out}} = T_{\text{in}} - 1$). Blok 1-3'teki bu altı katman boyunca, inception modülünden önce zaman ekseni 100'den 94'e küçülür — bunu aşağıdaki koddaki biçim yorumları açıkça gösterir.

Tasarım, büyük uzamsal filtrelerden bilinçli olarak kaçınır. $1 \times 2$ filtreler, LOB verisinin doğal eşleşme yapısına saygı gösterir — fiyat ile hacim, alış ile satış. Bu tümevarımsal önyargı çok önemlidir: bir $3 \times 3$ filtre, komşu seviyeleri ve tarafları finansal anlamı olmayan bir biçimde karıştırırdı.

Blok 2: Inception Modülü

Konvolüsyonel blok 40 özelliği kompakt bir uzamsal gösterime (genişlik 1) indirdikten sonra, inception modülü çok sayıda zamansal ölçekteki kalıpları aynı anda yakalamak için zaman boyutu boyunca çalışır.

DeepLOB inception modülünün, her biri 32 kanal üreten ve hepsi birleştirilen dört paralel yolu vardır:

• $1 \times 1$ darboğaz $\to$ $3 \times 1$ zamansal konvolüsyon: kısa vadeli zamansal kalıplar (3 zaman adımı)
• $1 \times 1$ darboğaz $\to$ $5 \times 1$ zamansal konvolüsyon: orta vadeli zamansal kalıplar (5 zaman adımı)
• $3 \times 1$ max-pool $\to$ $1 \times 1$ konvolüsyon: düzleştirilmiş, alt örneklenmiş bir görünüm tutan bir havuzlama yolu
• ($1 \times 1$ indirgemeleri, zamansal konvolüsyonlardan önce zamanın belirli bir anındaki darboğazlar olarak işlev görür)

Her zamansal yol, zaman boyutunun inception bloğu içinde korunması için simetrik dolgu kullanır (yukarıdaki konvolüsyon bloklarından farklı olarak). Çıktılar kanal boyutu boyunca birleştirilir ve ağa aynı anda çok ölçekli zamansal özelliklere erişim sağlar.

Bu, GoogLeNet inception mimarisinden esinlenmiştir, ancak 2B görüntüler yerine 1B zamansal veriye uyarlanmıştır. Temel kavrayış şudur: LOB dinamikleri çok sayıda zaman ölçeğinde işler — tik bazında gürültü, kısa vadeli momentum ve daha uzun ufuklu ortalamaya dönüş hepsi bir arada bulunur.

Aşağıdaki PyTorch yeniden uygulaması, kodun okunabilir kalması için basitleştirilmiş üç yollu bir varyant (iki zamansal konvolüsyon artı bir $1\times1$ yolu) sunar; max-pool yolunu atlar. Bunu açıkça belirtiyoruz çünkü bu, orijinal modül değil, makaleden bir sapmadır.

Blok 3: LSTM Dizi Modelleme

Inception modülünün çıktısı, tüm $T$ uzunluğundaki diziyi işleyen bir LSTM katmanına beslenir. LSTM, yalnızca konvolüsyonların gözden kaçıracağı uzun erimli zamansal bağımlılıkları yakalar — rejim değişiklikleri, günün saati etkileri ve evrilen piyasa koşulları.

LSTM'in son gizli durumu, üç sınıf (yükseliş, düşüş, durağan) üzerinde bir olasılık dağılımı üretmek için softmax aktivasyonlu, tam bağlı bir katmandan geçirilir.

Kayıp Fonksiyonu

Model, kategorik çapraz entropi ile eğitilir:

Burada $y_{i,c}$ one-hot kodlanmış gerçek etiket ve $\hat{y}_{i,c}$, $c$ sınıfı için tahmin edilen olasılıktır.

PyTorch Yeniden Uygulaması

Orijinal DeepLOB, TensorFlow arka ucu üzerinde Keras ile inşa edildi; yazarların deposu (zcakhaa) daha sonra bir PyTorch portu ekledi. Aşağıdaki kod, resmi olanı değil, kendi açıklayıcı PyTorch yeniden uygulamamızdır. Satır içinde işaret ettiğimiz iki noktada makaleden ayrılır: inception max-pool yolunu atlar (dört yerine üç yol) ve kanal sayılarını ölçeklendirir. Makale, konvolüsyon blokları boyunca 16 filtre ve inception yolu başına 32 filtre kullanır (LSTM girdisi $3 \times 32 = 96$), yaklaşık 60 bin parametreli kompakt bir model verir. Aşağıdaki kod parçası 32 konvolüsyon / 64 inception filtresi kullanır (LSTM girdisi 192) — kendi içinde tutarlı ve çalıştırılabilir, fakat orijinalinden daha ağır. Makaleyle eşleştirmek için konvolüsyon kanallarını 16'ya, inception kanallarını 32'ye ve input_size=96 olarak ayarlayın.

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

Veri Ön İşleme

FI-2010 veri kümesi z-skoru normalize edilmiş olarak gelir. Canlı emir defteri verisi için benzer şekilde normalize etmeniz gerekir:

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
        )

Eğitim Döngüsü

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")

Orijinal makaleden temel eğitim hiperparametreleri:

• Optimize edici: $\epsilon = 1$ ile Adam (alışılmadık derecede büyük — gürültülü finansal veride güncellemeleri kararlı kılmaya yardımcı olur)
• Öğrenme oranı: 0.01
• Toplu iş boyutu: 32
• Geriye bakış penceresi: $T = 100$ zaman adımı

Doğrulamada doğruluk yerine ağırlıklı F1 izleriz, çünkü üç sınıf dengesizdir — ve bir sonraki bölümün gösterdiği gibi, F1, tam da bu nedenle orijinal makalenin vurguladığı metriktir.

DeepLOB Neyi Yakalamak İçin İnşa Edilmiştir

DeepLOB'un çekici yönlerinden biri, bloklarının yukarıdaki elle üretilen özelliklerden ne kadar yakından ilham aldığıdır. Burada dikkatli olmak istiyoruz: makale bunları, eğitilmiş ağın kanıtlanmış özellikleri olarak değil, tasarım sezgileri olarak sunar. Filtre görselleştirmeleri, aktivasyon-dengesizlik korelasyonları veya LSTM'in neye dikkat ettiğine dair bir analiz yayımlamaz. Dolayısıyla aşağıdakileri ölçülmüş bulgular değil, mimari niyet olarak okuyun.

İlk konvolüsyonel blok. $1 \times 2$ filtreler, her seviyede fiyatı hacimle eşleştirir. Yapısal olarak bu, hacim ağırlıklı bir fiyat oluşturan işlemin aynısıdır — makale, ilk katmanı, özellik haritalarının micro-price benzeri bir büyüklük oluşturduğunu belirterek motive eder. Ağ, bu aileden bir şeyi geri kazanmak için inşa edilmiştir; herhangi bir belirli tahmin ediciyi kanıtlanabilir biçimde yeniden keşfettiğini iddia etmiyoruz.

İkinci konvolüsyonel blok. Alış-satış çiftleri boyunca çalışarak, bu filtreler çok sayıda seviyede dengesizlik benzeri özellikler öğrenecek konuma yerleştirilmiştir — yine, gösterilmiş bir korelasyonla değil, yapısı gereği.

Inception modülü. Çok ölçekli zamansal konvolüsyonlar, momentumu farklı frekanslarda yakalamayı amaçlar: $1\times1$ yolu zamanın belirli bir anındaki yapıya, $3\times1$ yolu kısa vadeli eğilimlere, $5\times1$ yolu biraz daha uzun olanlara ve (tam modülde) max-pool yolu düzleştirilmiş bir görünüme tepki verir.

LSTM katmanı. Yinelemeli bileşen, konvolüsyonların temsil edemediği uzun erimli bağımlılıkların belleğini ekler — rejim değişimleri ve günün saati etkileri. Daha güçlü iddialardan (örneğin LSTM'in, dalgalı rejimlerde yakın veriyi yeniden ağırlıklandıran bir "uyarlanabilir dikkat" uyguladığı gibi) kaçınıyoruz; makale bunu göstermez.

FI-2010 Üzerindeki Performans

Orijinal makale iki protokolü değerlendirir. Düzen 1, veri kümesinin daha önceki normalleştirme bölünmesini kullanır; Düzen 2, sonraki çalışmaların çoğunun karşılaştırma yaptığı derin öğrenme düzenidir. FI-2010 sınıf açısından dengesiz olduğundan, makale doğruluğu değil F1'i vurgular ve nöral olmayan temel modeller (SVM, MLP) için kesinlik/duyarlılık temelli rakamlar raporlar. İşte gerçek Düzen 2 sayıları (F1, %):

$k = 10$'da DeepLOB, 83.40 F1'inin yanında %84.47 doğruluk da raporlar. Düzen 2 yalnızca $k \in \{10, 20, 50\}$ raporlar — burada bir $k = 100$ satırı yoktur. (Düzen 1 ise $k \in \{10, 50, 100\}$ raporlar; DeepLOB F1 değerleri sırasıyla 77.66 / 74.96 / 76.58'dir.) Yukarıdaki tireler, makalenin bu protokolde o ufuklar için tablolaştırmadığı temel model hücrelerini işaretler.

Birkaç gözlem öne çıkar:

1. DeepLOB, kısa ufukta temel modelleri geniş bir farkla geçer. $k = 10$'da F1'i (83.40), LSTM (66.33), CNN-I (55.21), MLP (48.27) ve SVM'in (35.88) epey üzerindedir. Niteliksel sıralama — derin yinelemeli-konvolüsyonel modellerin düz CNN'ler, MLP'ler ve SVM'lerin önünde olması — sağlam çıkarımdır.
2. Ufuk eğilimi monoton değildir, "daha uzun olan daha kolaydır" değildir. Düzen 2 boyunca, $k$ değeri $10 \to 20 \to 50$ giderken DeepLOB'un F1'i $83.40 \to 72.82 \to 80.35$ olur — temiz bir yukarı yürüyüş değil, $k=20$'nin en zor olduğu U-şeklinde bir kalıp. Bir ufkun "daha kolay" olup olmaması büyük ölçüde düzene, eşik $\alpha$'ya ve etiket düzleştirme şemasına bağlıdır; bu sayılardan evrensel bir yasa çıkarmamalıyız.
3. DeepLOB, her hücrede her klasik yöntemi domine etmez. C(TABL) gibi güçlü temel modellere karşı, bazı ufuklarda farklar daralır; dolayısıyla "her yerde tüm klasik yaklaşımlardan daha iyi performans gösterir" durumu abartır. Savunulabilir iddia, onun rekabetçi-ila-en iyi olduğu ve kısa ufukta açıkça en iyi olduğudur.

Ve yine: makalenin kendi görüşü, FI-2010'un soruyu çözmek için fazla küçük ve fazla alt örneklenmiş olduğudur. Daha güçlü kanıtı, DeepLOB'un bir hisse senedi kümesi üzerinde eğitilip yine de ayrılmış hisse senetlerinde tahmin yapabildiği LSE çalışmasıdır — FI-2010'un gösteremeyeceği bir transfer öğrenme sonucu.

LOBFrame ve Tekrarlanabilirlik Krizi

LOBFrame kıyaslama çerçevesi (Briola, Bartolucci, Aste, 2024), bu sonuçlara ayıltıcı bir tamamlayıcı sunar. DeepLOB'un mimarisi sağlam olsa da, çerçeve birkaç önemli uyarıyı öne çıkarır:

Mikroyapı bağımlılığı. Model performansı, farklı mikroyapısal özelliklere sahip hisse senetleri arasında önemli ölçüde değişir. Likit, büyük-tikli hisse senetlerini tahmin etmek, likit olmayan, küçük-tikli araçlardan daha kolaydır. Bir hisse senedinde güçlü görünen bir model, başka birinde kayda değer ölçüde bozulabilir.

Tahmin vs kâr. Yüksek sınıflandırma doğruluğu, otomatik olarak işlem kârına dönüşmez. LOBFrame, tahmin edilen bir hareketin alış-satış spread'ini aşacak kadar büyük olup olmadığına bağlı metrikleri vurgular. Bir modelin spread'i aşması için yeterince sık ve yeterince büyük hareketlerde haklı çıkması gerekir — ve dar spread'li hisse senetleri için bu eşik yüksektir.

Etiket duyarlılığı. Eşik $\alpha$ ve ufuk $k$ seçimi, hem raporlanan doğruluğu hem de tahminlerin pratik değerini çarpıcı biçimde etkiler. Fazla dar etiketler gürültülü hedefler üretir; fazla geniş etiketler ise önemsiz biçimde "doğru" ama işe yaramaz tahminler üretir.

DeepLOB'un Ötesi: Mevcut Manzara

DeepLOB'un yayımlanmasından bu yana birkaç uzantı ortaya çıktı:

Limit emir defterleri için Transformer'lar (Wallbridge, 2020). Sonraki literatürde sıklıkla gevşek biçimde "TransLOB" olarak anılan modelin kendisi, nedensel/genişletilmiş bir konvolüsyonel özellik çıkarıcının ardından maskeli çok başlı öz-dikkat gelmesinden oluşur — basitçe LSTM'i bir Transformer'la değiştirilmiş DeepLOB değildir; inception+konvolüsyon yığınını yeniden kullanmaz. Dönemi için yeni bir FI-2010 son teknoloji düzeyini raporladı.

Kripto alanı varyantları. Birkaç grup, emir defteri dinamiklerinin hisse senetlerinden önemli ölçüde farklı olduğu kripto para piyasalarına DeepLOB tarzı mimariler uygular — daha geniş spread'ler, 7/24 işlem ve hepsi yeniden eğitim gerektiren farklı bir katılımcı karması.

Dikkat ile zenginleştirilmiş varyantlar. Bir çalışma çizgisi, inception ve LSTM blokları arasına çok başlı dikkat ekleyerek ağın, mevcut tahmin için en bilgilendirici seviyelere veya zaman adımlarına odaklanmasını sağlar.

LOB-Bench (Nagy, Frey, Li, Sarkar, Vyetrenko, Zohren, Calinescu, Foerster, 2025). Bu kıyaslama, dikkati tahminden üretime çevirir; emir defteri verisinin üretken modellerinin ne kadar gerçekçi olduğunu puanlar — yönlü tahminden ziyade backtest ve ajan eğitimiyle ilgilidir.

Üretim İçin Pratik Hususlar

Canlı bir işlem sisteminde DeepLOB tarzı bir model dağıtmayı düşünüyorsanız, birkaç mühendislik kaygısı ortaya çıkar:

Gecikme

Model, tahminleri işlem sisteminizin gecikme bütçesi içinde üretmelidir. Milisaniyenin altında gecikmelerle çalışan HFT sistemleri için, optimize edilmiş bir PyTorch çıkarımı bile fazla yavaş olabilir. Seçenekler şunları içerir:

• TensorRT optimizasyonu ile ONNX dışa aktarımı
• INT8'e niceleme
• En gecikme duyarlı uygulamalar için FPGA dağıtımı

Veri Hattı

Model, sabit bir frekansta normalize edilmiş, hizalanmış emir defteri anlık görüntüleri bekler. Pratikte LOB güncellemeleri eşzamansız olarak gelir. İhtiyacınız olanlar:

• Mevcut defter durumunu koruyan bir anlık görüntü yeniden yapılandırma motoru
• $(T, 40)$ girdi tensörünü üreten sabit frekanslı bir örnekleyici
• Yuvarlanan istatistikler kullanan çevrimiçi normalleştirme

Özellik Kararlılığı

Eğitim verisi üzerinde hesaplanan z-skoru normalleştirme parametreleri zaman içinde kayar. Fiyatlar değişir, volatilite rejimleri kayar, piyasa yapısı evrilir. Üretim sisteminin ihtiyacı olanlar:

• Yuvarlanan normalleştirme pencereleri (örn. istatistikleri günlük olarak yeniden hesaplama)
• Model yeniden eğitimini tetikleyecek rejim tespiti
• Girdi dağılımı kayması için izleme

Mikroyapıya Aşırı Uyum

LOB kalıpları mekâna özgü ve araca özgüdür. NASDAQ hisse senetleri üzerinde eğitilen bir model, yeniden eğitim olmadan Binance BTC/USDT üzerinde çalışmaz. Aynı mekân içinde bile modeller şunlara aşırı uyum sağlayabilir:

• Tik boyutu rejimi (büyük-tikli vs küçük-tikli hisse senetleri)
• Günün saati kalıpları (açılış müzayedesi, öğle durgunluğu, kapanış çaprazı)
• Zaman içinde değişen piyasa yapıcı davranışı

Sonuç

DeepLOB, derin öğrenmenin piyasa mikroyapısına temiz, iyi motive edilmiş bir uygulamasını temsil eder. Üç bloklu mimarisi — uzamsal özellikler için CNN, çok ölçekli zamansal kalıplar için inception, ardışık bağımlılıklar için LSTM — limit emir defteri verisinin yapısına doğal olarak eşleşir.

Temel kavrayış, yalnızca bir derin modelin elle üretilen özellikleri eşleyebilmesi ya da geçebilmesi değil, mimarinin tümevarımsal önyargılarının — $1 \times 2$ filtreler, inception paralelliği, yinelemeli bellek — emir defterlerinin nasıl çalıştığına dair gerçek alan bilgisini kodlamasıdır. Bu, finansal veriye fırlatılmış jenerik bir derin ağ değildir; limit emir defterinin belirli geometrisi etrafında tasarlanmış bir mimaridir. Ve en ikna edici kanıtı, yazarların kendilerinin güvenmediği FI-2010 lider tablosu değil, bir yıllık LSE verisi üzerindeki transfer öğrenme sonucudur.

Uygulayıcılar için DeepLOB güçlü bir temel model ve kullanışlı bir yapı taşıdır. Araştırmacılar için, yapılandırılmış finansal veri üzerinde performansı yalnızca model ölçeğinin değil, düşünülmüş mimari tasarımının yönlendirdiğini gösterir. Yalnızca gerçek sayıları aktarmayı, etiket şemasına dikkat etmeyi ve sınıflandırma doğruluğunu işlem kârından çok uzak bir şey olarak ele almayı unutmayın.

Kaynaklar

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