Reti neurali informate dalla fisica per i prezzi delle opzioni

La parte interessante dell’applicazione dei PINN ai derivati non è di Black-Scholes. Black-Scholes ha una forma chiusa; una rete che lo riproduce è un controllo di integrità, non un risultato. La parte interessante è tutto ciò che non ha una forma chiusa e dove le differenze finite finiscono fuori strada: la PDE a due fattori di Heston con le sue parziali miste $\partial^2 V / \partial S \partial v$, il problema americano dei confini liberi e l'equazione differenziale integro-differenziale parziale di Merton il cui termine integrale accoppia ogni punto del dominio a ogni altro punto.

Questo post riguarda il modo in cui ciascuno di questi entra in una funzione di perdita. Concretamente: il residuo del prezzo logaritmico che rende addestrabile il PINN di Black-Scholes, la rete Heston a tre input la cui derivata incrociata esce gratuitamente da autograd, il trattamento penalità contro due reti dell'esercizio iniziale e una quadratura di Gauss-Hermite che inserisce l'integrale di salto all'interno di un residuo PDE.

Ciò che non è è un punto di riferimento. Ogni numero sottostante che sembra un risultato è un obiettivo o una citazione ed è contrassegnato come tale. Il passaggio di misurazione viene definito alla fine.

I PINN sono stati introdotti da Raissi et al. (2019), e i meccanismi sono già trattati in questo blog in Il problema di Navier-Stokes, dove lo stesso trucco autograd-residual va a caccia di singolarità nelle equazioni fluide: la PDE diventa un termine di perdita, autodiff fornisce derivate esatte della rete rispetto ai suoi input e non viene mai costruita alcuna griglia. Qui l’unica cosa che cambia è quale PDE va ​​in perdita.

La PDE di Black-Scholes come vincolo fisico

La PDE Black-Scholes, il suo risultato finale $\max(S-K,0)$, e l'argomento di non arbitraggio alla base di esso sono trattati in La formula di Black-Scholes - questa sezione li presuppone e va direttamente alla forma su cui una rete può effettivamente essere addestrata.

Trasformazione del prezzo logaritmico

Lavorando direttamente con $S$ è problematico: il dominio è $[0, \infty)$ e la PDE ha coefficienti variabili. La trasformazione standard $x = \ln(S)$ lo converte in una forma a coefficiente costante:

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

Questa è un'equazione di convezione-diffusione-reazione $x \in (-\infty, \infty)$. I coefficienti variabili $S^2$ E $S$ se ne sono andati, il che conta per una rete: un residuo la cui grandezza cresce con $S^2$ è dominato dall'estremità lontana del dominio e l'ottimizzatore spende lì il suo budget.

Perdita del PINN per Black-Scholes

Lasciamo $u_\theta(x, t)$ essere la rete. Campione $N_r$ punti di collocazione $(x_i, t_i)$ all'interno, $N_b$ sui confini, e $N_0$ al momento terminale:

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

Ogni derivata parziale viene calcolata tramite torch.autograd.grad con create_graph=True, quindi i gradienti fluiscono attraverso il calcolo della derivata durante la backpropagation. Quel singolo flag è l'intero trucco dell'implementazione.

Implementazione di PyTorch

I parametri seguenti sono in stile criptovaluta piuttosto che da manuale: $\sigma = 0.7$ E $T = 0.08$ (all'incirca un'opzione BTC a 30 giorni) invece dell'equity-desk $\sigma = 0.2$, $T = 1.0$. La breve scadenza più un alto volume è il regime in cui la dipendenza dal payoff è più acuta e dove il PINN è più difficile da addestrare: questo è il 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

Due scelte strutturali da segnalare:

• Peso sulla condizione terminale. Il profitto aumenta di peso 10 volte perché definisce il problema. Senza una forte applicazione, la rete può soddisfare banalmente la PDE emettendo zero ovunque: la PDE omogenea ha infinite soluzioni e la condizione terminale è ciò che ne seleziona una.
• Ricampionamento dei punti di collocazione ad ogni epoca. I punti vengono disegnati nuovamente ad ogni passaggio, che agisce come regolarizzazione stocastica sul residuo. L’alternativa – un insieme di punti fissi – consente alla rete di sovradimensionare il residuo a quelle coordinate esatte.

Estensione al modello di volatilità stocastica di Heston

Prezzi di Black-Scholes con un'unica costante $\sigma$, che è esattamente il presupposto che GARCH(1,1) volatility Forecasting è costruito per rifiutare. Heston fa della volatilità un secondo fattore stocastico, la varianza istantanea $v$:

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

Dove $\kappa$ è la velocità di ritorno alla media, $\theta$ la varianza di lungo periodo, $\xi$ il vol-di-vol, e $dW_1 \cdot dW_2 = \rho\,dt$.

La PDE dei prezzi è bidimensionale nello stato:

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

È qui che un metodo senza mesh inizia a sembrare attraente. Uno schema alle differenze finite necessita di una griglia $(S, v, t)$ - un tipico $200 \times 100 \times 500$ È $10^7$ nodi. Aggiungi un terzo fattore stocastico, come i tassi stocastici, e la griglia diventa poco pratica. Monte Carlo scala meglio in termini di dimensioni ma converge lentamente, soprattutto per i greci.

Architettura PINN per Heston

La rete accetta tre ingressi $(x, v, t)$ con $x = \ln S$. Il parziale misto $\partial^2 u / \partial x \partial v$ – il termine che rende scomodi i programmi ADI – è un altro autograd.grad chiamata:

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

Notare che u_xv si ottiene differenziando u_x riguardo a v, riutilizzando il grafico costruito dalla prima chiamata. La simmetria del parziale misto significa differenziare u_v riguardo a x dovrebbe dare lo stesso tensore; in float32 non lo farà, esattamente, e il divario è un diagnostico economico per verificare se il grafico si sta comportando.

Opzioni americane e problemi di frontiera libera

Le opzioni americane aggiungono un vincolo di esercizio anticipato: il valore non deve mai scendere al di sotto del valore intrinseco. Ciò trasforma la PDE in un problema a confine libero, equivalentemente in un problema di complementarità lineare (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$

Dove $\mathcal{L}$ è l'operatore Black-Scholes e $\Phi(S)$ il compenso. Due modi per metterlo in perdita.

Metodo di penalità

Sostituisci il vincolo di complementarità con una penalità graduale:

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

con $\rho_p$ grande (tipicamente $10^4$ A $10^6$). Quando $V$ scende al di sotto dell'intrinseco, la penalità lo costringe a risalire e la perdita del PINN diventa:

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

Nessun cambiamento di architettura, solo un residuo modificato. Il costo è un nuovo iperparametro con un cattivo compromesso di condizionamento: troppo piccolo e il vincolo viene violato, troppo grande e il panorama delle perdite è dominato dal termine di penalità.

Avvicinamento diretto al confine libero

Addestra due reti insieme: una per il prezzo $u_\theta(S, t)$, uno per il limite ottimale dell'esercizio $S^*_\phi(t)$. La perdita comporta la PDE nella regione di continuazione, la condizione di smooth-pasting al confine e il profitto nella regione di esercizio. Il confine si presenta come un risultato di prima classe, che è ciò che effettivamente desideri per coprire un libro americano.

Modelli di diffusione a salto con PINN

Il modello di Merton aggiunge i salti di Poisson al moto browniano geometrico:

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

Dove $J$ è un processo di Poisson composto con intensità $\lambda$ e dimensioni del salto log-normale. Il prezzo diventa un’equazione integro-differenziale parziale (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 densità del moltiplicatore di salto.

L'integrale è ciò che rompe le differenze finite: accoppia ogni punto del dominio a ogni altro punto, distruggendo la struttura a bande su cui fa affidamento il risolutore. Un PINN non ha questa struttura da perdere. L'integrale è solo un altro termine nel residuo, valutato mediante quadratura in ogni punto di collocazione, e poiché la rete è definita ovunque, $V(Sy, t)$ è un passaggio in avanti gratuito anziché un'interpolazione:

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

Il residuo PIDE è quindi:

$\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]$ l'approssimazione della quadratura. Il ciclo costa n_quad passaggi in avanti extra per fase di allenamento, che finiscono tutti nel grafico autograd: il vero prezzo dei salti è la memoria, non la matematica.

Confronto con i metodi tradizionali

Le differenze strutturali sono reali e possono essere dichiarate senza parametri di riferimento:

Le righe delle prestazioni che normalmente vivrebbero qui - tempo di allenamento, latenza di inferenza, precisione - sono deliberatamente assenti, perché misurarle è un lavoro aperto, non una voce di tabella.

Dove è plausibile che i PINN vincano

Ripricing in tempo reale. Una volta addestrata, la valutazione è un passaggio successivo su un batch, quindi un intero libro viene rivalutato in un unico lancio del kernel anziché in una soluzione per set di parametri. Se questo batte un solutore Crank-Nicolson ben calibrato con dimensioni realistiche dei libri è una questione empirica e non misurata qui.

Modelli ad alta dimensione. La volatilità stocastica più i tassi stocastici più i salti sono 4+ dimensioni, dove le differenze finite sono effettivamente morte. I PINN degradano gradualmente in dimensione, a seconda della difficoltà di addestramento.

Greci continui. La rete è fluida e differenziabile, quindi Delta, Gamma, Theta e Vega provengono dallo stesso meccanismo di autogradazione del residuo PDE: nessun bump-and-revalue, nessun rumore di differenza finita. Questa è l'affermazione più forte nel post e anche quella che più necessita di una superficie Gamma misurata dietro di essa.

Soluzioni parametriche. Parametri del modello di alimentazione ($\sigma$, $\kappa$, $\theta$) come input di rete consente a un PINN di coprire una famiglia di modelli anziché una singola calibrazione.

Dove i PINN faticano

Costo di addestramento. Per un'opzione con un set di parametri, la risoluzione di una differenza finita termina prima che un PINN termini le sue prime mille epoche.

Nessun limite di errore. Le differenze finite con l'estrapolazione di Richardson raggiungono la precisione della macchina con un ordine di convergenza noto. Un PINN segnala un valore di perdita, che non è un limite di errore. Varianti sensibili all'incertezza (Bai et al., 2025) allegare intervalli di confidenza, ma il campo è giovane.

Difficoltà di ottimizzazione. Il panorama delle perdite è estremamente non convesso e la ponderazione tra PDE, confine e termini terminali è un problema di ottimizzazione. Il guasto caratteristico è una rete che porta il residuo PDE quasi allo zero ignorando completamente le condizioni al contorno: una soluzione perfettamente valida al problema sbagliato.

Riproducibilità. Diversi seed, distribuzioni di collocazione e impostazioni di ottimizzazione possono arrivare a soluzioni significativamente diverse. L’assemblaggio aiuta e moltiplica i costi.

Queste ultime due sono le parti di questo post che vale la pena trasformare in trame, perché sono modalità di fallimento che chiunque lo reimplementi colpirà.

Ciò che deve ancora essere misurato

Lo stato onesto di questo articolo: le formulazioni sono corrette e il codice funziona, ma nulla qui è stato confrontato sull'hardware o sui dati di questa scrivania. Il passaggio che lo renderebbe un risultato piuttosto che una derivazione:

1. Sup-norma e RMSE contro Black-Scholes in forma chiusa in tutto il $(S, t)$ griglia, per seme, cinque semi. Il solito obiettivo folcloristico è l'accordo con 4+ cifre decimali; il punto è testarlo a $\sigma = 0.7$, $T = 0.08$ e pubblicare i semi dove fallisce.
2. Errore Delta e Gamma, non solo errore di prezzo. Una rete che abbina i prezzi a quattro cifre con un errore rumoroso $\Gamma$ è inutile per la copertura, quindi Gamma è il criterio di accettazione.
3. Tempo di addestramento dell'orologio da parete e latenza di inferenza per opzione per un libro da 10.000 opzioni, rispetto a una soluzione Crank-Nicolson dello stesso problema sulla stessa GPU.
4. Le modalità di guasto, riprodotte deliberatamente. Ridurre il peso della perdita del confine finché la rete non soddisfa la PDE e non supera il confine; esegui cinque semi e traccia la diffusione. Entrambi sono economici da produrre e più utili di un'altra superficie di prezzo dall'aspetto corretto.
5. Adatta alle quotazioni reali di Deribit BTC, o come minimo mantieni i parametri criptorealistici di cui sopra anziché ripristinarli $\sigma = 0.2$, $T = 1.0$.
6. Scelte di architettura e ottimizzatori come risultati, non consigli. Più ampio rispetto a più profondo, tanh rispetto a ReLU (la derivata seconda discontinua di ReLU dovrebbe distruggere visibilmente il residuo), $\lambda_{\text{IC}}$ spazzate e Adam-poi-L-BFGS contro Adam da solo sono tutti esperimenti su una riga. Fino a quando non vengono pubblicati, sono folklore ripetuto dalla letteratura e questo post si rifiuta di ripeterli come raccomandazioni.

Le due affermazioni strutturali che sopravvivono senza misurazione, perché sono proprietà della formulazione piuttosto che di una corsa: utilizzano coordinate logaritmiche del prezzo (la PDE diventa coefficiente costante, che è un fatto di algebra), e ponderano la condizione terminale al di sopra del termine PDE (la PDE omogenea ammette la soluzione zero, che è un dato di fatto del problema).

Cos'altro c'è là fuori

Indicazioni che vale la pena conoscere, nessuna testata qui:

• Campionamento della collocazione adattativa residua: posizionare i punti in cui il residuo è ampio, vicino allo sciopero per Black-Scholes o vicino al confine Feller per Heston, anziché in modo uniforme. L'implementazione è 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]

• Trasferisci l'apprendimento tra scadenze e scadenze: ottimizza da un vicino $(K, T)$ invece di formare da zero, per mantenere una libreria che copra la catena delle opzioni.
• Macchine ad apprendimento estremo basate sulla fisica: congela i pesi nascosti, addestra solo il livello di output, riducendo l'addestramento a una soluzione lineare. Meno espressivo, ma Black-Scholes è abbastanza dimensionale da non avere importanza.
• Apprendimento dell'operatore (DeepONet, FNO): impara l'operatore della soluzione anziché la soluzione, mappando $(\sigma(\cdot), r(\cdot), \text{payoff}(\cdot)) \to V(\cdot,\cdot)$ quindi le nuove strutture di payoff non necessitano di riqualificazione. Vedi DeepSVM.

Conclusione

I PINN non sostituiscono le differenze finite o Monte Carlo. Per una singola opzione a bassa dimensionalità con un singolo set di parametri, le differenze finite vincono e non sono vicine. Il caso dei PINN è ristretto e specifico: modelli ad alta dimensione in cui le griglie muoiono, soluzioni parametriche riutilizzate in un libro e greche che provengono dallo stesso passaggio automatico del prezzo.

Ciò che questo post fornisce è il livello di traduzione: come il parziale misto di Heston, il confine libero americano e l'integrale di salto di Merton diventano ciascuno un termine in una funzione di perdita. Ciò che non fornisce ancora è la prova che le reti risultanti siano sufficientemente accurate da poter essere utilizzate come copertura. Questo è il passaggio successivo e finché non viene eseguito, considera tutto quanto sopra come una derivazione piuttosto che come una raccomandazione.

Riferimenti e ulteriori letture

• Raissi, M., Perdikaris, P., Karniadakis, G.E. (2019). Reti neurali informate dalla fisica: un quadro di apprendimento profondo per risolvere problemi diretti e inversi che coinvolgono equazioni differenziali parziali non lineari. Journal of Computational Physics, 378, 686-707.
• Dhiman, A., Kaur, D. (2023). Rete neurale basata sulla fisica per la determinazione dei prezzi delle opzioni. prestampa arXiv.
• Salvador, B. et al. (2023). Metodi meshless per la determinazione del prezzo delle opzioni americane attraverso reti neurali informate dalla fisica. Analisi ingegneristica con elementi di contorno.
• Bai, G. et al. (2025). Una soluzione di rete neurale informata sulla fisica e consapevole dell'incertezza per l'equazione di Black-Scholes. prestampa arXiv.
• Chen, Y. et al. (2025). Il processo di diffusione stocastica del salto ha informato le reti neurali per la determinazione del prezzo delle opzioni americane in condizioni di scarsità di dati. Soft computing applicato.
• Benth, FE et al. (2025). DeepSVM: apprendimento di modelli di volatilità stocastica con reti di operatori profondi informate dalla fisica. prestampa arXiv.
• Lui, Y. et al. (2024). Rete neurale basata sulla finanza: apprendere la geometria del prezzo delle opzioni. prestampa arXiv.
• MathWorks: Reti neurali informate dalla fisica (PINN) per la determinazione dei prezzi delle opzioni. Blog finanziario MATLAB, 2025.
• GitHub: BlackScholesPINN (implementazione PyTorch).
• Repository GitHub di Raissi PINN.