Comment calculer la volatilité implicite

La volatilité implicite se calcule par itérations, et non à l’aide d’une formule directe. Il n’existe pas d’expression fermée permettant de convertir le prix de marché d’une option en un niveau de volatilité. Un solveur commence donc par estimer une volatilité, valorise l’option avec Black-Scholes, compare ce prix théorique au cours coté, puis répète l’opération jusqu’à obtenir un écart inférieur à un centime. La suite présente la méthode complète : la fonction de valorisation, la boucle de recherche en Python avec la bibliothèque standard, et les raisons pour lesquelles deux fournisseurs publient des chiffres différents pour un même contrat.

Pourquoi la volatilité implicite n’a pas de formule fermée

Black-Scholes fonctionne dans un seul sens. On lui fournit un cours spot, un strike, une échéance, un taux d’intérêt et une volatilité, et il renvoie un prix théorique. Cinq de ces six variables sont observables. La volatilité ne l’est pas. Elle correspond à une hypothèse sur l’amplitude du mouvement de l’action entre aujourd’hui et l’échéance.

Les traders inversent le problème. Le prix est affiché à l’écran et la volatilité devient l’inconnue. La volatilité implicite est la volatilité qui fait coïncider le prix Black-Scholes avec le prix de marché de l’option. Sigma, le terme de volatilité, intervient deux fois dans la fonction de distribution normale, dans d1 comme dans d2, et aucune transformation algébrique ne permet de l’isoler. L’algèbre s’arrête là. La recherche numérique prend le relais. Ce que mesure la volatilité implicite explique l’interprétation ; cette page présente la méthode de calcul.

Deux propriétés du modèle facilitent cette recherche. Le prix théorique d’un call augmente chaque fois que la volatilité augmente, sans exception, et cette évolution est régulière. Une variable qui ne fait qu’augmenter peut être encadrée en resserrant progressivement un intervalle autour d’elle.

Le solveur s’exécute une fois par contrat

La sortie comporte un chiffre par contrat, et non un chiffre par action. Les contrats sur une même action, dans la même fenêtre d’échéance, donnent des résultats différents. Voici chaque option Apple (AAPL) comptant entre 20 et 45 jours avant l’échéance et ayant fait l’objet d’une transaction le 30 juin 2026, regroupée selon le strike rapporté au cours de l’action :

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)

En parcourant l’échelle des strikes, la zone 0.80-0.90 a donné 35.5%, la zone 0.95-1.00 a donné 28.1% et la zone 1.10-1.20 a donné 27.3%. Une entreprise, une séance, 6 réponses. La courbure de cette ligne a un nom : le skew de volatilité. Une volatilité unique par action ne peut pas la représenter.

Le prix Black-Scholes que le solveur doit retrouver

S désigne le cours de l’action, K le strike, T le temps restant jusqu’à l’échéance en années, r le taux sans risque et N() la fonction de répartition de la loi normale centrée réduite, c’est-à-dire la probabilité qu’un tirage suivant cette loi soit inférieur à une valeur donnée. Python intègre cette dernière fonction dans math.erf ; l’interpréteur seul suffit donc.

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

Sur une machine où vous n’êtes pas root, préfixez les deux commandes par sudo. Enregistrez ensuite le code suivant sous 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)

Il s’agit du modèle direct complet. Fournissez-lui une volatilité et il renvoie un prix.

Comment calculer la volatilité implicite, étape par étape

La méthode de dichotomie est la première à apprendre. Elle ne peut pas diverger et ne nécessite aucun calcul différentiel.

1. Encadrez la réponse entre 0,01 (1 % par an) et 5,0 (500 %). Toute option négociée se situe dans cette fourchette.
2. Évaluez le prix de l’option au milieu de l’intervalle.
3. Si le prix du modèle est supérieur à la cotation de marché, l’estimation est trop élevée : ramenez la borne haute au milieu de l’intervalle. S’il est inférieur, relevez la borne basse jusqu’au milieu.
4. Arrêtez-vous lorsque le prix du modèle se situe à moins d’un cent de la cotation.

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)

# Action à 100 $, strike à 100 $, trois mois, taux à 4 %, 5,00 $ affichés
print(round(implied_vol(5.00, 100.0, 100.0, 0.25, 0.04), 4))

Exécutez python3 iv.py. Le programme affiche environ 0,226, soit une volatilité implicite proche de 22,6 % par an pour cette cotation hypothétique. À chaque itération, l’intervalle est divisé par deux. Une fourchette de 4,99, divisée par deux vingt fois, devient inférieure à 0,00001. La limite de 100 itérations n’est donc jamais atteinte.

Pourquoi Newton-Raphson converge plus vite et où il atteint ses limites

La dichotomie ignore une information déjà contenue dans le modèle. La vega mesure la variation du prix de l’option pour une unité de volatilité, et Black-Scholes la donne sous forme fermée. Newton-Raphson l’utilise comme une pente : mesurez l’écart de prix, divisez-le par la vega, puis ajustez l’estimation de cette valeur.

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          # plus de pente, retour à la dichotomie
        step = (bs_call(S, K, T, r, sigma) - price) / v
        sigma -= step
        if sigma <= 0.0:
            return None          # le pas a conduit à une valeur absurde
        if abs(step) < 1e-6:
            return sigma
    return None

À proximité du cours, cette méthode converge en trois ou quatre itérations, contre une douzaine pour la dichotomie. Le problème vient du dénominateur : la vega diminue à mesure que le strike s’éloigne du cours de l’action. Pour ces mêmes contrats sur AAPL, la vega moyenne de chaque zone est présentée en pourcentage de la 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)

Les ailes ne conservent qu’une fraction de la sensibilité : 33.1% de la vega at the money dans la zone 0.80-0.90, et 31.6% dans la zone 1.10-1.20. Diviser une erreur de prix par un nombre aussi faible produit un pas très important, qui peut faire passer l’estimation sous zéro, là où le modèle n’a plus rien à dire. En production, les solveurs combinent les deux méthodes : ils commencent par encadrer la solution, puis la précisent avec Newton. La vega présente le grec lui-même.

Pourquoi deux sources donnent une volatilité implicite différente

Le modèle est public et le calcul ne prête pas à discussion. Le désaccord vient donc des données d’entrée.

• Mid contre dernier cours. Le solveur a besoin d’un seul prix. Un contrat coté avec une bid à 2,00 $ et une ask à 2,20 $ a un midpoint de 2,10 $, tandis que le dernier print peut être à 2,02 $ et remonter à 90 minutes. Sur un contrat de ce type, dix cents de prix représentent davantage qu’un point de volatilité.
• Dividendes et coût de portage. La fonction ci-dessus valorise un call européen sur une action qui ne verse aucun dividende. Un dividende détaché avant l’échéance réduit le prix forward, et chaque desk applique son propre ajustement ainsi que son propre taux.
• Exercice anticipé à l’américaine. Les options sur actions américaines peuvent être exercées n’importe quel jour, et ce droit a une valeur que la formule européenne ne peut pas intégrer. Un solveur qui l’ignore reporte l’écart sur la volatilité. Les arbres binomiaux valorisent directement le droit d’exercice.
• Cotations obsolètes. Un strike dont le dernier échange remonte à mardi peut toujours afficher une cotation. Le solveur traite alors la donnée reçue comme exacte.

La convergence rend les deux derniers points visibles. Le tableau ci-dessous porte sur huit grandes valeurs au 30 juin 2026. Il recense les contrats échangés avec 20 à 45 jours restants et présente à la fois la volatilité at the money et la proportion de contrats pour lesquels le calcul a convergé :

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 affichait la volatilité at the money la plus élevée parmi les 8 valeurs, à 47.7%, contre 14.4% pour SPY, dernière du classement. Sur la chaîne TSLA, 97.8% des contrats échangés ont abouti à une réponse convergente. Les autres correspondent à des strikes dont le prix transmis au solveur se situe en dehors de ce qu’une volatilité peut reproduire : une cotation inférieure à la valeur intrinsèque ou un marché croisé. La question de savoir si un chiffre de ce type est élevé est distincte : 30 % d’IV, est-ce élevé ? l’examine, tandis que le mouvement attendu le convertit en une fourchette en dollars.

Le même contrat, recalculé à chaque séance

Rien n’est conservé concernant la volatilité implicite. Elle est recalculée à partir du prix affiché à l’écran. Voici le contrat AAPL le plus négocié arrivant à échéance le 17 juillet 2026, suivi du 1er juin jusqu’à l’échéance. Le strike et la date d’échéance sont restés inchangés :

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

Sur 29 séances, la valeur calculée à l’ouverture était de 25.1%, avec 46 jours restants, puis de 26.6% à la clôture, avec 4 jours restants. Chaque point de cette courbe correspond à une exécution de la boucle ci-dessus à partir du cours coté lors de la séance concernée. Nos pages consacrées à chaque ticker publient le même calcul : volatilité implicite d’AAPL est recalculée quotidiennement sur toute la chaîne d’options. Le lecteur peut donc reproduire chaque valeur affichée à partir du code présent sur cette page.

FAQ sur le calcul de la volatilité implicite

Existe-t-il une formule pour calculer la volatilité implicite ?

Non. Black-Scholes fait correspondre la volatilité au prix, mais cette relation n’a pas d’inverse élémentaire, puisque sigma apparaît deux fois dans la loi normale. Chaque valeur de volatilité implicite que vous rencontrez, ici ou ailleurs, provient d’un solveur itératif.

Combien d’itérations nécessite le calcul ?

Chaque passage par dichotomie divise l’intervalle par deux. Une plage de 0,01 à 5,0 passe sous 0,00001 en vingt itérations. Il faut généralement une douzaine d’itérations pour faire correspondre le calcul à une cotation au centime près. La méthode de Newton-Raphson converge en trois ou quatre itérations lorsque le strike est proche du cours du sous-jacent, mais ses étapes peuvent devenir instables lorsque le vega est faible.

Pourquoi mon broker et un fournisseur de données affichent-ils des volatilités implicites différentes ?

Ils ont fourni des paramètres différents au solveur. Les écarts les plus courants concernent le mid quote par rapport au dernier trade, l’hypothèse de taux et de dividendes, ainsi que la prise en compte ou non de l’exercice anticipé de type américain par le modèle. Sur un strike peu liquide, une cotation obsolète peut à elle seule faire varier le résultat de plusieurs points.

Les calls et les puts au même strike donnent-ils la même volatilité implicite ?

En théorie, oui. La parité put-call les relie pour un même strike et une même échéance. En pratique, les deux cotations sont établies indépendamment. Les valeurs calculées diffèrent donc légèrement, ce qui explique aussi pourquoi les moyennes sur l’ensemble de la chaîne varient d’un fournisseur à l’autre.

Puis-je calculer la volatilité implicite sans données de marché ?

Oui, pour une cotation hypothétique. Le code ci-dessus utilise un prix, un strike, un spot, une durée jusqu’à l’échéance et un taux, tous saisis manuellement. Reproduire la valeur publiée en temps réel par un fournisseur est plus difficile : il faut utiliser exactement les mêmes paramètres que lui.

Chaque panneau présenté ici conserve la requête SQL qui le sous-tend. Ouvrez-en un, puis exécutez le même calcul sur une chaîne en temps réel depuis le terminal Strasmore.