Derivación de la volatilidad implícita mediante programación

Question

Estoy trabajando en un proyecto para calcular el valor de las opciones utilizando Python . Utilizo el modelo Black-Scholes, y puedo obtener resultados precisos introduciendo un valor determinado de volatilidad implícita. Normalmente obtengo la IV del libro de texto que tengo, o de opcionescalculadora de beneficios .

¿Cómo puedo derivar IV por mi cuenta? Hasta ahora he encontrado dos enfoques:

1. Este respuesta que dice que IV se puede derivar por iteración utilizando el BSM. He leído sobre esto en otras respuestas también, pero creo que no lo estoy entendiendo correctamente. Parece que dice que hay que introducir conjeturas y ajustar, hasta encontrar el IV que da el valor correcto a la opción. Pero para reconocer el IV correcto, necesitaría tener ya la respuesta, como del libro de texto o del OPC, ¿no? ¿Cómo implementaría esto de forma programada, sin cotejar con otra fuente?

2. Este pregunta que dice que se puede derivar el IV de los intercambios de varianza sin modelo. ¿Sería mejor para mi proyecto, en comparación con el método de iteración? Si es así, ¿cómo lo implementaría en la práctica, programáticamente?

Answer 1

La aproximación de la volatilidad implícita de las opciones europeas puede hacerse de varias maneras: ésta es sólo una. A continuación se muestra una implementación en python que utiliza Newton Raphson . Puede utilizar el implied_volatility para encontrar la volatilidad implícita aproximada. A continuación, puede comprobarlo introduciendo el resultado en la función option_price función.

import numpy as np
from scipy.stats import norm

"""
right = 'C' or 'P'
s = Spot Price
k =  Strike Price
t = Days to expiration
rfr = Risk-free Rate
sigma = volatility
div = Annual dividend rate. Defaulted to zero.
price = Known option price. Needed for implied_volatility function
"""

def d_one(s, k, t, rfr, sigma, div=0):
    """d1 calculation"""
    d_1 = (np.log(s / k) +
           (rfr - div + sigma ** 2 / 2) * t) / (sigma * np.sqrt(t))
    return d_1

def d_two(s, k, t, rfr, sigma, div=0):
    """d2 calculation"""
    d_2 = d_one(s, k, t, rfr, sigma, div) - sigma * np.sqrt(t)
    return d_2

def nd_one(right, s, k, t, rfr, sigma, div=0):
    """nd1 calculation"""
    if right == 'C':
        nd_1 = norm.cdf(d_one(s, k, t, rfr, sigma, div), 0, 1)
    elif right == 'P':
        nd_1 = norm.cdf(-d_one(s, k, t, rfr, sigma, div), 0, 1)
    return nd_1

def nd_two(right, s, k, t, rfr, sigma, div=0):
    """nd2 calculation"""
    if right == 'C':
        nd_2 = norm.cdf(d_two(s, k, t, rfr, sigma, div), 0, 1)
    elif right == 'P':
        nd_2 = norm.cdf(-d_two(s, k, t, rfr, sigma, div), 0, 1)
    return nd_2

def option_price(right, s, k, t, rfr, sigma, div=0):
    """option price"""
    right = right.upper()
    t /= 365
    if right == 'C':
        price = (s * np.exp(-div * t) *
                 nd_one(right, s, k, t, rfr, sigma, div)
                 - k * np.exp(-rfr * t) *
                 nd_two(right, s, k, t, rfr, sigma, div))
    elif right == 'P':
        price = (k * np.exp(-rfr * t) *
                 nd_two(right, s, k, t, rfr, sigma, div)
                 - s * np.exp(-div * t) *
                 nd_one(right, s, k, t, rfr, sigma, div))
    return price

def option_vega(s, k, t, rfr, sigma, div=0):
    """option vega"""
    t /= 365
    vega = (.01 * s * np.exp(-div * t) * np.sqrt(t)
            * norm.pdf(d_one(s, k, t, rfr, sigma, div)))
    return vega

def implied_volatility(right, s, k, t, rfr, price, div=0):
    """implied volatility approximation"""
    epsilon = 0.00000001
    sigma = 1.0

    def newton_raphson(right, s, k, t, rfr, sigma, price, epsilon, div=0):
        diff = option_price(right, s, k, t, rfr, sigma, div) - price
        while diff > epsilon:
            sigma = (sigma -
                     (option_price(right, s, k, t, rfr, sigma, div) - price) /
                     (option_vega(s, k, t, rfr, sigma, div) * 100))
            diff = np.abs(
                    option_price(right, s, k, t, rfr, sigma, div) - price)
        return sigma

    iv = newton_raphson(right, s, k, t, rfr, sigma, price, epsilon, div)
    return iv

Answer 2

La volatilidad esperada en el precio subyacente durante la vida de la opción es un componente importante del modelo de valoración de opciones de BSM. Cuando se calcula la volatilidad basándose en el precio actual del mercado, se está calculando lo que el mercado piensa que sería la volatilidad, por eso se llama volatilidad implícita.

Así que para responder a tu pregunta, puedes asumir un valor para la volatilidad y calcular el precio de la opción o utilizar el precio de la opción para calcular la volatilidad implícita.