GARCH(1,1): क्रिप्टो वोलैटिलिटी का पूर्वानुमान

BTC के दैनिक रिटर्न का चार्ट खोलिए और आपको वह चीज़ नज़र आएगी जिसके लिए रैंडम वॉक की किताबें आपको कभी तैयार नहीं करतीं: शांति और अराजकता झुंडों में आती हैं। 6% की गिरावट वाला दिन शायद ही अकेला होता है। वह 4-8% के उतार-चढ़ाव वाले एक पूरे हफ्ते के भीतर बैठा होता है, फिर बाज़ार सुकून की सांस लेता है और अगले तूफ़ान से पहले 1% के सुस्त सत्रों वाले एक महीने में बहता रहता है। रिटर्न स्वयं लगभग अप्रत्याशित दिखते हैं — आप भरोसे से यह नहीं कह सकते कि कल ऊपर जाएगा या नीचे — लेकिन उनका परिमाण गहराई से पूर्वानुमेय है। आज की उथल-पुथल आपको कल के बारे में बहुत कुछ बता देती है।

लगभग हर रिस्क टूल जिसे कोई ट्रेडर इस्तेमाल करता है, चुपचाप यह मान लेता है कि यह सच नहीं है। Black-Scholes एक विकल्प (option) की कीमत एक स्थिर $\sigma$ से लगाता है। एक स्थिर Value-at-Risk संख्या एक वोलैटिलिटी अनुमान को एक नॉर्मल क्वांटाइल से गुणा करती है। एक स्थिर 3% स्टॉप-लॉस एक बिल्कुल शांत मंगलवार और FOMC घोषणा या किसी बड़े एक्सचेंज डी-पेग के आसपास के घंटों को मानो एक जैसा रिस्क मानकर बर्ताव करता है। इनमें से हर एक ठीक उसी तरह टूटता है: यह एक समय के साथ बदलने वाली मात्रा को एक स्थिरांक में समेट देता है, और फिर हैरान हो जाता है जब वह स्थिरांक हिलने लगता है।

यह लेख क्रिप्टो के लिए वोलैटिलिटी मॉडलिंग पर चार-भाग की श्रृंखला का पहला भाग है। यह नींव रखता है: GARCH(1,1) मॉडल, यह क्रिप्टो रिटर्न पर इतना अच्छा क्यों फिट बैठता है, arch लाइब्रेरी से मैक्सिमम लाइकलीहुड द्वारा इसे ईमानदारी से कैसे अनुमानित (estimate) किया जाए, और एक कंडीशनल-वेरिएंस पूर्वानुमान को तुरंत उपयोगी दो चीज़ों में कैसे बदला जाए — एक पोजीशन साइज़ और एक स्टॉप चौड़ाई, जो दोनों बाज़ार के साथ सांस लेते हैं। भाग 2 असममिति (asymmetry) और भारी टेल जोड़ता है, भाग 3 मल्टीवेरिएट में जाता है, और भाग 4 पूरा वोलैटिलिटी-टारगेटिंग बैकटेस्ट जोड़ता है। यहां हम एप्लीकेशन को जानबूझकर सरल रखते हैं; ईमानदार, walk-forward-validated रणनीति भाग 4 का विषय है।

क्रिप्टो रिटर्न के स्टाइलाइज़्ड फैक्ट्स

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

1. वोलैटिलिटी क्लस्टरिंग। बड़ी चालों के बाद अक्सर बड़ी चालें (किसी भी दिशा की) आती हैं, और छोटी चालों के बाद छोटी चालें। Mandelbrot ने इसे 1963 में कॉटन की कीमतों में देखा था। औपचारिक रूप से, जबकि रिटर्न $r_t$ लगभग सीरियली अनकोरिलेटेड होते हैं, वर्ग किए गए रिटर्न $r_t^2$ (रियलाइज़्ड वेरिएंस का एक प्रॉक्सी) मज़बूत, धीरे-धीरे घटने वाला सकारात्मक ऑटोकोरिलेशन दिखाते हैं।

2. भारी टेल (लेप्टोकुर्टोसिस)। रिटर्न का अनकंडीशनल वितरण चरम मूल्यों पर एक गॉसियन की तुलना में कहीं ज़्यादा द्रव्यमान रखता है। जहां एक नॉर्मल वितरण की कुर्टोसिस 3 होती है, BTC के दैनिक लॉग-रिटर्न आमतौर पर 8-10 से ऊपर बैठते हैं, और अधिक फ्रीक्वेंसी वाले क्रिप्टो रिटर्न और भी बदतर हो सकते हैं। छह-सिग्मा वाले दिन, जिनके बारे में एक नॉर्मल मॉडल कहता है कि वे लगभग हर दस लाख साल में एक बार होने चाहिए, दशक में कई बार दिख जाते हैं।

3. रिटर्न में कोई रैखिक ऑटोकोरिलेशन नहीं, वर्ग किए गए रिटर्न में मज़बूत ऑटोकोरिलेशन। यही वह छाप है जो एक वास्तविक वोलैटिलिटी प्रक्रिया को एक साधारण ट्रेंड से अलग करती है। यदि आप $r_t$ को उसके ही लैग्स पर रिग्रेस करें तो आपको कुछ भी इस्तेमाल करने लायक नहीं मिलता। यदि आप $r_t^2$ को उसके लैग्स पर रिग्रेस करें, तो आपको एक स्पष्ट, स्थायी सिग्नल मिलता है। यही वह संरचना है जिसे एक वेरिएंस मॉडल को पकड़ना चाहिए — और यही वह चीज़ है जिसे एक स्थिर-$\sigma$ मॉडल फेंक देता है।

हम इन तीनों को कुछ पंक्तियों में देख सकते हैं। इसके लिए किसी खास डेटा स्रोत की ज़रूरत नहीं है; प्रोडक्शन में ccxt इस्तेमाल करें, लेकिन एक पुनरुत्पादनीय स्निपेट के लिए yfinance ठीक है।

import numpy as np
import pandas as pd
import yfinance as yf
from statsmodels.graphics.tsaplots import plot_acf
from statsmodels.stats.diagnostic import acorr_ljungbox
from scipy import stats

px = yf.download("BTC-USD", start="2021-01-01", end="2025-12-31")["Close"]
ret = np.log(px / px.shift(1)).dropna()          # log returns
ret = ret.rename("btc")

print(f"Observations:     {len(ret)}")
print(f"Ann. volatility:  {ret.std() * np.sqrt(365):.2%}")
print(f"Skewness:         {stats.skew(ret):.2f}")
print(f"Excess kurtosis:  {stats.kurtosis(ret):.2f}")   # 0 == Gaussian

lb_ret  = acorr_ljungbox(ret,        lags=[10], return_df=True)
lb_ret2 = acorr_ljungbox(ret ** 2,   lags=[10], return_df=True)
print("\nLjung-Box p-value, returns   (lag 10):", float(lb_ret["lb_pvalue"].iloc[0]))
print("Ljung-Box p-value, squared   (lag 10):", float(lb_ret2["lb_pvalue"].iloc[0]))

सामान्य नतीजा (उदाहरणस्वरूप — आपकी विंडो अलग होगी): 3 से काफी ऊपर एक्सेस कुर्टोसिस, कच्चे रिटर्न पर एक Ljung-Box p-value जो "कोई ऑटोकोरिलेशन नहीं" को अस्वीकार करने में नाकाम रहता है, और वर्ग किए गए रिटर्न पर एक p-value जो व्यावहारिक रूप से शून्य है। वह आखिरी विरोधाभास ही पूरा खेल है। दैनिक क्षितिज पर रिटर्न की दिशा में ट्रेड करने लायक कुछ नहीं है, लेकिन उनके वेरिएंस में बहुत सारी संरचना है, और वह संरचना पूर्वानुमेय है।

क्रिप्टो की 24/7 प्रकृति पर एक टिप्पणी। इक्विटी के विपरीत, कोई ओवरनाइट गैप और कोई वीकेंड क्लोज़ नहीं होता, इसलिए "दिन" एक साफ़ 24-घंटे का बार होता है और एनुअलाइज़ेशन फैक्टर $\sqrt{365}$ है, $\sqrt{252}$ नहीं। वोलैटिलिटी क्लस्टरिंग इंट्राडे स्केल पर भी बनी रहती है, जो मायने रखता है अगर आप घंटे के बार पर GARCH चलाते हैं — फंडिंग-रेट फ्लिप और लिक्विडेशन कैस्केड तीखे, क्लस्टर्ड वेरिएंस उछाल डालते हैं जिन्हें एक दैनिक मॉडल चिकना कर देता है।

ARCH से GARCH तक

अब समस्या स्पष्ट रूप से सामने है: एक ऐसे वेरिएंस को मॉडल करें जो स्थिर नहीं बल्कि हाल के अतीत पर निर्भर हो। इसे ठीक से करने वाला पहला मॉडल था Engle का ARCH (Autoregressive Conditional Heteroskedasticity, 1982), जिसने उन्हें 2003 में नोबेल पुरस्कार दिलाया।

रिटर्न को एक कंडीशनल मीन और एक शॉक के योग के रूप में लिखें:

$r_t = \mu_t + \varepsilon_t, \qquad \varepsilon_t = \sigma_t z_t, \qquad z_t \sim \text{i.i.d. } (0, 1)$

यहां $\sigma_t^2$ कंडीशनल वेरिएंस है — $t-1$ तक ज्ञात हर चीज़ के दिए जाने पर $r_t$ का वेरिएंस — और $z_t$ एक स्टैंडर्डाइज़्ड इनोवेशन है (सबसे सरल मामले में स्टैंडर्ड नॉर्मल)। शब्द "कंडीशनल" ही पूरा काम कर रहा है: अनकंडीशनली वेरिएंस स्थिर हो सकता है, लेकिन कल पर कंडीशन करने पर यह हिलता है।

Engle का ARCH($q$) आज के वेरिएंस को पिछले $q$ वर्ग किए गए शॉक्स के भारित योग के रूप में बनाता है:

$\sigma_t^2 = \omega + \sum_{i=1}^{q} \alpha_i \, \varepsilon_{t-i}^2$

जिसमें $\omega > 0$ और $\alpha_i \ge 0$ हैं ताकि वेरिएंस सकारात्मक बना रहे। यह क्लस्टरिंग को सीधे पकड़ता है: एक बड़ा शॉक $\varepsilon_{t-1}^2$ $\sigma_t^2$ को ऊपर धकेलता है, जो एक और बड़े शॉक की संभावना बढ़ाता है, जो वेरिएंस को ऊंचा बनाए रखता है। परेशानी अनुभवजन्य क्षय (decay) में है। असली बाज़ारों में वोलैटिलिटी पर्सिस्टेंस कई लैग्स तक फैली होती है, इसलिए इसे फिट करने के लिए ARCH मॉडल को एक बड़े $q$ की ज़रूरत होती है — अक्सर 8, 10, या ज़्यादा — और इसका मतलब है $\alpha_i$ का एक लंबा, अस्थिर वेक्टर अनुमानित करना जो ओवरफ़िट होता है।

Bollerslev की 1986 की सूझबूझ यह थी कि इस पूरे पर्सिस्टेंस को एक ही पैरामीटर से सोख लेने वाला एक टर्म जोड़ा जाए। GARCH(1,1) — Generalized ARCH — रिकर्शन यह है:

$\sigma_t^2 = \omega + \alpha \, \varepsilon_{t-1}^2 + \beta \, \sigma_{t-1}^2$

तीन पैरामीटर, तीन स्पष्ट व्याख्याएं:

• $\omega > 0$ — बेसलाइन या फ्लोर। एक स्थिरांक जो वेरिएंस के दीर्घकालिक स्तर को लंगर डालता है। वेरिएंस कभी उस स्तर से नीचे नहीं गिरता जिसे $\omega$ सहारा देता है।
• $\alpha \ge 0$ — खबर के प्रति प्रतिक्रिया। वेरिएंस कल के आश्चर्य $\varepsilon_{t-1}^2$ पर कितनी हिंसक प्रतिक्रिया देता है। बड़ा $\alpha$ का मतलब है कि कंडीशनल वेरिएंस उछल-कूद वाला और शॉक-संवेदनशील है।
• $\beta \ge 0$ — पर्सिस्टेंस या स्मृति। कल का कितना वेरिएंस आज में आगे बढ़ता है। बड़ा $\beta$ का मतलब है कि वोलैटिलिटी सहज और धीरे-धीरे घटने वाली है — शांति शांत रहती है, तूफ़ान तूफ़ानी रहते हैं।

इसकी सुंदरता रिकर्शन में है। क्योंकि $\sigma_{t-1}^2$ स्वयं एक $\beta \sigma_{t-2}^2$ टर्म रखता था, पीछे की ओर विस्तार करने से पता चलता है कि GARCH(1,1) एक ARCH($\infty$) है जिसमें पिछले वर्ग किए गए शॉक्स पर ज्यामितीय रूप से घटते भार $\alpha \beta^{k}$ हैं:

$\sigma_t^2 = \frac{\omega}{1-\beta} + \alpha \sum_{k=0}^{\infty} \beta^{k}\, \varepsilon_{t-1-k}^2$

तो एक अकेला $\beta$ आपको पिछले शॉक्स की एक अनंत, घातांकीय रूप से भारित स्मृति दिला देता है। यही वजह है कि एक साधारण GARCH(1,1) — तीन पैरामीटर — नियमित रूप से दस पैरामीटर वाले ARCH मॉडलों को पछाड़ देता है, और यही वजह है कि यह लागू वोलैटिलिटी मॉडलिंग का वर्कहॉर्स बन गया। यह वास्तव में RiskMetrics के EWMA वेरिएंस एस्टिमेटर का करीबी रिश्तेदार है, जो $\omega = 0$, $\alpha + \beta = 1$ का विशेष मामला है जिसमें $\beta$ 0.94 पर स्थिर है। GARCH इसे सामान्यीकृत करता है, डेटा को $\alpha$, $\beta$, और एक वास्तविक मीन-रिवर्जन स्तर चुनने देकर।

गुण: स्थिरता, दीर्घकालिक वेरिएंस, और हाफ-लाइफ

GARCH(1,1) रिकर्शन के कुछ गुण निकालने लायक हैं, क्योंकि यही वे चीज़ें हैं जो आपको मॉडल के बारे में तर्क करने देती हैं, न कि उसे अंधाधुंध फिट करने देती हैं।

अनकंडीशनल (दीर्घकालिक) वेरिएंस। मान लें कि प्रक्रिया कोवेरिएंस-स्थिर (covariance-stationary) है ताकि अनकंडीशनल वेरिएंस $\bar{\sigma}^2 = \mathbb{E}[\varepsilon_t^2] = \mathbb{E}[\sigma_t^2]$ मौजूद हो और समय के साथ स्थिर रहे। रिकर्शन के दोनों पक्षों की एक्सपेक्टेशन लें। चूंकि $\mathbb{E}[\varepsilon_{t-1}^2] = \mathbb{E}[\sigma_{t-1}^2] = \bar{\sigma}^2$:

$\bar{\sigma}^2 = \omega + \alpha\, \bar{\sigma}^2 + \beta\, \bar{\sigma}^2 \;\;\Longrightarrow\;\; \bar{\sigma}^2 = \frac{\omega}{1 - \alpha - \beta}$

यह वह स्तर है जिसकी ओर वोलैटिलिटी मीन-रिवर्ट करती है। यह तभी मौजूद है — और तभी सकारात्मक है — जब $\alpha + \beta < 1$ हो।

स्थिरता की शर्त। वही असमानता,

$\alpha + \beta < 1,$

GARCH(1,1) के लिए कोवेरिएंस-स्थिरता की शर्त है। मात्रा $\alpha + \beta$ वेरिएंस प्रक्रिया का पर्सिस्टेंस है: यह वह AR(1) गुणांक है जो नियंत्रित करता है कि एक वेरिएंस शॉक $\bar{\sigma}^2$ की ओर कैसे क्षय होता है। यदि $\alpha + \beta \ge 1$, तो अनकंडीशनल वेरिएंस अनंत (या अपरिभाषित) है और शॉक्स कभी पूरी तरह ख़त्म नहीं होते।

हम मीन-रिवर्जन को स्पष्ट रूप से देख सकते हैं। वेरिएंस विचलन $\sigma_t^2 - \bar{\sigma}^2$ परिभाषित करें। रिकर्शन पर थोड़ा बीजगणित (प्रतिस्थापन $\omega = \bar{\sigma}^2(1 - \alpha - \beta)$ करते हुए) एक्सपेक्टेशन में यह देता है:

$\mathbb{E}_t[\sigma_{t+k}^2] - \bar{\sigma}^2 = (\alpha + \beta)^{k}\,\bigl(\sigma_{t+1}^2 - \bar{\sigma}^2\bigr)$

वर्तमान वेरिएंस और उसके दीर्घकालिक स्तर के बीच का अंतर हर कदम पर $(\alpha + \beta)$ के गुणक से सिकुड़ता है। यही वह मल्टी-स्टेप पूर्वानुमान है जिसका इस्तेमाल हम आगे करते हैं।

वोलैटिलिटी हाफ-लाइफ। एक वेरिएंस शॉक को सामान्य की ओर आधा वापस क्षय होने में कितना समय लगता है? $(\alpha+\beta)^{h} = 1/2$ सेट करें और हल करें:

$h_{1/2} = \frac{\ln 0.5}{\ln(\alpha + \beta)}$

$\alpha + \beta = 0.95$ के लिए हाफ-लाइफ लगभग 13.5 दिन है; $0.98$ के लिए यह लगभग 34 दिन है; $0.99$ के लिए यह लगभग 69 दिन है। यह अकेली संख्या अक्सर कच्चे पैरामीटरों से ज़्यादा सहज होती है — यह आपको, आपके बार की इकाइयों में, बताती है कि वोलैटिलिटी कितनी चिपचिपी है।

क्रिप्टो में near-IGARCH समस्या। यहां क्रिप्टो-विशिष्ट पेच है। जब आप GARCH(1,1) को BTC या ETH रिटर्न पर फिट करते हैं, तो आप लगभग हमेशा $\alpha + \beta$ को 1 के बहुत करीब पाते हैं — 0.98, 0.99, कभी-कभी 0.995 जैसे मूल्य आम हैं। यह near-IGARCH (Integrated GARCH) व्यवस्था है। इसके वास्तविक परिणाम हैं:

• हाफ-लाइफ बहुत बड़ी हो जाती है (हफ़्तों से महीनों तक), इसलिए मॉडल वोलैटिलिटी को बहुत पर्सिस्टेंट और मुश्किल से मीन-रिवर्ट करने वाला मानता है।
• $\bar{\sigma}^2 = \omega/(1-\alpha-\beta)$ का अनुमान बेहद संवेदनशील हो जाता है: $\alpha+\beta$ में 0.99 से 0.995 तक का एक छोटा सा बदलाव निहित दीर्घकालिक वेरिएंस को दोगुना कर देता है। इस व्यवस्था में बिना कॉन्फिडेंस इंटरवल के दीर्घकालिक वोल के पॉइंट एस्टिमेट पर कभी भरोसा न करें।
• मल्टी-स्टेप पूर्वानुमान इतनी धीमी गति से मीन-रिवर्ट करते हैं कि, कुछ हफ़्तों से कम के व्यावहारिक क्षितिजों के लिए, GARCH लगभग वेरिएंस में एक रैंडम-वॉक की तरह व्यवहार करता है (जो कि EWMA मान लेता है)।

क्या near-integration वास्तविक है या संरचनात्मक टूटन (वोलैटिलिटी स्तर में एक स्थायी बदलाव जिसे मॉडल एक लंबे पर्सिस्टेंट एपिसोड के रूप में पढ़ रहा है) की एक कलाकृति है, यह एक वास्तविक बहस है। यह एक और वजह है कि पूरे इतिहास पर एक बार फिट करने के बजाय रोलिंग विंडोज़ पर रीफिट किया जाए, एक बात जिस पर हम कमज़ोरियों (pitfalls) में लौटते हैं। रीजीम संरचना विशेष रूप से एक स्पष्ट स्विचिंग मॉडल द्वारा बेहतर तरीके से संभाली जाती है — देखें hidden Markov models से रीजीम डिटेक्शन, जो GARCH का प्रतिस्थापन नहीं बल्कि उसका पूरक है।

मैक्सिमम लाइकलीहुड द्वारा एस्टिमेशन

GARCH पैरामीटर मैक्सिमम लाइकलीहुड द्वारा अनुमानित किए जाते हैं। तर्क सीधा है: $\theta = (\mu, \omega, \alpha, \beta)$ दिए जाने पर, रिकर्शन कंडीशनल वेरिएंस $\sigma_t^2(\theta)$ का एक पूरा पथ पैदा करता है, और इनोवेशन $z_t$ के लिए एक मान लिए गए वितरण के तहत हम लिख सकते हैं कि देखे गए रिटर्न कितने संभावित हैं। फिर हम उस लाइकलीहुड को अधिकतम करने के लिए $\theta$ चुनते हैं।

गॉसियन इनोवेशन मान लें $z_t \sim \mathcal{N}(0,1)$, तो $r_t \mid \mathcal{F}_{t-1} \sim \mathcal{N}(\mu, \sigma_t^2)$। एक अवलोकन की कंडीशनल डेंसिटी है

$f(r_t \mid \mathcal{F}_{t-1}) = \frac{1}{\sqrt{2\pi\sigma_t^2}}\exp\!\left(-\frac{(r_t - \mu)^2}{2\sigma_t^2}\right).$

क्योंकि मॉडल कंडीशनली लिखा गया है, संयुक्त लाइकलीहुड एक-कदम-आगे की डेंसिटीज़ के गुणनफल में विभाजित होती है, और लॉग-लाइकलीहुड एक सादा योग है:

$\ell(\theta) = -\frac{1}{2}\sum_{t=1}^{T}\left[\ln(2\pi) + \ln \sigma_t^2(\theta) + \frac{(r_t - \mu)^2}{\sigma_t^2(\theta)}\right].$

ध्यान देने लायक दो संरचनात्मक तथ्य। पहला, $\sigma_t^2$ एक जुर्माने ($\ln \sigma_t^2$ — मॉडल को उच्च वेरिएंस का दावा करने पर दंडित किया जाता है) और स्टैंडर्डाइज़्ड रेज़िड्युअल ($(r_t-\mu)^2/\sigma_t^2$ — मॉडल को आश्चर्यचकित होने पर दंडित किया जाता है) दोनों में दिखता है। ऑप्टिमम दोनों को संतुलित करता है, यही वह चीज़ है जो वेरिएंस को ट्रैक कराती है। दूसरा, रिकर्शन को एक सीड $\sigma_1^2$ चाहिए; सामान्य चुनाव रिटर्न का सैंपल वेरिएंस है, और कुछ हज़ार अवलोकनों के साथ सीड शायद ही मायने रखता है।

अधिकतम करने वाले के लिए कोई क्लोज़्ड फॉर्म नहीं है, इसलिए हम संख्यात्मक रूप से ऑप्टिमाइज़ करते हैं (arch एनालिटिक या न्यूमेरिकल ग्रेडिएंट के साथ एक क्वासी-न्यूटन मेथड इस्तेमाल करता है)। GARCH(1,1) के लिए लाइकलीहुड सतह आमतौर पर अच्छी व्यवहार वाली होती है, लेकिन व्यवहार में दो चीज़ें काटती हैं: पॉज़िटिविटी बाधाएं ($\omega,\alpha,\beta \ge 0$) और सीमा-निकट व्यवहार जब $\alpha+\beta \to 1$, जहां ऑप्टिमाइज़र धीरे-धीरे रेंग सकता है। दोनों को एक अच्छी लाइब्रेरी द्वारा आपके लिए संभाला जाता है — और आपको एक इस्तेमाल करनी चाहिए। हाथ से GARCH MLE बनाना एक अच्छा सीखने का अभ्यास है लेकिन प्रोडक्शन के लिए एक ख़राब चुनाव है।

arch लाइब्रेरी

Kevin Sheppard का arch पैकेज Python में मानक टूल है। पूरा फिट चार पंक्तियों में हो जाता है।

from arch import arch_model

r = ret * 100.0

model  = arch_model(r, mean="Constant", vol="Garch", p=1, q=1, dist="normal")
res    = model.fit(disp="off")
print(res.summary())

आर्गुमेंट के नामों के बारे में एक बात, क्योंकि वे उलझन का एक आम स्रोत हैं। arch में, p लैग्ड वेरिएंस की संख्या है ($\beta$ टर्म, GARCH ऑर्डर) और q लैग्ड वर्ग किए गए रेज़िड्युअल की संख्या है ($\alpha$ टर्म, ARCH ऑर्डर)। तो p=1, q=1 वही GARCH(1,1) है जो हमने निकाला। (Bollerslev का मूल नोटेशन इसे GARCH($p,q$) लिखता है जिसमें $p$ ARCH ऑर्डर के लिए है — दोनों परंपराएं आपस में बदली हुई हैं। अपनी याददाश्त पर नहीं, लाइब्रेरी के अपने डॉक्स पर भरोसा करें।)

सारांश पढ़ने पर, गुणांक तालिका मोटे तौर पर ऐसी दिखती है (BTC दैनिक रिटर्न के लिए उदाहरणस्वरूप मूल्य, कोई वास्तविक प्रयोग नहीं):

                     Volatility Model
==========================================================
                 coef    std err      t      P>|t|
----------------------------------------------------------
omega          0.4821     0.201    2.40    0.016
alpha[1]       0.0912     0.021    4.34    0.000
beta[1]        0.8994     0.024   37.5     0.000
==========================================================

इसे कैसे पढ़ें:

• alpha[1] + beta[1] = 0.0912 + 0.8994 = 0.9906। 1 से थोड़ा कम पर्सिस्टेंस — बिल्कुल जैसा चेतावनी दी गई थी, near-IGARCH व्यवस्था। हाफ-लाइफ $\approx \ln(0.5)/\ln(0.9906) \approx 73$ दिन।
• omega = 0.4821, तो दीर्घकालिक वेरिएंस है $0.4821 / (1 - 0.9906) = 51.3$ प्रतिशत-वर्ग इकाइयों में, यानी लगभग $\sqrt{51.3} \approx 7.2\%$ का दीर्घकालिक दैनिक वोलैटिलिटी, या लगभग $7.2\%\times\sqrt{365}\approx 138\%$ एनुअलाइज़्ड। यह एक प्रशंसनीय BTC संख्या है।
• alpha और beta दोनों दृढ़ता से सिग्निफिकेंट हैं। beta की तुलना में alpha का छोटा होना सामान्य है: क्रिप्टो वेरिएंस ज़्यादातर पर्सिस्टेंस (स्मृति) है, ताज़ा शॉक्स के प्रति एक मामूली लेकिन वास्तविक प्रतिक्रिया के साथ।

×100 स्केलिंग की चूक

यह arch से बकवास परिणाम पाने का सबसे आम तरीका है, इसलिए यह अपना अलग उपखंड पाने लायक है। ऑप्टिमाइज़र तब सबसे अच्छा काम करता है जब वह जो संख्याएं देखता है वे $O(1)$ से $O(100)$ की हों। दैनिक लॉग-रिटर्न $O(0.01)$ के होते हैं, इसलिए उनके वर्ग $O(0.0001)$ के होते हैं और $\omega$ को लगभग $10^{-6}$ के आसपास होना पड़ता है — एक ऐसी सीमा में जहां न्यूमेरिकल ग्रेडिएंट सटीकता खो देते हैं और फिट चुपचाप कन्वर्ज होने में नाकाम रह सकता है या बकवास स्टैंडर्ड एरर लौटा सकता है।

समाधान है 100 से स्केल किए गए रिटर्न (यानी प्रतिशत में) पर फिट करना, जैसा ऊपर दिखाया गया है। यदि आप भूल जाएं तो arch एक DataScaleWarning भी देगा। मॉडल से आप जो कुछ भी पढ़ते हैं वह तब प्रतिशत या प्रतिशत-वर्ग इकाइयों में होता है, और आपको लगातार अनस्केल करना होगा:

sigma_pct     = np.sqrt(res.forecast(horizon=1).variance.iloc[-1, 0])
sigma_decimal = sigma_pct / 100.0
print(f"1-day-ahead conditional vol: {sigma_decimal:.2%}")

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

कंडीशनल वेरिएंस का पूर्वानुमान

एक फिट किया गया मॉडल तभी उपयोगी है जब वह पूर्वानुमान लगाता है। GARCH किसी भी क्षितिज पर साफ़, एनालिटिक पूर्वानुमान देता है।

एक कदम आगे। समय $T$ पर (सैंपल के अंत में) हम $\varepsilon_T$ और $\sigma_T^2$ जानते हैं, इसलिए अगला वेरिएंस निर्धारित है:

$\sigma_{T+1}^2 = \omega + \alpha\,\varepsilon_T^2 + \beta\,\sigma_T^2.$

किसी एक्सपेक्टेशन की ज़रूरत नहीं — दाईं ओर की हर चीज़ अवलोकित है।

मल्टी-स्टेप आगे। $h \ge 2$ के लिए हम अभी तक बीच के शॉक्स नहीं जानते, इसलिए हम कंडीशनल एक्सपेक्टेशन लेते हैं। $\mathbb{E}_T[\varepsilon_{T+k}^2] = \mathbb{E}_T[\sigma_{T+k}^2]$ इस्तेमाल करते हुए (क्योंकि $\mathbb{E}[z^2]=1$), रिकर्शन पूर्वानुमानित वेरिएंस में एक सरल AR(1) में सिमट जाता है:

$\mathbb{E}_T[\sigma_{T+h}^2] = \omega + (\alpha + \beta)\,\mathbb{E}_T[\sigma_{T+h-1}^2].$

एक-कदम पूर्वानुमान से इसे इटरेट करने पर क्लोज़्ड फॉर्म मिलती है, जो कि वही मीन-रिवर्जन नतीजा है जो हमने पहले निकाला, स्पष्ट रूप से लिखा गया:

$\mathbb{E}_T[\sigma_{T+h}^2] = \bar{\sigma}^2 + (\alpha+\beta)^{\,h-1}\bigl(\sigma_{T+1}^2 - \bar{\sigma}^2\bigr), \qquad \bar{\sigma}^2 = \frac{\omega}{1-\alpha-\beta}.$

इसे ध्यान से पढ़ें, क्योंकि यह हर GARCH पूर्वानुमान की ज्यामिति है। वेरिएंस की टर्म संरचना आज के कंडीशनल वेरिएंस $\sigma_{T+1}^2$ से शुरू होती है और दीर्घकालिक स्तर $\bar{\sigma}^2$ की ओर ज्यामितीय रूप से क्षय होती है। यदि आज औसत से शांत है, तो पूर्वानुमान वक्र $\bar\sigma^2$ की ओर बढ़ता है; यदि आज एक संकट है, तो यह उसकी ओर गिरता है। उस क्षय की गति पूरी तरह $(\alpha+\beta)$ द्वारा तय होती है — और near-IGARCH क्रिप्टो व्यवस्था में, जहां $\alpha+\beta \approx 0.99$, क्षय इतना धीमा है कि कुछ हफ़्तों से कम के क्षितिजों के लिए पूर्वानुमान आज के स्तर से मुश्किल से हिलता है। यह समझने लायक है: छोटी होल्डिंग अवधियों के लिए, क्रिप्टो GARCH पूर्वानुमान मूलतः है "कल आज जैसा दिखता है, बस बहुत धीरे-धीरे रिवर्ट होते हुए।"

होल्डिंग क्षितिज तक एकत्रीकरण। ट्रेडर शायद ही किसी एक भविष्य के दिन के वेरिएंस की परवाह करते हैं। यदि आप $H$ दिनों के लिए एक पोजीशन होल्ड करते हैं और रिटर्न कंडीशनली अनकोरिलेटेड हैं (शुरुआत का स्टाइलाइज़्ड फैक्ट), तो संचयी $H$-दिन के रिटर्न का वेरिएंस एक-दिन के पूर्वानुमानित वेरिएंस का योग है:

$\sigma_{T}^{2}(H) = \sum_{h=1}^{H} \mathbb{E}_T[\sigma_{T+h}^2], \qquad \sigma_T(H) = \sqrt{\sigma_T^2(H)}.$

यही वह संख्या है जिसके ख़िलाफ़ आप असल में साइज़ करते हैं — आपकी होल्डिंग अवधि पर P&L का वोलैटिलिटी। ध्यान दें कि यह सीधा $\sqrt{H}\,\sigma_{T+1}$ स्केलिंग बिल्कुल नहीं है, जो केवल तभी सही है जब वेरिएंस स्थिर हो। जब आज का वेरिएंस $\bar\sigma^2$ से ऊपर है, मीन-रिवर्टिंग पूर्वानुमान असली $H$-दिन के वोल को स्क्वायर-रूट नियम से कम बनाता है; जब आज शांत है, तो यह ज़्यादा होता है। इसे सही करना ही एक स्टॉप के बीच का अंतर है जो टर्म संरचना का सम्मान करता है और एक जो नहीं करता।

कोड में:

H = 10
fc = res.forecast(horizon=H, reindex=False)

var_path_pct2 = fc.variance.iloc[-1].values        # [E_T sigma^2_{T+1}, ..., T+H]
var_path      = var_path_pct2 / (100.0 ** 2)       # back to decimal variance

daily_vol   = np.sqrt(var_path)
print("Forecast daily vol path:", np.round(daily_vol * 100, 2), "%")

H_day_var = var_path.sum()
H_day_vol = np.sqrt(H_day_var)
print(f"{H}-day holding-period vol: {H_day_vol:.2%}")

naive = np.sqrt(var_path[0] * H)
print(f"Naive sqrt(H) * sigma_1:   {naive:.2%}")

लंबे क्षितिजों के लिए GARCH सिमुलेशन पूर्वानुमान (method="simulation") का भी समर्थन करता है, जो इनोवेशन वितरण को आगे प्रसारित करते हैं और आपको पूरी पूर्वानुमानित डेंसिटी देते हैं, केवल उसका वेरिएंस नहीं — यह उपयोगी है जब इनोवेशन नॉन-गॉसियन हों, जैसा वे होंगे जब हम भाग 2 में Student-t और स्क्यूड वितरणों की ओर बढ़ेंगे। ऊपर की वेरिएंस-में-रैखिक मात्राओं के लिए, एनालिटिक पथ सटीक और मुफ़्त है।

डायग्नोस्टिक्स: क्या मॉडल ने असल में काम किया?

एक मॉडल को फिट करना उसे वैलिडेट करने जैसा नहीं है। GARCH का पूरा मक़सद कंडीशनल हेटेरोस्केडास्टिसिटी — वोलैटिलिटी क्लस्टरिंग — को सोखना है, ताकि जो बचे वह (लगभग) i.i.d. हो। तो सही जांच है स्टैंडर्डाइज़्ड रेज़िड्युअल को देखना

$\hat{z}_t = \frac{r_t - \hat\mu}{\hat\sigma_t}$

और पूछना: क्या क्लस्टरिंग चली गई है? यदि मॉडल ने वेरिएंस डायनामिक्स पकड़ लिए, तो $\hat z_t$ का यूनिट वेरिएंस होना चाहिए और, महत्वपूर्ण रूप से, उनके वर्गों $\hat z_t^2$ में कोई बचा हुआ ऑटोकोरिलेशन नहीं दिखना चाहिए। हम तीन टेस्ट चलाते हैं।

1. स्टैंडर्डाइज़्ड रेज़िड्युअल पर Ljung-Box। जांचता है कि $\hat z_t$ के स्तर में कोई रैखिक ऑटोकोरिलेशन नहीं बचा (यह असल में मीन मॉडल की जांच है, वेरिएंस मॉडल की नहीं)। अस्वीकार नहीं होना चाहिए।

2. वर्ग किए गए स्टैंडर्डाइज़्ड रेज़िड्युअल पर Ljung-Box। यह महत्वपूर्ण वाला है। यदि $\hat z_t^2$ में अभी भी महत्वपूर्ण ऑटोकोरिलेशन है, तो वेरिएंस मॉडल क्लस्टरिंग हटाने में नाकाम रहा — ऐसी संरचना है जिसे GARCH(1,1) ने नहीं पकड़ा, और आपको उच्च ऑर्डर, एक असममित वेरिएंट, या एक अलग इनोवेशन वितरण की ज़रूरत हो सकती है। अस्वीकार नहीं होना चाहिए।

3. ARCH-LM टेस्ट (Engle का Lagrange-multiplier टेस्ट)। $\hat z_t^2$ को उसके अपने लैग्स पर रिग्रेस करें और संयुक्त सिग्निफिकेंस के लिए टेस्ट करें। यह मूलतः टेस्ट 2 का एक औपचारिक संस्करण है और सीधे पूछता है "क्या कोई ARCH प्रभाव बचा है?" एक नॉन-सिग्निफिकेंट परिणाम पुष्टि करता है कि कंडीशनल हेटेरोस्केडास्टिसिटी को मॉडल कर दिया गया है।

from statsmodels.stats.diagnostic import acorr_ljungbox
from arch.unitroot.cointegration import engle_granger  # (unrelated; shown for import clarity)

z  = res.std_resid.dropna()          # standardized residuals
z2 = z ** 2

lb_z  = acorr_ljungbox(z,  lags=[10, 20], return_df=True)
lb_z2 = acorr_ljungbox(z2, lags=[10, 20], return_df=True)
print("Ljung-Box on standardized residuals:\n", lb_z, "\n")
print("Ljung-Box on SQUARED standardized residuals:\n", lb_z2, "\n")

lm = res.arch_lm_test(lags=10, standardized=True)
print(lm)

print(f"\nStd-resid excess kurtosis: {stats.kurtosis(z):.2f}")

अच्छा आउटपुट कैसा दिखता है: $\hat z_t^2$ पर Ljung-Box p-values (कच्चे वर्ग किए गए रिटर्न पर) लगभग-शून्य से 0.05 से आराम से ऊपर कूद जाते हैं, और ARCH-LM टेस्ट अस्वीकार करने में नाकाम रहता है। यही आपका सबूत है कि मॉडल ने दूसरे मोमेंट पर अपना काम किया।

अपूर्ण आउटपुट कैसा दिखता है — और क्रिप्टो पर एक सादे गॉसियन GARCH(1,1) से आपको क्या उम्मीद रखनी चाहिए — यह है कि क्लस्टरिंग टेस्ट पास हो जाते हैं लेकिन स्टैंडर्डाइज़्ड-रेज़िड्युअल कुर्टोसिस अभी भी ऊंचा है (कहें 0 के बजाय 4-6)। GARCH क्लस्टरिंग हटा देता है लेकिन एक अकेला भारी-टेल वाला अनकंडीशनल वितरण बचा रहता है, क्योंकि गॉसियन इनोवेशन टेल को दोबारा पैदा नहीं कर सकते। वह बची हुई भारी-टेल-नेस यहां ठीक करने वाला कोई बग नहीं है; यह भाग 2 की प्रेरणा है, असममित GARCH और क्रिप्टो में लीवरेज प्रभाव, जहां Student-t और skewed-t इनोवेशन तथा GJR/EGARCH असममिति टर्म ठीक इसी को संबोधित करते हैं।

एप्लीकेशन: वोलैटिलिटी-स्केल्ड साइजिंग और स्टॉप

अब हमारे पास कल के (और अगले $H$ दिनों के) वोलैटिलिटी का एक पूर्वानुमान है। हम इसका क्या करते हैं? दो सबसे सरल, सबसे ज़्यादा मूल्यवान इस्तेमाल हैं पोजीशन साइजिंग और स्टॉप प्लेसमेंट। हम यहां दोनों को जानबूझकर बुनियादी रखते हैं — पूरी वोल-टारगेटिंग रणनीति उसकी सभी व्यावहारिक मशीनरी के साथ भाग 4 है।

वोलैटिलिटी-टारगेटेड पोजीशन साइजिंग

विचार यह है कि एक ऐसी पोजीशन रखी जाए जिसका रिस्क योगदान समय के साथ लगभग स्थिर रहे, न कि एक ऐसी पोजीशन जिसका नोशनल स्थिर हो। यदि आप हमेशा एक ही डॉलर साइज़ तैनात करते हैं, तो आपका रिस्क उच्च-वोल व्यवस्थाओं में फूल जाता है और शांत व्यवस्थाओं में सिकुड़ जाता है — जो आप चाहते हैं उसके विपरीत। वोलैटिलिटी टारगेटिंग इसे उल्टा कर देती है: P&L के एक निश्चित लक्ष्य वोलैटिलिटी का लक्ष्य रखें, और पूर्वानुमान को साइज़ तय करने दें।

एक लक्षित एनुअलाइज़्ड वोलैटिलिटी $\sigma_{\text{target}}$ (कहें 20%) और एक पूर्वानुमानित एनुअलाइज़्ड वोलैटिलिटी $\hat\sigma_t$ के लिए, पोजीशन वेट है

$w_t = \frac{\sigma_{\text{target}}}{\hat{\sigma}_t}.$

जब पूर्वानुमानित वोल ज़्यादा है, आप साइज़ घटाते हैं; जब यह कम है, आप साइज़ बढ़ाते हैं। यही पूरा तंत्र है। क्योंकि $\hat\sigma_t$ पूर्वानुमानित है — $t+1$ पर रिटर्न रियलाइज़ होने से पहले $t$ पर ज्ञात — कोई लुक-अहेड नहीं है, बशर्ते आप टाइमिंग को लेकर अनुशासित हों (इस पर और बात कमज़ोरियों में)।

def vol_target_weight(sigma_forecast_annual, sigma_target_annual=0.20,
                      w_max=3.0):
    """Volatility-scaled position weight. Inputs/outputs in decimals.
    w_max caps leverage so a tiny forecast vol can't demand insane size."""
    w = sigma_target_annual / sigma_forecast_annual
    return float(np.clip(w, 0.0, w_max))

sigma_1d   = np.sqrt(res.forecast(horizon=1).variance.iloc[-1, 0]) / 100.0
sigma_ann  = sigma_1d * np.sqrt(365)
w          = vol_target_weight(sigma_ann, sigma_target_annual=0.20)
print(f"Forecast annual vol: {sigma_ann:.1%}  ->  position weight: {w:.2f}x")

यह उचित कैपिटल-आवंटन नियमों का प्रथम चचेरा भाई है। वोलैटिलिटी टारगेटिंग जवाब देती है "रिस्क को वोलैटिलिटी के साथ कितना स्केल होना चाहिए," जबकि Kelly criterion जवाब देता है "रिस्क को एज के साथ कितना स्केल होना चाहिए" — और दोनों एक पूरे साइजिंग स्टैक में गुणा होते हैं: साइज़ $\propto$ एज / वेरिएंस। ध्यान दें कि Kelly का वेरिएंस टर्म ठीक वही GARCH पूर्वानुमान है जो आपने अभी निकाला, यही वजह है कि एक लाइव वोलैटिलिटी मॉडल एक स्थिर ऐतिहासिक अनुमान की तुलना में Kelly साइजिंग को काफ़ी तेज़ बनाता है। यदि आपके एज अनुमान में स्वयं मापी गई अनिश्चितता है, तो conformal prediction साइज़ को मैच करने के लिए बढ़ाने या घटाने का एक वितरण-मुक्त तरीका देता है, और यह वोल टारगेटिंग के साथ साफ़ तरीके से जुड़ता है।

कैप w_max वैकल्पिक नहीं है। near-IGARCH व्यवस्था में एक शांत अवधि पूर्वानुमानित वोल को काफ़ी नीचे धकेल सकती है, और $\sigma_{\text{target}}/\hat\sigma_t$ ऐसा लीवरेज मांगेगा जो काग़ज़ पर ठीक है और जब शांति टूटती है तब विनाशकारी है — जो, वोलैटिलिटी क्लस्टरिंग के अनुसार, आख़िरकार होता ही है, अक्सर अचानक। लीवरेज को कैप करना यह स्वीकार करने का एक अनगढ़-लेकिन-प्रभावी तरीका है कि आपका पूर्वानुमान एक कंडीशनल मीन है, कोई गारंटी नहीं, और यह कि ग़लत होने का प्रतिफल असममित है। वह असममिति — एक तबाह हुआ अकाउंट एक सममित जीत से वापस नहीं आता — ठीक वही नुकसान-बनाम-लाभ असममिति है जो आपको एक केवल-वेरिएंस नियम के सुझाव से व्यवस्थित रूप से ज़्यादा रूढ़िवादी बनाना चाहिए।

वोलैटिलिटी-स्केल्ड स्टॉप

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

$\text{stop distance}_t = k \cdot \hat\sigma_t^{(H)}$

जहां $\hat\sigma_t^{(H)}$ आपके अपेक्षित होल्डिंग क्षितिज $H$ पर पूर्वानुमानित वोलैटिलिटी है (पूर्वानुमान सेक्शन से एकत्रित मात्रा) और $k$ एक गुणक है — आमतौर पर 1.5 से 3 — इस तरह चुना गया कि स्टॉप सामान्य उतार-चढ़ाव के बाहर लेकिन एक वास्तविक प्रतिकूल चाल के भीतर बैठे।

def vol_scaled_stop(entry_price, side, sigma_H, k=2.0):
    """
    entry_price : fill price
    side        : +1 long, -1 short
    sigma_H     : forecast volatility over the holding horizon (decimal)
    k           : stop width in vol units
    Returns the stop price.
    """
    stop_frac = k * sigma_H
    return entry_price * (1.0 - side * stop_frac)

var_path = res.forecast(horizon=10, reindex=False).variance.iloc[-1].values / (100.0 ** 2)
sigma_H  = np.sqrt(var_path.sum())

entry = float(px.iloc[-1])
stop  = vol_scaled_stop(entry, side=+1, sigma_H=sigma_H, k=2.0)
print(f"Entry {entry:,.0f}  |  10-day vol {sigma_H:.2%}  |  2-sigma stop {stop:,.0f}")

क्योंकि $\hat\sigma_t^{(H)}$ एक फ़्लैट ऐतिहासिक संख्या के बजाय मीन-रिवर्टिंग टर्म-संरचना पूर्वानुमान का इस्तेमाल करता है, स्टॉप अशांत व्यवस्थाओं में जाते हुए अपने आप चौड़ा होता है और वोलैटिलिटी कम होने पर संकरा होता है — टर्म संरचना आपके लिए ढलना कर देती है। यह वही पूर्वानुमान है जो साइज़ और स्टॉप दोनों को फीड करता है, जो एक फ़ीचर है: एक उच्च-वोल व्यवस्था में आप एक साथ कम होल्ड करते हैं और पोजीशन को ज़्यादा जगह देते हैं, और दोनों प्रभाव मिलकर काफ़ी कम टेल रिस्क में जुड़ जाते हैं। साइजिंग और स्टॉप एक वोलैटिलिटी दृष्टिकोण के दो प्रक्षेपण हैं, दो स्वतंत्र नॉब नहीं।

भाग 1 में हम एप्लीकेशन को यहीं तक ले जाते हैं। एक वास्तविक रणनीति को लगातार रीबैलेंसिंग से लेनदेन लागत, पूर्वानुमान की गणना कब की जाती है बनाम ट्रेड कब रखा जाता है इसकी टाइमिंग, टर्नओवर नियंत्रण, और — सबसे ऊपर — ईमानदार आउट-ऑफ़-सैंपल मूल्यांकन को संभालना होता है। यह सब भाग 4: वोलैटिलिटी-टारगेटिंग GARCH रणनीति में है, जहां हम पूरी चीज़ का निर्माण और walk-forward-टेस्ट करते हैं।

कमज़ोरियां

GARCH को फिट करना आसान है और उससे खुद को धोखा देना भी आसान है। नाकामी के तरीके सुसंगत हैं।

रिटर्न स्केलिंग। ऊपर कवर किया गया, लेकिन यह नंबर-वन बग है, इसलिए इसे दोहराना ज़रूरी है: arch को रिटर्न × 100 पर फिट करें, और हर आउटपुट को अनस्केल करें (वेरिएंस को $100^2$ से, वोलैटिलिटी को $100$ से)। यहां एक चुपचाप 100 गुना की त्रुटि हर डाउनस्ट्रीम साइजिंग और स्टॉप गणना को ज़हरीला बना देती है।

फिटिंग में लुक-अहेड। सूक्ष्म हत्यारा। यदि आप मॉडल को पूरे इतिहास पर फिट करते हैं और फिर उसी इतिहास पर "पूर्वानुमान" की गणना करते हैं, तो हर पूर्वानुमान ने चुपचाप भविष्य देख लिया है — पैरामीटर पूर्वानुमान तिथि के बाद के डेटा का इस्तेमाल करके अनुमानित किए गए थे। इन-सैंपल फिट शानदार दिखेगी और लाइव प्रदर्शन उससे बिल्कुल मेल नहीं खाएगा। हर बैकटेस्टेड पूर्वानुमान को उस पल में उपलब्ध डेटा पर ही फिट किए गए मॉडल से आना चाहिए: एक विस्तारित (expanding) या रोलिंग विंडो पर रीफिट करें, एक कदम पूर्वानुमान लगाएं, आगे बढ़ाएं। यह गैर-परक्राम्य (non-negotiable) है और यह पूरी तरह walk-forward optimization का विषय है। एक इन-सैंपल GARCH और एक उचित रूप से walk-forward GARCH के बीच का अंतर एक डेमो और एक ऐसे सिस्टम के बीच का अंतर है जो लाइव बाज़ारों के संपर्क से बचा रहता है — देखें backtest-live parity भी।

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

उच्च ऑर्डर का ओवरफिटिंग। GARCH(1,1) लगभग हमेशा काफ़ी है। GARCH(2,2) या GARCH(3,1) फिट करने का लालच, क्योंकि यह इन-सैंपल लॉग-लाइकलीहुड को थोड़ा ऊपर धकेलता है, आमतौर पर शोर-फिटिंग है; अतिरिक्त पैरामीटर शायद ही आउट-ऑफ़-सैंपल पूर्वानुमानों को बेहतर बनाते हैं और अक्सर सीमा के पास ऑप्टिमाइज़र को अस्थिर बना देते हैं। पारसिमोनियस मॉडल को प्राथमिकता दें, और यदि आपको ऑर्डर की तुलना करनी ही है, तो इन-सैंपल AIC से नहीं बल्कि एक walk-forward स्प्लिट पर आउट-ऑफ़-सैंपल पूर्वानुमान हानि से तुलना करें। जब रेज़िड्युअल डायग्नोस्टिक्स अभी भी एक समस्या दिखाते हैं, तो समाधान आमतौर पर एक बेहतर इनोवेशन वितरण या एक असममिति टर्म (भाग 2) है, एक उच्च ऑर्डर नहीं।

संरचनात्मक टूटन को पर्सिस्टेंस के रूप में पढ़ना। जैसा बताया गया, वोलैटिलिटी स्तर में एक स्थायी बदलाव (एक नई बाज़ार व्यवस्था, बाज़ार माइक्रोस्ट्रक्चर में एक बदलाव) GARCH द्वारा भ्रामक रूप से उच्च पर्सिस्टेंस के रूप में सोखा जा सकता है, जो $\alpha+\beta$ को 1 की ओर धकेलता है। यदि आपका दीर्घकालिक वोल अनुमान विंडोज़ के बीच अस्थिर दिखता है, तो near-IGARCH पॉइंट एस्टिमेट पर भरोसा करने के बजाय एक टूटन का शक करें। रोलिंग रीफिट और, जहां उचित हो, एक स्पष्ट रीजीम मॉडल इससे बचाव करते हैं।

वोलैटिलिटी पूर्वानुमानों को रिटर्न पूर्वानुमान समझना। GARCH चालों की परिमाण का पूर्वानुमान लगाता है, उनकी दिशा का नहीं। यह आपको बताता है कि कल की चाल कितनी बड़ी होने की संभावना है, किस दिशा में नहीं। यही ठीक वजह है कि इसका प्राकृतिक घर रिस्क प्रबंधन है — साइजिंग, स्टॉप, VaR — सिग्नल जनरेशन नहीं। एक अच्छे वेरिएंस पूर्वानुमान को एज न समझें।

यह आगे कहां जाता है

GARCH(1,1) नींव है, और यह जानबूझकर अधूरी है। यह श्रृंखला इस पर तीन दिशाओं में निर्माण करती है:

• असममिति और भारी टेल — असली क्रिप्टो वोलैटिलिटी नीचे की चालों पर ऊपर की चालों से ज़्यादा प्रतिक्रिया देती है (लीवरेज प्रभाव), और गॉसियन इनोवेशन टेल को दोबारा पैदा नहीं कर सकते। GJR-GARCH, EGARCH, और Student-t / skewed-t इनोवेशन भाग 2 हैं।
• मल्टीवेरिएट वोलैटिलिटी — क्रिप्टो एसेट्स के बीच सहसंबंध स्वयं समय के साथ बदलते हैं और क्रैश में उछलते हैं। पूरे कोवेरिएंस मैट्रिक्स को डायनामिक रूप से मॉडल करना भाग 3: DCC-GARCH है, जो सीधे Markowitz mean-variance और CVaR-आधारित आवंटन से जुड़ता है एक बार कोवेरिएंस डायनामिक हो जाए।
• पूरी रणनीति — साइजिंग, स्टॉप, लागत, टर्नओवर, और ईमानदार walk-forward मूल्यांकन भाग 4 में एक साथ आते हैं।

और जहां GARCH मार्जिनल्स संयुक्त रिस्क को फीड करते हैं: यहां का यूनिवेरिएट कंडीशनल-वेरिएंस मॉडल ठीक पोर्टफोलियो VaR/CVaR के लिए GARCH-EVT-copula पाइपलाइन का पहला चरण है। एक बार जब आपके पास प्रति-एसेट GARCH फिट से स्टैंडर्डाइज़्ड रेज़िड्युअल हों, तो आप उन्हें ट्रांसफ़ॉर्म करते हैं और एक copula के साथ जोड़ते हैं — मार्जिनल्स GARCH हैं, निर्भरता copula है। वह निर्माण, जिसमें टेल निर्भरता और EVT टेल ट्रीटमेंट शामिल है, संयुक्त क्रिप्टो रिस्क के लिए copula मॉडल में गहराई से कवर किया गया है; यह लेख वह यूनिवेरिएट इंजन है जो उसके नीचे बैठा है।

सारांश

• क्रिप्टो रिटर्न वोलैटिलिटी क्लस्टरिंग, भारी टेल, और कोई रिटर्न ऑटोकोरिलेशन नहीं लेकिन मज़बूत वर्ग-किए-गए-रिटर्न ऑटोकोरिलेशन दिखाते हैं। कोई भी टूल जो स्थिर वोलैटिलिटी मानता है — एक अकेले $\sigma$ वाला Black-Scholes, स्थिर VaR, स्थिर-प्रतिशत स्टॉप — इन तथ्यों के ख़िलाफ़ ग़लत रूप से स्पेसिफाई किया गया है।
• GARCH(1,1), $\sigma_t^2 = \omega + \alpha\varepsilon_{t-1}^2 + \beta\sigma_{t-1}^2$, तीन पैरामीटर के साथ समय-परिवर्तनशील कंडीशनल वेरिएंस मॉडल करता है: एक बेसलाइन $\omega$, एक शॉक प्रतिक्रिया $\alpha$, और एक पर्सिस्टेंस $\beta$। यह ज्यामितीय रूप से घटती स्मृति वाला एक ARCH($\infty$) है, यही वजह है कि यह उच्च-ऑर्डर ARCH को पछाड़ता है।
• स्थिरता के लिए $\alpha+\beta<1$ चाहिए; दीर्घकालिक वेरिएंस $\omega/(1-\alpha-\beta)$ है, पर्सिस्टेंस $\alpha+\beta$ है, और वोलैटिलिटी हाफ-लाइफ $\ln 0.5 / \ln(\alpha+\beta)$ है। क्रिप्टो near-IGARCH व्यवस्था में बैठता है ($\alpha+\beta\approx 0.99$): बहुत पर्सिस्टेंट, मीन-रिवर्ट करने में धीमा, और एक नाज़ुक दीर्घकालिक-वेरिएंस अनुमान के साथ।
• मैक्सिमम लाइकलीहुड द्वारा अनुमान लगाएं। गॉसियन लॉग-लाइकलीहुड एक-कदम डेंसिटीज़ का योग है; इसे arch_model(r*100, vol="Garch", p=1, q=1) से फिट करें। ×100 स्केलिंग याद रखें और हर आउटपुट को लगातार अनस्केल करें।
• पूर्वानुमान दर $(\alpha+\beta)^{h-1}$ पर दीर्घकालिक वेरिएंस की ओर ज्यामितीय रूप से मीन-रिवर्ट करते हैं। होल्डिंग-क्षितिज वोलैटिलिटी पाने के लिए दैनिक वेरिएंस पूर्वानुमानों को एकत्रित करें — सीधा $\sqrt{H}$ नियम नहीं।
• वर्ग किए गए स्टैंडर्डाइज़्ड रेज़िड्युअल पर Ljung-Box और ARCH-LM टेस्ट के साथ वैलिडेट करें। इन्हें पास करना पुष्टि करता है कि क्लस्टरिंग को मॉडल कर दिया गया था; बची हुई भारी टेल जो बनी रहती है भाग 2 को प्रेरित करती है।
• इसे लागू करें वोलैटिलिटी-टारगेटेड साइजिंग ($w_t = \sigma_{\text{target}}/\hat\sigma_t$, कैप्ड) और वोलैटिलिटी-स्केल्ड स्टॉप ($k\cdot\hat\sigma_t^{(H)}$) पर। एक पूर्वानुमान दोनों को चलाता है, तो उच्च-वोल व्यवस्थाओं को एक साथ छोटा साइज़ और चौड़ा स्टॉप मिलता है।
• वे कमज़ोरियां जो मायने रखती हैं: रिटर्न स्केलिंग, फिटिंग में लुक-अहेड (केवल अतीत के डेटा पर फिट करें, हमेशा walk-forward), पूर्वानुमान टाइमिंग, ओवर-ऑर्डरिंग, और एक वेरिएंस पूर्वानुमान को कभी दिशा पूर्वानुमान न समझना।

संदर्भ:

• Engle, R. F. (1982). Autoregressive Conditional Heteroscedasticity with Estimates of the Variance of United Kingdom Inflation. Econometrica, 50(4), 987-1007. DOI
• Bollerslev, T. (1986). Generalized Autoregressive Conditional Heteroskedasticity. Journal of Econometrics, 31(3), 307-327. DOI
• Mandelbrot, B. (1963). The Variation of Certain Speculative Prices. The Journal of Business, 36(4), 394-419. DOI
• Nelson, D. B. (1991). Conditional Heteroskedasticity in Asset Returns: A New Approach. Econometrica, 59(2), 347-370. DOI
• Katsiampa, P. (2017). Volatility estimation for Bitcoin: A comparison of GARCH models. Economics Letters, 158, 3-6. DOI
• Chu, J., Chan, S., Nadarajah, S., & Osterrieder, J. (2017). GARCH Modelling of Cryptocurrencies. Journal of Risk and Financial Management, 10(4), 17. DOI
• Sheppard, K. (2023). arch: Autoregressive Conditional Heteroskedasticity (ARCH) and other tools for financial econometrics in Python. GitHub.