Réseaux de neurones basés sur la physique pour la tarification des options

La partie intéressante de l’application des PINN aux produits dérivés n’est pas celle de Black-Scholes. Black-Scholes a une forme fermée ; un réseau qui le reproduit est un contrôle de santé mentale, pas un résultat. La partie intéressante est tout ce qui n'a pas de forme fermée et où les différences finies s'écartent : l'EDP à deux facteurs de Heston avec son partiel mixte $\partial^2 V / \partial S \partial v$, le problème américain de la frontière libre et l'équation intégro-différentielle partielle de Merton dont le terme intégral couple chaque point du domaine à chaque autre point.

Cet article explique comment chacun de ces éléments entre dans une fonction de perte. Concrètement : le résidu de log-prix qui rend le PINN de Black-Scholes entraînable, le réseau Heston à trois entrées dont la dérivée croisée tombe gratuitement de l'autograd, le traitement de pénalité contre deux réseaux de l'exercice précoce et une quadrature de Gauss-Hermite qui place l'intégrale de saut à l'intérieur d'un résidu PDE.

Ce n’est pas une référence. Chaque nombre ci-dessous qui ressemble à un résultat est soit une cible, soit une citation, et il est marqué comme tel. La passe de mesure est délimitée à la fin.

Les PINN ont été introduits par Raissi et al. (2019), et la mécanique est déjà abordée sur ce blog dans The Navier-Stokes Problem, où la même astuce d'autograd-résiduel recherche les singularités dans les équations fluides : l'EDP devient un terme de perte, l'autodiff fournit des dérivées exactes du réseau par rapport à ses entrées, et aucune grille n'est jamais construite. Ici, la seule chose qui change est quel PDE entre dans la perte.

L'EDP Black-Scholes comme contrainte physique

Le PDE Black-Scholes, sa récompense finale $\max(S-K,0)$, et l'argument de non-arbitrage qui le sous-tend sont traités dans La formule Black-Scholes — cette section les assume et va directement à la forme sur laquelle un réseau peut réellement être formé.

Transformation du prix du journal

Travailler directement avec $S$ est problématique : le domaine est $[0, \infty)$ et le PDE a des coefficients variables. La transformation standard $x = \ln(S)$ le convertit sous une forme à coefficient constant :

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

Il s’agit d’une équation de convection-diffusion-réaction sur $x \in (-\infty, \infty)$. Les coefficients variables $S^2$ et $S$ ont disparu, ce qui est important pour un réseau : un résidu dont l'ampleur évolue avec $S^2$ est dominé par l'extrémité du domaine et l'optimiseur y dépense son budget.

Perte du PINN pour Black-Scholes

Laissez $u_\theta(x, t)$ être le réseau. Échantillon $N_r$ points de colocalisation $(x_i, t_i)$ à l'intérieur, $N_b$ sur les frontières, et $N_0$ à l'heure 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$

Chaque dérivée partielle est calculée via torch.autograd.grad avec create_graph=True, de sorte que les gradients traversent le calcul de la dérivée pendant la rétropropagation. Ce seul indicateur constitue toute l’astuce de mise en œuvre.

Implémentation de PyTorch

Les paramètres ci-dessous sont plutôt cryptographiques que manuels : $\sigma = 0.7$ et $T = 0.08$ (environ une option BTC de 30 jours) au lieu du bureau d'équité $\sigma = 0.2$, $T = 1.0$. Une échéance courte et une volatilité élevée sont le régime dans lequel le problème de gain est le plus marqué et où le PINN est le plus difficile à former – ce qui est le point important.

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

Deux choix structurels méritent d’être signalés :

• Poids sur la condition terminale. Le gain est multiplié par 10 car il définit le problème. Sans une application stricte, le réseau peut satisfaire la PDE de manière triviale en produisant zéro partout – la PDE homogène a une infinité de solutions et la condition terminale est ce qui en sélectionne une.
• Rééchantillonnage des points de collocation à chaque époque. Les points sont dessinés à nouveau à chaque étape, ce qui agit comme une régularisation stochastique sur le résidu. L'alternative - un ensemble de points fixes - permet au réseau de surajuster le résidu à ces coordonnées exactes.

Extension au modèle de volatilité stochastique Heston

Prix ​​Black-Scholes avec une seule constante $\sigma$, ce qui est exactement l'hypothèse que GARCH(1,1) volatilité prévision est conçue pour rejeter. Heston fait de la volatilité un deuxième facteur stochastique, la variance instantanée $v$:

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

où $\kappa$ est la vitesse de retour à la moyenne, $\theta$ la variance à long terme, $\xi$ le vol-de-vol, et $dW_1 \cdot dW_2 = \rho\,dt$.

L’EDP de tarification est bidimensionnelle :

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

C’est là qu’une méthode sans maillage commence à paraître attrayante. Un schéma aux différences finies nécessite une grille dans $(S, v, t)$ — un typique $200 \times 100 \times 500$ est $10^7$ nœuds. Ajoutez un troisième facteur stochastique, tel que les taux stochastiques, et la grille devient peu pratique. Monte Carlo évolue mieux en dimension mais converge lentement, en particulier pour les Grecs.

Architecture PINN pour Heston

Le réseau prend trois entrées $(x, v, t)$ avec $x = \ln S$. Le partiel mixte $\partial^2 u / \partial x \partial v$ — le terme qui rend les systèmes ADI gênants — en est un de plus autograd.grad appel:

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

Noter que u_xv est obtenu en différenciant u_x en ce qui concerne v, en réutilisant le graphe construit par le premier appel. La symétrie du partiel mixte signifie différencier u_v en ce qui concerne x devrait donner le même tenseur ; dans float32, ce ne sera pas exactement le cas, et l'écart est un diagnostic bon marché pour savoir si le graphique se comporte.

Options américaines et problèmes de frontière libre

Les options américaines ajoutent une contrainte d’exercice précoce : la valeur ne doit jamais descendre en dessous de la valeur intrinsèque. Cela transforme l'EDP en un problème de frontière libre, équivalent à un problème de complémentarité linéaire (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$

où $\mathcal{L}$ est l'opérateur de Black-Scholes et $\Phi(S)$ la récompense. Deux façons de mettre cela en perte.

Méthode de pénalité

Remplacez la contrainte de complémentarité par une pénalité lisse :

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

avec $\rho_p$ grand (généralement $10^4$ à $10^6$). Quand $V$ descend en dessous de l'intrinsèque, la pénalité le force à remonter et la perte du PINN devient :

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

Aucun changement d'architecture, juste un résidu modifié. Le coût est un nouvel hyperparamètre avec un mauvais compromis de conditionnement : trop petit et la contrainte est violée, trop grand et le paysage des pertes est dominé par le terme de pénalité.

Approche directe des frontières libres

Former deux réseaux conjointement : un pour le prix $u_\theta(S, t)$, un pour la limite d'exercice optimale $S^*_\phi(t)$. La perte entraîne la PDE dans la région de continuation, la condition de collage en douceur à la frontière et le gain dans la région d'exercice. La limite apparaît comme un résultat de première classe, ce que vous recherchez réellement pour couvrir un livre américain.

Modèles de diffusion par saut avec PINN

Le modèle de Merton ajoute des sauts de Poisson au mouvement brownien géométrique :

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

où $J$ est un processus de Poisson composé d'intensité $\lambda$ et des tailles de sauts log-normales. La tarification devient une équation intégro-différentielle partielle (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$

avec $f(y)$ la densité du multiplicateur de saut.

L'intégrale est ce qui brise les différences finies : elle couple chaque point du domaine à chaque autre point, détruisant ainsi la structure en bandes sur laquelle s'appuie le solveur. Un PINN n’a pas cette structure à perdre. L'intégrale n'est qu'un autre terme du résidu, évalué par quadrature à chaque point de collocation, et comme le réseau est défini partout, $V(Sy, t)$ est une passe avant gratuite plutôt qu'une interpolation :

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

Le résidu PIDE est alors :

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

avec $I[u]$ l'approximation en quadrature. La boucle coûte n_quad des passes avant supplémentaires par étape d'entraînement, qui atterrissent toutes dans le graphique d'autogradation - le vrai prix des sauts est la mémoire, pas les mathématiques.

Comparaison avec les méthodes traditionnelles

Les différences structurelles sont réelles et peuvent être constatées sans référence :

Les lignes de performances qui vivraient normalement ici (temps de formation, latence d'inférence, précision) sont délibérément absentes, car les mesurer est un travail ouvert et non une entrée de tableau.

Où les PINN gagnent-ils de manière plausible

Retarification en temps réel. Une fois entraînée, l'évaluation est une transmission directe sur un lot, de sorte qu'un livre entier est retarifé en un seul lancement de noyau plutôt qu'en une seule résolution par ensemble de paramètres. Que cela batte un solveur de Crank-Nicolson bien réglé pour des tailles de livres réalistes est une question empirique et non mesurée ici.

Modèles de grande dimension. La volatilité stochastique plus les taux stochastiques plus les sauts sont de 4+ dimensions, où les différences finies sont effectivement mortes. Les PINN se dégradent gracieusement en dimension, sous réserve de difficultés de formation.

Grecs continus. Le réseau est fluide et différenciable, donc Delta, Gamma, Theta et Vega proviennent de la même machinerie autograd que le résidu PDE - pas de choc et de réévaluation, pas de bruit de différence finie. Il s’agit de l’affirmation la plus forte du message et également de celle qui nécessite le plus une surface Gamma mesurée derrière elle.

Solutions paramétriques. Paramètres du modèle d'alimentation ($\sigma$, $\kappa$, $\theta$) en tant qu'entrées réseau, un PINN permet de couvrir une famille de modèles plutôt qu'un seul étalonnage.

Là où les PINN ont du mal

Coût de formation. Pour une option pour un ensemble de paramètres, une résolution de différences finies est terminée avant qu'un PINN ne termine ses mille premières époques.

Aucune limite d'erreur. Les différences finies avec l'extrapolation de Richardson atteignent la précision machine avec un ordre de convergence connu. Un PINN signale une valeur de perte, qui n'est pas liée à une erreur. Variantes tenant compte de l'incertitude (Bai et al., 2025) attachez des intervalles de confiance, mais le domaine est jeune.

Difficulté d'optimisation. Le paysage des pertes est très non convexe et la pondération entre les termes PDE, frontière et terminaux est un problème de réglage. La défaillance caractéristique est un réseau qui amène le résidu PDE à un niveau proche de zéro tout en ignorant complètement les conditions aux limites – une solution parfaitement valable au mauvais problème.

Reproductibilité. Différentes graines, distributions de colocalisation et paramètres d'optimisation peuvent aboutir à des solutions très différentes. L'assemblage aide et multiplie les coûts.

Ces deux dernières parties de cet article valent le plus la peine d'être transformées en intrigues, car ce sont des modes d'échec que toute personne réimplémentant cela rencontrera.

Ce qui doit encore être mesuré

L'état honnête de cet article : les formulations sont correctes et le code fonctionne, mais rien ici n'a été comparé au matériel de ce bureau ou aux données de ce bureau. La passe qui en ferait un résultat plutôt qu’une dérivation :

1. Sup-norm et RMSE contre Black-Scholes de forme fermée à travers le $(S, t)$ grille, par graine, cinq graines. L'objectif habituel du folklore est l'accord à plus de 4 décimales ; le but est de tester cela à $\sigma = 0.7$, $T = 0.08$ et publiez les graines là où cela échoue.
2. Erreur Delta et Gamma, pas seulement une erreur de prix. Un réseau faisant correspondre les prix à quatre chiffres avec un bruit $\Gamma$ est inutile pour la couverture, donc Gamma est le critère d'acceptation.
3. Temps de formation d'horloge murale et latence d'inférence par option pour un livre de 10 000 options, par rapport à une résolution Crank-Nicolson du problème identique sur le même GPU.
4. Les modes de défaillance, reproduits délibérément. Réduisez la perte de limite jusqu'à ce que le réseau satisfasse la PDE et manque la limite ; exécutez cinq graines et tracez la propagation. Les deux sont peu coûteux à produire et plus utiles qu’une autre surface de prix d’apparence correcte.
5. Ajuster aux cotations réelles de Deribit BTC, ou au minimum conserver les paramètres crypto-réalistes ci-dessus plutôt que de revenir à $\sigma = 0.2$, $T = 1.0$.
6. Les choix d'architecture et d'optimisation sont des résultats et non des conseils. Plus large que plus profond, tanh contre ReLU (la dérivée seconde discontinue de ReLU devrait visiblement détruire le résidu), $\lambda_{\text{IC}}$ les balayages, et Adam-then-L-BFGS contre Adam seul sont toutes des expériences sur une seule ligne. Jusqu'à ce qu'ils soient exécutés, ils sont du folklore répété à partir de la littérature, et cet article refuse de les répéter à titre de recommandations.

Les deux affirmations structurelles qui survivent sans mesure, car ce sont des propriétés de la formulation plutôt que d'une exécution : utiliser des coordonnées log-prix (l'EDP devient un coefficient constant, ce qui est un fait concernant l'algèbre) et pondérer la condition terminale au-dessus du terme de l'EDP (l'EDP homogène admet la solution nulle, ce qui est un fait concernant le problème).

Qu'y a-t-il d'autre

Itinéraires intéressants à connaître, aucun d'entre eux n'a été testé ici :

• Échantillonnage de collocation adaptatif des résidus — placez les points où le résidu est important, près de la direction pour Black-Scholes ou près de la limite Feller pour Heston, plutôt qu'uniformément. La mise en œuvre est courte :

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]

• Transférer l'apprentissage à travers les grèves et les échéances — peaufiner à partir d'un voisin $(K, T)$ au lieu de se former à partir de zéro, de maintenir une bibliothèque couvrant la chaîne d'options.
• Machines d'apprentissage extrêmes basées sur la physique : gèlez les poids cachés, entraînez uniquement la couche de sortie, réduisant ainsi l'entraînement à une résolution linéaire. Moins expressif, mais Black-Scholes est suffisamment de faible dimension pour que cela n'ait pas d'importance.
• Apprentissage de l'opérateur (DeepONet, FNO) — apprenez l'opérateur de la solution plutôt que la solution, cartographie $(\sigma(\cdot), r(\cdot), \text{payoff}(\cdot)) \to V(\cdot,\cdot)$ les nouvelles structures de rémunération n’ont donc pas besoin d’être recyclées. Voir DeepSVM.

Conclusion

Les PINN ne remplacent pas les différences finies ou Monte Carlo. Pour une seule option de faible dimension avec un seul ensemble de paramètres, les différences finies l’emportent et ce n’est pas proche. Le cas des PINN est restreint et spécifique : des modèles de grande dimension dans lesquels les grilles meurent, des solutions paramétriques réutilisées dans un livre et des grecs issus du même passage autodiff que le prix.

Ce que cet article propose, c'est la couche de traduction - comment le partiel mixte de Heston, la frontière libre américaine et l'intégrale de saut de Merton deviennent chacun un terme dans une fonction de perte. Ce qu’il ne fournit pas encore, c’est la preuve que les réseaux qui en résultent sont suffisamment précis pour permettre une couverture. C'est la prochaine passe, et jusqu'à ce qu'elle soit exécutée, traitez tout ce qui précède comme une dérivation plutôt que comme une recommandation.

Références et lectures complémentaires

• Raissi, M., Perdikaris, P., Karniadakis, G.E. (2019). Réseaux de neurones fondés sur la physique : un cadre d'apprentissage en profondeur pour résoudre des problèmes directs et inverses impliquant des équations aux dérivées partielles non linéaires. Journal de physique computationnelle, 378, 686-707. -Dhiman, A., Kaur, D. (2023). Réseau neuronal éclairé par la physique pour la tarification des options. Préimpression arXiv.
• Salvador, B. et coll. (2023). Méthodes sans maillage pour la tarification des options américaines via des réseaux de neurones fondés sur la physique. Analyse technique avec éléments limites. -Bai, G. et al. (2025). Une solution de réseau neuronal tenant compte de l'incertitude et basée sur la physique pour l'équation de Black-Scholes. Préimpression arXiv.
• Chen, Y. et coll. (2025). Le processus de diffusion par saut stochastique a informé les réseaux de neurones pour la tarification des options américaines en cas de pénurie de données. Informatique douce appliquée.
• Benth, FE et al. (2025). DeepSVM : Apprentissage de modèles de volatilité stochastique avec des réseaux d'opérateurs profonds informés par la physique. Préimpression arXiv.
• Lui, Y. et al. (2024). Réseau neuronal informé par la finance : apprendre la géométrie de la tarification des options. Préimpression arXiv. -MathWorks : Réseaux de neurones basés sur la physique (PINN) pour la tarification des options. Blog financier MATLAB, 2025.
• GitHub : BlackScholesPINN (implémentation de PyTorch).
• Dépôt GitHub des PINN Raissi.