Implied Volatility எவ்வாறு கணக்கிடப்படுகிறது?

Implied volatility, ஒரு formula மூலம் அல்ல; iteration முறையில் கணக்கிடப்படுகிறது. ஒரு option-ன் market price-ஐ volatility எண்ணாக மாற்றும் closed-form expression எதுவும் இல்லை. எனவே solver முதலில் ஒரு volatility மதிப்பை ஊகிக்கிறது. பின்னர் Black-Scholes முறையில் option-ஐ விலைநிர்ணயம் செய்து, அந்த model price-ஐ quote-உடன் ஒப்பிடுகிறது. இரண்டும் penny அளவிலும் ஒன்றாகும் வரை இந்தச் செயல்முறை மீண்டும் மீண்டும் நடைபெறும். அடுத்து வருவது முழுமையான முறையாகும்: pricing function, standard library Python-இல் செயல்படுத்தப்படும் search loop, மேலும் ஒரே contract-க்கு இரண்டு vendors ஏன் வெவ்வேறு எண்களை வெளியிடுகின்றன என்பதற்கான காரணங்கள்.

Implied volatility-க்கு ஏன் closed-form formula இல்லை

Black-Scholes மாதிரி ஒரு திசையில் செயல்படுகிறது. Spot price, strike price, expiry-க்கு மீதமுள்ள காலம், interest rate, volatility ஆகியவற்றை உள்ளீடுகளாக வழங்கினால், அது ஒரு theoretical price-ஐக் கணக்கிடுகிறது. இந்த ஆறு அளவுகளில் ஐந்தை சந்தையில் காண முடியும். Volatility மட்டும் காணக்கூடியது அல்ல. இப்போது முதல் expiry வரை பங்கு விலை எவ்வளவு தூரம் நகரும் என்பதற்கான ஒரு மதிப்பீடுதான் அது.

Traders இந்தப் பிரச்சினையைத் தலைகீழாக அணுகுகிறார்கள். Price திரையில் உள்ளது; volatility தெரியாத அளவாக உள்ளது. Implied volatility என்பது, Black-Scholes price option-ன் market price-க்கு சமமாகும் வகையில் உள்ளீடாக வழங்கப்படும் volatility ஆகும். Volatility term-ஆகிய Sigma, normal distribution function-ன் உள்ளே d1 மற்றும் d2 ஆகிய இரண்டிலும் இடம்பெறுகிறது. அதைத் தனியாகப் பிரித்தெடுக்க எந்த algebraic rearrangement-மும் இல்லை. அங்கே algebra-வின் வரம்பு முடிகிறது. அதன் பின் numerical search பயன்படுத்தப்படுகிறது. Implied volatility அளவிடுவது என்ன அதன் விளக்கத்தை வழங்குகிறது; இந்தப் பக்கம் கணக்கீட்டு முறையை விளக்குகிறது.

இந்த மாதிரியின் இரண்டு பண்புகள் தேடலை எளிதாக்குகின்றன. Volatility உயரும்போதெல்லாம் call-ன் model price விதிவிலக்கின்றி உயர்கிறது; அதன் மாற்றமும் சீராக இருக்கும். தொடர்ந்து உயர்கின்ற ஒரு அளவை, அதன் இருபுறமும் ஒரு வரம்பை அமைத்து படிப்படியாகச் சுருக்கி கண்டறியலாம்.

ஒவ்வொரு contract-க்கும் solver ஒருமுறை இயங்கும்

வெளியீட்டில் ஒவ்வொரு பங்குக்கும் ஒன்றாக அல்ல, ஒவ்வொரு contract-க்கும் ஒரு எண்ணே இருக்கும். ஒரே stock-ஐச் சேர்ந்த, ஒரே expiry window-வில் உள்ள contract-களின் முடிவுகளும் ஒன்றுக்கொன்று மாறுபடும். June 30, 2026 அன்று வர்த்தகம் செய்யப்பட்ட, 20 முதல் 45 நாட்கள் வரை மீதமுள்ள Apple (AAPL) options அனைத்தும், share price-இன் ஒரு பங்காகக் கணக்கிடப்பட்ட strike அடிப்படையில் தொகுக்கப்பட்டுள்ளன:

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% ஆகவும் இருந்தது. ஒரே நிறுவனம், ஒரே trading session, 6 பதில்கள். அந்த வளைவில் உள்ள வளைவுக்கு ஒரு பெயர் உண்டு: volatility skew. ஒரு stock-க்கு ஒதுக்கப்படும் ஒரே volatility-யால் அந்த வளைவை வரைய முடியாது.

Solver-க்கு பொருத்த வேண்டிய Black-Scholes விலை

S என்பது பங்கின் விலை; K என்பது strike விலை; T என்பது expiry-க்கு மீதமுள்ள காலம், ஆண்டுகளில்; r என்பது risk-free rate; N() என்பது standard normal cumulative distribution. அதாவது, standard normal random value ஒன்று குறிப்பிட்ட புள்ளிக்குக் கீழே வரும் probability. Python-ல் இந்த இறுதி செயல்பாடு math.erf-ல் உள்ளது. எனவே interpreter மட்டும் போதுமானது.

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

நீங்கள் root பயனராக இல்லாத கணினியில், இரண்டு commands-க்கும் முன் 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)

இதுவே முழுமையான forward model. அதற்கு ஒரு volatility-ஐ வழங்கினால், அது ஒரு விலையைத் தரும்.

Implied volatility கணக்கிடப்படும் முறை: படிப்படியாக

முதலில் கற்றுக்கொள்ள வேண்டிய முறை Bisection ஆகும். இதில் கணக்கீடு divergence அடையாது. Calculus-மும் தேவையில்லை.

1. பதிலை 0.01 (ஆண்டுக்கு 1%) முதல் 5.0 (500%) வரையிலான வரம்புக்குள் நிர்ணயிக்கவும். வர்த்தகம் செய்யப்படும் ஒவ்வொரு option-மும் இந்த வரம்புக்குள் இருக்கும்.
2. இந்த வரம்பின் நடுப்புள்ளியைப் பயன்படுத்தி option-ன் விலையை கணக்கிடவும்.
3. Model price, market quote-ஐ விட அதிகமாக இருந்தால், கணிப்பு மிக அதிகமாக உள்ளது. ஆகவே, வரம்பின் மேல் எல்லையை நடுப்புள்ளியாகக் குறைக்கவும். அது குறைவாக இருந்தால், கீழ் எல்லையை நடுப்புள்ளி வரை உயர்த்தவும்.
4. Model price, quote-ன் விலையிலிருந்து ஒரு cent-க்குள் வந்ததும் நிறுத்தவும்.

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 stock, $100 strike, three months, 4% rates, $5.00 on the screen
print(round(implied_vol(5.00, 100.0, 100.0, 0.25, 0.04), 4))

python3 iv.py-ஐ இயக்கவும். அது சுமார் 0.226 எனக் காட்டும். இந்தக் கற்பனை quote-க்கான implied volatility, ஆண்டுக்கு சுமார் 22.6% ஆகும். ஒவ்வொரு சுற்றிலும் வரம்பு பாதியாகக் குறையும். 4.99 அகலமுள்ள வரம்பை இருபது முறை பாதியாகப் பிரித்தால், அது 0.00001-ஐ விடக் குறுகியதாகிவிடும். எனவே, 100 iteration-களுக்கான உச்சவரம்பு ஒருபோதும் செயல்படாது.

Newton-Raphson ஏன் வேகமாக converges ஆகிறது, மேலும் அது எங்கு தோல்வியடைகிறது

Bisection, model-இல் ஏற்கனவே உள்ள தகவலைப் பயன்படுத்தாமல் விட்டுவிடுகிறது. Vega என்பது volatility ஒரு unit மாறும்போது option-ன் விலை எவ்வளவு மாறுகிறது என்பதாகும். Black-Scholes இதை closed form-ஆக வழங்குகிறது. Newton-Raphson இதை ஒரு slope-ஆகப் பயன்படுத்துகிறது: pricing error-ஐ அளந்து, அதை vega-ஆல் வகுத்து, கிடைக்கும் அளவுக்கு guess-ஐ மாற்றுகிறது.

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          # no slope left, hand the job back to bisection
        step = (bs_call(S, K, T, r, sigma) - price) / v
        sigma -= step
        if sigma <= 0.0:
            return None          # the step overshot into nonsense
        if abs(step) < 1e-6:
            return sigma
    return None

At the money நிலைக்கு அருகில், இது Bisection-ன் பன்னிரண்டு passes-க்கு மாறாக மூன்று அல்லது நான்கு passes-ல் முடிவை அடைகிறது. இதன் தோல்வி denominator-ல் உள்ளது: strike, share price-இலிருந்து விலகிச் செல்லும்போது vega குறைகிறது. அதே AAPL contracts-க்கு, ஒவ்வொரு zone-ன் சராசரி vega, at the money reading-ன் சதவீதமாகக் காட்டப்பட்டுள்ளது:

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 பகுதியில் sensitivity-யின் ஒரு பகுதி மட்டுமே இருக்கும்: 33.1% zone-ல் at the money vega-வில் 0.80-0.90, 1.10-1.20 zone-ல் 31.6%. இவ்வளவு சிறிய எண்ணால் pricing error-ஐ வகுத்தால், மிகப் பெரிய step உருவாகும். இதனால் guess, zero-க்குக் கீழ் செல்லக்கூடும்; அங்கு model-ஆல் மேற்கொண்டு எதையும் கணிக்க முடியாது. Production solvers, இந்த இரண்டு முறைகளையும் இணைக்கின்றன. முதலில் range-ஐ bracket செய்து, பின்னர் Newton மூலம் துல்லியப்படுத்துகின்றன. Vega பகுதியில் அந்த greek குறித்து விளக்கப்பட்டுள்ளது.

இரண்டு ஆதாரங்கள் வேறுபட்ட implied volatility-ஐ ஏன் தெரிவிக்கின்றன

Model பொதுவில் கிடைக்கிறது. கணிதக் கணக்கிலும் முரண்பாடு இல்லை. எனவே வேறுபாடு inputs-ல் உள்ளது.

• Mid மற்றும் last விலைகள். Solver-க்கு ஒரே ஒரு விலை தேவை. ஒரு contract-க்கு $2.00 bid மற்றும் $2.20 offer இருந்தால், midpoint $2.10 ஆகும். ஆனால் last print, தொண்ணூறு நிமிடங்களுக்கு முன் பதிவான $2.02 ஆக இருக்கலாம். இத்தகைய contract-ல் விலையின் பத்து cents வேறுபாடு, volatility-யின் ஒரு point-ஐவிட அதிக தாக்கம் கொண்டது.
• Dividends மற்றும் carry. மேலே உள்ள function, dividend செலுத்தாத பங்கின் European call-க்கு விலை நிர்ணயிக்கிறது. Expiry-க்கு முன் செலுத்தப்படும் dividend, forward price-ஐக் குறைக்கும். ஒவ்வொரு trading desk-ம் தனக்கான adjustment மற்றும் rate-ஐப் பயன்படுத்துகிறது.
• American early exercise. US single-stock options-ஐ எந்த trading நாளிலும் exercise செய்யலாம். அந்த உரிமைக்கு மதிப்பு உள்ளது; அதை European formula கணக்கில் சேர்க்க முடியாது. அதை புறக்கணிக்கும் solver, அந்த வேறுபாட்டை volatility-க்குள் தள்ளுகிறது. Binomial trees, exercise உரிமைக்கு நேரடியாக விலை நிர்ணயிக்கின்றன.
• Stale quotes. செவ்வாய்க்கிழமை last trade ஆன strike-க்கும் quote தொடர்ந்து காட்டப்படலாம். Solver-க்கு வழங்கப்படும் எந்த quote-யையும் அது உண்மையாகக் கருதுகிறது.

Convergence, கடைசி இரண்டு காரணிகளையும் வெளிப்படுத்துகிறது. கீழே உள்ள panel, June 30, 2026 அன்று பரவலாக அறியப்பட்ட எட்டு பெயர்களை எடுத்துக்கொள்கிறது. Expiry-க்கு 20 முதல் 45 நாட்கள் மீதமுள்ள traded contracts-ஐ எண்ணி, at-the-money volatility மற்றும் solve converged ஆன contracts-ன் பங்கைக் காட்டுகிறது:

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 reading-ஐப் பதிவு செய்தது. கீழ்நிலையில் இருந்த SPY-க்கு இது 14.4% ஆக இருந்தது. TSLA chain-ல், traded contracts-ன் 97.8% converged answer-ஐ வழங்கின. மீதமுள்ளவை, solver-க்கு வழங்கப்பட்ட price எந்த volatility-யாலும் உருவாக்க முடியாத strikes ஆகும்; அல்லது intrinsic value-க்குக் குறைவான quote, அல்லது crossed market ஆகும். இத்தகைய எண்ணிக்கை உயர்ந்ததா என்பது தனியான கேள்வி: 30% IV உயர்ந்ததா அதை ஆராய்கிறது; expected move அதை dollar range-ஆக மாற்றுகிறது.

ஒவ்வொரு வர்த்தக அமர்விலும் மீண்டும் கணக்கிடப்படும் அதே contract

Implied volatility தொடர்பான எந்த மதிப்பும் சேமித்து வைக்கப்படாது. திரையில் காணப்படும் அந்த நேரத்திய விலையை அடிப்படையாகக் கொண்டு அது மீண்டும் கணக்கிடப்படுகிறது. கீழே, July 17, 2026 அன்று expiry ஆகும், அதிகமாக வர்த்தகம் செய்யப்பட்ட AAPL contract கொடுக்கப்பட்டுள்ளது. இது June 1 முதல் expiry வரை தொடர்ந்து கண்காணிக்கப்பட்டது. Strike price மாறவில்லை; expiry தேதியும் மாறவில்லை:

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%-இல் தொடங்கியது. அப்போது expiry வரை 46 நாட்கள் இருந்தன. அது 26.6%-இல் முடிவடைந்தது; அப்போது 4 நாட்கள் மீதமிருந்தன. அந்த வரிக்கோட்டில் உள்ள ஒவ்வொரு புள்ளியும், அந்த அமர்வின் quote-ஐப் பயன்படுத்தி மேலே குறிப்பிடப்பட்ட loop ஒருமுறை இயக்கப்பட்டதைக் குறிக்கிறது. எங்கள் ஒவ்வொரு ticker-க்கான பக்கங்களிலும் இதே கணக்கீடு வெளியிடப்படுகிறது: AAPL implied volatility முழு chain-ஐயும் தினசரி கணக்கிடுகிறது. எனவே, அந்தப் பக்கத்தில் உள்ள எந்த மதிப்பையும் இப்பக்கத்தில் உள்ள code-ஐப் பயன்படுத்தி வாசகர் மீண்டும் உருவாக்கலாம்.

Implied volatility கணக்கீடு: அடிக்கடி கேட்கப்படும் கேள்விகள்

Implied volatility-க்கு formula உள்ளதா?

இல்லை. Black-Scholes, volatility-யை price-ஆக மாற்றிக் காட்டுகிறது. ஆனால் அந்த mapping-க்கு எளிய inverse இல்லை. காரணம், sigma normal distribution-க்குள் இரண்டு இடங்களில் தோன்றுகிறது. நீங்கள் இங்கேயோ வேறு எங்கோ காணும் ஒவ்வொரு implied volatility எண்ணும் iterative solver மூலம் பெறப்படுகிறது.

இந்தக் கணக்கீட்டுக்கு எத்தனை iterations தேவைப்படும்?

ஒவ்வொரு bisection pass-லும் bracket பாதியாகக் குறைகிறது. எனவே 0.01 முதல் 5.0 வரையிலான range, இருபது passes-ல் 0.00001-க்குக் கீழே சுருங்கும். Quote-ஐ nearest cent அளவுக்கு பொருத்துவதற்கு பொதுவாக சுமார் ஒரு டஜன் passes போதுமானவை. Money-க்கு அருகிலுள்ள options-ல் Newton-Raphson மூன்று அல்லது நான்கு iterations-ல் முடிவை அளிக்கும். ஆனால் vega குறைவாக இருக்கும் இடங்களில் அதன் steps சரியாக இயங்காமல் போகலாம்.

எனது broker மற்றும் data vendor வெவ்வேறு implied volatility-ஐ ஏன் காட்டுகின்றன?

அவர்கள் solver-க்கு வெவ்வேறு inputs-ஐ வழங்கியுள்ளனர். பொதுவாக mid quote மற்றும் last trade ஆகியவற்றின் வேறுபாடு, பயன்படுத்திய rate மற்றும் dividend assumption, மேலும் American early exercise-ஐ model கையாளுகிறதா என்பவை முக்கியமான வேறுபாடுகள். Thinly traded strike-ல் stale quote மட்டும் கூட முடிவை பல points அளவுக்கு மாற்றக்கூடும்.

ஒரே strike-ல் உள்ள calls மற்றும் puts ஒரே implied volatility-ஐ அளிக்குமா?

கோட்பாட்டில் ஆம். ஒரே strike மற்றும் expiry-யில் put-call parity இரண்டையும் ஒன்றுடன் ஒன்று இணைக்கிறது. நடைமுறையில், இரண்டு quotes-ம் தனித்தனியாக நிர்ணயிக்கப்படுகின்றன. எனவே கணக்கிடப்பட்ட எண்களில் சிறிய வேறுபாடு இருக்கும். இதுவே chain முழுவதிலான averages, vendors-க்கு இடையே மாறுபடுவதற்கான மேலும் ஒரு காரணம்.

Market data இல்லாமல் implied volatility-ஐ கணக்கிட முடியுமா?

ஆம், hypothetical quote-க்கு கணக்கிடலாம். மேலே உள்ள code-ல் price, strike, spot, time to expiry மற்றும் rate ஆகியவற்றை கையால் உள்ளிடலாம். ஆனால் live vendor எண்ணுடன் பொருத்துவது சற்று கடினமான பகுதி. அதற்கு vendor பயன்படுத்திய அதே inputs தேவைப்படும்.

இங்குள்ள ஒவ்வொரு panel-லும் அதற்குப் பின்னுள்ள SQL சேமிக்கப்பட்டுள்ளது. ஒன்றைத் திறந்து, Strasmore terminal-ல் live chain மீது அதே solve-ஐ இயக்குங்கள்.