Simulación de Monte Carlo con movimiento browniano: modelar el riesgo de precios de forma correcta

Los equipos de tesorería, los inversionistas y los gestores de riesgo rara vez necesitan saber el precio de un activo el próximo año. Necesitan conocer el rango: cuánto podría subir, cuánto podría caer y qué tan probable es cada resultado. La simulación de Monte Carlo responde esa pregunta generando miles de trayectorias de precio posibles y leyendo la distribución de resultados.

El modelo más común detrás de esas trayectorias es el movimiento browniano geométrico (GBM). Supone que los precios se mueven de forma aleatoria alrededor de una tendencia, descrita por dos parámetros: la deriva, la tasa promedio a la que cambia el precio, y la volatilidad, cuánto se mueve alrededor de esa tendencia. También supone que los retornos logarítmicos siguen una distribución normal.

Para mostrar cómo funciona, simulamos el precio de la acción de Apple entre 2021 y 2024 y comparamos las trayectorias simuladas con lo que realmente ocurrió.

Primer método: la fórmula de Black-Scholes

El marco de Black-Scholes supone retornos log-normales, lo que da la expresión estándar del precio en el momento t:

S(t) = S(0) * exp((μ - 0.5 * σ²) * t + σ * W(t))

Aquí μ es la deriva, σ la volatilidad y W(t) un movimiento browniano estándar. El término -0.5 * σ² corrige el arrastre de la volatilidad, y forma parte de la fórmula.

El código siguiente estima la deriva y la volatilidad a partir de los retornos diarios de Apple y simula 1.000 trayectorias.

import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt

apple = yf.download("AAPL", start="2021-01-01", end="2024-01-01")
apple.columns = apple.columns.levels[0]
price = apple.Close
returns = price.pct_change().dropna()

t = len(returns)           # number of daily steps
dt = 1                     # one trading day per step
mu = returns.mean()        # drift
sigma = returns.std()      # volatility
simulations = 1000
S0 = price.iloc[0]

def gbm_paths(mu, sigma, W):
    return np.exp((mu - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * W)

Ws = np.random.standard_normal(size=(simulations, t))
gbm = gbm_paths(mu, sigma, Ws)
gbm = np.insert(gbm, 0, S0, axis=1).cumprod(axis=1)

x_axis = range(0, t + 1)
fig, ax = plt.subplots(figsize=(12, 5.5))
for path in gbm:
    ax.plot(x_axis, path, color="grey", linewidth=0.1)
ax.plot(x_axis, price, color="red", linewidth=1)

Segundo método: modelar directamente los retornos logarítmicos

Si los retornos son log-normales, sus logaritmos son normales, y pueden simularse con un movimiento browniano estándar y luego convertirse de nuevo en precios. Es el mismo modelo visto desde otro ángulo, y a menudo es más fácil de explicar.

log_returns = np.log(returns + 1)
mu_log = log_returns.mean()
sigma_log = log_returns.std()

def bm_paths(mu, sigma, W):
    return mu + sigma * W

bm = bm_paths(mu_log, sigma_log, Ws)
bm = S0 * np.exp(bm.cumsum(axis=1))
bm = np.insert(bm, 0, S0, axis=1)

fig, ax = plt.subplots(figsize=(12, 5.5))
for path in bm:
    ax.plot(x_axis, path, color="grey", linewidth=0.1)
ax.plot(x_axis, price, color="red", linewidth=1)

Lo que muestra la comparación

Ambos métodos producen distribuciones prácticamente idénticas, lo que confirma que son dos caminos válidos hacia el mismo modelo. Para quienes toman decisiones, el valor no está en las trayectorias individuales sino en el rango que describen: la banda en la que probablemente se moverá el precio y la probabilidad de llegar a un nivel que dañaría al negocio.