Implied Volatility ची गणना कशी केली जाते?

Implied volatility ची गणना
Implied volatility ची गणना सूत्राद्वारे नाही, तर iteration द्वारे केली जाते. Option च्या बाजारभावावरून volatility चा आकडा काढण्यासाठी कोणतेही closed-form expression उपलब्ध नाही. त्यामुळे, एक solver आधी एक volatility गृहीत धरतो, Black-Scholes मॉडेल वापरून option ची किंमत काढतो, आणि त्या मॉडेलची किंमत बाजारातील quote शी तुलना करतो. जोपर्यंत या दोन्ही किमती एका पैशाच्या फरकापर्यंत समान होत नाहीत, तोपर्यंत ही प्रक्रिया पुन्हा पुन्हा केली जाते. खाली या संपूर्ण पद्धतीचे वर्णन दिले आहे: pricing function, standard library Python मधील search loop, आणि एकाच contract साठी दोन विक्रेते वेगवेगळे आकडे का प्रकाशित करतात याची कारणे.

Implied volatility साठी बंदिस्त स्वरूपाचे सूत्र का नसते

Black-Scholes मॉडेल एकाच दिशेने काम करते. यामध्ये स्पॉट प्राईस, स्ट्राईक प्राईस, एक्सपायरीसाठी लागणारा वेळ, व्याजदर आणि व्होलॅटिलिटी (अस्थिरता) टाकली की ते एक सैद्धांतिक किंमत (theoretical price) देते. या सहापैकी पाच घटक बाजारात सहज दिसतात. मात्र, व्होलॅटिलिटी दिसत नाही. आजपासून एक्सपायरीपर्यंत शेअरची किंमत किती प्रवास करेल, हा केवळ एक अंदाज असतो.

ट्रेडर्स या समस्येची उलट प्रक्रिया करतात. स्क्रीनवर किंमत दिसते आणि व्होलॅटिलिटी अज्ञात असते. Implied volatility म्हणजे असा व्होलॅटिलिटी इनपुट, ज्यामुळे Black-Scholes मॉडेलची किंमत ऑप्शनच्या बाजारभावाइतकी होते. सिग्मा (व्होलॅटिलिटी दर्शवणारा घटक) हा नॉर्मल डिस्ट्रिब्युशन फंक्शनमध्ये d1 आणि d2 अशा दोन ठिकाणी असतो, त्यामुळे त्याला वेगळे काढण्यासाठी कोणतेही समीकरण मांडता येत नाही. बीजगणित इथेच थांबते. त्यानंतर 'न्यूमेरिकल सर्च' (numerical search) पद्धतीचा वापर करावा लागतो. Implied volatility कशाचे मोजमाप करते यामध्ये याचे अर्थ स्पष्ट केले आहेत; हे पान त्याच्या तांत्रिक प्रक्रियेवर आधारित आहे.

या मॉडेलचे दोन गुणधर्म ही शोध प्रक्रिया सोपी करतात. व्होलॅटिलिटी वाढली की कॉल ऑप्शनची मॉडेल किंमत अपवाद न ठेवता वाढते आणि ती सातत्याने बदलते. जी राशी केवळ वाढत जाते, तिला एका विशिष्ट मर्यादेत (bracket) पकडून अचूक किमतीपर्यंत पोहोचणे शक्य असते.

सॉल्व्हर प्रत्येक कॉन्ट्रॅक्टसाठी एकदाच चालतो

याचे आउटपुट प्रत्येक स्टॉकसाठी एक नसून प्रत्येक कॉन्ट्रॅक्टसाठी एक संख्या असते, आणि एकाच स्टॉकवर एकाच expiry विंडोमधील कॉन्ट्रॅक्ट्समध्ये तफावत असू शकते. 30 जून 2026 रोजी ट्रेड झालेल्या 20 ते 45 दिवसांची मुदत असलेल्या सर्व Apple (AAPL) ऑप्शन्सची, शेअरच्या किमतीच्या तुलनेत strike priceनुसार केलेली विभागणी खालीलप्रमाणे आहे:

WITH toFloat64(strike_price) / toFloat64(underlying_close) AS moneyness
SELECT multiIf(moneyness < 0.90, '0.80-0.90',
               moneyness < 0.95, '0.90-0.95',
               moneyness < 1.00, '0.95-1.00',
               moneyness < 1.05, '1.00-1.05',
               moneyness < 1.10, '1.05-1.10',
                                 '1.10-1.20') AS strike_vs_spot,
       round(100 * avg(toFloat64(implied_volatility)), 1) AS implied_vol_pct,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = toDate('2026-06-30')
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND moneyness BETWEEN 0.80 AND 1.20
GROUP BY strike_vs_spot
ORDER BY min(moneyness)

strike ladder वर पाहिल्यास, 0.80-0.90 झोनचे मूल्य 35.5%, 0.95-1.00 झोनचे मूल्य 28.1% आणि 1.10-1.20 झोनचे मूल्य 27.3% असे आले आहे. एक कंपनी, एक सत्र आणि 6 उत्तरे. या वक्रातील वळणाला volatility skew असे म्हणतात आणि एका स्टॉकसाठी एकच volatility हे वक्र दर्शवू शकत नाही.

सॉल्वरला जुळवावी लागणारी Black-Scholes किंमत

S म्हणजे शेअरची किंमत, K म्हणजे strike price, T म्हणजे वर्षांमध्ये दिलेली expiry पर्यंतची मुदत, r म्हणजे risk-free rate आणि N() म्हणजे standard normal cumulative distribution, ज्याचा अर्थ असा की standard normal draw एखाद्या ठराविक बिंदूच्या खाली येण्याची संभाव्यता. Python मध्ये हा शेवटचा भाग math.erf मध्ये समाविष्ट असतो, त्यामुळे केवळ इंटरप्रिटर पुरेसा आहे.

apt-get update && apt-get install -y python3

जर तुम्ही मशीनवर root युजर नसाल, तर दोन्ही कमांड्सच्या आधी sudo जोडा. त्यानंतर हे iv.py म्हणून सेव्ह करा:

import math

def norm_cdf(x):
 return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))

def bs_call(S, K, T, r, sigma):
 if T <= 0.0 or sigma <= 0.0:
 return max(S - K, 0.0)
 d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
 d2 = d1 - sigma * math.sqrt(T)
 return S * norm_cdf(d1) - K * math.exp(-r * T) * norm_cdf(d2)

हे पूर्ण फॉरवर्ड मॉडेल आहे. यात volatility प्रविष्ट करा आणि किंमत मिळवा.

Implied volatility ची गणना टप्प्याटप्प्याने कशी केली जाते

Bisection ही सर्वात आधी शिकण्यासारखी पद्धत आहे. ही पद्धत कधीही विचलित (diverge) होत नाही आणि यासाठी कोणत्याही calculus ची आवश्यकता नसते.

1. उत्तराची व्याप्ती 0.01 (वार्षिक 1%) आणि 5.0 (500%) च्या दरम्यान निश्चित करा. प्रत्येक traded option याच मर्यादेत असतो.
2. या मर्यादेच्या मध्यबिंदूवर (midpoint) option ची किंमत काढा.
3. जर मॉडेलची किंमत बाजारातील किमतीपेक्षा जास्त असेल, तर तुमचा अंदाज खूप जास्त आहे असे समजा: मर्यादेची वरची बाजू मध्यबिंदूवर खाली आणा. जर ती कमी असेल, तर खालची बाजू वरच्या दिशेला सरकवा.
4. जेव्हा मॉडेलची किंमत बाजारातील किमतीच्या एका सेंटच्या आत येते, तेव्हा प्रक्रिया थांबवा.

def implied_vol(price, S, K, T, r, lo=0.01, hi=5.0, tol=0.01):
 for _ in range(100):
 mid = 0.5 * (lo + hi)
 diff = bs_call(S, K, T, r, mid) - price
 if abs(diff) < tol:
 return mid
 if diff > 0.0:
 hi = mid
 else:
 lo = mid
 return 0.5 * (lo + hi)

# $100 स्टॉक, $100 स्ट्राईक, तीन महिने, 4% दर, स्क्रीनवर $5.00
print(round(implied_vol(5.00, 100.0, 100.0, 0.25, 0.04), 4))

python3 iv.py रन करा. हे साधारण 0.226 प्रिंट करते, म्हणजेच त्या काल्पनिक किमतीसाठी वार्षिक 22.6% च्या आसपास implied volatility मिळते. प्रत्येक फेरी मर्यादेला निम्म्यावर आणते आणि 4.99 रुंदीची मर्यादा वीस वेळा निम्मी केल्यास ती 0.00001 पेक्षा कमी होते, त्यामुळे 100 iterations ची मर्यादा कधीही ओलांडली जात नाही.

Newton-Raphson पद्धत अधिक वेगाने का कार्य करते आणि ती कुठे अपयशी ठरते

Bisection पद्धत मॉडेलकडे आधीच उपलब्ध असलेली माहिती सोडून देते. Vega म्हणजे अस्थिरतेच्या (volatility) प्रति युनिटनुसार optionच्या किमतीत होणारा बदल, आणि Black-Scholes मॉडेल हे बंद स्वरूपात (closed form) उपलब्ध करून देते. Newton-Raphson पद्धत याला एक उतार (slope) मानते: किमतीतील त्रुटी मोजा, तिला vega ने भागा आणि त्या प्रमाणात अंदाजाची पुढची पायरी निश्चित करा.

def bs_vega(S, K, T, r, sigma):
 d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
 return S * math.sqrt(T) * math.exp(-0.5 * d1 * d1) / math.sqrt(2.0 * math.pi)

def implied_vol_newton(price, S, K, T, r, sigma=0.5):
 for _ in range(20):
 v = bs_vega(S, K, T, r, sigma)
 if v < 1e-8:
 return None # उतार उरलेला नाही, काम पुन्हा bisection कडे सोपवा
 step = (bs_call(S, K, T, r, sigma) - price) / v
 sigma -= step
 if sigma <= 0.0:
 return None # पायरी ओलांडून निरर्थक आकड्यापर्यंत पोहोचली
 if abs(step) < 1e-6:
 return sigma
 return None

At-the-money स्थितीत ही पद्धत bisectionच्या डझनभर पायऱ्यांच्या तुलनेत तीन किंवा चार प्रयत्नांतच अचूक उत्तर देते. या पद्धतीचे अपयश छेदाच्या (denominator) ठिकाणी दडलेले असते: जसा strike price शेअरच्या किमतीपासून दूर जातो, तसा vega कमी होत जातो. AAPLच्या त्याच contractsसाठी, प्रत्येक क्षेत्रातील सरासरी vega हा at-the-money रीडिंगच्या टक्केवारीनुसार खालीलप्रमाणे दर्शविला आहे:

WITH toFloat64(strike_price) / toFloat64(underlying_close) AS moneyness,
     (
         SELECT avg(toFloat64(vega))
         FROM global_markets.options_greeks
         WHERE underlying_symbol = 'AAPL'
           AND date = toDate('2026-06-30')
           AND days_to_expiry BETWEEN 20 AND 45
           AND iv_converged = 1
           AND volume > 0
           AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.025
     ) AS atm_vega
SELECT multiIf(moneyness < 0.90, '0.80-0.90',
               moneyness < 0.95, '0.90-0.95',
               moneyness < 1.00, '0.95-1.00',
               moneyness < 1.05, '1.00-1.05',
               moneyness < 1.10, '1.05-1.10',
                                 '1.10-1.20') AS strike_vs_spot,
       round(100 * avg(toFloat64(vega)) / atm_vega, 1) AS vega_pct_of_atm,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = toDate('2026-06-30')
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND moneyness BETWEEN 0.80 AND 1.20
GROUP BY strike_vs_spot
ORDER BY min(moneyness)

Wings (बाहेरील strike prices) मध्ये संवेदनशीलता खूप कमी असते: 0.80-0.90 क्षेत्रात at-the-money vega च्या 33.1% इतकी, तर 1.10-1.20 क्षेत्रात 31.6% इतकी असते. किमतीतील त्रुटीला इतक्या लहान संख्येने भागल्यास एक मोठी पायरी (step) मिळते, ज्यामुळे अंदाज शून्याच्या खाली जाऊ शकतो, जिथे मॉडेल काहीही सांगू शकत नाही. प्रत्यक्ष व्यवहारातील solvers या दोन्ही पद्धतींचा वापर करतात; आधी bisection ने व्याप्ती (bracket) निश्चित केली जाते आणि नंतर Newton-Raphson ने अचूकता मिळवली जाते. Vega या ग्रीक घटकाची सविस्तर माहिती देते.

दोन स्रोत भिन्न implied volatility का दर्शवतात

मॉडेल सार्वजनिक आहे आणि गणित निश्चित आहे, त्यामुळे मतभेद इनपुटमध्ये असतात.

• मिड (Mid) विरुद्ध शेवटचा व्यवहार (Last). सॉल्वरला एका किमतीची गरज असते. ज्या करारासाठी $2.00 bid आणि $2.20 offer अशी कोटेशन आहे, त्याचा मिडपॉईंट $2.10 आहे, तर शेवटचा व्यवहार नव्वद मिनिटांपूर्वी $2.02 वर झालेला असू शकतो. अशा करारावर, दहा सेंटची किंमत एका पॉईंटच्या volatility पेक्षा जास्त महत्त्वाची असते.
• डिव्हिडंड आणि कॅरी (Carry). वरील फंक्शन अशा स्टॉकवरील युरोपियन कॉलची किंमत ठरवते ज्यावर कोणताही लाभांश मिळत नाही. एक्सपायरीच्या आधीचा लाभांश फॉरवर्ड किंमत कमी करतो आणि प्रत्येक ट्रेडिंग डेस्क स्वतःचे ॲडजस्टमेंट आणि स्वतःचा दर लागू करते.
• अमेरिकन अर्ली एक्सरसाइज. अमेरिकन सिंगल स्टॉक ऑप्शन्स कोणत्याही दिवशी एक्सरसाइज केले जाऊ शकतात आणि या अधिकाराचे मूल्य युरोपियन फॉर्म्युलामध्ये कुठेही मांडता येत नाही. जो सॉल्वर याकडे दुर्लक्ष करतो, तो फरक volatility मध्ये ढकलतो. बायोनोमियल ट्रीज (Binomial trees) एक्सरसाइजच्या अधिकाराची किंमत थेट ठरवतात.
• जुनी कोटेशन्स (Stale quotes). ज्या स्ट्राईकवर मंगळवारी शेवटचा व्यवहार झाला होता, त्याचे कोटेशन अजूनही दिसत असते आणि सॉल्वरला जे काही दिले जाते, त्याला तो सत्य मानतो.

कन्व्हर्जन्समुळे (Convergence) शेवटच्या दोन गोष्टी स्पष्ट होतात. खालील तक्त्यात 30 जून 2026 रोजी आठ प्रसिद्ध कंपन्यांचे शेअर्स घेतले आहेत, 20 ते 45 दिवस शिल्लक असलेले व्यवहार झालेले कॉन्ट्रॅक्ट्स मोजले आहेत आणि at the money volatility तसेच ज्या कॉन्ट्रॅक्ट्समध्ये सॉल्व्ह कन्व्हर्ज झाले आहे त्यांचा हिस्सा दर्शविला आहे:

WITH abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) AS distance_from_spot
SELECT underlying_symbol AS symbol,
       round(100 * avgIf(toFloat64(implied_volatility), iv_converged = 1 AND distance_from_spot < 0.05), 1) AS atm_iv_pct,
       round(100 * countIf(iv_converged = 1) / count(), 1) AS solved_pct,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE date = toDate('2026-06-30')
  AND underlying_symbol IN ('AAPL', 'MSFT', 'NVDA', 'AMZN', 'TSLA', 'SPY', 'KO', 'JNJ')
  AND days_to_expiry BETWEEN 20 AND 45
  AND volume > 0
GROUP BY symbol
HAVING countIf(iv_converged = 1 AND distance_from_spot < 0.05) > 0
ORDER BY atm_iv_pct DESC

TSLA ने 8 कंपन्यांमध्ये 47.7% सह सर्वाधिक at the money रीडिंग नोंदवले, तर SPY 14.4% सह तळाला होते. TSLA चेनवर, 97.8% व्यवहार झालेल्या कॉन्ट्रॅक्ट्सनी कन्व्हर्ज्ड उत्तर दिले. उर्वरित अशा स्ट्राईक्स आहेत जिथे सॉल्वरला दिलेली किंमत कोणत्याही volatility द्वारे मिळवता येत नाही, जसे की intrinsic value पेक्षा कमी कोटेशन किंवा क्रॉस मार्केट. 30% IV सारखा आकडा जास्त मानला जावा का, हा एक वेगळा प्रश्न आहे: 30% IV जास्त आहे का यावर चर्चा करते आणि अपेक्षित हालचाल त्याचे रूपांतर डॉलरच्या रेंजमध्ये करते.

प्रत्येक सत्रात पुन्हा सोडवलेला तोच करार

Implied volatility बद्दल कोणतीही माहिती साठवून ठेवली जात नाही. स्क्रीनवर जी किंमत असेल, त्यावरून ती पुन्हा मोजली जाते. खाली 17 जुलै 2026 रोजी संपणारा AAPL चा सर्वाधिक ट्रेड झालेला करार दिला आहे, ज्याचा मागोवा 1 जूनपासून ते एक्सपायरीपर्यंत घेतला आहे. स्ट्राइक प्राईस आणि एक्सपायरीमध्ये कोणताही बदल झालेला नाही:

WITH (
         SELECT ticker
         FROM global_markets.options_greeks
         WHERE underlying_symbol = 'AAPL'
           AND date = toDate('2026-06-30')
           AND expiration_date = toDate('2026-07-17')
           AND iv_converged = 1
           AND volume > 0
         ORDER BY volume DESC
         LIMIT 1
     ) AS pinned_contract
SELECT date,
       round(100 * avg(toFloat64(implied_volatility)), 1) AS implied_vol_pct,
       round(avg(days_to_expiry)) AS days_to_expiry
FROM global_markets.options_greeks
WHERE ticker = pinned_contract
  AND date BETWEEN toDate('2026-06-01') AND toDate('2026-07-17')
  AND iv_converged = 1
  AND volume > 0
GROUP BY date
ORDER BY date

29 सत्रांमध्ये, सोडवलेले रीडिंग 25.1% वर सुरू झाले, तेव्हा 46 दिवस शिल्लक होते आणि ते 26.6% वर संपले, तेव्हा 4 दिवस शिल्लक होते. त्या रेषेवरील प्रत्येक बिंदू म्हणजे त्या सत्राच्या कोटच्या तुलनेत वरील लूपचा एक रन आहे. आमची प्रति टिकर पृष्ठे समान सोल्युशन प्रकाशित करतात: AAPL implied volatility हे संपूर्ण चेनवर दररोज चालवले जाते, जेणेकरून वाचक या पृष्ठावरील कोड वापरून कोणताही आकडा पुन्हा तयार करू शकेल.

Implied volatility गणनेबाबत वारंवार विचारले जाणारे प्रश्न

Implied volatility साठी काही सूत्र आहे का?

नाही. Black-Scholes मॉडेल volatility ला किमतीशी जोडते, परंतु या मॅपिंगचे कोणतेही प्राथमिक व्यस्त (inverse) सूत्र नाही, कारण sigma हे normal distribution मध्ये दोनदा येते. तुम्हाला येथे किंवा इतरत्र दिसणारा प्रत्येक implied volatility चा आकडा हा iterative solver द्वारे काढलेला असतो.

या गणनेसाठी किती iterations लागतात?

प्रत्येक bisection pass हा bracket अर्धा करतो, त्यामुळे 0.01 ते 5.0 ही श्रेणी वीस passes मध्ये 0.00001 च्या खाली येते, आणि एखाद्या quote ला जवळच्या cent पर्यंत जुळवण्यासाठी साधारणपणे बारा iterations लागतात. Newton-Raphson पद्धत 'near the money' असताना तीन किंवा चार पायऱ्यांमध्ये उत्तर देते, परंतु जिथे vega कमी असतो तिथे या पद्धतीचे steps अस्थिर ठरू शकतात.

माझा ब्रोकर आणि डेटा व्हेंडर वेगवेगळी implied volatility का दाखवतात?

त्यांनी solver मध्ये वेगवेगळे inputs दिले आहेत. सामान्य तफावतीची कारणे म्हणजे mid quote विरुद्ध last trade, व्याजदर आणि dividend बाबतची गृहीतके, आणि मॉडेल American early exercise हाताळते की नाही हे होय. कमी व्यवहार (thin strike) असलेल्या ठिकाणी, केवळ एक जुना quote सुद्धा उत्तरात काही points चा फरक पाडू शकतो.

एकाच strike वरचे calls आणि puts समान implied volatility देतात का?

सिद्धांतानुसार हो, कारण put-call parity त्यांना एकाच strike आणि expiry वर जोडते. प्रत्यक्षात, दोन्ही quotes स्वतंत्रपणे ठरवले जातात आणि काढलेली उत्तरे थोडी वेगळी असतात; हे देखील एक कारण आहे की संपूर्ण chain ची सरासरी व्हेंडर्समध्ये वेगवेगळी असते.

मी मार्केट डेटाशिवाय implied volatility मोजू शकतो का?

हो, काल्पनिक quote साठी. वरील कोडमध्ये किंमत, strike, spot, expiry साठी लागणारा वेळ आणि व्याजदर हे सर्व हाताने टाईप करावे लागतात. लाइव्ह व्हेंडरच्या आकड्याशी जुळणी करणे हा अधिक कठीण भाग आहे: त्यासाठी व्हेंडरने वापरलेले नेमके inputs लागतात.

येथील प्रत्येक पॅनेल त्यामागील SQL साठवतो. एक पॅनेल उघडा आणि Strasmore टर्मिनलवर लाइव्ह chain विरुद्ध तीच solve प्रक्रिया चालवा.