DeepLOB: लिमिट ऑर्डर बुक्स पर डीप लर्निंग

लिमिट ऑर्डर बुक आधुनिक इलेक्ट्रॉनिक बाजारों की केंद्रीय डेटा संरचना है। हर बिड, हर आस्क, हर कैंसिलेशन — सब कुछ LOB में रहता है। दशकों से, क्वांटिटेटिव शोधकर्ताओं ने इस डेटा से हाथ से फीचर्स तैयार किए हैं: ऑर्डर इम्बैलेंस अनुपात, वेटेड मिड-प्राइस, क्यू पोजिशन सिग्नल। DeepLOB ने एक अलग रास्ता अपनाया — यह एक हाइब्रिड CNN-LSTM आर्किटेक्चर का उपयोग करके सीधे कच्चे ऑर्डर बुक स्नैपशॉट से ये फीचर्स सीखता है।

2019 में Oxford-Man Institute में Zhang, Zohren और Roberts द्वारा प्रकाशित, DeepLOB ने दिखाया कि एक ही डीप नेटवर्क, जो कच्चे बुक डेटा पर एंड-टू-एंड प्रशिक्षित है, मिड-प्राइस मूवमेंट की भविष्यवाणी में मजबूत क्लासिकल बेसलाइनों के बराबर या उनसे बेहतर है। हालांकि, हमें प्रमाण के बारे में सटीक होना चाहिए। बेंचमार्क FI-2010 डेटासेट वह है जिसे अधिकांश पेपर उद्धृत करते हैं, लेकिन स्वयं लेखक इसे अपर्याप्त मानते हैं — "बहुत छोटा, डाउनसैंपल्ड और कम तरल बाजार से लिया गया" — और लंदन स्टॉक एक्सचेंज (LSE) डेटा पर एक दूसरा, बहुत बड़ा मूल्यांकन अपने मजबूत परिणाम के रूप में प्रस्तुत करते हैं। वह LSE अध्ययन पांच प्रशिक्षण स्टॉक्स और पांच परीक्षण स्टॉक्स पर लगभग एक साल तक फैला है, लगभग 100M+ नमूनों के क्रम में, और ट्रांसफर लर्निंग को प्रदर्शित करता है: स्टॉक्स के एक सेट पर प्रशिक्षित मॉडल अभी भी अनदेखे स्टॉक्स पर भविष्यवाणी करता है। वह ट्रांसफर परिणाम, न कि FI-2010 लीडरबोर्ड, पेपर की असली मुख्य बात है। यह पोस्ट आर्किटेक्चर, गणित, असली आंकड़ों, और एक कार्यशील PyTorch पुनर्कार्यान्वयन का विच्छेदन करती है।

डेटा संरचना के रूप में लिमिट ऑर्डर बुक

एक लिमिट ऑर्डर बुक दो क्रमबद्ध सूचियां रखती है — बिड (खरीद ऑर्डर) और आस्क (बिक्री ऑर्डर) — प्रत्येक मूल्य स्तर के अनुसार व्यवस्थित। प्रत्येक स्तर पर, बुक लंबित ऑर्डरों का मूल्य और कुल वॉल्यूम रिकॉर्ड करती है।

$L$ स्तरों वाली एक ऑर्डर बुक के लिए, समय $t$ पर एक एकल स्नैपशॉट $4L$ मानों का एक वेक्टर है:

जहां $p_i^{a}$ और $v_i^{a}$ स्तर $i$ पर आस्क मूल्य और वॉल्यूम हैं, और $p_i^{b}$, $v_i^{b}$ संबंधित बिड-साइड मान हैं। स्तर 1 में सर्वश्रेष्ठ बिड और सर्वश्रेष्ठ आस्क (BBO) होते हैं; उनका अंतर बिड-आस्क स्प्रेड है।

FI-2010 बेंचमार्क डेटासेट में, $L = 10$, जिससे प्रति स्नैपशॉट 40 फीचर्स मिलते हैं। FI-2010 NASDAQ Nordic (Kesko, Outokumpu, Sampo, Rautaruukki, Wartsila) पर पांच फिनिश इक्विटीज़ के लगभग 4 मिलियन कच्चे लिमिट-ऑर्डर संदेशों से, दस लगातार ट्रेडिंग दिनों में, 1-14 जून 2010 को बनाया गया है। महत्वपूर्ण रूप से, DeepLOB 4M स्नैपशॉट्स पर प्रशिक्षित नहीं होता: बेंचमार्क उन संदेशों को (हर 10 घटनाओं पर) डाउनसैंपल करके 394,337 नमूनों के एक सामान्यीकृत प्रतिनिधित्व में बदल देता है। वह डाउनसैंपल्ड, सामान्यीकृत रूप ही है जिसे मॉडल वास्तव में देखता है — यही एक कारण है कि लेखक FI-2010 को अंतिम शब्द मानने के विरुद्ध चेतावनी देते हैं।

मिड-प्राइस और इसकी गतिविधियां

समय $t$ पर मिड-प्राइस सर्वश्रेष्ठ बिड और आस्क का औसत है:

DeepLOB $k$ घटनाओं के भविष्य के क्षितिज पर मिड-प्राइस मूवमेंट की दिशा का अनुमान लगाता है। लेबल एक स्मूथ किया गया रिटर्न है, लेकिन ध्यान रहे साहित्य में दो स्मूथिंग परंपराएं हैं, और वे परस्पर बदली नहीं जा सकतीं:

• भविष्य-औसत बनाम वर्तमान मूल्य (Tsantekidis et al.): अगली $k$ घटनाओं में औसत मिड-प्राइस की तुलना कच्चे वर्तमान मिड-प्राइस से करता है।
• भविष्य-औसत बनाम पिछला-औसत (Ntakaris et al., विहित FI-2010 लेबल, वही जो DeepLOB ने अपने LSE डेटा के लिए उपयोग किया): संदर्भ और लक्ष्य दोनों स्मूथ किए गए हैं।

संदर्भ को स्मूथ करना (न कि केवल भविष्य को) सिंगल-टिक उतार-चढ़ाव से लेबल शोर को काफी कम करता है, यही कारण है कि पिछला/अगला-औसत रूप पसंद किया जाता है। जो भी उपयोग करें, निरंतर रिटर्न को $\pm\alpha$ के निश्चित थ्रेशोल्ड का उपयोग करके तीन वर्गों में विभाजित किया जाता है — ऊपर, नीचे, स्थिर:

FI-2010 डेटासेट पांच भविष्यवाणी क्षितिजों के लिए लेबल प्रदान करता है: $k \in \{10, 20, 30, 50, 100\}$ घटनाएं।

पारंपरिक LOB फीचर्स

डीप लर्निंग से पहले, शोधकर्ता हाथ से तैयार फीचर्स पर निर्भर थे। इन्हें समझना आवश्यक है, क्योंकि DeepLOB जानबूझकर इनमें से कई से मिलता-जुलता संरचित है — इसका आर्किटेक्चर इन मात्राओं से प्रेरित है, भले ही यह उन्हें बिल्कुल पुनरुत्पादित न करे।

ऑर्डर बुक इम्बैलेंस (OBI)

सबसे व्यापक रूप से उपयोग किया जाने वाला माइक्रोस्ट्रक्चर सिग्नल। बुक के शीर्ष पर:

आस्क वॉल्यूम की तुलना में अधिक बिड वॉल्यूम ऊपर की ओर दबाव का सुझाव देता है। मल्टी-लेवल इम्बैलेंस $L$ स्तरों में एकत्रित होता है:

वॉल्यूम-वेटेड मिड-प्राइस

मानक मिड-प्राइस दोनों पक्षों को समान रूप से वेट करता है। वॉल्यूम-वेटेड मिड-प्राइस (जिसे वेटेड मिड, या VAMP भी कहा जाता है) बुक के भारी पक्ष की ओर झुकता है। टॉप-ऑफ-बुक इम्बैलेंस को $I = v_1^{b}/(v_1^{b}+v_1^{a})$ लिखते हुए, यह दोनों मूल्यों का इम्बैलेंस-वेटेड औसत है:

क्रॉस-वेटिंग पर ध्यान दें: आस्क मूल्य को बिड वॉल्यूम से वेट किया जाता है और इसके विपरीत भी। जब बिड वॉल्यूम हावी होता है ($I \to 1$), वेटेड मिड आस्क की ओर शिफ्ट होता है — यह उम्मीद दर्शाता है कि एक असंतुलित बुक भारी पक्ष की ओर बढ़कर हल हो जाएगी।

नामकरण पर सावधानी का एक शब्द। यह स्थिर, वॉल्यूम-वेटेड मिड Stoikov का माइक्रोप्राइस नहीं है। Stoikov का माइक्रो-प्राइस (2018) एक मार्टिंगेल-समायोजित अनुमानक $M_t + g(I, S)$ है जो स्प्रेड और इम्बैलेंस कैसे विकसित होते हैं इसके पुनरावर्ती सुधार से प्राप्त होता है — Stoikov की पूरी बात यह है कि भोला वेटेड मिड पक्षपाती है और मार्टिंगेल नहीं है। ये दो अलग वस्तुएं हैं; हम यहां वेटेड मिड का उपयोग इसकी सरलता के लिए करते हैं, माइक्रोप्राइस के विकल्प के रूप में नहीं।

डेप्थ इम्बैलेंस

BBO से परे बुक के आकार को मापता है:

स्प्रेड और सापेक्ष स्प्रेड

ये फीचर्स शक्तिशाली लेकिन सीमित हैं। इन्हें डिज़ाइन करने के लिए डोमेन विशेषज्ञता की आवश्यकता होती है, ये जटिल नॉनलीनियर अंतःक्रियाओं को नहीं पकड़ते, और लगातार स्नैपशॉट्स में टेम्पोरल डायनामिक्स को नज़रअंदाज़ करते हैं। DeepLOB तीनों सीमाओं को संबोधित करता है।

DeepLOB आर्किटेक्चर

आर्किटेक्चर में तीन ब्लॉक हैं, प्रत्येक की एक अलग भूमिका है:

1. कन्वोल्यूशनल ब्लॉक — ऑर्डर बुक स्नैपशॉट से स्पेशियल फीचर्स निकालता है
2. इंसेप्शन मॉड्यूल — मल्टी-स्केल टेम्पोरल पैटर्न पकड़ता है
3. LSTM ब्लॉक — समय के साथ सीक्वेंशियल निर्भरताओं का मॉडल बनाता है

नेटवर्क का इनपुट $(T, L \times 4)$ आकार का एक टेंसर है, जहां $T$ लुकबैक विंडो है (पेपर में 100 टाइमस्टेप्स) और $L \times 4 = 40$ दोनों पक्षों पर मूल्य और वॉल्यूम के 10 स्तरों के लिए है।

ब्लॉक 1: कन्वोल्यूशनल फीचर एक्सट्रैक्शन

पहली कन्वोल्यूशनल परतें प्रत्येक स्तर पर मूल्य और वॉल्यूम के बीच अंतःक्रियाओं को सीखने के लिए फीचर डायमेंशन के साथ काम करती हैं।

परत 1: प्रत्येक मूल्य-वॉल्यूम जोड़ी पर लागू $1 \times 2$ फिल्टर आकार और $(1, 2)$ स्ट्राइड वाला एक कन्वोल्यूशन। यह प्रत्येक $(p_i, v_i)$ जोड़ी को एक ही फीचर में सारांशित करता है — प्रत्येक स्तर पर एक "मूल्य-वॉल्यूम अंतःक्रिया" की गणना के समान। चौड़ाई 40 से घटकर 20 हो जाती है।

परत 2: एक $1 \times 2$, स्ट्राइड $(1, 2)$ कन्वोल्यूशन जो उसी स्तर पर मिलान किए गए बिड-आस्क जोड़ों में काम करता है। यह प्रति-स्तर स्प्रेड और इम्बैलेंस जानकारी पकड़ता है। चौड़ाई 20 से घटकर 10 हो जाती है।

परत 3: एक $1 \times 10$ कन्वोल्यूशन जो सभी 10 स्तरों में एकीकृत करता है, डेप्थ डायमेंशन को चौड़ाई 1 में समेट देता है। यह प्रति टाइमस्टेप एक एकल एकत्रित फीचर उत्पन्न करता है जो पूरे डेप्थ प्रोफ़ाइल को एनकोड करता है।

प्रत्येक $1 \times 2$ / $1 \times 10$ चरण के बाद टाइम अक्ष के साथ दो $(4, 1)$ कन्वोल्यूशन आते हैं, प्रत्येक के साथ LeakyReLU एक्टिवेशन और बैच नॉर्मलाइज़ेशन। ध्यान दें कि padding=(1, 0) वाले ये $(4, 1)$ कन्वोल्यूशन टाइम डायमेंशन को संरक्षित नहीं करते: प्रत्येक इसे एक कदम छोटा करता है ($T_{\text{out}} = T_{\text{in}} - 1$)। ब्लॉक 1-3 में ऐसी छह परतों में, इंसेप्शन मॉड्यूल से पहले टाइम अक्ष 100 से घटकर 94 हो जाता है — यह कुछ ऐसा है जो नीचे कोड में शेप टिप्पणियां स्पष्ट करती हैं।

डिज़ाइन जानबूझकर बड़े स्पेशियल फिल्टरों से बचता है। $1 \times 2$ फिल्टर LOB डेटा की प्राकृतिक जोड़ी संरचना का सम्मान करते हैं — मूल्य के साथ वॉल्यूम, बिड के साथ आस्क। यह इंडक्टिव बायस महत्वपूर्ण है: एक $3 \times 3$ फिल्टर आसन्न स्तरों और पक्षों को इस तरह मिला देगा जिसका कोई वित्तीय अर्थ नहीं है।

ब्लॉक 2: इंसेप्शन मॉड्यूल

कन्वोल्यूशनल ब्लॉक द्वारा 40 फीचर्स को एक कॉम्पैक्ट स्पेशियल रिप्रजेंटेशन (चौड़ाई 1) में घटाने के बाद, इंसेप्शन मॉड्यूल एक साथ कई टेम्पोरल स्केल पर पैटर्न पकड़ने के लिए टाइम डायमेंशन के साथ काम करता है।

DeepLOB इंसेप्शन मॉड्यूल में चार समानांतर पथ हैं, प्रत्येक 32 चैनल उत्पन्न करता है, सभी को जोड़ा गया:

• $1 \times 1$ बॉटलनेक $\to$ $3 \times 1$ टेम्पोरल कन्वोल्यूशन: अल्पकालिक टेम्पोरल पैटर्न (3 टाइमस्टेप्स)
• $1 \times 1$ बॉटलनेक $\to$ $5 \times 1$ टेम्पोरल कन्वोल्यूशन: मध्यम अवधि के टेम्पोरल पैटर्न (5 टाइमस्टेप्स)
• $3 \times 1$ मैक्स-पूल $\to$ $1 \times 1$ कन्वोल्यूशन: एक पूलिंग पथ जो एक स्मूथ, डाउनसैंपल्ड दृश्य बनाए रखता है
• ($1 \times 1$ रिडक्शन टेम्पोरल कन्वोल्यूशन से पहले पॉइंट-इन-टाइम बॉटलनेक के रूप में कार्य करते हैं)

प्रत्येक टेम्पोरल पथ सिमेट्रिक पैडिंग का उपयोग करता है ताकि इंसेप्शन ब्लॉक के भीतर टाइम डायमेंशन बनी रहे (ऊपर के कन्वोल्यूशन ब्लॉक्स के विपरीत)। आउटपुट को चैनल डायमेंशन के साथ जोड़ा जाता है, जिससे नेटवर्क को एक साथ मल्टी-स्केल टेम्पोरल फीचर्स तक पहुंच मिलती है।

यह GoogLeNet इंसेप्शन आर्किटेक्चर से प्रेरित है, लेकिन 2D छवियों के बजाय 1D टेम्पोरल डेटा के लिए अनुकूलित है। मुख्य अंतर्दृष्टि यह है कि LOB डायनामिक्स कई समय पैमानों पर काम करते हैं: टिक-दर-टिक शोर, अल्पकालिक मोमेंटम, और लंबे-क्षितिज मीन रिवर्जन सभी एक साथ मौजूद रहते हैं।

नीचे दिया गया PyTorch पुनर्कार्यान्वयन एक सरलीकृत तीन-पथ वेरिएंट प्रस्तुत करता है (दो टेम्पोरल कन्वोल्यूशन प्लस एक $1\times1$ पथ) ताकि कोड पठनीय बना रहे; यह मैक्स-पूल पथ को छोड़ देता है। हम इसे स्पष्ट रूप से इंगित करते हैं क्योंकि यह पेपर से एक विचलन है, मूल मॉड्यूल नहीं।

ब्लॉक 3: LSTM सीक्वेंस मॉडलिंग

इंसेप्शन मॉड्यूल का आउटपुट एक LSTM परत में फीड किया जाता है जो पूरी $T$-लंबाई सीक्वेंस को प्रोसेस करता है। LSTM लंबी दूरी की टेम्पोरल निर्भरताओं को पकड़ता है जिन्हें केवल कन्वोल्यूशन छोड़ देंगे — रेजिम परिवर्तन, दिन के समय के प्रभाव, और विकसित होती बाजार स्थितियां।

LSTM की अंतिम हिडन स्टेट को तीन वर्गों (ऊपर, नीचे, स्थिर) पर एक प्रायिकता वितरण उत्पन्न करने के लिए सॉफ्टमैक्स एक्टिवेशन वाली एक फुली कनेक्टेड परत से गुजारा जाता है।

लॉस फंक्शन

मॉडल को कैटेगोरिकल क्रॉस-एंट्रॉपी के साथ प्रशिक्षित किया जाता है:

जहां $y_{i,c}$ वन-हॉट एनकोडेड सत्य लेबल है और $\hat{y}_{i,c}$ वर्ग $c$ के लिए अनुमानित प्रायिकता है।

PyTorch पुनर्कार्यान्वयन

मूल DeepLOB को TensorFlow बैकएंड पर Keras में बनाया गया था; लेखकों के रिपॉजिटरी (zcakhaa) ने बाद में एक PyTorch पोर्ट जोड़ा। नीचे दिया गया कोड हमारा अपना उदाहरणात्मक PyTorch पुनर्कार्यान्वयन है, आधिकारिक नहीं। यह पेपर से दो तरीकों से विचलित होता है जिन्हें हम इनलाइन फ्लैग करते हैं: यह इंसेप्शन मैक्स-पूल पथ को छोड़ देता है (चार के बजाय तीन पथ), और यह चैनल काउंट को बढ़ाता है। पेपर पूरे कन्वोल्यूशन ब्लॉक्स में 16 फिल्टर और प्रति इंसेप्शन पथ 32 फिल्टर (LSTM इनपुट $3 \times 32 = 96$) का उपयोग करता है, जिससे लगभग 60k पैरामीटर का एक कॉम्पैक्ट मॉडल मिलता है। नीचे दिया गया स्निपेट 32 कन्वोल्यूशन / 64 इंसेप्शन फिल्टर (LSTM इनपुट 192) का उपयोग करता है — आंतरिक रूप से संगत और चलाने योग्य, लेकिन मूल से भारी। पेपर से मेल खाने के लिए, कन्वोल्यूशन चैनलों को 16, इंसेप्शन चैनलों को 32, और 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

डेटा प्रीप्रोसेसिंग

FI-2010 डेटासेट z-score सामान्यीकृत रूप में आता है। लाइव ऑर्डर बुक डेटा के लिए, आपको इसी तरह सामान्यीकरण करने की आवश्यकता है:

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
        )

प्रशिक्षण लूप

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

मूल पेपर से मुख्य प्रशिक्षण हाइपरपैरामीटर:

• ऑप्टिमाइज़र: Adam $\epsilon = 1$ के साथ (असामान्य रूप से बड़ा — शोरगुल वाले वित्तीय डेटा पर अपडेट को स्थिर करने में मदद करता है)
• लर्निंग रेट: 0.01
• बैच साइज़: 32
• लुकबैक विंडो: $T = 100$ टाइमस्टेप्स

हम वैलिडेशन में एक्यूरेसी के बजाय वेटेड F1 को ट्रैक करते हैं, क्योंकि तीन वर्ग असंतुलित हैं — और, जैसा कि अगला भाग दिखाता है, F1 वह मीट्रिक है जिस पर मूल पेपर ठीक इसी कारण से जोर देता है।

DeepLOB को क्या पकड़ने के लिए बनाया गया है

DeepLOB का एक आकर्षक पहलू यह है कि इसके ब्लॉक ऊपर दिए गए हाथ से तैयार फीचर्स से कितने निकटता से प्रेरित हैं। हमें यहां सावधान रहना चाहिए: पेपर इन्हें डिज़ाइन अंतर्ज्ञान के रूप में प्रस्तुत करता है, न कि प्रशिक्षित नेटवर्क के सिद्ध गुणों के रूप में। यह फिल्टर विज़ुअलाइज़ेशन, एक्टिवेशन-इम्बैलेंस सहसंबंध, या LSTM किस पर ध्यान देता है इसका विश्लेषण प्रकाशित नहीं करता। इसलिए निम्नलिखित को आर्किटेक्चरल इरादे के रूप में पढ़ें, मापे गए निष्कर्षों के रूप में नहीं।

पहला कन्वोल्यूशनल ब्लॉक। $1 \times 2$ फिल्टर प्रत्येक स्तर पर मूल्य को वॉल्यूम के साथ जोड़ते हैं। संरचनात्मक रूप से, यह वही ऑपरेशन है जो वॉल्यूम-वेटेड मूल्य बनाता है — पेपर पहली परत को यह बताते हुए प्रेरित करता है कि इसके फीचर मैप एक माइक्रो-प्राइस जैसी मात्रा बनाते हैं। नेटवर्क उस परिवार में कुछ पुनर्प्राप्त करने के लिए बनाया गया है; हम यह दावा नहीं करते कि यह किसी विशिष्ट अनुमानक को सिद्ध रूप से फिर से खोजता है।

दूसरा कन्वोल्यूशनल ब्लॉक। बिड-आस्क जोड़ों पर काम करके, ये फिल्टर कई स्तरों पर इम्बैलेंस जैसी विशेषताओं को सीखने के लिए स्थित हैं — फिर से, प्रदर्शित सहसंबंध के बजाय निर्माण द्वारा।

इंसेप्शन मॉड्यूल। मल्टी-स्केल टेम्पोरल कन्वोल्यूशन का उद्देश्य विभिन्न आवृत्तियों पर मोमेंटम को पकड़ना है: $1\times1$ पथ पॉइंट-इन-टाइम संरचना पर प्रतिक्रिया करता है, $3\times1$ पथ अल्पकालिक रुझानों पर, $5\times1$ पथ थोड़े लंबे रुझानों पर, और (पूर्ण मॉड्यूल में) मैक्स-पूल पथ एक स्मूथ दृश्य पर।

LSTM परत। आवर्ती घटक लंबी दूरी की निर्भरताओं की स्मृति जोड़ता है जिन्हें कन्वोल्यूशन प्रस्तुत नहीं कर सकते — रेजिम शिफ्ट और दिन के समय के प्रभाव। हम मजबूत दावों से बचते हैं (जैसे कि LSTM एक "अनुकूली ध्यान" लागू करता है जो अस्थिर रेजिम में हाल के डेटा को पुनर्भारित करता है); पेपर यह नहीं दिखाता।

FI-2010 पर प्रदर्शन

मूल पेपर दो प्रोटोकॉल का मूल्यांकन करता है। सेटअप 1 डेटासेट के पुराने सामान्यीकरण विभाजन का उपयोग करता है; सेटअप 2 वह डीप-लर्निंग सेटअप है जिससे अधिकांश बाद का काम तुलना करता है। चूंकि FI-2010 क्लास-असंतुलित है, पेपर एक्यूरेसी नहीं बल्कि F1 पर जोर देता है, और गैर-न्यूरल बेसलाइनों (SVM, MLP) के लिए प्रिसिजन/रिकॉल-आधारित आंकड़े रिपोर्ट करता है। यहां असली सेटअप 2 आंकड़े हैं (F1, %):

$k = 10$ पर, DeepLOB अपने 83.40 F1 के साथ 84.47% एक्यूरेसी भी रिपोर्ट करता है। सेटअप 2 केवल $k \in \{10, 20, 50\}$ रिपोर्ट करता है — यहां $k = 100$ पंक्ति नहीं है। (सेटअप 1 $k \in \{10, 50, 100\}$ रिपोर्ट करता है, क्रमशः 77.66 / 74.96 / 76.58 के DeepLOB F1 के साथ।) ऊपर दिए गए डैश उन बेसलाइन सेल को चिह्नित करते हैं जिन्हें पेपर इस प्रोटोकॉल में उन क्षितिजों पर सारणीबद्ध नहीं करता।

कई अवलोकन सामने आते हैं:

1. DeepLOB छोटे क्षितिज पर बड़े अंतर से बेसलाइनों को पीछे छोड़ता है। $k = 10$ पर इसका F1 (83.40) LSTM (66.33), CNN-I (55.21), MLP (48.27), और SVM (35.88) से काफी ऊपर है। गुणात्मक क्रम — साधारण CNN, MLP, और SVM से ऊपर डीप रिकरेंट-कन्वोल्यूशनल मॉडल — मजबूत निष्कर्ष है।
2. क्षितिज प्रवृत्ति गैर-मोनोटोनिक है, "लंबा आसान है" नहीं। सेटअप 2 में, DeepLOB का F1 $83.40 \to 72.82 \to 80.35$ जाता है जैसे-जैसे $k$ $10 \to 20 \to 50$ जाता है — एक U-आकार का पैटर्न, जिसमें $k=20$ सबसे कठिन है, एक स्पष्ट ऊपर की ओर मार्च नहीं। क्या कोई क्षितिज "आसान" है यह सेटअप, थ्रेशोल्ड $\alpha$, और लेबल-स्मूथिंग स्कीम पर बहुत निर्भर करता है; हमें इन आंकड़ों में एक सार्वभौमिक नियम नहीं पढ़ना चाहिए।
3. DeepLOB हर सेल में हर क्लासिकल विधि पर हावी नहीं होता। C(TABL) जैसी मजबूत बेसलाइनों के खिलाफ कुछ क्षितिजों पर अंतर संकीर्ण हो जाता है, इसलिए "हर जगह सभी क्लासिकल दृष्टिकोणों से बेहतर प्रदर्शन करता है" मामले को बढ़ा-चढ़ाकर पेश करता है। रक्षात्मक दावा यह है कि यह प्रतिस्पर्धी-से-श्रेष्ठ है, और छोटे क्षितिज पर स्पष्ट रूप से सर्वश्रेष्ठ है।

और फिर से: पेपर का अपना दृष्टिकोण यह है कि FI-2010 प्रश्न का समाधान करने के लिए बहुत छोटा और बहुत डाउनसैंपल्ड है। इसका मजबूत प्रमाण LSE अध्ययन है, जहां DeepLOB स्टॉक्स के एक सेट पर प्रशिक्षित होता है और फिर भी अनदेखे स्टॉक्स पर भविष्यवाणी करता है — एक ट्रांसफर-लर्निंग परिणाम जिसे FI-2010 नहीं दिखा सकता।

LOBFrame और प्रतिकृति संकट

LOBFrame बेंचमार्क फ्रेमवर्क (Briola, Bartolucci, Aste, 2024) इन परिणामों के लिए एक गंभीर पूरक प्रदान करता है। जबकि DeepLOB का आर्किटेक्चर ठोस है, फ्रेमवर्क कई महत्वपूर्ण चेतावनियां उजागर करता है:

माइक्रोस्ट्रक्चर निर्भरता। मॉडल प्रदर्शन विभिन्न माइक्रोस्ट्रक्चरल विशेषताओं वाले स्टॉक्स में काफी भिन्न होता है। तरल, बड़े-टिक स्टॉक्स अतरल, छोटे-टिक इंस्ट्रूमेंट्स की तुलना में भविष्यवाणी करना आसान होते हैं। एक मॉडल जो एक स्टॉक पर मजबूत दिखता है, दूसरे पर काफी बिगड़ सकता है।

भविष्यवाणी बनाम मुनाफा। उच्च वर्गीकरण एक्यूरेसी स्वचालित रूप से ट्रेडिंग मुनाफे में तब्दील नहीं होती। LOBFrame उन मीट्रिक्स पर जोर देता है जो इससे जुड़े हैं कि क्या एक अनुमानित मूवमेंट बिड-आस्क स्प्रेड को पार करने के लिए पर्याप्त बड़ा है। एक मॉडल को स्प्रेड पर काबू पाने के लिए पर्याप्त बार, और पर्याप्त बड़ी चालों पर, सही होना चाहिए — और टाइट-स्प्रेड स्टॉक्स के लिए यह बार ऊंचा है।

लेबल संवेदनशीलता। थ्रेशोल्ड $\alpha$ और क्षितिज $k$ का चुनाव रिपोर्ट की गई एक्यूरेसी और भविष्यवाणियों के व्यावहारिक मूल्य दोनों को नाटकीय रूप से प्रभावित करता है। बहुत टाइट लेबल शोरगुल वाले लक्ष्य उत्पन्न करते हैं; बहुत चौड़े लेबल तुच्छ रूप से "सटीक" लेकिन बेकार भविष्यवाणियां उत्पन्न करते हैं।

DeepLOB से आगे: वर्तमान परिदृश्य

DeepLOB के प्रकाशन के बाद से, कई विस्तार सामने आए हैं:

लिमिट ऑर्डर बुक्स के लिए ट्रांसफॉर्मर (Wallbridge, 2020). अक्सर बाद के साहित्य में ढीले ढंग से "TransLOB" कहा जाता है, मॉडल स्वयं एक कॉज़ल/डाइलेटेड कन्वोल्यूशनल फीचर एक्सट्रैक्टर है जिसके बाद मास्क्ड मल्टी-हेड सेल्फ-अटेंशन आता है — बस LSTM को ट्रांसफॉर्मर से बदला हुआ DeepLOB नहीं; यह इंसेप्शन+कन्वोल्यूशन स्टैक का पुनः उपयोग नहीं करता। इसने अपने समय के लिए FI-2010 पर एक नया स्टेट ऑफ द आर्ट रिपोर्ट किया।

क्रिप्टो-डोमेन वेरिएंट। कई समूह DeepLOB-शैली आर्किटेक्चर को क्रिप्टोकरेंसी बाजारों पर लागू करते हैं, जहां ऑर्डर बुक डायनामिक्स इक्विटीज़ से काफी भिन्न होते हैं — व्यापक स्प्रेड, 24/7 ट्रेडिंग, और एक अलग प्रतिभागी मिश्रण जो सभी पुनर्प्रशिक्षण की मांग करते हैं।

अटेंशन-संवर्धित वेरिएंट। काम की एक पंक्ति इंसेप्शन और LSTM ब्लॉक्स के बीच मल्टी-हेड अटेंशन डालती है, जिससे नेटवर्क को वर्तमान भविष्यवाणी के लिए सबसे अधिक जानकारीपूर्ण स्तरों या टाइमस्टेप्स पर ध्यान केंद्रित करने की अनुमति मिलती है।

LOB-Bench (Nagy, Frey, Li, Sarkar, Vyetrenko, Zohren, Calinescu, Foerster, 2025). यह बेंचमार्क भविष्यवाणी से जनरेशन की ओर ध्यान मोड़ता है, यह स्कोर करते हुए कि ऑर्डर बुक डेटा के जनरेटिव मॉडल कितने यथार्थवादी हैं — दिशात्मक पूर्वानुमान के बजाय बैकटेस्टिंग और एजेंट प्रशिक्षण के लिए प्रासंगिक।

प्रोडक्शन के लिए व्यावहारिक विचार

यदि आप एक लाइव ट्रेडिंग सिस्टम में DeepLOB-शैली का मॉडल तैनात करने पर विचार कर रहे हैं, तो कई इंजीनियरिंग चिंताएं उत्पन्न होती हैं:

लेटेंसी

मॉडल को आपके ट्रेडिंग सिस्टम के लेटेंसी बजट के भीतर भविष्यवाणियां उत्पन्न करनी चाहिए। सब-मिलीसेकंड लेटेंसी पर काम करने वाले HFT सिस्टम के लिए, यहां तक कि एक अनुकूलित PyTorch इन्फरेंस भी बहुत धीमा हो सकता है। विकल्पों में शामिल हैं:

• TensorRT ऑप्टिमाइज़ेशन के साथ ONNX एक्सपोर्ट
• INT8 में क्वांटाइज़ेशन
• सबसे लेटेंसी-संवेदनशील एप्लिकेशन के लिए FPGA परिनियोजन

डेटा पाइपलाइन

मॉडल एक निश्चित आवृत्ति पर सामान्यीकृत, संरेखित ऑर्डर बुक स्नैपशॉट की अपेक्षा करता है। व्यवहार में, LOB अपडेट अतुल्यकालिक रूप से आते हैं। आपको चाहिए:

• एक स्नैपशॉट पुनर्निर्माण इंजन जो वर्तमान बुक स्थिति को बनाए रखता है
• एक निश्चित-आवृत्ति सैंपलर जो $(T, 40)$ इनपुट टेंसर उत्पन्न करता है
• रोलिंग सांख्यिकी का उपयोग करके ऑनलाइन सामान्यीकरण

फीचर स्थिरता

प्रशिक्षण डेटा पर गणना किए गए z-score सामान्यीकरण पैरामीटर समय के साथ बदलते हैं। मूल्य बदलते हैं, अस्थिरता रेजिम शिफ्ट होते हैं, बाजार संरचना विकसित होती है। एक प्रोडक्शन सिस्टम को चाहिए:

• रोलिंग सामान्यीकरण विंडो (जैसे, प्रतिदिन सांख्यिकी की पुनर्गणना)
• मॉडल पुनर्प्रशिक्षण को ट्रिगर करने के लिए रेजिम डिटेक्शन
• इनपुट वितरण शिफ्ट के लिए निगरानी

माइक्रोस्ट्रक्चर पर ओवरफिटिंग

LOB पैटर्न वेन्यू-विशिष्ट और इंस्ट्रूमेंट-विशिष्ट होते हैं। NASDAQ इक्विटीज़ पर प्रशिक्षित एक मॉडल बिना पुनर्प्रशिक्षण के Binance BTC/USDT पर काम नहीं करेगा। यहां तक कि उसी वेन्यू के भीतर, मॉडल इन पर ओवरफिट हो सकते हैं:

• टिक साइज़ रेजिम (बड़े-टिक बनाम छोटे-टिक स्टॉक्स)
• दिन के समय के पैटर्न (ओपनिंग नीलामी, लंच लल, क्लोजिंग क्रॉस)
• मार्केट मेकर व्यवहार जो समय के साथ बदलता है

निष्कर्ष

DeepLOB मार्केट माइक्रोस्ट्रक्चर पर डीप लर्निंग के एक स्वच्छ, अच्छी तरह से प्रेरित अनुप्रयोग का प्रतिनिधित्व करता है। इसका तीन-ब्लॉक आर्किटेक्चर — स्पेशियल फीचर्स के लिए CNN, मल्टी-स्केल टेम्पोरल पैटर्न के लिए इंसेप्शन, सीक्वेंशियल निर्भरताओं के लिए LSTM — लिमिट ऑर्डर बुक डेटा की संरचना पर स्वाभाविक रूप से मैप होता है।

मुख्य अंतर्दृष्टि केवल यह नहीं है कि एक डीप मॉडल हाथ से तैयार फीचर्स के बराबर या उनसे बेहतर हो सकता है, बल्कि यह कि आर्किटेक्चर के इंडक्टिव बायस — $1 \times 2$ फिल्टर, इंसेप्शन समानांतरता, आवर्ती स्मृति — ऑर्डर बुक कैसे काम करते हैं इस बारे में वास्तविक डोमेन ज्ञान को एनकोड करते हैं। यह वित्तीय डेटा पर फेंका गया एक सामान्य डीप नेटवर्क नहीं है; यह लिमिट ऑर्डर बुक की विशिष्ट ज्यामिति के आसपास डिज़ाइन किया गया एक आर्किटेक्चर है। और इसका सबसे विश्वसनीय प्रमाण FI-2010 लीडरबोर्ड नहीं है जिस पर स्वयं लेखकों को भरोसा नहीं है, बल्कि LSE डेटा के एक वर्ष पर ट्रांसफर-लर्निंग परिणाम है।

चिकित्सकों के लिए, DeepLOB एक मजबूत बेसलाइन और एक उपयोगी बिल्डिंग ब्लॉक है। शोधकर्ताओं के लिए, यह प्रदर्शित करता है कि विचारशील आर्किटेक्चर डिज़ाइन — न कि केवल मॉडल स्केल — संरचित वित्तीय डेटा पर प्रदर्शन को आगे बढ़ाता है। बस असली आंकड़ों को उद्धृत करना, लेबल स्कीम पर नज़र रखना, और वर्गीकरण एक्यूरेसी को ट्रेडिंग मुनाफे से बहुत दूर मानना याद रखें।

संदर्भ

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