गैर-पैरामीट्रिक मूल्य मॉडलिंग के लिए गाऊसी प्रक्रियाएं

"क्लासिक एमएल बेसलाइन" श्रृंखला का हिस्सा।

दो चीज़ें गॉसियन प्रक्रिया को इस ब्लॉग पर एक अलग लेख के लायक बनाती हैं, और उनमें से कोई भी "यह आपको अनिश्चितता नहीं देती है।"

पहला है कर्नेल डिज़ाइन। एक जीपी का संपूर्ण आगमनात्मक पूर्वाग्रह एक कार्य में रहता है $k(x, x')$ , और वह फ़ंक्शन कुछ ऐसा है जिसे आप जानबूझकर लिखते हैं: पथ कितना कठिन है, क्या यह दोहराता है, क्या पुनरावृत्ति कम हो जाती है। मानक टूलकिट में और कुछ भी आपको बाज़ार की गतिशीलता के बारे में एक संरचनात्मक परिकल्पना बताने की अनुमति नहीं देता है जो स्पष्ट रूप से और फिर उसमें फिट बैठता है। दूसरा है सीमांत संभावना - मॉडल से प्राप्त जटिलता दंड के साथ एक प्रशिक्षण उद्देश्य, किसी आयोजित-आउट सेट से नहीं। इस ब्लॉग पर ओवरफिटिंग आर्क में हर दूसरा लेख ([प्लेटो विश्लेषण] (/hi/blog/post/plateau-analysis-overfitting), पीबीओ, डिफ्लेटेड शार्प) मौजूद है क्योंकि सत्यापन-सेट नियमितीकरण खोज के तहत नाजुक है। एक जीपी का दावा है कि उसे इसकी आवश्यकता नहीं है। यह दावा परीक्षण योग्य है, और इसका परीक्षण करना किसी अन्य अनिश्चितता-आकार वाले ट्यूटोरियल की तुलना में अधिक दिलचस्प है।

अनिश्चितता पर ही: जीपी पश्च विचरण संरचनात्मक है - यह उसी अनुमान से निकलता है जो बाद में फिट किए गए मॉडल के चारों ओर लपेटे जाने के बजाय माध्य उत्पन्न करता है। यह [अनुरूप भविष्यवाणी] (/hi/blog/post/conformal-prediction-trading) के साथ वास्तविक विरोधाभास है, जो पहले से ही इस ब्लॉग पर बताता है कि स्थिति आकार निर्धारण के लिए अनिश्चितता सही इनपुट क्यों है और आपके पास एक अंतराल होने के बाद उसके साथ क्या करना है। यह लेख उस मामले पर दोबारा बहस नहीं करता है; यह मॉडल के पीछे जाता है।

इसके बाद कर्नेल और अनुमान मशीनरी, एक GPyTorch कार्यान्वयन है, और - अंत में स्पष्ट रूप से कहा गया है - इस लेख में अभी तक माप नहीं हैं।

गाऊसी प्रक्रिया क्या है?

जीपी पहले से ही इस ब्लॉग पर बायेसियन-ऑप्टिमाइज़ेशन सरोगेट के रूप में ऑप्टुना बनाम कोऑर्डिनेट डीसेंट में समान नोटेशन और समान लो-डायमेंशनलिटी कैविएट के साथ दिखाई देते हैं। यहां जीपी स्वयं मॉडल है, जिसे हाइपरपैरामीटर खोज सतह के बजाय बाजार डेटा के लिए फिट किया गया है, इसलिए उपचार अधिक गहरा हो जाता है।

गाऊसी प्रक्रिया यादृच्छिक चर का एक संग्रह है, जिसकी किसी भी सीमित संख्या में एक संयुक्त गाऊसी वितरण होता है। यह कार्यों पर वितरण है, मापदंडों पर वितरण नहीं।

औपचारिक रूप से, एक समारोह $f: \mathcal{X} \to \mathbb{R}$ यदि इनपुट के किसी सीमित सेट के लिए जीपी से लिया गया है $\{x_1, x_2, \ldots, x_n\} \subset \mathcal{X}$ :

$\begin{pmatrix} f(x_1) \\ f(x_2) \\ \vdots \\ f(x_n) \end{pmatrix} \sim \mathcal{N}\left(\begin{pmatrix} m(x_1) \\ m(x_2) \\ \vdots \\ m(x_n) \end{pmatrix}, \begin{pmatrix} k(x_1, x_1) & \cdots & k(x_1, x_n) \\ \vdots & \ddots & \vdots \\ k(x_n, x_1) & \cdots & k(x_n, x_n) \end{pmatrix}\right)$

कहाँ $m(x) = \mathbb{E}[f(x)]$ माध्य फलन है और $k(x, x') = \text{Cov}(f(x), f(x'))$ सहप्रसरण (कर्नेल) फ़ंक्शन है। हम इसे संक्षिप्त रूप से इस प्रकार लिखते हैं:

$f \sim \mathcal{GP}(m(\cdot), k(\cdot, \cdot))$

माध्य फ़ंक्शन औसत व्यवहार के बारे में पूर्व धारणा को कूटबद्ध करता है $f$ . ट्रेडिंग में, हम आम तौर पर सेट करते हैं $m(x) = 0$ , इस धारणा को एन्कोडिंग करते हुए कि हमारे पास रिटर्न पर कोई पूर्व दिशात्मक पूर्वाग्रह नहीं है। सारी संरचना कर्नेल में चली जाती है।

गैर-पैरामीट्रिक क्यों?

5 विशेषताओं वाले एक रैखिक प्रतिगमन मॉडल में 6 पैरामीटर हैं। 64 इकाइयों की दो छिपी हुई परतों वाले एक तंत्रिका नेटवर्क में हजारों इकाइयाँ होती हैं। जीपी में मापदंडों की कोई निश्चित संख्या नहीं होती - मॉडल की जटिलता डेटा के साथ बढ़ती है। 10 अवलोकनों के साथ, जीपी 10-आयामी गाऊसी को परिभाषित करता है। 10,000 अवलोकनों के साथ, यह 10,000-आयामी गाऊसी को परिभाषित करता है।

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

वित्तीय मॉडलिंग के लिए, यह मूल्यवान है। बाज़ार बदलते हैं. सुविधाओं और रिटर्न के बीच संबंध गैर-रेखीय, गैर-स्थिर और शासन-निर्भर है। पैरामीट्रिक मॉडल ऐसी संरचना लागू करते हैं जो वास्तविकता से मेल नहीं खा सकती है। जीपी डेटा को बोलने देते हैं।

कर्नेल फ़ंक्शंस: एन्कोडिंग बाज़ार संरचना

कर्नेल फ़ंक्शन $k(x, x')$ गाऊसी प्रक्रिया की आत्मा है। यह किन्हीं दो इनपुट बिंदुओं पर फ़ंक्शन मानों के बीच सहप्रसरण को निर्दिष्ट करके परिभाषित करता है कि कौन से फ़ंक्शन प्राथमिकता से संभावित हैं। अलग-अलग कर्नेल सहजता, आवधिकता और लंबी दूरी के व्यवहार के बारे में अलग-अलग धारणाओं को कूटबद्ध करते हैं।

रेडियल बेसिस फ़ंक्शन (आरबीएफ) / स्क्वायर एक्सपोनेंशियल

आरबीएफ कर्नेल सबसे आम शुरुआती बिंदु है:

$k_{\text{RBF}}(x, x') = \sigma^2 \exp\left(-\frac{\|x - x'\|^2}{2\ell^2}\right)$

कहाँ $\sigma^2$ सिग्नल विचरण (आउटपुट स्केल) है और $\ell$ लंबाई का पैमाना है. आरबीएफ कर्नेल के साथ जीपी से तैयार किए गए फ़ंक्शन असीम रूप से भिन्न होते हैं - बहुत सहज।

ट्रेडिंग व्याख्या: लंबाई पैमाना $\ell$ यह नियंत्रित करता है कि दो डेटा बिंदु कितनी दूर हो सकते हैं और फिर भी सहसंबद्ध हो सकते हैं। छोटी लंबाई के पैमाने का मतलब है कि मॉडल स्थानीय पैटर्न पर प्रतिक्रिया करता है; लंबी लंबाई के पैमाने का मतलब है कि यह व्यापक रुझानों को पकड़ता है। संकेत विचरण $\sigma^2$ फ़ंक्शन के आयाम को नियंत्रित करता है - अनुमानित रिटर्न कितना बड़ा हो सकता है।

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

मातृ कर्नेल

मैटरन वर्ग एक सहजता पैरामीटर पेश करके आरबीएफ को सामान्यीकृत करता है $\nu$ :

$k_{\text{Matern}}(x, x') = \sigma^2 \frac{2^{1-\nu}}{\Gamma(\nu)} \left(\frac{\sqrt{2\nu}\|x - x'\|}{\ell}\right)^{\nu} K_{\nu}\left(\frac{\sqrt{2\nu}\|x - x'\|}{\ell}\right)$

कहाँ $K_{\nu}$ दूसरे प्रकार का संशोधित बेसेल फ़ंक्शन है। जैसा $\nu \to \infty$ , मैटरन कर्नेल आरबीएफ में परिवर्तित हो जाता है। सामान्य विकल्प:

$\nu = 1/2$ : ऑर्नस्टीन-उहलेनबेक प्रक्रिया के समतुल्य। कार्य निरंतर होते हैं लेकिन भिन्न नहीं होते - कच्चे, ब्राउनियन गति की तरह।
$\nu = 3/2$ : कार्य एक बार भिन्न होते हैं। चिकनाई और लचीलेपन के बीच एक अच्छा संतुलन।
$\nu = 5/2$ : फ़ंक्शन दो बार भिन्न होते हैं। से भी अधिक चिकना $3/2$ लेकिन आरबीएफ से कम कठोर।

ट्रेडिंग व्याख्या: द मेटरन- $3/2$ वित्तीय समय श्रृंखला के लिए कर्नेल यकीनन सबसे अच्छा डिफ़ॉल्ट है। यह उस प्रकार की खुरदरापन की अनुमति देता है जो वास्तविक मूल्य पथ बिना किसी उतार-चढ़ाव के प्रदर्शित होते हैं $\nu = 1/2$ . यह "अस्थिरता कठिन है" साहित्य (गैथेरल, जैसन, और रोसेनबाम, 2018) के साथ संरेखित है, जो अनुभवजन्य रूप से दिखाता है कि अस्थिरता पथ के आसपास हर्स्ट प्रतिपादक हैं $H \approx 0.1$ , ब्राउनियन गति से कहीं अधिक कठोर।

मेटरन कर्नेल द्वारा शास्त्रीय अस्थिरता मॉडल को मात देने का मुख्य प्रकाशित साक्ष्य रिज़वी एट अल हैं। (2017), जो रैंडम वॉक की तुलना में लगभग 20% बेहतर एमएसई और GARCH से 50% बेहतर रिपोर्ट करते हैं - 2017 के दैनिक मुद्रा-जोड़ी डेटा पर, क्रिप्टो नहीं, और यहां पुन: प्रस्तुत नहीं किया गया। इसे कर्नेल को आज़माने के लिए प्रेरणा के रूप में मानें, बेंचमार्क के रूप में नहीं। इस ब्लॉग का अपना GARCH(1,1) वास्तविक BTC दैनिक डेटा पर फिट बैठता है, Ljung-Box और ARCH-LM डायग्नोस्टिक्स के साथ, [क्रिप्टो के लिए GARCH अस्थिरता पूर्वानुमान] (/hi/blog/post/garch-volatility-forecasting-crypto) में है; एक ही नमूने पर मैटरन जीपी के खिलाफ आमने-सामने की तुलना ईमानदार तुलना होगी, और इसे चलाया नहीं गया है।

आवधिक कर्नेल

वित्तीय बाज़ारों में चक्रीय पैटर्न होते हैं: इंट्राडे वॉल्यूम वक्र, सप्ताह के दिन के प्रभाव, मासिक पुनर्संतुलन प्रवाह, त्रैमासिक आय सीज़न। आवधिक कर्नेल इन्हें कैप्चर करता है:

$k_{\text{Periodic}}(x, x') = \sigma^2 \exp\left(-\frac{2\sin^2\left(\pi|x - x'|/p\right)}{\ell^2}\right)$

कहाँ $p$ अवधि है. इस कर्नेल से निकाले गए फ़ंक्शन अवधि के साथ दोहराए जाते हैं $p$ , लंबाई पैमाने द्वारा संशोधित $\ell$ जो नियंत्रित करता है कि किसी अवधि के भीतर सहसंबंध कितनी तेजी से घटता है।

ट्रेडिंग व्याख्या: सेट $p = 24$ (घंटे) इंट्राडे पैटर्न कैप्चर करने के लिए, या $p = 5$ (व्यापार दिवस) साप्ताहिक सीज़न के लिए। फूरियर सुविधाओं के विपरीत, आवधिक कर्नेल निश्चित संख्या में हार्मोनिक्स नहीं मानता है - जीपी डेटा से चक्र का आकार सीखता है।

गुठली का संयोजन: योगात्मक और गुणक संरचना

जीपी कर्नेल की वास्तविक शक्ति संरचना में निहित है। अगर $k_1$ और $k_2$ वैध कर्नेल हैं, इसलिए ये हैं:

योग: $k_1 + k_2$ - फ़ंक्शन स्वतंत्र घटकों का योग है (योज्य अपघटन)
उत्पाद: $k_1 \times k_2$ - घटकों के बीच बातचीत (उदाहरण के लिए, स्थानीय रूप से आवधिक व्यवहार)

वित्तीय रिटर्न के लिए एक उपयोगी समग्र कर्नेल:

$k(x, x') = k_{\text{Matern-3/2}}(x, x') + k_{\text{Periodic}}(x, x') \cdot k_{\text{RBF}}(x, x')$

यह सिग्नल को इसमें विघटित करता है:

एक गैर-सुचारू, एपेरियोडिक प्रवृत्ति घटक (मैटरन-3/2)
एक आवधिक घटक जिसका आयाम समय के साथ घटता जाता है (आवधिक)। $\times$ आरबीएफ)

उत्पाद $k_{\text{Periodic}} \cdot k_{\text{RBF}}$ एक स्थानीय आवधिक कर्नेल बनाता है: पैटर्न दोहराता है, लेकिन दूर की पुनरावृत्ति का पास की तुलना में कम प्रभाव होता है। यह वित्तीय मौसमी के लिए बिल्कुल सही है, जो बाजार की सूक्ष्म संरचना के विकसित होने के साथ-साथ समय के साथ बदलती रहती है।

स्पेक्ट्रल मिश्रण कर्नेल

अधिकतम लचीलेपन के लिए, वर्णक्रमीय मिश्रण (एसएम) कर्नेल (विल्सन और एडम्स, 2013) गाऊसी के मिश्रण के रूप में कर्नेल के वर्णक्रमीय घनत्व को मानकीकृत करता है:

$k_{\text{SM}}(x, x') = \sum_{q=1}^{Q} w_q \exp\left(-2\pi^2 \|x - x'\|^2 v_q\right) \cos\left(2\pi \|x - x'\| \mu_q\right)$

कहाँ $w_q$ मिश्रण भार हैं, $v_q$ वर्णक्रमीय भिन्नताएं हैं, और $\mu_q$ वर्णक्रमीय साधन (आवृत्तियाँ) हैं। बोचनर के प्रमेय के अनुसार, किसी भी स्थिर कर्नेल को इस तरह दर्शाया जा सकता है। एसएम कर्नेल आवधिक घटकों, लंबी दूरी के रुझान और छोटी दूरी के सहसंबंधों को एक साथ खोज सकता है - सभी डेटा से।

ट्रेडिंग व्याख्या: एसएम कर्नेल तब उपयोगी होता है जब आप नहीं जानते कि डेटा में कौन से पैटर्न मौजूद हैं। यह रिटर्न श्रृंखला में छिपी हुई आवधिकों की पहचान कर सकता है (उदाहरण के लिए, स्वचालित पुनर्संतुलन द्वारा संचालित क्रिप्टो बाजारों में सूक्ष्म 4-घंटे का चक्र)। नकारात्मक पक्ष अधिक हाइपरपैरामीटर और छोटे डेटासेट के साथ ओवरफिटिंग का जोखिम है।

पश्च अनुमान: पूर्व से भविष्यवाणी तक

प्रशिक्षण डेटा दिया गया $\mathcal{D} = \{(x_i, y_i)\}_{i=1}^n$ कहाँ $y_i = f(x_i) + \epsilon_i$ और $\epsilon_i \sim \mathcal{N}(0, \sigma_n^2)$ , परीक्षण बिंदुओं पर जीपी पश्च $X_*$ एक बंद-रूप समाधान है। यह अधिकांश बायेसियन मॉडलों की तुलना में जीपी का प्रमुख कम्प्यूटेशनल लाभ है।

पश्च समीकरण

चलो $K = k(X, X)$ हो $n \times n$ प्रशिक्षण सहप्रसरण मैट्रिक्स, $K_* = k(X_*, X)$ हो $m \times n$ क्रॉस-कोवेरिएंस मैट्रिक्स, और $K_{**} = k(X_*, X_*)$ हो $m \times m$ सहप्रसरण मैट्रिक्स का परीक्षण करें। पिछला हिस्सा है:

$f_* | X, y, X_* \sim \mathcal{N}(\bar{f}_*, \text{Cov}(f_*))$

कहाँ:

$\bar{f}_* = K_* (K + \sigma_n^2 I)^{-1} y$

$\text{Cov}(f_*) = K_{**} - K_* (K + \sigma_n^2 I)^{-1} K_*^T$

पश्च माध्य $\bar{f}_*$ यह प्रशिक्षण लक्ष्यों का एक रैखिक संयोजन है, जो परीक्षण और प्रशिक्षण बिंदुओं के बीच कर्नेल समानता द्वारा भारित होता है। पश्च सहप्रसरण $\text{Cov}(f_*)$ पूर्व सहप्रसरण से प्रारंभ होता है $K_{**}$ और प्रशिक्षण डेटा से प्राप्त जानकारी को घटा देता है। जहां प्रशिक्षण डेटा सघन है, वहां पिछला विचरण छोटा है। जहां प्रशिक्षण डेटा विरल है, पिछला विचरण पूर्व की ओर लौट जाता है।

सीमांत संभावना, और परीक्षण योग्य दावा

कर्नेल हाइपरपैरामीटर $\theta$ (लंबाई पैमाने, भिन्नता, शोर स्तर) लॉग सीमांत संभावना को अधिकतम करके सीखा जाता है:

$\log p(y | X, \theta) = -\frac{1}{2} y^T (K + \sigma_n^2 I)^{-1} y - \frac{1}{2} \log |K + \sigma_n^2 I| - \frac{n}{2} \log 2\pi$

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

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

यह दावा विशेष रूप से इस ब्लॉग पर संदेह का पात्र है। पठार विश्लेषण से पता चलता है कि एकल-बिंदु सत्यापन स्कोर एक खराब चयन मानदंड है और मजबूती पड़ोस के आकार में रहती है; पीबीओ यह निर्धारित करता है कि इन-सैंपल विजेता कितनी बार आउट-ऑफ-सैंपल खो देता है; डिफ्लेटेड शार्प परीक्षणों की संख्या में कीमतें। सीमांत संभावना अभी भी एक नमूना उद्देश्य है जिसे अधिकतम किया जा रहा है $\theta$ - ऑकैम फ़ैक्टर मॉडल क्षमता को दंडित करता है, न कि कई फिट किए गए कर्नेलों पर चयन को। यदि आप बारह उम्मीदवार कर्नेल को फिट करते हैं और सर्वोत्तम सीमांत संभावना वाले को चुनते हैं, तो आप बहु-परीक्षण क्षेत्र में वापस आ जाते हैं और अपस्फीति तर्क अपरिवर्तित लागू होता है। गलत संस्करण: क्या सीमांत-संभावना चयन एक ही डेटा और एक ही कर्नेल परिवार पर सत्यापन-सेट चयन की तुलना में एक छोटा इन-सैंपल/आउट-ऑफ-सैंपल अंतर उत्पन्न करता है? वह मापने योग्य है और नीचे नहीं मापा जाता है।

सीमांत संभावना सतह में स्थानीय ऑप्टिमा भी है। एकाधिक यादृच्छिक पुनरारंभ या सावधानीपूर्वक प्रारंभिकरण मामला - प्रशिक्षण इनपुट की औसत जोड़ीदार दूरी और लक्ष्य के नमूना भिन्नता के लिए शोर भिन्नता के लिए लंबाई पैमाने को प्रारंभ करना एक उचित प्रारंभिक बिंदु है।

कम्प्यूटेशनल लागत और मापनीयता

अड़चन उलटी है $(K + \sigma_n^2 I)$ , जिसकी लागत है $O(n^3)$ समय में और $O(n^2)$ स्मृति में. क्यूबिक वॉल पर इस ब्लॉग पर पहले से ही दूसरी दिशा से तर्क दिया गया है: [खोज विधि बनाम मूल्यांकन लागत] (/hi/blog/post/search-method-crossover-eval-cost) उद्देश्य सस्ता होने पर जीपी-आधारित बायेसियन अनुकूलन को पूरी तरह से अयोग्य घोषित कर देता है, क्योंकि सरोगेट की लागत उसके द्वारा बचाए गए मूल्यांकन से अधिक होती है। यहाँ भी अंकगणित वही है; आवेदन अलग है. बाज़ार डेटा के लिए उपयुक्त मॉडल के रूप में, क्यूबिक शब्द एक अयोग्यता नहीं बल्कि एक बजट है: यह प्रशिक्षण विंडो पर एक कठोर सीमा निर्धारित करता है।

ट्रेडिंग अनुप्रयोगों के लिए स्केलेबिलिटी रणनीतियाँ:

विरल जीपी (उत्प्रेरण बिंदु)। बदलें $n \times n$ एक के साथ मैट्रिक्स $m \times m$ मैट्रिक्स कहाँ $m \ll n$ . प्रेरक बिंदु $Z = \{z_1, \ldots, z_m\}$ छद्म इनपुट हैं जो प्रशिक्षण डेटा का सारांश प्रस्तुत करते हैं। हेन्समैन एट अल द्वारा एसवीजीपी (स्टोकेस्टिक वेरिएशनल जीपी) फॉर्मूलेशन। (2013) लागत के साथ मिनी-बैच प्रशिक्षण की अनुमति देता है $O(nm^2)$ प्रति पुनरावृत्ति. GPyTorch मूल रूप से इसका समर्थन करता है।
संरचित कर्नेल इंटरपोलेशन (एसकेआई/केआईएसएस-जीपी)। जब इनपुट ग्रिड पर होते हैं तो कर्नेल मैट्रिक्स में क्रोनेकर और टोप्लिट्ज़ संरचना का शोषण होता है। लागत कम कर देता है $O(n + g \log g)$ कहाँ $g$ ग्रिड का आकार है. नियमित रूप से नमूना समय श्रृंखला (उदाहरण के लिए, 1-मिनट बार) के लिए आदर्श।
स्लाइडिंग विंडो पर स्थानीय जीपी। केवल हाल के डेटा पर अलग-अलग जीपी को प्रशिक्षित करें। यह वह जगह है जहां जीपी-विशिष्ट बाधा काटती है: मानक कर्नेल स्थिर होते हैं ( $k(x,x')$ पर ही निर्भर करता है $x - x'$ ) और बाज़ार नहीं हैं, इसलिए सामान्य उत्तर एक रोलिंग विंडो है - लेकिन विंडो की लंबाई ऊपर से सीमित है $O(n^3)$ , सिर्फ आँकड़ों से नहीं। वॉक-फ़ॉरवर्ड ऑप्टिमाइज़ेशन सामान्य रूप से एंकर्ड बनाम रोलिंग विंडो, ट्रेन/टेस्ट लंबाई और पुनः-ऑप्टिमाइज़ेशन आवृत्ति को कवर करता है; एक जीपी के लिए, विंडो साइज़िंग एक सांख्यिकीय निर्णय के साथ-साथ एक गणना निर्णय भी है, और एक एंकर्ड (लगातार बढ़ती) विंडो बिना किसी अनुमान के कुछ हज़ार बिंदुओं से अधिक उपलब्ध नहीं है। वह रीफ़्रेमिंग व्यावहारिक परिणाम है: जीपी के साथ आपको "सभी इतिहास का उपयोग करें" चुनने का विकल्प नहीं मिलता है।

रिटर्न भविष्यवाणी के लिए जीपी: एक व्यावहारिक रूपरेखा

फ़ीचर डिज़ाइन: 5-20 फ़ीचर क्यों, 500 नहीं

बाजार-डेटा एमएल के लिए सामान्य सुविधा वर्गीकरण - ऑर्डर बुक असंतुलन, बुक प्रेशर, वीपीआईएन, काइल का लैम्ब्डा, एहसास-अस्थिरता विशेषताएं, चक्रीय समय एन्कोडिंग, क्रॉस-एसेट और फंडिंग-रेट सिग्नल - पहले से ही [मशीन लर्निंग के साथ स्प्रेड मॉडलिंग] (/hi/blog/post/spread-modeling-machine-learning) में रखी गई है; उस सूची का उपयोग करें.

जीपी-विशिष्ट क्या है वह सूची का आकार है। कर्नेल विधियाँ उच्च आयामों में ख़राब हो जाती हैं: दूरियाँ केंद्रित हो जाती हैं, और एक स्थिर कर्नेल भेदभाव खो देता है। एक वित्तीय जीपी के लिए व्यावहारिक सीमा 5-20 इनपुट है, न कि सैकड़ों इनपुट जो एक ग्रेडिएंट-बूस्टेड पेड़ खुशी से खाता है। जो तंत्र इसे जीवित रखता है वह ARD (स्वचालित प्रासंगिकता निर्धारण) है: प्रत्येक इनपुट आयाम को अपनी लंबाई का पैमाना दें $\ell_d$ , और सीमांत-संभावना प्रशिक्षण धक्का देता है $\ell_d \to \infty$ उन आयामों के लिए जिनमें कोई संकेत नहीं है, क्योंकि अनंत लंबाई के पैमाने का मतलब है कि कर्नेल उस समन्वय को अनदेखा करता है। फ़ीचर चयन फिटिंग और सीखे गए का उपोत्पाद बन जाता है $\ell_d$ प्रासंगिकता रैंकिंग के रूप में सीधे पढ़ने योग्य हैं - जो इसे गलत साबित करने योग्य भी बनाता है: वास्तविक सलाखों पर समग्र कर्नेल को फिट करें, लंबाई के पैमाने को प्रिंट करें, और देखें कि क्या जिन विशेषताओं पर आप विश्वास करते हैं वे वही हैं जो मॉडल रखता है।

स्थिति का आकार और परहेज

जीपी पोस्टीरियर देता है $\sigma_*(x)$ सीधे, इसलिए यह अंतराल चौड़ाई के साथ [जोखिम-जागरूक स्थिति आकार के लिए अनुरूप भविष्यवाणी] (/hi/blog/post/conformal-prediction-trading) में विकसित किनारे-अनुपात आकार और नो-ट्रेड फ़िल्टर में सीधे गिर जाता है $w_t = 2\kappa\sigma_*(x)$ . एकमात्र अंतर उत्पत्ति का है: जीपी अंशांकन सेट के बजाय मॉडल से ही चौड़ाई उत्पन्न करता है, इसलिए यह पिछले अवशेषों की वैश्विक मात्रा के बजाय प्रशिक्षण डेटा के सापेक्ष परीक्षण बिंदु कहां बैठता है, इसके साथ भिन्न होता है।

GPyTorch के साथ कार्यान्वयन

GPyTorch स्केलेबल GP अनुमान के लिए एक PyTorch-आधारित लाइब्रेरी है। यह जीपी को भोलेपन से परे स्केल करने के लिए जीपीयू त्वरण, स्वचालित विभेदन और आधुनिक रैखिक बीजगणित तकनीकों (संयुग्म ग्रेडिएंट्स, लैंज़ोस अपघटन) का लाभ उठाता है। $O(n^3)$ सीमा.

रिटर्न भविष्यवाणी के लिए बुनियादी सटीक जीपी

import torch
import gpytorch
import numpy as np
from torch.utils.data import TensorDataset, DataLoader


class ExactGPModel(gpytorch.models.ExactGP):
    """Exact GP with a composite kernel for financial returns."""

    def __init__(self, train_x, train_y, likelihood):
        super().__init__(train_x, train_y, likelihood)
        self.mean_module = gpytorch.means.ZeroMean()

        # Composite kernel: Matern-3/2 + Periodic * RBF
        self.covar_matern = gpytorch.kernels.ScaleKernel(
            gpytorch.kernels.MaternKernel(nu=1.5, ard_num_dims=train_x.shape[1])
        )
        self.covar_periodic = gpytorch.kernels.ScaleKernel(
            gpytorch.kernels.PeriodicKernel()
        )
        self.covar_rbf_decay = gpytorch.kernels.ScaleKernel(
            gpytorch.kernels.RBFKernel()
        )

    def forward(self, x):
        mean = self.mean_module(x)
        # Additive: Matern component + locally periodic component
        covar = self.covar_matern(x) + self.covar_periodic(x) * self.covar_rbf_decay(x)
        return gpytorch.distributions.MultivariateNormal(mean, covar)

ard_num_dims वह है जो ऊपर चर्चा किए गए प्रति-आयाम लंबाई पैमानों को सक्षम बनाता है। प्रशिक्षण के बाद, model.covar_matern.base_kernel.lengthscale पढ़ने के लिए सदिश है.

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

def train_gp(train_x, train_y, n_epochs=200, lr=0.05, device=None):
    """Train the GP by maximizing the marginal log-likelihood.

    Returns the device alongside the model so that callers move test
    tensors to the same place -- otherwise prediction crashes on GPU.
    """
    if device is None:
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    train_x = train_x.to(device)
    train_y = train_y.to(device)

    likelihood = gpytorch.likelihoods.GaussianLikelihood().to(device)
    model = ExactGPModel(train_x, train_y, likelihood).to(device)

    model.train()
    likelihood.train()

    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model)

    losses = []
    for epoch in range(n_epochs):
        optimizer.zero_grad()
        output = model(train_x)
        loss = -mll(output, train_y)
        loss.backward()
        optimizer.step()
        losses.append(loss.item())

        if (epoch + 1) % 50 == 0:
            noise = likelihood.noise.item()
            print(
                f"Epoch {epoch+1}/{n_epochs} | "
                f"Loss: {loss.item():.4f} | "
                f"Noise: {noise:.6f}"
            )

    return model, likelihood, device, losses

अनिश्चितता के साथ भविष्यवाणी

def predict_with_uncertainty(model, likelihood, test_x, device):
    """Generate predictions with uncertainty estimates."""
    model.eval()
    likelihood.eval()

    test_x = test_x.to(device)

    with torch.no_grad(), gpytorch.settings.fast_pred_var():
        posterior = likelihood(model(test_x))

        mean = posterior.mean
        variance = posterior.variance
        lower, upper = posterior.confidence_region()  # 2-sigma bounds

    return {
        "mean": mean.cpu().numpy(),
        "std": variance.sqrt().cpu().numpy(),
        "lower_2sigma": lower.cpu().numpy(),
        "upper_2sigma": upper.cpu().numpy(),
    }

The fast_pred_var() संदर्भ प्रबंधक पूर्वानुमानित भिन्नताओं की गणना करने के लिए LOVE (लैंक्ज़ोस वेरिएंस एस्टीमेट्स) एल्गोरिदम का उपयोग करता है $O(n)$ के बजाय समय $O(n^2)$ .

एंड-टू-एंड ट्रेडिंग पाइपलाइन

नीचे दिए गए फ़ीचर बिल्डर पर ध्यान दें: प्रत्येक रोलिंग आँकड़ा सख्ती से पीछे की ओर दिखने वाला होना चाहिए, और इनपुट मानकीकरण को केवल प्रशिक्षण स्लाइस पर फिट किया जाना चाहिए। वह दूसरा बिंदु सामान्य स्वच्छता नहीं है - यह बिल्कुल सामान्यीकरण रिसाव चैनल है जिसे [लुक-फॉरवर्ड बायस टैक्सोनॉमी] (/hi/blog/post/look-ahead-bias-taxonomy) में विच्छेदित और मापा जाता है, जो प्रत्येक लीक प्रकार से उत्पन्न शार्प मुद्रास्फीति की रिपोर्ट करता है। एक जीपी निर्माण के आधार पर अपने इनपुट को मानकीकृत करता है, इसलिए यह वह रिसाव है जिसका वह सबसे अधिक सामना करता है।

import pandas as pd


def build_features(df: pd.DataFrame, lookback: int = 10) -> pd.DataFrame:
    """Build features for GP-based return prediction."""
    features = pd.DataFrame(index=df.index)

    # Lagged returns
    for lag in range(1, lookback + 1):
        features[f"ret_lag_{lag}"] = df["close"].pct_change().shift(lag)

    # Volatility ratio (short / long)
    ret = df["close"].pct_change()
    features["vol_ratio"] = (
        ret.rolling(10).std() / ret.rolling(50).std()
    )

    # Volume z-score
    features["vol_zscore"] = (
        (df["volume"] - df["volume"].rolling(50).mean())
        / df["volume"].rolling(50).std()
    )

    # Order book imbalance (if available)
    if "bid_vol" in df.columns and "ask_vol" in df.columns:
        features["obi"] = (
            (df["bid_vol"] - df["ask_vol"])
            / (df["bid_vol"] + df["ask_vol"])
        )

    # Cyclical time encoding
    if hasattr(df.index, "hour"):
        hours = df.index.hour + df.index.minute / 60.0
        features["time_sin"] = np.sin(2 * np.pi * hours / 24)
        features["time_cos"] = np.cos(2 * np.pi * hours / 24)

    features.dropna(inplace=True)
    return features


def run_gp_strategy(
    df: pd.DataFrame,
    train_window: int = 500,
    retrain_every: int = 50,
    confidence_threshold: float = 1.0,
    risk_fraction: float = 0.02,
    max_leverage: float = 1.0,
):
    """Walk-forward GP trading strategy with uncertainty-based sizing."""
    features = build_features(df)
    returns = df["close"].pct_change().reindex(features.index)
    target = returns.shift(-1)  # predict next-bar return

    # Align and drop NaN
    mask = features.notna().all(axis=1) & target.notna()
    features = features[mask]
    target = target[mask]

    positions = pd.Series(0.0, index=features.index)
    predictions = pd.DataFrame(
        index=features.index, columns=["mean", "std"], dtype=float
    )

    model = likelihood = device = None
    # Standardization stats are set on every retrain and read on every
    # iteration; initialize them so the loop cannot silently read stale
    # or undefined values if the bounds ever change.
    x_mean = x_std = y_mean = y_std = None

    for i in range(train_window, len(features)):
        # Retrain periodically
        if model is None or (i - train_window) % retrain_every == 0:
            train_x = torch.tensor(
                features.iloc[i - train_window : i].values,
                dtype=torch.float32,
            )
            train_y = torch.tensor(
                target.iloc[i - train_window : i].values,
                dtype=torch.float32,
            )

            # Standardize on the training slice only (no leakage).
            x_mean, x_std = train_x.mean(0), train_x.std(0) + 1e-8
            y_mean, y_std = train_y.mean(), train_y.std() + 1e-8
            train_x_norm = (train_x - x_mean) / x_std
            train_y_norm = (train_y - y_mean) / y_std

            model, likelihood, device, _ = train_gp(
                train_x_norm, train_y_norm, n_epochs=100
            )

        # Predict
        test_x = torch.tensor(
            features.iloc[i : i + 1].values, dtype=torch.float32
        )
        test_x_norm = (test_x - x_mean) / x_std

        pred = predict_with_uncertainty(model, likelihood, test_x_norm, device)

        # De-standardize
        pred_mean = pred["mean"][0] * y_std.item() + y_mean.item()
        pred_std = pred["std"][0] * y_std.item()

        predictions.iloc[i] = [pred_mean, pred_std]

        # Confidence-gated position sizing.
        # z_score is unbounded as pred_std -> 0, so cap the notional.
        z_score = abs(pred_mean) / (pred_std + 1e-8)
        if z_score > confidence_threshold:
            size = min(z_score * risk_fraction, max_leverage)
            positions.iloc[i] = np.sign(pred_mean) * size

    # Calculate PnL
    strategy_returns = positions.shift(1) * returns
    return strategy_returns, predictions, positions

विरल जीपी के साथ बड़े डेटासेट तक स्केलिंग

जब प्रशिक्षण विंडो कुछ हज़ार अंकों से अधिक हो जाती है, तो सटीक जीपी अनुमान धीमा हो जाता है। परिवर्तनशील विरल जीपी पर स्विच करें:

class SparseGPModel(gpytorch.models.ApproximateGP):
    """Sparse variational GP for large-scale return prediction."""

    def __init__(self, inducing_points):
        variational_distribution = (
            gpytorch.variational.CholeskyVariationalDistribution(
                inducing_points.size(0)
            )
        )
        variational_strategy = (
            gpytorch.variational.VariationalStrategy(
                self,
                inducing_points,
                variational_distribution,
                learn_inducing_locations=True,
            )
        )
        super().__init__(variational_strategy)
        self.mean_module = gpytorch.means.ZeroMean()
        self.covar_module = gpytorch.kernels.ScaleKernel(
            gpytorch.kernels.MaternKernel(nu=1.5)
        )

    def forward(self, x):
        mean = self.mean_module(x)
        covar = self.covar_module(x)
        return gpytorch.distributions.MultivariateNormal(mean, covar)


def train_sparse_gp(train_x, train_y, n_inducing=128, n_epochs=50, batch_size=256):
    """Train sparse GP with mini-batch stochastic variational inference."""
    # Initialize inducing points via k-means or random subset
    indices = torch.randperm(train_x.size(0))[:n_inducing]
    inducing_points = train_x[indices]

    model = SparseGPModel(inducing_points)
    likelihood = gpytorch.likelihoods.GaussianLikelihood()

    model.train()
    likelihood.train()

    optimizer = torch.optim.Adam(
        [{"params": model.parameters()}, {"params": likelihood.parameters()}],
        lr=0.01,
    )
    mll = gpytorch.mlls.VariationalELBO(
        likelihood, model, num_data=train_y.size(0)
    )

    dataset = TensorDataset(train_x, train_y)
    loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

    for epoch in range(n_epochs):
        for x_batch, y_batch in loader:
            optimizer.zero_grad()
            output = model(x_batch)
            loss = -mll(output, y_batch)
            loss.backward()
            optimizer.step()

    return model, likelihood

128 प्रेरक अंकों के साथ, प्रति-बैच लागत है $O(128^2 \times \text{batch\_size})$ - प्रति बैच लगभग 4 मिलियन ऑपरेशन। यह एक ही GPU पर 100,000+ अवलोकनों के डेटासेट को आसानी से संभालता है।

डीप कर्नेल लर्निंग: जीपी न्यूरल नेटवर्क से मिलता है

जब इनपुट स्थान उच्च-आयामी होता है या सुविधाओं और रिटर्न के बीच संबंध अत्यधिक गैर-रेखीय होता है, तो एक सादा कर्नेल संघर्ष कर सकता है। डीप कर्नेल लर्निंग (डीकेएल) जीपी कर्नेल को लागू करने से पहले एक तंत्रिका नेटवर्क के माध्यम से इनपुट पास करता है:

$k_{\text{DKL}}(x, x') = k_{\text{base}}(g_\phi(x), g_\phi(x'))$

कहाँ $g_\phi$ पैरामीटर वाला एक तंत्रिका नेटवर्क है $\phi$ और $k_{\text{base}}$ एक मानक कर्नेल है (जैसे, मैटरन-3/2)। नेटवर्क एक फीचर प्रतिनिधित्व सीखता है जहां जीपी कर्नेल सबसे प्रभावी होता है। संपूर्ण मॉडल - नेटवर्क पैरामीटर और कर्नेल हाइपरपैरामीटर - को सीमांत संभावना को अधिकतम करके शुरू से अंत तक प्रशिक्षित किया जाता है।

class DeepKernelGP(gpytorch.models.ExactGP):
    """GP with a neural network feature extractor."""

    def __init__(self, train_x, train_y, likelihood, input_dim):
        super().__init__(train_x, train_y, likelihood)
        self.mean_module = gpytorch.means.ZeroMean()

        # Feature extractor: input_dim -> 8 -> 4 -> 2
        self.feature_extractor = torch.nn.Sequential(
            torch.nn.Linear(input_dim, 8),
            torch.nn.ReLU(),
            torch.nn.Linear(8, 4),
            torch.nn.ReLU(),
            torch.nn.Linear(4, 2),
        )

        self.covar_module = gpytorch.kernels.ScaleKernel(
            gpytorch.kernels.MaternKernel(nu=1.5, ard_num_dims=2)
        )

    def forward(self, x):
        # Project through neural network
        features = self.feature_extractor(x)
        mean = self.mean_module(features)
        covar = self.covar_module(features)
        return gpytorch.distributions.MultivariateNormal(mean, covar)

डीकेएल जीपी की अनिश्चितता मात्रा निर्धारण के साथ तंत्रिका नेटवर्क के प्रतिनिधित्व सीखने को जोड़ती है। जीपी परत यह सुनिश्चित करती है कि प्रशिक्षण डेटा से दूर भविष्यवाणियों में उच्च अनिश्चितता है - कुछ ऐसा जो मानक तंत्रिका नेटवर्क प्रदान करने में विफल रहता है। यह भी ध्यान दें कि डीकेएल बिल्कुल उसी लचीलेपन को पुनः प्रस्तुत करता है जिसकी सीमांत संभावना को पुलिस को माना जाता था: ओकाम फैक्टर कर्नेल को दंडित करता है, लेकिन इसके सामने वाले नेटवर्क में हजारों मुफ्त पैरामीटर हैं और ऐसा कोई दंड नहीं है।

लुडकोव्स्की और रिस्क (2025), मात्रात्मक वित्त के लिए गाऊसी प्रक्रिया मॉडल, विकल्प मूल्य निर्धारण और पोर्टफोलियो अनुकूलन सहित व्यापक मात्रात्मक-वित्त संदर्भ में डीकेएल का सर्वेक्षण; वे परिणाम उनके हैं, उनकी समस्याओं पर हैं, और क्रिप्टो रिटर्न भविष्यवाणी के बारे में सबूत नहीं हैं।

निदान और ख़तरे

अंशांकन

एक अच्छी तरह से कैलिब्रेटेड जीपी में पूर्वानुमानित अंतराल होते हैं जो अनुभवजन्य कवरेज से मेल खाते हैं। चेक वही है जो [अनुरूप भविष्यवाणी] (/hi/blog/post/conformal-prediction-trading) में उपयोग किया जाता है - जो इस सिद्धांत को भी शामिल करता है कि सीमांत कवरेज सशर्त कवरेज क्यों नहीं है, एक सीमा जो जीपी अंतराल पर भी उतनी ही लागू होती है:

from scipy.stats import norm

def calibration_report(predictions, actuals):
    """Check if GP uncertainty is well-calibrated."""
    z_scores = (actuals - predictions["mean"]) / (predictions["std"] + 1e-8)

    for sigma in [1, 2, 3]:
        expected_outside = 2 * (1 - norm.cdf(sigma))
        actual_outside = (np.abs(z_scores) > sigma).mean()
        print(
            f"{sigma}-sigma | Expected outside: {expected_outside:.3f} | "
            f"Actual outside: {actual_outside:.3f}"
        )

1/2/3 सिग्मा पर अपेक्षित अधिकता 0.317 / 0.046 / 0.003 है। जो संख्या मायने रखती है वह यह है कि यह क्रिप्टो बार पर वास्तविक वॉक-फॉरवर्ड रन पर क्या प्रिंट करता है, और वह तालिका अभी तक इस लेख में नहीं है। पूर्व अपेक्षा यह है कि जीपी अति आत्मविश्वासी है - फैट-टेल्ड, गैर-स्थिर रिटर्न पर गाऊसी संभावना को 3 सिग्मा पर बुरी तरह से छिपाया जाना चाहिए - लेकिन "चाहिए" कोई माप नहीं है।

शेष ख़तरे

इनपुट स्केलिंग। लंबाई स्केल इनपुट स्केल के सापेक्ष होते हैं, इसलिए एक सुविधा सीमाबद्ध होती है $[0, 10000]$ और एक की दूरी तय की गई $[0, 1]$ कोई सार्थक बात साझा नहीं कर सकते $\ell$ ; ARD वह है जो विषम श्रेणियों को बचाता है, और मानकीकरण वह है जो ARD के आरंभीकरण को समझदार बनाता है।
सीमांत संभावना को ओवरफिट करना। कई कर्नेल हाइपरपैरामीटर (विशेष रूप से मिश्रित या वर्णक्रमीय मिश्रण कर्नेल) के साथ, सीमांत संभावना अभी भी ओवरफिट हो सकती है। प्रायर का उपयोग करें: औसत जोड़ीदार दूरी पर केंद्रित लंबाई के पैमाने पर एक लॉग-सामान्य प्रायर, भिन्नताओं पर आधा-सामान्य प्रायर।
सहसंयोजक मैट्रिक्स कंडीशनिंग। $(K + \sigma_n^2 I)$ शोर होने पर संख्यात्मक रूप से एकवचन बन सकता है $\sigma_n^2$ बहुत छोटा है या जब प्रशिक्षण बिंदु लगभग दोहराए गए हों। GPyTorch जोड़ता है $10^{-6}$ विकर्ण पर घबराना; खराब स्थिति वाले वित्तीय डेटा की अक्सर अधिक आवश्यकता होती है।
आगे देखो पूर्वाग्रह। ऊपर और, मापा विस्तार से, [आगे देखो पूर्वाग्रह वर्गीकरण] (/hi/blog/post/look-ahead-bias-taxonomy) में कवर किया गया है।

जीपी बनाम अन्य मॉडलों का उपयोग कब करें

कसौटी	जीपी	एक्सजीबूस्ट	तंत्रिका नेटवर्क
अंतर्निहित अनिश्चितता	हाँ (संरचनात्मक)	नहीं (अनुरूप/बूटस्ट्रैप की आवश्यकता है)	नहीं (एमसी ड्रॉपआउट/समूह की आवश्यकता है)
डेटा दक्षता	उत्कृष्ट (<1000 नमूने)	*	*
स्केलेबिलिटी	ख़राब सटीक, अच्छा विरल	*	*
अरैखिकता	कर्नेल-निर्भर	*	*
व्याख्यात्मकता	कर्नेल अपघटन + एआरडी लंबाई स्केल	*	*
गैर-स्थिरता	स्लाइडिंग विंडो या डीकेएल की आवश्यकता है	*	*

* XGBoost और न्यूरल-नेटवर्क कॉलम के लिए, यहां एक ताजा दावे के बजाय प्रकाशित तुलनाओं को देखें: [मशीन लर्निंग के साथ स्प्रेड मॉडलिंग] (/hi/blog/post/spread-modeling-machine-learning) में वित्तीय सारणीबद्ध डेटा (डेटा-आकार सीमा, व्याख्या, शासन अनुकूलन, विलंबता) और टेम्पोरल फ्यूजन) के लिए ग्रेडिएंट-बूस्टिंग-बनाम-डीप-लर्निंग तालिका है। ट्रांसफार्मर में टीएफटी बनाम एलएसटीएम बनाम वेनिला ट्रांसफार्मर है।

जीपी का उपयोग तब करें जब:

आपके पास छोटे से मध्यम डेटासेट हैं (प्रति प्रशिक्षण विंडो में ~10,000 से कम अवलोकन)
आप सिग्नल के बारे में एक स्पष्ट, निरीक्षण योग्य संरचनात्मक परिकल्पना चाहते हैं (प्रवृत्ति + मौसमी + शोर)
अनिश्चितता प्रशिक्षण डेटा से दूरी के साथ भिन्न होनी चाहिए, न कि केवल वैश्विक अवशिष्ट मात्रा के साथ

जीपी का उपयोग न करें जब:

आपको लाखों अवलोकनों पर उप-मिलीसेकंड अनुमान की आवश्यकता है
इनपुट आयाम ~50 से अधिक है
सिग्नल जटिल उच्च-क्रम सुविधा इंटरैक्शन में रहता है जो स्थिर कर्नेल का प्रतिनिधित्व नहीं कर सकता है (डीकेएल ओकैम संपत्ति की कीमत पर मदद करता है)

यह लेख अभी तक क्या माप नहीं पाया है

उपरोक्त सभी चीजें मॉडल मशीनरी हैं। इनमें से कोई भी इस बात का सबूत नहीं है कि एक जीपी क्रिप्टो पर पैसा बनाता है, और इस ब्लॉग का मानक यह है कि लेख में अपने स्वयं के नंबर होते हैं। खुले आइटम, जिस क्रम में उन्हें चलाया जाना चाहिए:

वास्तविक BTCUSDT 1m बार पर ARD लंबाई स्केल। समग्र कर्नेल को फ़िट करें, प्रिंट करें $\ell_d$ प्रति सुविधा. यह सीधे तौर पर "एआरडी अंतर्निहित सुविधा चयन है" दावे का परीक्षण करता है और एक गलत साबित होने वाली सुविधा-प्रासंगिकता रैंकिंग तैयार करता है।
वॉक-फॉरवर्ड रन से अंशांकन तालिका। 1/2/3 सिग्मा पर अपेक्षित बनाम अनुभवजन्य अधिकता, स्पष्ट रूप से बताई गई है, जिसमें वह मामला भी शामिल है जहां जीपी अति आत्मविश्वासी हो जाता है।
आत्मविश्वास-युक्त रणनीति, वॉक-फॉरवर्ड, उसी पांच प्रमुख बातों पर ईमानदार नकारात्मक, परीक्षण गणना के लिए अपवित्र। यदि यह विफल हो जाता है, तो यह उस श्रृंखला में एक और नकारात्मक परिणाम के रूप में आ जाता है।
दीवार-घड़ी $O(n^3)$ वक्र के लिए $n = 250 / 500 / 1000 / 2000 / 5000$ , सटीक बनाम एसवीजीपी, इसलिए स्केलेबिलिटी अनुभाग एक दावे के बजाय एक चार्ट पर आधारित है।

निष्कर्ष

व्यापार में गॉसियन प्रक्रियाओं का मामला यह नहीं है कि "वे आपको त्रुटि पट्टियाँ देते हैं" - अनुरूप भविष्यवाणी आपको कम वितरण संबंधी मान्यताओं के साथ त्रुटि पट्टियाँ देती है और एक कवरेज गारंटी जीपी के पास नहीं है। मामला यह है कि एक जीपी आपको अपनी संरचनात्मक परिकल्पना को एक कर्नेल के रूप में लिखने के लिए कहता है, इसे एक ऐसे उद्देश्य के विरुद्ध फिट करता है जो अपनी जटिलता में मूल्य रखता है, और फिर आपको बताता है कि एआरडी लंबाई स्केल के माध्यम से यह वास्तव में आपकी कौन सी सुविधाओं का उपयोग करता है। यह एक असामान्य रूप से सुपाठ्य मॉडल है।

लागत समान रूप से ठोस हैं: क्यूबिक स्केलिंग जो आपके प्रशिक्षण विंडो को सीमित करती है, स्थिरता की धारणाएं कि एक रोलिंग विंडो केवल आंशिक रूप से मरम्मत करती है, एक गाऊसी संभावना है कि वसा-पूंछ वाले रिटर्न का उल्लंघन होगा, और - एक बार जब आप गहरी कर्नेल सीखने के लिए पहुंचते हैं - बहुत ही ओकम संपत्ति का शांत नुकसान जिसने पहली जगह में सीमांत संभावना को प्रेरित किया। जो कुछ बचा है वह व्यापार योग्य है या नहीं यह एक अनुभवजन्य प्रश्न है, और ऊपर सूचीबद्ध चार माप ही इसका उत्तर देंगे।

सन्दर्भ

रासमुसेन, सी.ई., और विलियम्स, सी.के.आई. (2006)। मशीन लर्निंग के लिए गाऊसी प्रक्रियाएं। एमआईटी प्रेस.
विल्सन, ए., और एडम्स, आर. (2013)। पैटर्न डिस्कवरी और एक्सट्रपलेशन के लिए गाऊसी प्रोसेस कर्नेल। आईसीएमएल.
हेन्समैन, जे., फूसी, एन., और लॉरेंस, एन.डी. (2013)। बड़े डेटा के लिए गाऊसी प्रक्रियाएँ। यूएआई.
गैथेरल, जे., जैसन, टी., और रोसेनबाम, एम. (2018)। अस्थिरता कठिन है. मात्रात्मक वित्त, 18(6).
रिज़वी, एस.ए.ए., रॉबर्ट्स, एस.जे., ओसबोर्न, एम.ए., और न्यिकोसा, एफ. (2017)। गाऊसी प्रक्रिया लिफ़ाफ़े के साथ वित्तीय अस्थिरता का पूर्वानुमान लगाने के लिए एक नवीन दृष्टिकोण। arXiv:1705.00891.
लुडकोव्स्की, एम., और रिस्क, जे. (2025)। मात्रात्मक वित्त के लिए गाऊसी प्रक्रिया मॉडल। स्प्रिंगर.
गार्डनर, जे.आर., प्लीस, जी., बिंदेल, डी., वेनबर्गर, के.क्यू., और विल्सन, ए.जी. (2018)। GPyTorch: GPU त्वरण के साथ ब्लैकबॉक्स मैट्रिक्स-मैट्रिक्स गाऊसी प्रक्रिया अनुमान। न्यूरआईपीएस।