Redes neuronales basadas en la física para la fijación de precios de opciones

La parte interesante de aplicar PINN a derivados no es Black-Scholes. Black-Scholes tiene una forma cerrada; una red que la reproduce es una comprobación de cordura, no un resultado. Lo interesante es todo lo que no tiene una forma cerrada y donde las diferencias finitas se quedan sin camino: el PDE de dos factores de Heston con su parcial mixto $\partial^2 V / \partial S \partial v$, el problema americano de fronteras libres y la ecuación integrodiferencial parcial de Merton cuyo término integral acopla cada punto del dominio con todos los demás puntos.

Esta publicación trata sobre cómo cada uno de ellos entra en una función de pérdida. Concretamente: el residuo de precio logarítmico que hace que el PINN de Black-Scholes sea entrenable, la red Heston de tres entradas cuya derivada cruzada sale de autogrado de forma gratuita, el tratamiento de penalización versus dos redes del ejercicio temprano y una cuadratura de Gauss-Hermite que coloca la integral de salto dentro de un residual PDE.

Lo que no es es un punto de referencia. Cada número a continuación que parece un resultado es un objetivo o una cita, y está marcado como tal. La pasada de medición tiene su alcance al final.

Los PINN fueron introducidos por Raissi et al. (2019), y la mecánica ya está cubierta en este blog en El problema de Navier-Stokes, donde el mismo truco de autograd-residual busca singularidades en ecuaciones de fluidos: el PDE se convierte en un término de pérdida, el autodiff proporciona derivadas exactas de la red con respecto a sus entradas y nunca se construye ninguna grilla. Aquí lo único que cambia es qué PDE sufre la pérdida.

La PDE de Black-Scholes como restricción física

El PDE Black-Scholes, su resultado final $\max(S-K,0)$, y el argumento de no arbitraje detrás de esto se tratan en La fórmula Black-Scholes: esta sección los asume y va directamente a la forma en la que realmente se puede entrenar una red.

Transformación de precios logarítmicos

Trabajando directamente con $S$ es problemático: el dominio es $[0, \infty)$ y la PDE tiene coeficientes variables. La transformación estándar $x = \ln(S)$ lo convierte a una forma de coeficiente constante:

$\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 \frac{\partial^2 V}{\partial x^2} + \left(r - \frac{1}{2}\sigma^2\right)\frac{\partial V}{\partial x} - rV = 0$

Esta es una ecuación de reacción de convección-difusión en $x \in (-\infty, \infty)$. Los coeficientes variables. $S^2$ y $S$ han desaparecido, lo que importa para una red: un residuo cuya magnitud aumenta con $S^2$ está dominado por el otro extremo del dominio y el optimizador gasta su presupuesto allí.

Pérdida de PINN para Black-Scholes

dejar $u_\theta(x, t)$ ser la red. Muestra $N_r$ puntos de colocación $(x_i, t_i)$ en el interior, $N_b$ en los límites y $N_0$ a la hora terminal:

$\mathcal{L}_{\text{PDE}} = \frac{1}{N_r}\sum_{i=1}^{N_r}\left[\frac{\partial u_\theta}{\partial t} + \frac{1}{2}\sigma^2 \frac{\partial^2 u_\theta}{\partial x^2} + \left(r - \frac{\sigma^2}{2}\right)\frac{\partial u_\theta}{\partial x} - r u_\theta\right]^2$

$\mathcal{L}_{\text{IC}} = \frac{1}{N_0}\sum_{j=1}^{N_0}\left[u_\theta(x_j, T) - \max(e^{x_j} - K, 0)\right]^2$

$\mathcal{L}_{\text{BC}} = \frac{1}{N_b}\sum_{k=1}^{N_b}\left[u_\theta(x_{\min}, t_k)\right]^2 + \frac{1}{N_b}\sum_{k=1}^{N_b}\left[u_\theta(x_{\max}, t_k) - (e^{x_{\max}} - Ke^{-r(T-t_k)})\right]^2$

Cada derivada parcial se calcula mediante torch.autograd.grad con create_graph=True, por lo que los gradientes fluyen a través del cálculo de la derivada durante la retropropagación. Esa única bandera es todo el truco de implementación.

Implementación de PyTorch

Los parámetros a continuación tienen un sabor criptográfico en lugar de un libro de texto: $\sigma = 0.7$ y $T = 0.08$ (aproximadamente una opción BTC de 30 días) en lugar de la mesa de acciones $\sigma = 0.2$, $T = 1.0$. Un vencimiento corto más un alto volumen es el régimen en el que la distorsión de los beneficios es más pronunciada y en el que el PINN es más difícil de entrenar, y ese es el punto.

import torch
import torch.nn as nn
import numpy as np

r = 0.05        # risk-free rate
sigma = 0.7     # volatility
K = 1.0         # strike (moneyness-normalized)
T = 0.08        # ~30 days
x_min, x_max = -1.0, 1.0  # log-price domain (S/K in [0.37, 2.72])

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")


class BSPINN(nn.Module):
    """Physics-Informed Neural Network for Black-Scholes PDE."""

    def __init__(self, hidden_dim=128, num_layers=4):
        super().__init__()
        layers = [nn.Linear(2, hidden_dim), nn.Tanh()]
        for _ in range(num_layers - 1):
            layers += [nn.Linear(hidden_dim, hidden_dim), nn.Tanh()]
        layers.append(nn.Linear(hidden_dim, 1))
        self.net = nn.Sequential(*layers)

    def forward(self, x, t):
        inputs = torch.cat([x, t], dim=1)
        return self.net(inputs)


def compute_pde_residual(model, x, t):
    """Compute Black-Scholes PDE residual using autodiff."""
    x.requires_grad_(True)
    t.requires_grad_(True)
    u = model(x, t)

    grads = torch.autograd.grad(u, [x, t], grad_outputs=torch.ones_like(u),
                                create_graph=True)
    u_x, u_t = grads[0], grads[1]

    u_xx = torch.autograd.grad(u_x, x, grad_outputs=torch.ones_like(u_x),
                               create_graph=True)[0]

    residual = u_t + 0.5 * sigma**2 * u_xx + (r - 0.5 * sigma**2) * u_x - r * u
    return residual


def terminal_condition(x):
    """European call payoff: max(S - K, 0) = max(exp(x) - K, 0)."""
    return torch.relu(torch.exp(x) - K)


def train_pinn(epochs=10000, lr=1e-3, n_interior=5000, n_boundary=500, n_terminal=1000):
    model = BSPINN().to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)

    for epoch in range(epochs):
        optimizer.zero_grad()

        x_int = (torch.rand(n_interior, 1, device=device)
                 * (x_max - x_min) + x_min)
        t_int = torch.rand(n_interior, 1, device=device) * T

        residual = compute_pde_residual(model, x_int, t_int)
        loss_pde = (residual ** 2).mean()

        x_tc = (torch.rand(n_terminal, 1, device=device)
                * (x_max - x_min) + x_min)
        t_tc = torch.ones(n_terminal, 1, device=device) * T
        u_tc = model(x_tc, t_tc)
        loss_ic = ((u_tc - terminal_condition(x_tc)) ** 2).mean()

        t_bc = torch.rand(n_boundary, 1, device=device) * T

        x_lo = torch.full((n_boundary, 1), x_min, device=device)
        loss_bc_lo = (model(x_lo, t_bc) ** 2).mean()

        x_hi = torch.full((n_boundary, 1), x_max, device=device)
        target_hi = torch.exp(x_hi) - K * torch.exp(-r * (T - t_bc))
        loss_bc_hi = ((model(x_hi, t_bc) - target_hi) ** 2).mean()

        loss = loss_pde + 10.0 * loss_ic + loss_bc_lo + loss_bc_hi

        loss.backward()
        optimizer.step()
        scheduler.step()

        if epoch % 1000 == 0:
            print(f"Epoch {epoch:5d} | PDE: {loss_pde:.2e} | "
                  f"IC: {loss_ic:.2e} | BC: {loss_bc_lo + loss_bc_hi:.2e}")

    return model

Dos opciones estructurales que vale la pena señalar:

• Peso en la condición terminal. El pago obtiene un peso 10 veces mayor porque define el problema. Sin una aplicación estricta, la red puede satisfacer la PDE de manera trivial generando cero en todas partes: la PDE homogénea tiene infinitas soluciones y la condición terminal es lo que selecciona una.
• Remuestreo de puntos de colocación en cada época. Los puntos se dibujan nuevos en cada paso, lo que actúa como regularización estocástica del residual. La alternativa, un conjunto de puntos fijos, permite a la red sobreajustar el residual en esas coordenadas exactas.

Ampliación al modelo de volatilidad estocástica de Heston

Precios de Black-Scholes con una única constante $\sigma$, que es exactamente la suposición que el pronóstico de volatilidad GARCH(1,1) está diseñado para rechazar. Heston hace de la volatilidad un segundo factor estocástico, la varianza instantánea. $v$:

$dS = rS\,dt + \sqrt{v}S\,dW_1$ $dv = \kappa(\theta - v)\,dt + \xi\sqrt{v}\,dW_2$

dónde $\kappa$ es la velocidad de reversión media, $\theta$ la varianza de largo plazo, $\xi$ el vol de vol, y $dW_1 \cdot dW_2 = \rho\,dt$.

La PDE de fijación de precios tiene un estado bidimensional:

$\frac{\partial V}{\partial t} + \frac{1}{2}vS^2\frac{\partial^2 V}{\partial S^2} + \rho\xi v S\frac{\partial^2 V}{\partial S \partial v} + \frac{1}{2}\xi^2 v\frac{\partial^2 V}{\partial v^2} + rS\frac{\partial V}{\partial S} + \kappa(\theta - v)\frac{\partial V}{\partial v} - rV = 0$

Aquí es donde un método sin malla empieza a parecer atractivo. Un esquema en diferencias finitas necesita una cuadrícula en $(S, v, t)$ - un típico $200 \times 100 \times 500$ es $10^7$ nodos. Agregue un tercer factor estocástico, como las tasas estocásticas, y la cuadrícula se vuelve poco práctica. Montecarlo escala mejor en dimensión pero converge lentamente, especialmente para los griegos.

Arquitectura PINN para Heston

La red toma tres entradas. $(x, v, t)$ con $x = \ln S$. El parcial mixto $\partial^2 u / \partial x \partial v$ (el término que hace que los esquemas ADI sean incómodos) es uno más autograd.grad llamar:

class HestonPINN(nn.Module):
    def __init__(self, hidden_dim=256, num_layers=5):
        super().__init__()
        layers = [nn.Linear(3, hidden_dim), nn.Tanh()]
        for _ in range(num_layers - 1):
            layers += [nn.Linear(hidden_dim, hidden_dim), nn.Tanh()]
        layers.append(nn.Linear(hidden_dim, 1))
        self.net = nn.Sequential(*layers)

    def forward(self, x, v, t):
        return self.net(torch.cat([x, v, t], dim=1))


def heston_pde_residual(model, x, v, t, kappa, theta, xi, rho, r):
    x.requires_grad_(True)
    v.requires_grad_(True)
    t.requires_grad_(True)
    u = model(x, v, t)

    u_x, u_v, u_t = torch.autograd.grad(
        u, [x, v, t], torch.ones_like(u), create_graph=True
    )
    u_xx = torch.autograd.grad(u_x, x, torch.ones_like(u_x), create_graph=True)[0]
    u_vv = torch.autograd.grad(u_v, v, torch.ones_like(u_v), create_graph=True)[0]
    u_xv = torch.autograd.grad(u_x, v, torch.ones_like(u_x), create_graph=True)[0]

    residual = (
        u_t
        + 0.5 * v * u_xx
        + rho * xi * v * u_xv
        + 0.5 * xi**2 * v * u_vv
        + (r - 0.5 * v) * u_x
        + kappa * (theta - v) * u_v
        - r * u
    )
    return residual

Tenga en cuenta que u_xv se obtiene diferenciando u_x con respecto a v, reutilizando el gráfico creado por la primera llamada. Simetría de los medios parciales mixtos diferenciando u_v con respecto a x debería dar el mismo tensor; en float32 no lo hará, exactamente, y la brecha es un diagnóstico barato de si el gráfico se está comportando.

Opciones americanas y problemas de fronteras libres

Las opciones estadounidenses añaden una restricción al ejercicio temprano: el valor nunca debe caer por debajo del intrínseco. Esto convierte al PDE en un problema de fronteras libres, equivalentemente a un problema de complementariedad lineal (LCP):

$\frac{\partial V}{\partial t} + \mathcal{L}V \leq 0, \quad V \geq \Phi(S), \quad \left(\frac{\partial V}{\partial t} + \mathcal{L}V\right)(V - \Phi(S)) = 0$

dónde $\mathcal{L}$ es el operador Black-Scholes y $\Phi(S)$ la recompensa. Dos formas de poner esto en pérdida.

Método de penalización

Reemplace la restricción de complementariedad con una penalización suave:

$\frac{\partial V}{\partial t} + \mathcal{L}V + \rho_p \cdot \max(\Phi(S) - V, 0) = 0$

con $\rho_p$ grande (normalmente $10^4$ a $10^6$). Cuando $V$ cae por debajo del intrínseco, la penalización lo obliga a retroceder y la pérdida de PINN se convierte en:

$\mathcal{L}_{\text{PDE}}^{\text{American}} = \frac{1}{N_r}\sum_i \left[\frac{\partial u_\theta}{\partial t} + \mathcal{L}u_\theta + \rho_p \cdot \max(\Phi - u_\theta, 0)\right]^2$

Sin cambios de arquitectura, solo un residual modificado. El costo es un nuevo hiperparámetro con una mala compensación condicionada: demasiado pequeño y se viola la restricción, demasiado grande y el panorama de pérdidas está dominado por el término de penalización.

Aproximación directa a límites libres

Formar dos redes de forma conjunta: una por el precio $u_\theta(S, t)$, uno para el límite óptimo del ejercicio $S^*_\phi(t)$. La pérdida conlleva la PDE en la región de continuación, la condición de pegado suave en el límite y la recompensa en la región de ejercicio. El límite resulta un resultado de primera clase, que es lo que realmente se necesita para cubrir un libro americano.

Modelos de difusión por salto con PINN

El modelo de Merton añade saltos de Poisson al movimiento browniano geométrico:

$dS = (r - \lambda \bar{k})S\,dt + \sigma S\,dW + S\,dJ$

dónde $J$ es un proceso de Poisson compuesto con intensidad $\lambda$ y tamaños de salto log-normales. La fijación de precios se convierte en una ecuación integrodiferencial parcial (PIDE):

$\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 S^2 \frac{\partial^2 V}{\partial S^2} + (r - \lambda\bar{k})S\frac{\partial V}{\partial S} - (r + \lambda)V + \lambda \int_0^\infty V(Sy, t) f(y)\,dy = 0$

con $f(y)$ la densidad del multiplicador de salto.

La integral es lo que rompe las diferencias finitas: acopla cada punto del dominio con todos los demás puntos, destruyendo la estructura de bandas en la que se basa el solucionador. Un PINN no tiene esa estructura que perder. La integral es simplemente otro término del residual, evaluado por cuadratura en cada punto de colocación, y debido a que la red está definida en todas partes, $V(Sy, t)$ es un pase libre hacia adelante en lugar de una interpolación:

def jump_integral(model, x, t, lam, mu_j, sigma_j, n_quad=32):
    """Approximate jump integral using Gauss-Hermite quadrature."""
    nodes, weights = np.polynomial.hermite.hermgauss(n_quad)
    nodes = torch.tensor(nodes, dtype=torch.float32, device=x.device)
    weights = torch.tensor(weights, dtype=torch.float32, device=x.device)

    y_nodes = mu_j + sigma_j * np.sqrt(2) * nodes
    integral = torch.zeros_like(x)

    for i in range(n_quad):
        x_shifted = x + y_nodes[i]
        v_shifted = model(x_shifted, t)
        integral += weights[i] * v_shifted

    integral *= 1.0 / np.sqrt(np.pi)
    return integral

El residuo PIDE es entonces:

$\text{Residual} = \frac{\partial u}{\partial t} + \frac{1}{2}\sigma^2 u_{xx} + (r - \lambda\bar{k} - \frac{\sigma^2}{2})u_x - (r + \lambda)u + \lambda \cdot I[u]$

con $I[u]$ la aproximación en cuadratura. El circuito cuesta n_quad pases hacia adelante adicionales por paso de entrenamiento, todos los cuales aterrizan en el gráfico de autogrado: el precio real de los saltos es la memoria, no las matemáticas.

Comparación con métodos tradicionales

Las diferencias estructurales son reales y pueden expresarse sin un punto de referencia:

Las filas de rendimiento que normalmente habitarían aquí (tiempo de entrenamiento, latencia de inferencia, precisión) están deliberadamente ausentes, porque medirlas es un trabajo abierto, no una entrada de la tabla.

Dónde es posible que ganen los PINN

Modificación de precios en tiempo real. Una vez entrenada, la evaluación es un paso adelante sobre un lote, por lo que un libro completo se modifica en un lanzamiento del kernel en lugar de una solución por conjunto de parámetros. Si eso supera a un solucionador de Crank-Nicolson bien ajustado en tamaños de libros realistas es una cuestión empírica y no se puede medir aquí.

Modelos de alta dimensión. La volatilidad estocástica más las tasas estocásticas más los saltos son 4+ dimensiones, donde las diferencias finitas están efectivamente muertas. Los PINN se degradan gradualmente en tamaño, sujeto a dificultades de entrenamiento.

Griegos continuos. La red es fluida y diferenciable, por lo que Delta, Gamma, Theta y Vega provienen de la misma maquinaria de autogrado que el PDE residual: sin golpes y revalorizaciones, sin ruido de diferencias finitas. Este es el reclamo más fuerte de la publicación y también el que más necesita una superficie Gamma medida detrás.

Soluciones paramétricas. Parámetros del modelo de alimentación ($\sigma$, $\kappa$, $\theta$) ya que las entradas de red permiten que un PINN cubra una familia de modelos en lugar de una única calibración.

Donde luchan los PINN

Costo de capacitación. Para una opción en un conjunto de parámetros, una resolución de diferencias finitas finaliza antes de que un PINN finalice sus primeras mil épocas.

Sin límites de error. Las diferencias finitas con la extrapolación de Richardson alcanzan la precisión de la máquina con un orden de convergencia conocido. Un PINN informa un valor de pérdida, que no está vinculado a un error. Variantes conscientes de la incertidumbre (Bai et al., 2025) adjuntamos intervalos de confianza, pero el campo es joven.

Dificultad de optimización. El panorama de pérdidas es muy no convexo y la ponderación entre los términos PDE, límite y terminal es un problema de ajuste. La falla característica es una red que lleva el residuo de PDE a casi cero mientras ignora por completo las condiciones de contorno: una solución perfectamente válida para el problema equivocado.

Reproducibilidad. Diferentes semillas, distribuciones de colocación y configuraciones del optimizador pueden generar soluciones significativamente diferentes. El montaje ayuda y multiplica los costes.

Esas dos últimas son las partes de esta publicación que más vale la pena convertir en tramas, porque son modos de falla que cualquiera que vuelva a implementar esto encontrará.

Lo que aún necesita medirse

El estado honesto de este artículo: las formulaciones son correctas y el código se ejecuta, pero nada aquí ha sido comparado con el hardware de este escritorio o con los datos de este escritorio. El pase que lo convertiría en un resultado en lugar de una derivación:

1. Sup-norm y RMSE contra Black-Scholes de forma cerrada en todo el $(S, t)$ cuadrícula, por semilla, cinco semillas. El objetivo habitual del folclore es la concordancia con más de 4 decimales; el punto es probar que en $\sigma = 0.7$, $T = 0.08$ y publicar las semillas donde falla.
2. Error Delta y Gamma, no sólo error de precio. Una red que iguala precios a cuatro dígitos con un ruido $\Gamma$ es inútil para la cobertura, por lo que Gamma es el criterio de aceptación.
3. Tiempo de entrenamiento de reloj de pared y latencia de inferencia por opción para un libro de 10,000 opciones, frente a una solución de Crank-Nicolson del problema idéntico en la misma GPU.
4. Los modos de falla, reproducidos deliberadamente. Reducir la pérdida de límite hasta que la red satisfaga la PDE y no alcance el límite; Ejecute cinco semillas y trace la extensión. Ambas son baratas de producir y más útiles que otra superficie de precios de apariencia correcta.
5. Ajustarse a las cotizaciones reales de Deribit BTC o, como mínimo, mantener los parámetros criptorrealistas anteriores en lugar de volver a $\sigma = 0.2$, $T = 1.0$.
6. Las opciones de arquitectura y optimizador son hallazgos, no consejos. Más amplio versus más profundo, tanh versus ReLU (la segunda derivada discontinua de ReLU debería arruinar visiblemente el residual), $\lambda_{\text{IC}}$ barridos, y Adam-luego-L-BFGS versus Adam solo son todos experimentos de una sola línea. Hasta que se publiquen, son folclore repetido de la literatura, y esta publicación se niega a repetirlos como recomendaciones.

Las dos afirmaciones estructurales que sobreviven sin medición, porque son propiedades de la formulación más que de una ejecución: usar coordenadas logarítmicas de precios (la PDE se convierte en coeficiente constante, lo cual es un hecho sobre el álgebra) y ponderar la condición terminal por encima del término de la PDE (la PDE homogénea admite la solución cero, lo cual es un hecho sobre el problema).

¿Qué más hay por ahí?

Instrucciones que vale la pena conocer, ninguna de ellas probada aquí:

• Muestreo de colocación adaptativa residual: coloque puntos donde el residual sea grande, cerca del rumbo para Black-Scholes o cerca del límite de Feller para Heston, en lugar de hacerlo de manera uniforme. La implementación es breve:

def adaptive_resample(model, x_pool, t_pool, n_select):
    """Select collocation points with highest PDE residual."""
    with torch.no_grad():
        residuals = compute_pde_residual(model, x_pool, t_pool).abs()
    probs = residuals.squeeze() / residuals.sum()
    indices = torch.multinomial(probs, n_select, replacement=False)
    return x_pool[indices], t_pool[indices]

• Transferir aprendizaje entre huelgas y vencimientos: ajuste desde un vecino $(K, T)$ en lugar de capacitarse desde cero, mantener una biblioteca que cubra la cadena de opciones.
• Máquinas de aprendizaje extremas basadas en la física: congela pesos ocultos, entrena solo la capa de salida, reduciendo el entrenamiento a una solución lineal. Menos expresivo, pero Black-Scholes tiene dimensiones lo suficientemente bajas como para que no importe.
• Aprendizaje del operador (DeepONet, FNO): aprenda el operador de la solución en lugar de la solución, mapeo $(\sigma(\cdot), r(\cdot), \text{payoff}(\cdot)) \to V(\cdot,\cdot)$ por lo que las nuevas estructuras de pago no necesitan reentrenamiento. Consulte DeepSVM.

Conclusión

Los PINN no reemplazan las diferencias finitas ni Monte Carlo. Para una sola opción de baja dimensión en un solo conjunto de parámetros, las diferencias finitas ganan y no están cerca. El argumento a favor de los PINN es estrecho y específico: modelos de alta dimensión en los que las cuadrículas mueren, soluciones paramétricas reutilizadas en un libro y griegos que provienen del mismo pase de diferenciación automática que el precio.

Lo que ofrece esta publicación es la capa de traducción: cómo el parcial mixto de Heston, el límite libre estadounidense y la integral de salto de Merton se convierten cada uno en un término en una función de pérdida. Lo que aún no ofrece es evidencia de que las redes resultantes sean lo suficientemente precisas como para protegerse. Ese es el siguiente paso y, hasta que se ejecute, trate todo lo anterior como una derivación en lugar de una recomendación.

Referencias y lecturas adicionales

• Raissi, M., Perdikaris, P., Karniadakis, G.E. (2019). [Redes neuronales basadas en la física: un marco de aprendizaje profundo para resolver problemas directos e inversos que involucran ecuaciones diferenciales parciales no lineales] (https://www.sciencedirect.com/science/article/abs/pii/S0021999118307125). Revista de Física Computacional, 378, 686-707.
• Dhiman, A., Kaur, D. (2023). Red neuronal basada en la física para el precio de opciones. preimpresión de arXiv.
• Salvador, B. et al. (2023). Métodos sin malla para la fijación de precios de opciones estadounidenses a través de redes neuronales basadas en la física. Análisis de Ingeniería con Elementos de Frontera. -Bai, G. et al. (2025). Una solución de red neuronal basada en la física y consciente de la incertidumbre para la ecuación de Black-Scholes. preimpresión de arXiv.
• Chen, Y. et al. (2025). El proceso de difusión de salto estocástico informó a las redes neuronales para la fijación de precios de opciones estadounidenses en condiciones de escasez de datos. Computación Suave Aplicada.
• Benth, FE et al. (2025). DeepSVM: Aprendizaje de modelos de volatilidad estocástica con redes de operadores profundos basados ​​en la física. preimpresión de arXiv.
• Él, Y. et al. (2024). Red neuronal basada en finanzas: aprendizaje de la geometría del precio de las opciones. preimpresión de arXiv.
• MathWorks: Redes neuronales basadas en la física (PINN) para precios de opciones. Blog de finanzas de MATLAB, 2025.
• GitHub: BlackScholesPINN (implementación de PyTorch).
• Repositorio GitHub de PINN de Raissi.