Operatore neurale di Fourier per la modellazione finanziaria basata su PDE

Ogni rete neurale su questo blog finora ha approssimato una funzione: caratteristiche dentro, un numero fuori. L'operatore neurale di Fourier si avvicina a un operatore: una mappa tra spazi funzionali a dimensione infinita, dove l'input è un'intera superficie di volatilità e l'output è un'intera superficie di prezzo. Questo è un oggetto diverso, ha bisogno di macchinari diversi, e il macchinario è il punto di questo articolo: un kernel apprendibile con valori complessi applicato alle modalità di Fourier più basse, valutato attraverso un andata e ritorno FFT in $O(n \log n)$.

Il prezzo delle opzioni è il punto in cui questo arriva nella finanza. Black-Scholes, Heston, volatilità locale: tutte le PDE, tutte risolte oggi un parametro alla volta. Un operatore apprende l'intera famiglia di parametri in una sola volta e il passaggio in avanti risultante è un singolo kernel GPU in batch anziché un ciclo di marcia temporale.

Questa è la promessa. La versione onesta di questo articolo separa i meccanismi, che sono solidi e riproducibili dal codice seguente, dalle dichiarazioni sulle prestazioni, che nella letteratura FNO sono riportate rispetto a linee di base che nessuno in questa serie accetterebbe senza essere esaminate. La meccanica viene prima; l'agenda delle misurazioni si trova alla fine, contrassegnata come non eseguita.

Dall'approssimazione delle funzioni all'apprendimento degli operatori

Funzioni approssimate delle reti neurali classiche: dato un input $x \in \mathbb{R}^n$, producono un output $y \in \mathbb{R}^m$. Ciò è potente, ma fondamentalmente limitato quando gli oggetti di interesse sono essi stessi funzioni. Nella risoluzione delle PDE finanziarie, l’input non è un singolo numero: è una funzione che descrive le condizioni iniziali/al contorno, una superficie di volatilità o una struttura a termine. L'output è un'altra funzione: la superficie del prezzo $(S, t)$ spazio.

L'apprendimento dell'operatore solleva il problema verso spazi a dimensione infinita. Invece di imparare $f: \mathbb{R}^n \to \mathbb{R}^m$, impariamo un operatore:

$\mathcal{G}: \mathcal{A} \to \mathcal{U}$

Dove $\mathcal{A}$ E $\mathcal{U}$ sono spazi di funzioni di Banach. Per i prezzi delle opzioni, $\mathcal{A}$ potrebbe essere lo spazio delle superfici di volatilità $\sigma(S,t)$ E $\mathcal{U}$ lo spazio delle corrispondenti superfici dei prezzi $V(S,t)$.

Due architetture dominano il panorama dell’apprendimento degli operatori:

1. DeepONet (Lu et al., 2021): utilizza una rete di filiali per codificare la funzione di input e una rete di trunk per codificare la posizione della query. L'output è il loro prodotto interiore. Basato sul teorema di approssimazione universale per gli operatori di Chen e Chen (1995).

2. Operatore neurale di Fourier (Li et al., 2021): parametrizza il kernel integrale nello spazio di Fourier, utilizzando la FFT per una convoluzione globale efficiente. Risoluzione invariante per costruzione.

Entrambi sono approssimatori universali per operatori continui, ma FNO ha un vantaggio strutturale per i problemi PDE: la sua distorsione spettrale cattura naturalmente la struttura globale e uniforme delle soluzioni PDE. Presenta anche uno svantaggio strutturale per quanto riguarda specificamente i guadagni delle opzioni, su cui torneremo: una base di Fourier troncata e un nodo allo strike non sono alleati naturali.

Architettura FNO in dettaglio

L'operatore neurale di Fourier, introdotto da Li et al. all'ICLR 2021, si basa su un'osservazione semplice ma potente: la funzione di Green (nucleo integrale) di molte PDE ha una rappresentazione compatta nello spazio di Fourier. Piuttosto che apprendere un kernel nello spazio fisico, che richiede $O(n^2)$ parametri per $n$ punti della griglia: FNO lo apprende nello spazio delle frequenze con solo i più bassi $k_{\max}$ modalità, riducendo la complessità a $O(n \log n)$ tramite la FFT.

L'architettura iterativa

Un FNO è composto da:

1. Strato sollevante $P$: una mappa lineare puntuale che proietta l'input dalla dimensione del canale originale a una rappresentazione latente di dimensione superiore: $v_0(x) = P(a(x))$.

2. Strati Fourier (ripetuto $L$ volte): Ogni livello si applica:

$v_{l+1}(x) = \sigma\left(W_l \, v_l(x) + \mathcal{K}_l(v_l)(x)\right)$

Dove $W_l$ è una trasformazione lineare locale (puntuale $1 \times 1$ convoluzione) e $\mathcal{K}_l$ è un operatore integrale globale implementato tramite la FFT:

$\mathcal{K}_l(v_l)(x) = \mathcal{F}^{-1}\left(R_l \cdot \mathcal{F}(v_l)\right)(x)$

Qui $\mathcal{F}$ denota la FFT, $R_l$ è un tensore di peso con valori complessi apprendibili applicato al più basso $k_{\max}$ Modi di Fourier e $\sigma$ è un'attivazione non lineare puntuale (tipicamente GELU).

3. Livello di proiezione $Q$: associa la rappresentazione latente alla dimensione di output: $u(x) = Q(v_L(x))$.

Perché lo spazio di Fourier?

La convoluzione spettrale $R_l \cdot \mathcal{F}(v_l)$ è una moltiplicazione nel dominio della frequenza, che equivale a una convoluzione globale nello spazio fisico, ma calcolata $O(n \log n)$ invece di $O(n^2)$. Questo non è solo un trucco di efficienza. Le soluzioni PDE sono tipicamente fluide e dominate da componenti a bassa frequenza. Troncando a $k_{\max}$ modalità, FNO agisce come un filtro passa-basso apprendibile che regolarizza naturalmente la soluzione ed evita artefatti ad alta frequenza.

Fondamentalmente, si afferma che FNO è invariante alla discretizzazione: una volta addestrato su una griglia di dimensioni $n$, può essere valutato su qualsiasi risoluzione $m \neq n$ semplicemente regolando la dimensione della FFT e il riempimento zero o troncando i pesi spettrali. Questa proprietà di super-risoluzione zero-shot è unica tra i solutori PDE neurali ed è la prima affermazione in questo articolo che merita una misurazione piuttosto che una citazione. Vedere l'agenda delle misurazioni di seguito.

La PDE per cui stiamo imparando l'operatore

La PDE di Black-Scholes — derivata, sezionata termine per termine e fornita con la sua soluzione call/put in forma chiusa in La formula di Black-Scholes — è l'obiettivo dell'operatore:

$\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 S^2 \frac{\partial^2 V}{\partial S^2} + rS\frac{\partial V}{\partial S} - rV = 0$

Tutto ciò che segue lo tratta come una scatola nera con una risposta nota. Questa risposta nota è esattamente il motivo per cui è il caso di test giusto: un operatore addestrato sull'output alle differenze finite può essere valutato rispetto a norm.cdf prezzi esatti, cosa che quasi nessun benchmark FNO in letteratura può fare.

Formulazione FNO

Riformuliamo il problema come apprendimento dell'operatore. Definire:

• Funzione di input $a(S, t)$: codifica i parametri PDE. Ciò può includere la superficie di volatilità $\sigma(S, t)$, la funzione di payoff e il tasso privo di rischio come canali impilati sul $(S, t)$ griglia.
• Funzione di uscita $u(S, t) = V(S, t)$: la superficie del prezzo dell'opzione.

La FNO impara $\mathcal{G}_\theta: a \mapsto u$ da un set di dati di $(a^{(i)}, u^{(i)})$ coppie generate da un solutore tradizionale. Dopo l'addestramento, l'inferenza per qualsiasi nuova configurazione di parametri è un singolo passaggio in avanti.

Generazione dei dati di formazione

import numpy as np
from scipy.stats import norm

def black_scholes_fd(sigma, r, K, T, S_max=300, N_S=256, N_t=256):
    """Solve Black-Scholes PDE via explicit finite differences.

    NOTE: this is an interpreted double loop — the *worst* CPU baseline,
    exactly the kind called out in /en/blog/post/when-gpu-pays-off-sweep-roofline.
    It is fine for generating training data offline. It is NOT the baseline
    any speedup claim should be measured against; vectorize the inner loop
    over i (or use scipy sparse + implicit stepping) before timing anything.
    """
    dS = S_max / N_S
    dt = T / N_t
    S = np.linspace(0, S_max, N_S + 1)

    V = np.maximum(S - K, 0).astype(np.float64)

    for j in range(N_t):
        V_new = V.copy()
        for i in range(1, N_S):
            delta = (V[i+1] - V[i-1]) / (2 * dS)
            gamma = (V[i+1] - 2*V[i] + V[i-1]) / (dS**2)
            V_new[i] = V[i] + dt * (
                0.5 * sigma**2 * S[i]**2 * gamma
                + r * S[i] * delta
                - r * V[i]
            )
        V_new[0] = 0
        V_new[N_S] = S_max - K * np.exp(-r * (T - (j+1)*dt))
        V = V_new

    return S, V

Per la formazione, campioniamo migliaia di configurazioni di parametri, variabili $\sigma \in [0.05, 0.80]$, $r \in [0.01, 0.10]$, $K \in [50, 150]$, $T \in [0.1, 2.0]$ - e risolverli ciascuno con il metodo delle differenze finite. Il set di dati risultante di coppie input-output è ciò da cui apprende l'FNO.

Scaling Up: il modello della volatilità stocastica di Heston

La volatilità costante è un presupposto notoriamente falso, e il motivo per cui fallisce - il sorriso, le code grasse - è l'argomento della sezione "Dura realtà" di La formula di Black-Scholes. Heston risolve il problema rendendo la varianza una seconda variabile di stato:

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

con $\text{Corr}(dW_1, dW_2) = \rho$. La PDE corrispondente al prezzo dell'opzione $V(S, v, t)$ è bidimensionale nello spazio:

$\frac{\partial V}{\partial t} + \frac{1}{2}vS^2\frac{\partial^2 V}{\partial S^2} + \rho\xi vS\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 l'apprendimento degli operatori guadagna terreno e l'argomentazione è strutturale piuttosto che empirica. Schemi alle differenze finite su a $(S, v, t)$ scala della griglia come $O(N_S \times N_v \times N_t)$, il termine di derivazione incrociata $\partial^2 V / \partial S \partial v$ complica la discretizzazione e ogni nuovo set di parametri $(\kappa, \theta, \xi, \rho, r)$ paga nuovamente l'intero costo. Un operatore lo paga una volta al momento della formazione. La struttura spaziale 2D della PDE Heston si mappa direttamente anche sulla FFT 2D negli strati di Fourier, quindi l'architettura sottostante si generalizza con un cambiamento di dimensione piuttosto che con una riprogettazione.

FNO per i prezzi delle opzioni: implementazione PyTorch

Di seguito è riportata un'implementazione FNO completa e autonoma per l'apprendimento dell'operatore Black-Scholes. L'architettura segue Li et al. (2021) con adattamenti per il contesto finanziario.

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.fft import rfft, irfft

class SpectralConv1d(nn.Module):
    """1D Fourier layer: spectral convolution via FFT."""

    def __init__(self, in_channels: int, out_channels: int, modes: int):
        super().__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.modes = modes  # Number of Fourier modes to keep

        scale = 1.0 / (in_channels * out_channels)
        self.weights = nn.Parameter(
            scale * torch.randn(in_channels, out_channels, modes, dtype=torch.cfloat)
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        batch_size = x.shape[0]

        x_ft = rfft(x, dim=-1)

        out_ft = torch.zeros(
            batch_size, self.out_channels, x_ft.size(-1),
            dtype=torch.cfloat, device=x.device
        )
        out_ft[:, :, :self.modes] = torch.einsum(
            "bix,iox->box", x_ft[:, :, :self.modes], self.weights
        )

        return irfft(out_ft, n=x.size(-1), dim=-1)


class FNOBlock(nn.Module):
    """Single Fourier Neural Operator block."""

    def __init__(self, channels: int, modes: int):
        super().__init__()
        self.spectral_conv = SpectralConv1d(channels, channels, modes)
        self.pointwise = nn.Conv1d(channels, channels, kernel_size=1)
        self.norm = nn.InstanceNorm1d(channels)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return F.gelu(self.norm(self.spectral_conv(x) + self.pointwise(x)))


class FNO1d(nn.Module):
    """
    Fourier Neural Operator for 1D PDE problems.

    Learns the mapping: PDE parameters -> solution function
    """

    def __init__(
        self,
        in_channels: int = 3,    # e.g., sigma(S), payoff(S), grid(S)
        out_channels: int = 1,   # V(S)
        hidden_channels: int = 64,
        modes: int = 32,
        num_layers: int = 4,
    ):
        super().__init__()
        self.lift = nn.Linear(in_channels, hidden_channels)
        self.blocks = nn.ModuleList(
            [FNOBlock(hidden_channels, modes) for _ in range(num_layers)]
        )
        self.proj = nn.Sequential(
            nn.Linear(hidden_channels, 128),
            nn.GELU(),
            nn.Linear(128, out_channels),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.lift(x)                    # -> (batch, spatial, hidden)
        x = x.permute(0, 2, 1)              # -> (batch, hidden, spatial)

        for block in self.blocks:
            x = block(x)

        x = x.permute(0, 2, 1)              # -> (batch, spatial, hidden)
        return self.proj(x)                  # -> (batch, spatial, out_channels)

Ciclo di allenamento

import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

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

    N_samples = 5000
    N_S = 256
    S_max = 300.0
    S_grid = np.linspace(0, S_max, N_S + 1)

    inputs, targets = [], []
    for _ in range(N_samples):
        sigma = np.random.uniform(0.05, 0.80)
        r = np.random.uniform(0.01, 0.10)
        K = np.random.uniform(50, 150)
        T = np.random.uniform(0.1, 2.0)

        _, V = black_scholes_fd(sigma, r, K, T, S_max=S_max, N_S=N_S)

        sigma_field = np.full(N_S + 1, sigma)
        payoff = np.maximum(S_grid - K, 0)
        grid_norm = S_grid / S_max

        inp = np.stack([sigma_field, payoff, grid_norm], axis=-1)
        inputs.append(inp)
        targets.append(V[:, None])

    X = torch.tensor(np.array(inputs), dtype=torch.float32)
    Y = torch.tensor(np.array(targets), dtype=torch.float32)

    dataset = TensorDataset(X, Y)
    loader = DataLoader(dataset, batch_size=64, shuffle=True)

    model = FNO1d(in_channels=3, out_channels=1, hidden_channels=64, modes=32).to(device)
    optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200)

    for epoch in range(200):
        model.train()
        total_loss = 0.0
        for batch_x, batch_y in loader:
            batch_x, batch_y = batch_x.to(device), batch_y.to(device)

            pred = model(batch_x)
            loss = torch.mean(
                torch.norm(pred - batch_y, dim=1)
                / torch.norm(batch_y, dim=1).clamp(min=1e-8)
            )

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            total_loss += loss.item()

        scheduler.step()
        if (epoch + 1) % 20 == 0:
            avg = total_loss / len(loader)
            print(f"Epoch {epoch+1:3d} | Relative L2 Loss: {avg:.6f}")

    return model

Inferenza: prezzi in tempo reale

@torch.no_grad()
def price_option(model, sigma, K, S_grid, device="cuda"):
    """
    Price a European call for given sigma and strike.
    Returns prices for all S in S_grid — single forward pass.
    """
    S_max = S_grid[-1]
    payoff = np.maximum(S_grid - K, 0)
    grid_norm = S_grid / S_max
    sigma_field = np.full_like(S_grid, sigma)

    inp = np.stack([sigma_field, payoff, grid_norm], axis=-1)
    x = torch.tensor(inp, dtype=torch.float32).unsqueeze(0).to(device)

    pred = model(x)
    return pred.squeeze().cpu().numpy()

FNO vs. PINN: un confronto pratico

Le reti neurali informate dalla fisica e gli operatori neurali di Fourier rappresentano filosofie fondamentalmente diverse per la risoluzione di PDE con le reti neurali. Comprendere i loro compromessi è la ragione pratica per preoccuparsi dell'apprendimento dell'operatore.

PINN: ottimizzazione per istanza

I PINN inseriscono il residuo PDE direttamente nella perdita: Il problema di Navier-Stokes copre il meccanismo, l'autodiff physics_loss implementazione e il risultato della ricerca sulla singolarità di DeepMind. L'unica proprietà che conta qui è strutturale: un PINN viene addestrato per set di parametri. Modifica $\sigma$, $r$, $K$ O $T$ e ottimizzi di nuovo da zero.

Punti di forza: non sono richiesti dati etichettati. Applica direttamente la struttura PDE. Funziona con qualsiasi PDE che puoi annotare.

Punti deboli: è necessario riqualificarsi per ogni nuovo set di parametri $(\sigma, r, K, T)$. La formazione prevede il bilanciamento di molteplici termini di perdita (residuo PDE, condizioni al contorno, condizioni iniziali) che spesso porta a patologie di ottimizzazione. La convergenza può essere lenta: in genere 10.000-100.000 passaggi di gradiente per istanza del problema. Fallisce su sistemi multiscala e caotici in cui il panorama delle perdite diventa altamente non convesso.

FNO: Apprendimento Operatore Ammortizzato

FNO apprende l'operatore della soluzione dai dati. Richiede un set di dati di addestramento generato da un solutore classico, ma una volta addestrato si generalizza nell'intero spazio dei parametri.

Punti di forza: inferenza inferiore al millisecondo nei benchmark pubblicati. Generalizza su parametri invisibili senza riqualificazione. Invariante alla risoluzione: addestramento a bassa risoluzione, valutazione ad alta risoluzione. Gestisce naturalmente soluzioni PDE uniformi tramite polarizzazione spettrale.

Punti deboli: richiede dati di addestramento da un risolutore classico (problema dell'uovo e della gallina per PDE veramente nuove). L'errore di approssimazione è limitato ma diverso da zero. Meno interpretabile degli approcci vincolati dalla PDE. E la distorsione spettrale che aiuta a trovare soluzioni fluide è una responsabilità in termini di profitto.

Confronto testa a testa

La tabella seguente è riportata in letteratura, non misurata qui: le righe di precisione e velocità in particolare provengono da Li et al. (2021) e lavoro di follow-up su benchmark fluidi, non dai prezzi delle opzioni sul nostro hardware. Leggi le righe strutturali (dati necessari, generalizzazione, invarianza della risoluzione) come quelle affidabili.

L'ibrido: operatori neurali informati sulla fisica (PINO)

PINO (Li et al., 2024) combina entrambi gli approcci. Utilizza l'architettura FNO ma aumenta la perdita guidata dai dati con un termine residuo PDE:

$\mathcal{L}_{\text{PINO}} = \mathcal{L}_{\text{data}} + \lambda \, \mathcal{L}_{\text{PDE}}$

La scomposizione è la parte utile. $\mathcal{L}_{\text{data}}$ ancora l'operatore all'output del risolutore ovunque sia disponibile; $\lambda \mathcal{L}_{\text{PDE}}$ lo vincola ovunque non lo fai, comprese le regioni dello spazio dei parametri che non hai mai campionato. Per la determinazione del prezzo delle opzioni, quel secondo termine è interessante per un motivo specifico della finanza: il residuo PDE è un vincolo difficile che puoi anche valutare al momento dell'inferenza come autocontrollo, che è la base del fallback di monitoraggio dei residui riportato di seguito.

Considerazioni pratiche per la distribuzione della produzione

La metà generica di questo - budget di latenza di inferenza, costruzione della pipeline di dati, monitoraggio della deriva, riqualificazione periodica - è già coperta per un modello neurale in un sistema di trading nella sezione di produzione di DeepLOB: Deep Learning on Limit Order Books, e si applica invariata. Quello che segue è solo ciò che è specifico di un operatore.

Pipeline di dati: campionamento dello spazio dei parametri

La generazione di dati di addestramento è il principale collo di bottiglia e, a differenza di un modello di dati di mercato, sei tu a scegliere la tua distribuzione, il che significa che puoi sbagliare in un modo invisibile nella perdita. Per l'operatore Black-Scholes con 4 parametri sono sufficienti 5.000–10.000 campioni. Per Heston con 5 parametri più un dominio spaziale 2D, sono tipici 20.000-50.000 campioni. Utilizzare il campionamento adattivo: concentrare i campioni in regioni parametriche in cui la soluzione varia rapidamente – vicino al denaro, scadenze brevi, elevata volatilità – perché il campionamento uniforme della scatola spende la maggior parte del suo budget in regioni deep-ITM e deep-OTM dove l’operatore è quasi lineare e impara bene da pochissimi esempi.

Ottimizzazione dell'architettura

• Modalità ($k_{\max}$): Inizia con $N/4$ Dove $N$ è la dimensione della griglia spaziale. Per $N=256$, utilizzare le modalità 32–64. Troppe poche modalità perdono dettagli vicino ai confini del colpo; troppi troppo adattati al rumore.
• Strati: 4 strati di Fourier sono standard. Reti più profonde (6–8) aiutano per problemi 2D come Heston ma aumentano la memoria.
• Canali nascosti: 64 per 1D Black-Scholes, 128 per 2D Heston. Scalare con la complessità del problema.

Precisione: la questione fp32

SpectralConv1d assegna torch.cfloat - complesso a precisione singola - e ogni viaggio di andata e ritorno FFT viene eseguito con quella precisione. Questo blog ha già osservato una pipeline finanziaria fp32 restituire spazzatura silenziosa in The GPU Precision Trap, dove una formulazione matematicamente corretta della somma del prefisso ha perso catastroficamente alle magnitudini fp32. La domanda analoga qui è diretta: a $S \approx 100$ con i prezzi espressi al centesimo, vale un viaggio spettrale di andata e ritorno FP32 $10^{-2}$ assoluto, oppure la crescita di magnitudo intermedia della FFT mangia le ultime cifre significative?

Controllo degli errori

Per la determinazione dei prezzi delle opzioni di produzione, sono necessari limiti di errore da poter difendere.

1. Incertezza calibrata: una deviazione standard dell'insieme non è una garanzia di copertura, e questo blog ha i meccanismi per farlo correttamente: dividere il conforme su una griglia di parametri trattenuta, con ACI/DtACI per il caso non scambiabile, in Previsione conforme per dimensionamento della posizione consapevole del rischio. Avvolgendo l'FNO in split conformal sopra il $(\sigma, r, K, T)$ la griglia fornisce intervalli senza distribuzione sul prezzo.
2. Monitoraggio residuo: calcola il residuo PDE della previsione FNO come controllo post-hoc. Se $\|\text{residual}\| > \epsilon$, ricorrere a un risolutore classico. Questo è gratuito in termini di inferenza: il residuo è uno stencil a differenza finita su un array che già possiedi.
3. Apprendimento attivo: indirizza gli input ad alta incertezza al risolutore classico, aggiungi i risultati al set di addestramento e riqualifica periodicamente. L'ampiezza dell'intervallo conforme da (1) è il segnale di instradamento naturale.

L'agenda della misurazione

Questa è la parte che decide se vale la pena implementare l'architettura di cui sopra e nulla di tutto ciò è ancora stato completato. È elencato qui anziché sepolto perché l'alternativa – affermare un'accelerazione del titolo – è proprio il registro che questo blog esiste per evitare.

1. L'aumento di velocità è una curva, non un numero. Quando la GPU ripaga stabilisce la forma: $S(B) = aB/(O + bB)$, passando da sopra dominato a $B=1$ a un plateau limitato dal calcolo e mostra un titolo 167x che si scompone in 27x di algoritmo per 6,2x di hardware. La misurazione FNO deve seguire questo modello: segnare il passaggio in avanti a $B \in \{1, 8, 64, 512\}$ e riportare l'intera curva. Fondamentalmente, la linea di base deve essere un risolutore di differenze finite vettorizzato, multi-core: il black_scholes_fd sopra c'è un doppio loop interpretato, l'esatta linea di base della "peggiore implementazione della CPU" nominata dall'articolo e il confronto di un operatore GPU in batch con esso produrrebbe un numero che non significa nulla.

2. Accuratezza rispetto alla forma chiusa. Questo è l'esperimento che Black-Scholes rende quasi gratuito e che i benchmark di fluidodinamica non possono fare affatto: addestrarsi sui dati generati da FD, quindi ottenere un punteggio rispetto all'esatto norm.cdf prezzi in tutto il $(\sigma, r, K, T)$ scatola. Denuncia il parente $L^2$, e segnala la distribuzione dell'errore, in particolare vicino allo strike e alla scadenza, dove la soluzione è meno fluida e la base spettrale troncata dovrebbe avere maggiori difficoltà.

3. Violazioni di non arbitraggio. Un operatore esperto non ha alcuna ragione strutturale per rispettare i vincoli di forma che una superficie di prezzo deve soddisfare: monotonia in $K$, convessità dentro $K$, E $V \geq \max(S-K, 0)$. Misurare il tasso di violazione attraverso la casella dei parametri trasforma la domanda aperta di questo articolo - possiamo garantire condizioni di non arbitraggio nell'operatore appreso? - da un gesto di mano in un numero.

4. Invarianza di discretizzazione, testata anziché asserita. Train at $N_S = 128$, valutare a $N_S = 512$, segnala l'errore. La modalità di guasto prevista è denominata e specifica: Gibbs suona al nodo $\max(S-K, 0)$. Una base di Fourier troncata che ricostruisce una funzione con una derivata prima discontinua oscilla attorno ad essa, e la super-risoluzione zero-shot può peggiorare la situazione anziché migliorarla esponendo modalità che la risoluzione di addestramento non ha mai visto. Se la super-risoluzione peggiora in prossimità dello sciopero, quel risultato negativo ha più valore dell’affermazione di marketing che sostituisce: nessuno nella letteratura FNO valuta le opzioni con un vantaggio di profitto.

Se non è possibile eseguire gli esperimenti da 1 a 4, questo articolo non dovrebbe essere spedito. Ciò che rimane senza di essi è un'esposizione ben scritta del documento dell'ICLR di qualcun altro.

Oltre le opzioni alla vaniglia

Supponendo che l’agenda di cui sopra sopravviva al contatto con la misurazione, il quadro FNO si estende naturalmente a strumenti più complessi:

• Opzioni americane: aggiungi un limite di esercizio anticipato come canale di output aggiuntivo. L'FNO apprende contemporaneamente sia la superficie del prezzo che il limite di esercizio ottimale.
• Opzioni barriera: codifica i livelli di barriera come canali di ingresso. Si noti che una barriera è una seconda discontinuità e la preoccupazione di Gibbs relativa all’agenda di misurazione si applica con maggiore forza, non con minore forza.
• Paniere multi-asset: utilizza FNO 2D o 3D per opzioni paniere su 2-3 sottostanti. La maledizione della dimensionalità è meno grave rispetto ai solutori basati su griglia perché l'FNO opera su un numero fisso di modalità.
• Volatilità locale: inserisci l'intera superficie di volatilità locale di Dupire $\sigma_{\text{loc}}(S,t)$ come funzione spaziale. Questo è il caso d'uso più naturale per l'apprendimento degli operatori: l'input è una funzione, non un parametro scalare.

Conclusione

Il contributo dell'operatore neurale di Fourier è concettuale prima che computazionale: invece di risolvere una PDE alla volta, si parametrizza l'operatore di soluzione stesso, e facendo ciò nello spazio di Fourier si ottiene un'architettura che è $O(n \log n)$, universale su operatori continui e flessibile nella risoluzione per costruzione. Ciò segue molto da Li et al. (2021) e dal codice sopra, che funziona.

Ciò che non segue è un numero di accelerazione. Le cifre 100x-1000x della letteratura sono misurate su benchmark fluidi rispetto a linee di base la cui qualità è raramente dichiarata, e questa serie ha dedicato un intero articolo a mostrare quanto di tale titolo sia solitamente un algoritmo piuttosto che hardware. Le affermazioni che giustificherebbero l'inserimento di un operatore in un motore di determinazione dei prezzi - precisione FP32 a livello di centesimi, un tasso limitato di violazione di nessun arbitraggio, super-risoluzione che sopravvive a un nodo di profitto e una curva di accelerazione rispetto a un risolutore CPU competente - sono tutte misurabili, tutte economiche su Black-Scholes perché esiste la forma chiusa, e tutte ancora non misurate qui.

Questo è lo stato della bozza: il meccanismo è reale, la promessa è plausibile e le prove sono pendenti.

Riferimenti e approfondimenti:

• Li, Z., Kovachki, N., Azizzadenesheli, K., et al. "Operatore neurale di Fourier per equazioni alle derivate parziali parametriche." ICLR 2021. arXiv:2010.08895
• Lu, L., Jin, P., Pang, G., Zhang, Z., & Karniadakis, G.E. "Apprendimento degli operatori non lineari tramite DeepONet." Nature Machine Intelligence, 2021. doi:10.1038/s42256-021-00302-5
• Li, Z., et al. "Operatore neurale informato sulla fisica per l'apprendimento di equazioni alle derivate parziali". ACM/IMS Journal of Data Science, 2024. OpenReview
• neuraloperator Libreria PyTorch: github.com/neuraloperator/neuraloperator
• Salvador, M., et al. "Apprendimento della rete neurale dell'equazione di Black-Scholes per il prezzo delle opzioni". arXiv:2405.05780
• Bai, Y., et al. "L'intelligenza artificiale Black-Scholes: rete neurale informata sulla finanza." arXiv:2412.12213