Opérateur neuronal de Fourier pour la modélisation financière basée sur la PDE

Jusqu'à présent, chaque réseau neuronal de ce blog s'est rapproché d'une fonction : des fonctionnalités entrantes, un nombre sortant. L'opérateur neuronal de Fourier se rapproche d'un opérateur — une carte entre des espaces fonctionnels de dimension infinie, où l'entrée est une surface de volatilité entière et la sortie est une surface de prix entière. C'est un objet différent, il nécessite une machinerie différente, et la machinerie est le but de cet article : un noyau à valeurs complexes apprenable appliqué aux modes de Fourier les plus bas, évalué via un aller-retour FFT dans $O(n \log n)$.

C’est dans le domaine de la finance que cela se produit dans la tarification des options. Black-Scholes, Heston, volatilité locale – tous les PDE, tous résolus aujourd'hui, un paramètre à la fois. Un opérateur apprend toute la famille de paramètres en même temps, et le passage direct qui en résulte est un noyau GPU unique par lots plutôt qu'une boucle temporelle.

C'est la promesse. La version honnête de cet article sépare les mécanismes, qui sont solides et reproductibles à partir du code ci-dessous, des allégations de performances, qui dans la littérature FNO sont rapportées par rapport à des lignes de base que personne dans cette série n'accepterait sans examen. La mécanique passe en premier ; l'agenda de mesure arrive à la fin, marqué comme non exécuté.

De l'approximation des fonctions à l'apprentissage des opérateurs

Fonctions approximatives des réseaux de neurones classiques : étant donné une entrée $x \in \mathbb{R}^n$, ils produisent une sortie $y \in \mathbb{R}^m$. C’est puissant, mais fondamentalement limité lorsque les objets d’intérêt sont eux-mêmes des fonctions. Dans la résolution d'EDP financière, l'entrée n'est pas un nombre unique : il s'agit d'une fonction décrivant les conditions initiales/aux limites, une surface de volatilité ou une structure de termes. La production est une autre fonction : la surface des prix sur $(S, t)$ espace.

L'apprentissage des opérateurs élève le problème dans des espaces de dimension infinie. Au lieu d'apprendre $f: \mathbb{R}^n \to \mathbb{R}^m$, on apprend un opérateur :

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

où $\mathcal{A}$ et $\mathcal{U}$ sont des espaces de fonctions de Banach. Pour le prix des options, $\mathcal{A}$ pourrait être l'espace des surfaces de volatilité $\sigma(S,t)$ et $\mathcal{U}$ l'espace des surfaces de prix correspondantes $V(S,t)$.

Deux architectures dominent le paysage de l'apprentissage des opérateurs :

1. DeepONet (Lu et al., 2021) : utilise un réseau de succursales pour coder la fonction d'entrée et un réseau principal pour coder l'emplacement de la requête. La sortie est leur produit interne. Fondé sur le théorème d'approximation universelle pour les opérateurs de Chen et Chen (1995).

2. Opérateur neuronal de Fourier (Li et al., 2021) : paramétre le noyau intégral dans l'espace de Fourier, en utilisant la FFT pour une convolution globale efficace. Invariant en résolution par construction.

Les deux sont des approximateurs universels pour les opérateurs continus, mais FNO présente un avantage structurel pour les problèmes PDE : son biais spectral capture naturellement la structure globale et fluide des solutions PDE. Cela présente également un désavantage structurel pour les paiements des options en particulier, sur lequel nous reviendrons : une base de Fourier tronquée et un problème au niveau de la grève ne sont pas des alliés naturels.

Architecture FNO en détail

L'opérateur neuronal de Fourier, introduit par Li et al. à l'ICLR 2021, s'appuie sur une observation simple mais puissante : la fonction de Green (noyau intégral) de nombreuses PDE a une représentation compacte dans l'espace de Fourier. Plutôt que d'apprendre un noyau dans l'espace physique - ce qui nécessite $O(n^2)$ paramètres pour $n$ points de grille - FNO l'apprend dans l'espace de fréquence avec seulement le plus bas $k_{\max}$ modes, réduisant la complexité à $O(n \log n)$ via la FFT.

L'architecture itérative

Un FNO se compose de :

1. Couche de levage $P$ : Une carte linéaire ponctuelle qui projette l'entrée de sa dimension de canal d'origine vers une représentation latente de dimension supérieure : $v_0(x) = P(a(x))$.

2. Couches de Fourier (répétées $L$ fois) : Chaque couche s’applique :

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

où $W_l$ est une transformée linéaire locale (point par point $1 \times 1$ convolution) et $\mathcal{K}_l$ est un opérateur intégral global implémenté via la FFT :

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

Ici $\mathcal{F}$ désigne la FFT, $R_l$ est un tenseur de poids à valeurs complexes apprenable appliqué au plus bas $k_{\max}$ modes de Fourier, et $\sigma$ est une activation non linéaire ponctuelle (généralement GELU).

3. Couche de projection $Q$ : mappe la représentation latente à la dimension de sortie : $u(x) = Q(v_L(x))$.

Pourquoi l'Espace de Fourier ?

La convolution spectrale $R_l \cdot \mathcal{F}(v_l)$ est une multiplication dans le domaine fréquentiel, qui équivaut à une convolution globale dans l'espace physique - mais calculée en $O(n \log n)$ au lieu de $O(n^2)$. Ce n’est pas seulement une astuce d’efficacité. Les solutions PDE sont généralement fluides et dominées par des composants basse fréquence. En tronquant à $k_{\max}$ modes, FNO agit comme un filtre passe-bas apprenable qui régularise naturellement la solution et évite les artefacts haute fréquence.

Fondamentalement, FNO est prétendument invariant par discrétisation : une fois formé sur une grille de taille $n$, il peut être évalué sur n'importe quelle résolution $m \neq n$ en ajustant simplement la taille de la FFT et en effectuant un remplissage nul ou en tronquant les poids spectraux. Cette propriété de super-résolution zéro est unique parmi les solveurs neuronaux PDE - et c'est la première affirmation de cet article qui mérite une mesure plutôt qu'une citation. Voir l'agenda des mesures ci-dessous.

Le PDE pour lequel nous apprenons l'opérateur

Le PDE de Black-Scholes — dérivé, disséqué terme par terme et donné avec sa solution call/put sous forme fermée dans La formule Black-Scholes — est la cible de l'opérateur :

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

Tout ce qui suit le traite comme une boîte noire avec une réponse connue. Cette réponse connue est exactement la raison pour laquelle il s'agit du bon scénario de test : un opérateur formé sur la sortie aux différences finies peut être évalué par rapport à norm.cdf des prix exacts, ce que presque aucun référentiel FNO dans la littérature ne peut faire.

Formulation FNO

Nous reformulons le problème en tant qu'apprentissage des opérateurs. Définir :

• Fonction d'entrée $a(S, t)$: code les paramètres PDE. Cela peut inclure la surface de volatilité $\sigma(S, t)$, la fonction de paiement et le taux sans risque en tant que canaux empilés sur le $(S, t)$ grille.
• Fonction de sortie $u(S, t) = V(S, t)$: la surface du prix de l'option.

La FNO apprend $\mathcal{G}_\theta: a \mapsto u$ à partir d'un ensemble de données de $(a^{(i)}, u^{(i)})$ paires générées par un solveur traditionnel. Après la formation, l'inférence pour toute nouvelle configuration de paramètres est une seule passe avant.

Génération de données de formation

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

Pour la formation, nous échantillonnons des milliers de configurations de paramètres, variant $\sigma \in [0.05, 0.80]$, $r \in [0.01, 0.10]$, $K \in [50, 150]$, $T \in [0.1, 2.0]$ - et résolvez chacun avec la méthode des différences finies. L’ensemble de données résultant de paires d’entrées-sorties est ce dont le FNO apprend.

Mise à l'échelle : le modèle de volatilité stochastique de Heston

La volatilité constante est une fausse hypothèse connue, et la raison pour laquelle elle échoue – le sourire, les grosses queues – fait l'objet de la section « Dure réalité » de La formule Black-Scholes. Heston le corrige en faisant de la variance une deuxième variable d'état :

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

avec $\text{Corr}(dW_1, dW_2) = \rho$. Le PDE correspondant au prix de l’option $V(S, v, t)$ est bidimensionnel dans l'espace :

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

C’est là que l’apprentissage des opérateurs gagne sa place, et l’argument est structurel plutôt qu’empirique. Schémas aux différences finies sur un $(S, v, t)$ échelle de grille comme $O(N_S \times N_v \times N_t)$, le terme dérivé croisé $\partial^2 V / \partial S \partial v$ complique la discrétisation, et chaque nouveau jeu de paramètres $(\kappa, \theta, \xi, \rho, r)$ paie à nouveau le coût total. Un opérateur le paie une fois au moment de la formation. La structure spatiale 2D du Heston PDE correspond également directement à la FFT 2D dans les couches de Fourier, de sorte que l'architecture ci-dessous se généralise avec un changement de dimension plutôt qu'une refonte.

FNO pour la tarification des options : implémentation de PyTorch

Vous trouverez ci-dessous une implémentation FNO complète et autonome pour l'apprentissage de l'opérateur Black-Scholes. L'architecture suit Li et al. (2021) avec des adaptations pour le contexte financier.

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)

Boucle d'entraînement

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

Inférence : tarification en temps réel

@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 : une comparaison pratique

Les réseaux de neurones fondés sur la physique et les opérateurs neuronaux de Fourier représentent des philosophies fondamentalement différentes pour résoudre les PDE avec des réseaux de neurones. Comprendre leurs compromis est la raison pratique de se soucier de l'apprentissage des opérateurs.

PINN : optimisation par instance

Les PINN mettent le résidu PDE directement dans la perte — Le problème Navier-Stokes couvre le mécanisme, l'autodiff physics_loss implémentation et le résultat de la recherche de singularité DeepMind. La seule propriété qui compte ici est structurelle : un PINN est formé par ensemble de paramètres. Modification $\sigma$, $r$, $K$ ou $T$ et vous optimisez à nouveau à partir de zéro.

Forces : Aucune donnée étiquetée requise. Applique directement la structure PDE. Fonctionne pour n'importe quel PDE que vous pouvez écrire.

Faiblesses : doit se recycler pour chaque nouveau jeu de paramètres $(\sigma, r, K, T)$. La formation consiste à équilibrer plusieurs termes de perte (résiduel PDE, conditions aux limites, conditions initiales) ce qui conduit souvent à des pathologies d'optimisation. La convergence peut être lente : généralement 10 000 à 100 000 étapes de gradient par instance de problème. Échoue sur des systèmes multi-échelles et chaotiques où le paysage des pertes devient très non convexe.

FNO : Apprentissage opérateur amorti

FNO apprend l'opérateur de solution à partir des données. Il nécessite un ensemble de données de formation généré par un solveur classique, mais une fois formé, il se généralise à tout l'espace des paramètres.

Forces : inférence inférieure à la milliseconde dans les benchmarks publiés. Se généralise à des paramètres invisibles sans recyclage. Invariant en résolution : entraînez-vous à basse résolution, évaluez à haute résolution. Gère naturellement les solutions PDE fluides via un biais spectral.

Faiblesses : Nécessite des données de formation provenant d'un solveur classique (problème de la poule et de l'œuf pour de véritables nouveaux PDE). L'erreur d'approximation est limitée mais non nulle. Moins interprétable que les approches contraintes par PDE. Et le biais spectral qui aide à obtenir des solutions fluides est un handicap en cas de problème de rentabilité.

Comparaison face à face

Le tableau ci-dessous est rapporté dans la littérature, non mesuré ici — les lignes de précision et d'accélération en particulier proviennent de Li et al. (2021) et des travaux de suivi sur des benchmarks fluides, et non sur la tarification des options sur notre matériel. Lisez les lignes structurelles (données nécessaires, généralisation, invariance de résolution) comme étant les plus fiables.

L'hybride : les opérateurs neuronaux informés par la physique (PINO)

PINO (Li et al., 2024) combine les deux approches. Il utilise l'architecture FNO mais augmente la perte liée aux données avec un terme résiduel PDE :

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

La décomposition est la partie utile. $\mathcal{L}_{\text{data}}$ ancre l'opérateur à la sortie du solveur partout où vous l'avez ; $\lambda \mathcal{L}_{\text{PDE}}$ le contraint partout où vous ne le faites pas, y compris les régions de l'espace des paramètres que vous n'avez jamais échantillonnées. Pour la tarification des options, ce deuxième terme est attractif pour une raison spécifique à la finance : le résidu PDE est une contrainte dure que vous pouvez également évaluer au moment de l'inférence en tant qu'auto-vérification, qui est la base du repli de surveillance des résidus ci-dessous.

Considérations pratiques pour le déploiement de la production

La moitié générique de cela - budgets de latence d'inférence, construction du pipeline de données, surveillance de la dérive, recyclage périodique - est déjà couverte pour un modèle neuronal dans un système commercial dans la section production de [DeepLOB : Deep Learning on Limit Order Books] (/fr/blog/post/deeplob-deep-learning-order-book), et elle s'applique inchangée. Ce qui suit n'est que ce qui est spécifique à un opérateur.

Pipeline de données : échantillonnage de l'espace des paramètres

La génération de données de formation est le principal goulot d'étranglement et contrairement à un modèle de données de marché, vous choisissez votre propre distribution, ce qui signifie que vous pouvez vous tromper d'une manière invisible dans la perte. Pour l'opérateur de Black-Scholes avec 4 paramètres, 5 000 à 10 000 échantillons suffisent. Pour Heston avec 5 paramètres plus un domaine spatial 2D, 20 000 à 50 000 échantillons sont typiques. Utilisez l'échantillonnage adaptatif : concentrez les échantillons dans les régions paramétriques où la solution varie rapidement (proche de l'argent, échéances courtes, forte volatilité) car l'échantillonnage uniforme de la boîte dépense la majeure partie de son budget sur les régions ITM profondes et OTM profondes où l'opérateur est presque linéaire et apprend bien à partir de très peu d'exemples.

Optimisation de l'architecture

• Modes ($k_{\max}$) : Commencez par $N/4$ où $N$ est la taille de la grille spatiale. Pour $N=256$, utilisez les modes 32 à 64. Trop peu de modes perdent des détails près des limites latérales ; trop de surajustement au bruit.
• Couches : 4 couches de Fourier sont standard. Des réseaux plus profonds (6 à 8) aident à résoudre les problèmes 2D comme Heston mais augmentent la mémoire.
• Canaux cachés : 64 pour 1D Black-Scholes, 128 pour 2D Heston. Adaptez-vous à la complexité du problème.

Précision : la question fp32

SpectralConv1d alloue torch.cfloat - complexe simple précision - et chaque aller-retour FFT s'exécute avec cette précision. Ce blog a déjà vu un pipeline financier fp32 renvoyer des déchets silencieux dans The GPU Precision Trap, où une formulation de somme de préfixe mathématiquement correcte a été perdue de manière catastrophique aux magnitudes fp32. La question analogue ici est directe : à $S \approx 100$ avec des prix indiqués au centime près, un aller-retour spectral fp32 tient-il à $10^{-2}$ absolue, ou la croissance d'ampleur intermédiaire de la FFT mange-t-elle les derniers chiffres significatifs ?

Contrôle des erreurs

Pour la tarification des options de production, vous avez besoin de limites d’erreur que vous pouvez défendre.

1. ** Incertitude calibrée ** : un écart type d'ensemble n'est pas une garantie de couverture, et ce blog dispose des outils nécessaires pour le faire correctement : divisé en conformité sur une grille de paramètres maintenue, avec ACI/DtACI pour le cas non échangeable, dans Prédiction conforme pour un dimensionnement de position conscient du risque. Envelopper le FNO en split conforme sur le $(\sigma, r, K, T)$ la grille donne des intervalles sans distribution sur le prix.
2. Surveillance résiduelle : calculez le résidu PDE de la prédiction FNO en tant que vérification post-hoc. Si $\|\text{residual}\| > \epsilon$, revenez à un solveur classique. C'est libre d'inférence - le résidu est un pochoir à différences finies sur un tableau que vous possédez déjà.
3. Apprentissage actif : acheminez les entrées à haute incertitude vers le solveur classique, ajoutez les résultats à l'ensemble de formation et recyclez-vous périodiquement. La largeur de l'intervalle conforme de (1) est le signal de routage naturel.

Le programme de mesure

C'est la partie qui décide si l'architecture ci-dessus vaut la peine d'être déployée, et rien de tout cela n'est encore fait. Il est répertorié ici plutôt que enterré parce que l’alternative – affirmer une accélération des titres – est précisément le registre que ce blog existe pour éviter.

1. L'accélération est une courbe, pas un nombre. When the GPU Pay Off établit la forme : $S(B) = aB/(O + bB)$, passant d'une situation dominée par les frais généraux à $B=1$ à un plateau lié au calcul, et il montre un titre 167x se décomposant en 27x d'algorithme multiplié par 6,2x de matériel. La mesure FNO doit suivre ce modèle : enregistrez la passe avant à $B \in \{1, 8, 64, 512\}$ et rapportez toute la courbe. Il est essentiel que la ligne de base soit un solveur de différences finies vectorisé et multicœur - le black_scholes_fd ci-dessus est une double boucle interprétée, la ligne de base exacte de la "pire implémentation de CPU" que l'article nomme, et comparer un opérateur GPU par lots avec celui-ci produirait un nombre qui ne signifie rien.

2. Précision par rapport à la forme fermée. C'est l'expérience que Black-Scholes réalise presque gratuitement et que les tests de dynamique des fluides ne peuvent pas du tout faire : s'entraîner sur des données générées par FD, puis évaluer par rapport à la forme fermée. norm.cdf les prix à travers le $(\sigma, r, K, T)$ boîte. Signaler le parent $L^2$, et signalez l'erreur distribution - en particulier près de la frappe et de l'expiration, où la solution est la moins fluide et où la base spectrale tronquée devrait avoir le plus de difficultés.

3. Violations de non-arbitrage. Un opérateur érudit n’a aucune raison structurelle de respecter les contraintes de forme qu’une surface de prix doit satisfaire : monotonie dans $K$, convexité dans $K$, et $V \geq \max(S-K, 0)$. La mesure du taux de violation dans la boîte de paramètres transforme la question ouverte de cet article — pouvons-nous garantir des conditions de non-arbitrage chez l'opérateur appris ? — d'un simple signe de la main en un nombre.

4. Invariance de discrétisation, testée plutôt qu'affirmée. Entraînez-vous à $N_S = 128$, évaluer à $N_S = 512$, signalez l'erreur. Le mode de défaillance attendu est nommé et spécifique : Gibbs sonne au coude $\max(S-K, 0)$. Une base de Fourier tronquée reconstruisant une fonction avec une dérivée première discontinue oscille autour d'elle, et la super-résolution zéro peut aggraver la situation plutôt que l'améliorer en exposant des modes que la résolution d'entraînement n'a jamais vus. Si la super-résolution se dégrade à l’approche de la frappe, ce résultat négatif a plus de valeur que l’affirmation marketing qu’il remplace – personne dans la littérature FNO n’évalue les options avec un problème de gain.

Si les expériences 1 à 4 ne peuvent pas être exécutées, cet article ne devrait pas être expédié. Ce qui reste sans eux est une exposition bien écrite de l'article ICLR de quelqu'un d'autre.

Au-delà des options vanille

En supposant que le programme ci-dessus survit au contact avec la mesure, le cadre FNO s’étend naturellement à des instruments plus complexes :

• Options américaines : ajoutez une limite d'exercice précoce comme canal de sortie supplémentaire. Le FNO apprend simultanément à la fois la surface des prix et la limite d’exercice optimale.
• Options de barrière : Encodez les niveaux de barrière en tant que canaux d'entrée. Notez qu’une barrière est une deuxième discontinuité, et la préoccupation de Gibbs issue du programme de mesure s’applique avec plus de force, pas moins.
• Paniers multi-actifs : utilisez le FNO 2D ou 3D pour les options de panier sur 2 à 3 sous-jacents. La malédiction de la dimensionnalité est moins grave que pour les solveurs basés sur une grille car le FNO fonctionne sur un nombre fixe de modes.
• Volatilité locale : saisissez la surface complète de la volatilité locale de Dupire $\sigma_{\text{loc}}(S,t)$ comme fonction spatiale. Il s'agit du cas d'utilisation le plus naturel pour l'apprentissage des opérateurs : l'entrée est une fonction, pas un paramètre scalaire.

Conclusion

La contribution de l'opérateur neuronal de Fourier est conceptuelle avant d'être informatique : au lieu de résoudre une PDE à la fois, vous paramétrez l'opérateur de solution lui-même, et cela dans l'espace de Fourier produit une architecture qui est $O(n \log n)$, universel sur les opérateurs continus et flexible en résolution par construction. Cela découle de Li et al. (2021) et à partir du code ci-dessus, qui s'exécute.

Ce qui ne suit pas, c'est un numéro d'accélération. Les chiffres 100x à 1000x de la littérature sont mesurés sur des références fluides par rapport à des références dont la qualité est rarement indiquée, et cette série a consacré un article entier à montrer à quel point un tel titre est généralement un algorithme plutôt qu'un matériel. Les affirmations qui justifieraient l’insertion d’un opérateur dans un moteur de tarification – une précision fp32 au niveau du centime, un taux de violation limité sans arbitrage, une super-résolution qui survit à un problème de gain et une courbe d’accélération par rapport à un solveur de processeur compétent – sont toutes mesurables, toutes bon marché sur Black-Scholes car la forme fermée existe, et toutes ne sont toujours pas mesurées ici.

Tel est l’état de ce projet : le mécanisme est réel, la promesse est plausible et les preuves sont en attente.

Références et lectures complémentaires :

• Li, Z., Kovachki, N., Azizzadenesheli, K., et al. "Opérateur neuronal de Fourier pour les équations différentielles partielles paramétriques." ICLR 2021. arXiv:2010.08895
• Lu, L., Jin, P., Pang, G., Zhang, Z. et Karniadakis, GE. "Apprendre les opérateurs non linéaires via DeepONet." Nature Machine Intelligence, 2021. doi:10.1038/s42256-021-00302-5
• Li, Z., et al. "Opérateur neuronal informé par la physique pour l'apprentissage des équations aux dérivées partielles." ACM/IMS Journal of Data Science, 2024. OpenReview
• neuraloperator Bibliothèque PyTorch : github.com/neuraloperator/neuraloperator -Salvador, M., et al. "Apprentissage par réseau neuronal de l'équation de Black-Scholes pour la tarification des options." arXiv:2405.05780 -Bai, Y., et al. « L'IA Black-Scholes : un réseau neuronal axé sur la finance. » arXiv:2412.12213