Op natuurkunde geïnformeerde neurale netwerken voor optieprijzen

Het interessante deel van het toepassen van PINN's op derivaten is niet Black-Scholes. Black-Scholes heeft een gesloten vorm; een netwerk dat het reproduceert is een gezond verstandscontrole, geen resultaat. Het interessante deel is alles dat geen een gesloten vorm heeft en waar eindige verschillen opraken: de tweefactorige PDE van Heston met zijn gemengde gedeeltelijke $\partial^2 V / \partial S \partial v$, het Amerikaanse vrije-grensprobleem, en de gedeeltelijke integro-differentiaalvergelijking van Merton, waarvan de integrale term elk punt in het domein aan elk ander punt koppelt.

Dit bericht gaat over hoe elk van deze in een verliesfunctie terechtkomt. Concreet: het log-prijsresidu dat de Black-Scholes PINN trainbaar maakt, het Heston-netwerk met drie inputs waarvan de kruisderivaat gratis uit autograd valt, de boete-versus-twee-netwerkbehandeling van vroege oefening, en een Gauss-Hermite-kwadratuur die de sprongintegraal binnen een PDE-residu plaatst.

Wat het niet is, is een benchmark. Elk getal daaronder dat op een resultaat lijkt, is een doel of een citaat, en wordt als zodanig gemarkeerd. Aan het einde wordt de meetpas beoordeeld.

PINN's werden geïntroduceerd door Raissi et al. (2019), en de werking ervan wordt al besproken op deze blog in The Navier-Stokes Problem, waar dezelfde autograd-rest-truc op zoek gaat naar singulariteiten in vloeistofvergelijkingen: de PDE wordt een verliesterm, autodiff levert exacte afgeleiden van het netwerk met betrekking tot zijn inputs, en er wordt nooit een raster gebouwd. Het enige dat hier verandert, is welke PDE verlies lijdt.

De Black-Scholes PDE als natuurkundige beperking

De Black-Scholes PDE, de uiteindelijke uitbetaling $\max(S-K,0)$, en het argument dat er geen arbitrage achter zit, worden behandeld in The Black-Scholes Formula – deze sectie gaat ervan uit en gaat rechtstreeks naar de vorm waarop een netwerk feitelijk kan worden getraind.

Log-prijstransformatie

Direct werken met $S$ is problematisch: het domein is dat wel $[0, \infty)$ en de PDE heeft variabele coëfficiënten. De standaardtransformatie $x = \ln(S)$ converteert het naar een vorm met constante coëfficiënt:

$\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$

Dit is een convectie-diffusie-reactievergelijking $x \in (-\infty, \infty)$. De variabele coëfficiënten $S^2$ En $S$ zijn verdwenen, wat belangrijk is voor een netwerk: een residu waarvan de omvang meeschaalt $S^2$ wordt gedomineerd door het uiteinde van het domein en de optimizer besteedt zijn budget daar.

PINN-verlies voor Black-Scholes

Laat $u_\theta(x, t)$ wees het netwerk. Steekproef $N_r$ collocatie punten $(x_i, t_i)$ in het interieur, $N_b$ op de grenzen, en $N_0$ op eindtijd:

$\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$

Elke partiële afgeleide wordt berekend via torch.autograd.grad met create_graph=True, dus gradiënten stromen door de afgeleide berekening tijdens backpropagation. Die ene vlag is de hele implementatietruc.

PyTorch-implementatie

De onderstaande parameters hebben een crypto-smaak in plaats van een leerboek: $\sigma = 0.7$ En $T = 0.08$ (ongeveer een BTC-optie van 30 dagen) in plaats van de equity-desk $\sigma = 0.2$, $T = 1.0$. Korte looptijd plus hoog volume is het regime waarbij de knik in de uitbetaling het scherpst is en waar de PINN het moeilijkst te trainen is – en dat is het punt.

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

Twee structurele keuzes die het markeren waard zijn:

• Gewicht op de eindvoorwaarde. De uitbetaling krijgt 10x een gewicht omdat deze het probleem definieert. Zonder sterke handhaving kan het netwerk de PDE triviaal bevredigen door overal nul uit te voeren - de homogene PDE heeft oneindig veel oplossingen en de terminale voorwaarde is wat er één selecteert.
• Resampling van collocatiepunten elk tijdperk. Punten worden bij elke stap opnieuw getrokken, wat fungeert als stochastische regularisatie van het residu. Het alternatief – een set vaste punten – zorgt ervoor dat het netwerk het residu op die exacte coördinaten overschrijdt.

Uitbreiding naar het Heston Stochastic Volatiliteitsmodel

Black-Scholes-prijzen met één enkele constante $\sigma$, wat precies de veronderstelling is dat GARCH(1,1) volatility forecasting is gebouwd om te verwerpen. Heston maakt van volatiliteit een tweede stochastische factor: de momentane variantie $v$:

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

waar $\kappa$ is de gemiddelde omkeersnelheid, $\theta$ de langetermijnvariantie, $\xi$ de vol-van-vol, en $dW_1 \cdot dW_2 = \rho\,dt$.

De prijsstelling van PDE is tweedimensionaal:

$\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$

Dit is waar een gaasvrije methode er aantrekkelijk uit begint te zien. Een eindig verschilschema heeft een raster nodig $(S, v, t)$ – een typisch $200 \times 100 \times 500$ is $10^7$ knooppunten. Voeg een derde stochastische factor toe, zoals stochastische tarieven, en het raster wordt onpraktisch. Monte Carlo schaalt qua afmetingen beter, maar convergeert langzaam, vooral voor Grieken.

PINN-architectuur voor Heston

Het netwerk heeft drie ingangen $(x, v, t)$ met $x = \ln S$. Het gemengde deel $\partial^2 u / \partial x \partial v$ – de term die ADI-regelingen lastig maakt – is er nog een autograd.grad telefoongesprek:

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

Merk dat op u_xv wordt verkregen door te differentiëren u_x met betrekking tot v, waarbij de grafiek wordt hergebruikt die door de eerste aanroep is gemaakt. Symmetrie van het gemengde deel betekent differentiëren u_v met betrekking tot x zou dezelfde tensor moeten geven; in float32 zal dit niet precies het geval zijn, en de kloof is een goedkope diagnose voor de vraag of de grafiek zich gedraagt.

Amerikaanse opties en problemen met de vrije grenzen

Amerikaanse opties voegen een vroege uitoefeningsbeperking toe: de waarde mag nooit onder de intrinsieke waarde dalen. Dit verandert de PDE in een vrije-grensprobleem, equivalent aan een lineair complementariteitsprobleem (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$

waar $\mathcal{L}$ is de Black-Scholes-operator en $\Phi(S)$ de uitbetaling. Twee manieren om dit in een verlies te brengen.

Strafmethode

Vervang de complementariteitsbeperking door een soepele straf:

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

met $\rho_p$ groot (typisch $10^4$ naar $10^6$). Wanneer $V$ daalt tot onder de intrinsieke waarde, de straf dwingt het weer omhoog en het PINN-verlies wordt:

$\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$

Geen architectuurverandering, alleen een aangepast residu. De kosten zijn een nieuwe hyperparameter met een slechte conditioneringsafweging: te klein en de beperking wordt geschonden, te hoog en het verlieslandschap wordt gedomineerd door de strafterm.

Directe vrije grensbenadering

Train twee netwerken samen: één voor de prijs $u_\theta(S, t)$, één voor de optimale trainingsgrens $S^*_\phi(t)$. Het verlies draagt ​​de PDE in het voortzettingsgebied, de soepele plakconditie aan de grens en de uitbetaling in het oefengebied. De grens komt naar voren als een eersteklas resultaat, en dat is wat je eigenlijk wilt voor het afdekken van een Amerikaans boek.

Jump-diffusiemodellen met PINN's

Het model van Merton voegt Poisson-sprongen toe aan de geometrische Brownse beweging:

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

waar $J$ is een samengesteld Poisson-proces met intensiteit $\lambda$ en log-normale spronggroottes. Prijzen worden een gedeeltelijke integro-differentiaalvergelijking (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$

met $f(y)$ de dichtheid van de sprongvermenigvuldiger.

De integraal is wat eindige verschillen verbreekt; hij koppelt elk punt in het domein aan elk ander punt en vernietigt daarmee de bandenstructuur waarop de oplosser vertrouwt. Een PINN heeft die structuur niet te verliezen. De integraal is gewoon een andere term in het residu, geëvalueerd door kwadratuur op elk collocatiepunt, en omdat het netwerk overal gedefinieerd is, $V(Sy, t)$ is een vrije voorwaartse pas in plaats van een interpolatie:

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

Het PIDE-residu is dan:

$\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]$

met $I[u]$ de kwadratuurbenadering. De lus kost n_quad extra voorwaartse passen per trainingsstap, die allemaal in de autograd-grafiek terechtkomen - de echte prijs van sprongen is geheugen, geen wiskunde.

Vergelijking met traditionele methoden

De structurele verschillen zijn reëel en kunnen zonder benchmark worden vastgesteld:

De prestatierijen die hier normaal gesproken zouden voorkomen – trainingstijd, inferentielatentie, nauwkeurigheid – zijn opzettelijk afwezig, omdat het meten ervan het open werk is en geen tabelinvoer.

Waar PINN's aannemelijk winnen

Realtime herprijzing. Eenmaal getraind, is evaluatie een voorwaartse pass over een batch, dus de prijs van een heel boek wordt herzien in één kernellancering in plaats van één oplossing per parameterset. Of dat beter is dan een goed afgestelde Crank-Nicolson-oplosser bij realistische boekformaten, is een empirische vraag die hier niet wordt gemeten.

Hoogdimensionale modellen. Stochastische volatiliteit plus stochastische koersen plus sprongen zijn 4+ dimensies, waarbij eindige verschillen feitelijk dood zijn. PINN's degraderen gracieus in afmeting, afhankelijk van de trainingsmoeilijkheden.

Continue Grieken. Het netwerk is soepel en differentieerbaar, dus Delta, Gamma, Theta en Vega komen uit dezelfde autograd-machinerie als het PDE-residu – geen bump-and-revalue, geen ruis met eindige verschillen. Dit is de sterkste claim in de post en ook de claim die het meest behoefte heeft aan een gemeten Gamma-oppervlak erachter.

Parametrische oplossingen. Voermodelparameters ($\sigma$, $\kappa$, $\theta$) als netwerkinvoer zorgt ervoor dat één PINN een familie modellen kan bestrijken in plaats van een enkele kalibratie.

Waar PINN's het moeilijk hebben

Trainingskosten. Voor één optie bij één parameterset is het oplossen van een eindig verschil voorbij voordat een PINN zijn eerste duizend tijdperken beëindigt.

Geen foutgrenzen. Eindige verschillen met Richardson-extrapolatie bereiken machineprecisie met een bekende convergentievolgorde. Een PINN rapporteert een verlieswaarde, die niet foutgebonden is. Onzekerheidsbewuste varianten (Bai et al., 2025) hechten betrouwbaarheidsintervallen, maar het veld is jong.

Optimalisatiemoeilijkheid. Het verlieslandschap is zeer niet-convex en de weging tussen PDE-, grens- en terminale termen is een afstemmingsprobleem. De karakteristieke mislukking is een netwerk dat het PDE-residu naar bijna nul brengt, terwijl de randvoorwaarden volledig worden genegeerd – een volkomen geldige oplossing voor het verkeerde probleem.

Reproduceerbaarheid. Verschillende zaden, collocatiedistributies en optimalisatie-instellingen kunnen op betekenisvol verschillende oplossingen terechtkomen. Ensembling helpt en vermenigvuldigt de kosten.

Die laatste twee zijn de delen van dit bericht die het meest de moeite waard zijn om in plots om te zetten, omdat het faalmodi zijn die iedereen die dit opnieuw implementeert, zal tegenkomen.

Wat nog moet worden gemeten

De eerlijke staat van dit artikel: de formuleringen zijn correct en de code werkt, maar niets hier is gebenchmarkt op de hardware van dit bureau of op de gegevens van dit bureau. De pas die er een resultaat van zou maken in plaats van een afleiding:

1. Sup-norm en RMSE tegen Black-Scholes in gesloten vorm over de hele wereld $(S, t)$ rooster, per zaadje, vijf zaden. Het gebruikelijke folkloristische doel is overeenstemming tot meer dan 4 decimalen; het punt is om dat te testen $\sigma = 0.7$, $T = 0.08$ en publiceer de zaden waar het mislukt.
2. Delta- en gammafout, niet alleen prijsfout. Een netwerk dat prijzen op vier cijfers afstemt met een ruis $\Gamma$ is nutteloos voor hedging, dus Gamma is het acceptatiecriterium.
3. Wandkloktrainingstijd en latentie per optie inferentie voor een boek met 10.000 opties, tegen een oplossing van Crank-Nicolson voor hetzelfde probleem op dezelfde GPU.
4. De faalmodi, opzettelijk gereproduceerd. Verlaag het grensverlies totdat het netwerk voldoet aan de PDE en de grens mist; voer vijf zaden uit en breng de verspreiding in kaart. Beide zijn goedkoop te produceren en nuttiger dan een ander correct ogend prijsoppervlak.
5. Aanpassen aan echte Deribit BTC-koersen, of op zijn minst de crypto-realistische parameters hierboven behouden in plaats van terug te keren naar $\sigma = 0.2$, $T = 1.0$.
6. Architectuur- en optimalisatiekeuzes zijn bevindingen, geen advies. Breder versus dieper, tanh versus ReLU (de discontinue tweede afgeleide van ReLU zou het residu zichtbaar moeten verwoesten), $\lambda_{\text{IC}}$ sweeps, en Adam-toen-L-BFGS versus Adam alleen zijn allemaal experimenten van één regel. Totdat ze worden uitgevoerd, worden ze folklore herhaald uit de literatuur, en dit bericht weigert ze als aanbevelingen te herhalen.

De twee structurele claims die zonder meting overleven, omdat ze eigenschappen van de formulering zijn in plaats van van een run: gebruik log-prijscoördinaten (de PDE wordt een constante coëfficiënt, wat een feit is over de algebra), en weeg de terminale voorwaarde boven de PDE-term (de homogene PDE geeft de nuloplossing toe, wat een feit is over het probleem).

Wat is er nog meer

Routebeschrijving die de moeite waard zijn om te weten, geen van hen is hier getest:

• Residueel-adaptieve collocatiebemonstering — plaats punten waar het residu groot is, dichtbij de staking voor Black-Scholes of dichtbij de Feller-grens voor Heston, in plaats van uniform. De implementatie is kort:

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]

• Breng leer over van stakingen en looptijden – verfijn het van een buurman $(K, T)$ in plaats van helemaal opnieuw te trainen, om een ​​bibliotheek bij te houden die de optieketen bestrijkt.
• Op natuurkunde gebaseerde extreme leermachines — bevries verborgen gewichten, train alleen de uitvoerlaag en reduceer training tot één lineaire oplossing. Minder expressief, maar Black-Scholes is laagdimensionaal genoeg dat het er misschien niet toe doet.
• Operator leren (DeepONet, FNO) — leer de oplossingsoperator kennen in plaats van de oplossing, in kaart brengen $(\sigma(\cdot), r(\cdot), \text{payoff}(\cdot)) \to V(\cdot,\cdot)$ nieuwe uitbetalingsstructuren behoeven dus geen herscholing. Zie DeepSVM.

Conclusie

PINN's vervangen eindige verschillen of Monte Carlo niet. Voor een enkele laag-dimensionale optie bij een enkele parameterset winnen eindige verschillen en is deze niet dichtbij. Het geval voor PINN's is smal en specifiek: hoogdimensionale modellen waarbij rasters afsterven, parametrische oplossingen die in een boek worden hergebruikt, en Grieken die afkomstig zijn van dezelfde autodiff-pas als de prijs.

Wat dit bericht oplevert is de vertaallaag: hoe de Heston-gemengde gedeeltelijke, de Amerikaanse vrije grens en de Merton-sprongintegraal elk een term in een verliesfunctie worden. Wat het nog niet oplevert, is het bewijs dat de resulterende netwerken nauwkeurig genoeg zijn om zich mee in te dekken. Dat is de volgende pas, en totdat deze loopt, behandel alles hierboven als een afleiding in plaats van als een aanbeveling.

Referenties en verder lezen

• Raissi, M., Perdikaris, P., Karniadakis, G.E. (2019). Natuurkundig geïnformeerde neurale netwerken: een diepgaand leerraamwerk voor het oplossen van voorwaartse en inverse problemen met niet-lineaire partiële differentiaalvergelijkingen. Journal of Computational Physics, 378, 686-707.
• Dhiman, A., Kaur, D. (2023). Natuurkundig geïnformeerd neuraal netwerk voor optieprijzen. arXiv voordruk.
• Salvador, B. et al. (2023). Meshless-methoden voor Amerikaanse optieprijzen via op natuurkunde geïnformeerde neurale netwerken. Technische analyse met grenselementen.
• Bai, G. et al. (2025). Een onzekerheidsbewuste, op fysica gebaseerde neurale netwerkoplossing voor de Black-Scholes-vergelijking. arXiv voordruk.
• Chen, Y. et al. (2025). Het stochastische jump-diffusieproces informeerde neurale netwerken voor Amerikaanse optieprijzen onder dataschaarste. Toegepaste Soft Computing.
• Benth, FE et al. (2025). DeepSVM: stochastische volatiliteitsmodellen leren met op natuurkunde geïnformeerde diepe operatornetwerken. arXiv voordruk.
• Hij, Y. et al. (2024). Financieel geïnformeerd neuraal netwerk: de geometrie van optieprijzen leren. arXiv voordruk.
• MathWorks: op natuurkunde geïnformeerde neurale netwerken (PINN's) voor optieprijzen. MATLAB financiële blog, 2025.
• GitHub: BlackScholesPINN (PyTorch-implementatie).
• Raissi PINNs GitHub-repository.