ఇంప్లైడ్ వోలాటిలిటీని ఎలా లెక్కిస్తారు

Implied volatilityను ఒకే సూత్రంతో కాకుండా పునరావృత గణన ద్వారా లెక్కిస్తారు. ఆప్షన్ మార్కెట్ ధరను తిరిగి volatility సంఖ్యగా మార్చే closed-form expression లేదు. అందువల్ల solver ఒక volatilityని అంచనా వేసి, Black-Scholesతో ఆప్షన్ ధరను లెక్కిస్తుంది. ఆ model ధరను quoteతో పోల్చుతుంది. రెండు ధరలు ఒక్క పెన్నీ వరకు సరిపడేంతవరకు ఈ ప్రక్రియను పునరావృతం చేస్తుంది. తరువాతి భాగంలో మొత్తం పద్ధతి ఉంటుంది: pricing function, standard library Pythonలో search loop, అలాగే ఒకే contractకు ఇద్దరు vendors వేర్వేరు సంఖ్యలను ఎందుకు ప్రచురిస్తారో వివరణ.

ఇంప్లైడ్ వోలాటిలిటీకి closed-form సూత్రం ఎందుకు లేదు

Black-Scholes ఒకే దిశలో పనిచేస్తుంది. దానికి spot price, strike price, expiry వరకు మిగిలిన సమయం, వడ్డీ రేటు, volatility ఇస్తే, అది సైద్ధాంతిక ధరను ఇస్తుంది. ఈ ఆరు పరిమాణాల్లో ఐదు గమనించగలిగేవి. Volatility మాత్రం గమనించలేం. ఇప్పటి నుంచి expiry వరకు షేరు ధర ఎంత దూరం కదులుతుందనే అంచనా అది.

ట్రేడర్లు ఈ సమస్యను తలకిందులు చేస్తారు. ధర స్క్రీన్‌పై ఉంటుంది, volatility తెలియని పరిమాణంగా ఉంటుంది. Black-Scholes ధర, option మార్కెట్ ధరకు సమానంగా వచ్చేలా చేసే volatility inputనే implied volatility అంటారు. Volatility పదమైన Sigma, normal distribution functionలో d1 మరియు d2 రెండింటిలోనూ ఉంటుంది. దాన్ని ఒంటరిగా వేరుచేసే algebraic మార్పు లేదు. అక్కడ algebra ఆగిపోతుంది. తర్వాత numerical search ఉపయోగిస్తారు. Implied volatility ఏం కొలుస్తుంది అనే పేజీ దాని అర్థాన్ని వివరిస్తుంది; ఈ పేజీ గణన విధానాన్ని వివరిస్తుంది.

మోడల్‌లోని రెండు లక్షణాలు ఈ శోధనను సులభం చేస్తాయి. Volatility పెరిగినప్పుడల్లా call యొక్క model price పెరుగుతుంది; దీనికి మినహాయింపులు లేవు. అలాగే ధర సాఫీగా మారుతుంది. ఒకే దిశలో పెరిగే పరిమాణాన్ని దాని చుట్టూ ఉన్న పరిమితులను క్రమంగా కుదించడం ద్వారా ఖచ్చితంగా కనుగొనవచ్చు.

ఒప్పందానికి ఒకసారి solver అమలు అవుతుంది

అవుట్‌పుట్ ప్రతి స్టాక్‌కు ఒక్కటి కాదు, ప్రతి contractకు ఒక సంఖ్య. ఒకే స్టాక్‌కు చెందిన, ఒకే expiry windowలో ఉన్న contracts కూడా పరస్పరం భిన్నమైన ఫలితాలను ఇస్తాయి. June 30, 2026న ట్రేడ్ అయిన, ఇంకా 20 నుంచి 45 రోజులు మిగిలి ఉన్న ప్రతి Apple (AAPL) optionను share priceలో strike భాగంగా చూపిస్తూ, 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 zoneకు 35.5%, 0.95-1.00 zoneకు 28.1%, 1.10-1.20 zoneకు 27.3%గా పరిష్కారం వచ్చింది. ఒక కంపెనీ, ఒక trading session, 6 సమాధానాలు. ఆ వక్రంలో కనిపించే వంపుకు volatility skew అనే పేరు ఉంది. ఒకే స్టాక్‌కు ఒకే volatility విలువతో దాన్ని చూపించడం సాధ్యం కాదు.

సోల్వర్ సరిపోల్చాల్సిన Black-Scholes ధర

S షేర్ ధర, K strike ధర, T గడువు వరకు మిగిలిన సమయం సంవత్సరాల్లో, r risk-free rate, N() standard normal cumulative distributionను సూచిస్తాయి. అంటే standard normal draw ఒక నిర్దిష్ట బిందువు కంటే దిగువన ఉండే 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ను ఇన్‌పుట్‌గా ఇస్తే ధర లభిస్తుంది.

ఇంప్లైడ్ వోలాటిలిటీని దశలవారీగా ఎలా లెక్కించాలి

ముందుగా నేర్చుకోవాల్సిన పద్ధతి బైసెక్షన్. ఇది ఎప్పుడూ విఫలమై దూరంగా వెళ్లదు. కాల్క్యులస్ కూడా అవసరం లేదు.

1. సమాధానాన్ని సంవత్సరానికి 0.01 (1%) నుంచి 5.0 (500%) మధ్య పరిమితం చేయండి. ట్రేడయ్యే ప్రతి option ఈ పరిధిలోనే ఉంటుంది.
2. ఈ పరిధి మధ్య విలువ వద్ద option ధరను లెక్కించండి.
3. మోడల్ ధర మార్కెట్ quote కంటే ఎక్కువగా ఉంటే, అంచనా చాలా ఎక్కువగా ఉంది. పరిధి పై పరిమితిని మధ్య విలువకు తగ్గించండి. మోడల్ ధర తక్కువగా ఉంటే, దిగువ పరిమితిని పైకి పెంచండి.
4. మోడల్ ధర quoteకు ఒక సెంట్ లోపు దూరంలోకి వచ్చే వరకు కొనసాగించండి.

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కు సంవత్సరానికి ఇంప్లైడ్ వోలాటిలిటీ దాదాపు 22.6%. ప్రతి దశలో పరిధి సగానికి తగ్గుతుంది. 4.99 వెడల్పు ఉన్న పరిధిని ఇరవై సార్లు సగానికి తగ్గిస్తే అది 0.00001 కంటే తక్కువగా ఉంటుంది. కాబట్టి 100 iterations పరిమితి ఎప్పుడూ అడ్డంకి కాదు.

న్యూటన్-రాఫ్సన్ ఎందుకు వేగంగా కన్‌వర్జ్ అవుతుంది, ఎక్కడ విఫలమవుతుంది

బైసెక్షన్ పద్ధతి మోడల్‌లో ఇప్పటికే ఉన్న సమాచారాన్ని ఉపయోగించకుండా వదిలేస్తుంది. Vega అనేది volatilityలో ప్రతి యూనిట్ మార్పుకు option ధరలో వచ్చే మార్పు. Black-Scholes దీన్ని closed formలో ఇస్తుంది. న్యూటన్-రాఫ్సన్ దీన్ని 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          # 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కి సమీపంలో ఈ పద్ధతి బైసెక్షన్‌లో అవసరమయ్యే డజను దశలతో పోలిస్తే మూడు లేదా నాలుగు దశల్లోనే ఫలితాన్ని ఇస్తుంది. దీని వైఫల్యానికి కారణం denominatorలో ఉంటుంది: strike, షేరు ధరకు దూరంగా వెళ్లే కొద్దీ 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% at the money vega, 0.80-0.90 zoneలో; 31.6%, 1.10-1.20 zoneలో. ఇంత చిన్న సంఖ్యతో pricing errorను భాగిస్తే చాలా పెద్ద step వస్తుంది. దాంతో అంచనా సున్నా కంటే దిగువకు వెళ్లవచ్చు. అప్పుడు మోడల్‌కు చెప్పడానికి ఏమీ మిగలదు. Production solvers సాధారణంగా ఈ రెండు పద్ధతులను కలిపి ఉపయోగిస్తాయి. ముందుగా rangeను bracket చేసి, తర్వాత న్యూటన్ పద్ధతితో తుది సర్దుబాటు చేస్తాయి. Vegaలో ఈ greek గురించి వివరించాం.

వేర్వేరు వనరులు భిన్నమైన implied volatility ఎందుకు చూపిస్తాయి

మోడల్ అందరికీ అందుబాటులో ఉంది. లెక్కలు కూడా ఖరారయ్యాయి. కాబట్టి వ్యత్యాసానికి కారణం ఇన్‌పుట్లలోనే ఉంటుంది.

• Mid లేదా last. Solverకు ఒక ధర అవసరం. ఒక కాంట్రాక్ట్‌కు bid $2.00, offer $2.20గా ఉంటే midpoint $2.10 అవుతుంది. అయితే last print తొంభై నిమిషాల క్రితం జరిగిన $2.02 ట్రేడ్ కావచ్చు. ఇలాంటి కాంట్రాక్ట్‌లో ధరలో పది సెంట్ల తేడా volatilityలో ఒక పాయింట్ కంటే ఎక్కువ ప్రభావం చూపుతుంది.
• డివిడెండ్లు, carry. పై function ఎలాంటి డివిడెండ్ చెల్లించని షేరుపై European call ధరను లెక్కిస్తుంది. expiryకి ముందు చెల్లించే డివిడెండ్ forward priceను తగ్గిస్తుంది. ప్రతి trading desk తన సొంత adjustment, rateను ఉపయోగిస్తుంది.
• American early exercise. US single stock optionsను ఏ ట్రేడింగ్ రోజునైనా exercise చేయవచ్చు. ఆ హక్కుకు విలువ ఉంటుంది. European formulaలో దాన్ని చేర్చే అవకాశం లేదు. దాన్ని పట్టించుకోని solver ఆ వ్యత్యాసాన్ని volatilityలోకి నెట్టేస్తుంది. Binomial trees exercise హక్కుకు నేరుగా ధర కడతాయి.
• పాత quotes. మంగళవారం చివరిసారిగా ట్రేడ్ అయిన strikeకు ఇప్పటికీ quote కనిపించవచ్చు. Solverకు అందినదే నిజమని అది పరిగణిస్తుంది.

Convergence ద్వారా చివరి రెండు అంశాలు స్పష్టంగా కనిపిస్తాయి. కింది ప్యానెల్ 2026 జూన్ 30న ఎనిమిది ప్రసిద్ధ కంపెనీల షేర్లను తీసుకుని, గడువు ముగియడానికి 20 నుంచి 45 రోజులు మిగిలిన ట్రేడ్ అయిన కాంట్రాక్టులను లెక్కిస్తుంది. తరువాత at the money volatilityతో పాటు, solve converged అయిన కాంట్రాక్టుల వాటాను చూపిస్తుంది:

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లో at the money reading 8 పేర్లలో అత్యధికంగా, 47.7%గా ఉంది. అట్టడుగున ఉన్న SPYకు ఇది 14.4%. TSLA chainలో ట్రేడ్ అయిన కాంట్రాక్టులలో 97.8% converged answer ఇచ్చాయి. మిగిలినవి solverకు అందించిన ధరను ఏ volatilityతోనూ పునరుత్పత్తి చేయలేని strikes. ఇందులో intrinsic value కంటే తక్కువ quote లేదా crossed market కూడా ఉండవచ్చు. ఇలాంటి సంఖ్యను అధికంగా పరిగణించాలా అనేది వేరే ప్రశ్న. 30% IV అధికమా అనే అంశం దానిని పరిశీలిస్తుంది. ఆశించిన ధర కదలిక దాన్ని డాలర్ పరిధిగా మారుస్తుంది.

అదే కాంట్రాక్ట్, ప్రతి సెషన్‌లో మళ్లీ లెక్కింపు

Implied volatilityకి సంబంధించిన ఏ విలువా నిల్వ చేయబడదు. స్క్రీన్‌పై కనిపిస్తున్న ధర ఆధారంగా దాన్ని ప్రతిసారీ మళ్లీ లెక్కిస్తాం. క్రింద జూలై 17, 2026న గడువు ముగిసే, అత్యధికంగా ట్రేడైన AAPL కాంట్రాక్ట్‌ను జూన్ 1 నుంచి గడువు వరకు అనుసరించాం. Strike మారలేదు. గడువు తేదీ కూడా మారలేదు.

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 రోజులు మిగిలి ఉన్నాయి. ఆ రేఖపై ఉన్న ప్రతి బిందువు, ఆ సెషన్‌ quoteకు పై లూప్‌ను ఒకసారి అమలు చేసి పొందిన ఫలితం. మా ప్రతి ticker పేజీలో ఇదే విధమైన లెక్కింపు ప్రచురించబడుతుంది: AAPL implied volatility మొత్తం options chainపై ప్రతిరోజూ దీన్ని అమలు చేస్తుంది. అందువల్ల ఈ పేజీలోని codeతో అక్కడి ప్రతి విలువను పాఠకుడు పునరుత్పత్తి చేయవచ్చు.

Implied volatility లెక్కింపు గురించి తరచుగా అడిగే ప్రశ్నలు

Implied volatilityకు ఏదైనా సూత్రం ఉందా?

లేదు. Black-Scholes volatilityని ధరకు అనుసంధానిస్తుంది. కానీ ఆ అనుసంధానానికి సరళమైన inverse ఉండదు, ఎందుకంటే sigma normal distributionలో రెండుసార్లు కనిపిస్తుంది. మీరు ఇక్కడ లేదా మరెక్కడ చూసే ప్రతి implied volatility సంఖ్య iterative solver ద్వారా లెక్కించబడుతుంది.

ఈ లెక్కింపుకు ఎన్ని iterations పడతాయి?

ప్రతి bisection దశలో bracket సగానికి తగ్గుతుంది. అందువల్ల 0.01 నుంచి 5.0 వరకు ఉన్న పరిధి ఇరవై దశల్లో 0.00001 కంటే తక్కువకు తగ్గుతుంది. Quoteను సమీప centకు సరిపోల్చడానికి సాధారణంగా దాదాపు పన్నెండు దశలు పడతాయి. Vega తక్కువగా ఉన్న ప్రాంతాల్లో కొన్ని దశలు సరిగా పనిచేయకపోవచ్చు. ఆ పరిమితిని అంగీకరిస్తే, at-the-money పరిస్థితుల్లో Newton-Raphson సాధారణంగా మూడు లేదా నాలుగు దశల్లో ఫలితానికి చేరుతుంది.

నా broker మరియు data vendor వేర్వేరు implied volatilityలను ఎందుకు చూపిస్తున్నాయి?

వారు solverలో వేర్వేరు inputs ఉపయోగించారు. సాధారణ తేడాలు mid quoteకు బదులుగా last trade ఉపయోగించడం, rate మరియు dividend assumption, అలాగే model American early exerciseను పరిగణిస్తుందా లేదా అన్నవి. తక్కువగా ట్రేడ్ అయ్యే strikeలో stale quote ఒక్కటే ఫలితాన్ని కొన్ని points మేర మార్చగలదు.

ఒకే strike వద్ద calls మరియు putsకు ఒకే implied volatility వస్తుందా?

సిద్ధాంతపరంగా అవును. ఒకే strike మరియు expiry వద్ద put-call parity వాటిని పరస్పరం అనుసంధానిస్తుంది. ఆచరణలో రెండు quotes స్వతంత్రంగా నిర్ణయించబడతాయి. అందువల్ల లెక్కించిన సంఖ్యల్లో స్వల్ప తేడా ఉంటుంది. ఇదే కారణంగా option chain అంతటా తీసుకునే averages vendors మధ్య మారుతాయి.

Market data లేకుండా implied volatilityను లెక్కించగలనా?

అవును, hypothetical quote కోసం లెక్కించవచ్చు. పై codeలో price, strike, spot, expiryకి మిగిలిన సమయం, rateలను చేతితో నమోదు చేయవచ్చు. Live vendor సంఖ్యతో సరిపోల్చడం కష్టమైన భాగం. దానికి vendor ఉపయోగించిన inputsనే ఉపయోగించాలి.

ఇక్కడి ప్రతి panel వెనుక ఉన్న SQLను నిల్వ చేస్తుంది. ఏదైనా panelను తెరిచి, Strasmore terminalలో live chainపై అదే solveను అమలు చేయండి.