Differential Machine Learning
apprendre la forme de la fonction de prix, et non seulement ses valeurs

Le problème de l'approximation des fonctions de valorisation

L'objectif du papier est de construire une approximation \( \hat f \) de la fonction de valorisation d'un produit dérivé, capable de fournir le prix et les sensibilités à une vitesse comparable à celle d'une formule fermée, alors que la valorisation exacte nécessite une simulation de Monte-Carlo complète.

Une fonction de valorisation associe à un état \(x\) — comprenant les variables de marché, les variables liées à la trajectoire passée du sous-jacent (path-dependency) et les paramètres du modèle et de l'instrument — une valeur \(f(x)\). Pour des instruments simples valorisés dans des modèles simples, comme un call européen sous Black-Scholes, cette fonction est connue sous forme fermée. En revanche, dès que l'on considère des modèles plus réalistes (volatilité locale, volatilité stochastique, modèles hybrides) et des produits exotiques, la valorisation doit s'effectuer numériquement, le plus souvent par simulation de Monte-Carlo. Cette approche, bien que robuste, présente un coût de calcul élevé qui la rend trop lente pour de nombreux usages.

L'origine du besoin : les calculs réglementaires

Historiquement, le besoin d'approximations rapides provient de la gestion des risques des portefeuilles de produits dérivés. Toutefois, le véritable enjeu moderne réside dans les calculs réglementaires, dont les principaux sont les suivants :

• XVA : ensemble des ajustements de valorisation (CVA pour le risque de défaut de la contrepartie, FVA pour le coût de financement, etc.), dont le calcul exige de connaître la valeur future du portefeuille dans un grand nombre de scénarios de marché ;
• CCR (Counterparty Credit Risk) : mesure de l'exposition au risque de contrepartie, fondée sur la distribution des valeurs futures du portefeuille ;
• FRTB (Fundamental Review of the Trading Book) : cadre réglementaire de calcul du capital pour le risque de marché, qui requiert de nombreuses revalorisations du portefeuille ;
• SIMM-MVA : calcul du coût de la marge initiale sur la durée de vie du portefeuille, qui nécessite non seulement les valeurs futures, mais également les sensibilités futures du portefeuille dans chaque scénario.

Tous ces calculs partagent une même structure : il faut revaloriser un portefeuille entier, et parfois ses sensibilités, dans des milliers de scénarios de marché. Si l'on effectue un Monte-Carlo complet dans chacun de ces scénarios, on aboutit à des simulations imbriquées (nested Monte-Carlo) : pour chaque trajectoire externe représentant un scénario de marché futur, il faut lancer un nouveau paquet de simulations internes afin d'estimer la valeur du portefeuille conditionnellement à ce scénario. Le coût total, proportionnel au produit du nombre de scénarios par le nombre de trajectoires internes, devient rapidement prohibitif.

Deux régimes d'apprentissage distincts

Une solution naturelle consiste à remplacer le Monte-Carlo imbriqué par une approximation \( \hat f \) apprise sur des données simulées, que l'on évalue ensuite quasi instantanément dans chaque scénario. Le papier distingue deux manières très différentes de construire une telle approximation, résumées dans le tableau suivant :

Le cadre d'apprentissage par moindres carrés (LSM)

Cette section présente le cadre théorique sur lequel repose l'ensemble du papier, hérité de la méthode de Longstaff-Schwartz et de Carrière. L'idée fondatrice est qu'un label d'entraînement n'a pas besoin d'être un prix : un payoff simulé sur un seul chemin suffit. En effet, le prix d'un produit dérivé est une espérance conditionnelle, et la régression par moindres carrés estime précisément des espérances conditionnelles.

Construction du jeu de données d'entraînement

On cherche à approximer la fonction de valorisation à une date d'exposition \(T_1 \ge 0\). L'état complet du système à cette date s'écrit \(X_{T_1} = [S_{T_1}, U_{T_1}]\), où \(S_{T_1}\) désigne l'état du modèle (le spot dans le cadre de Black-Scholes ; le couple spot-variance dans le cadre de Heston ; 16 dimensions par devise pour un modèle de Cheyette à 4 facteurs) et \(U_{T_1}\) l'état de la transaction, c'est-à-dire l'ensemble des variables liées à la trajectoire passée : franchissement éventuel d'une barrière, coupons déjà fixés, ou toute variable du script décrivant le produit. Le label associé est le payoff actualisé, échantillonné sur un seul chemin simulé conditionnellement à cet état :

L'ensemble du jeu de données d'entraînement se simule donc pour le coût d'une seule valorisation par Monte-Carlo. Les labels ainsi obtenus sont bruités, puisqu'un unique payoff est une réalisation très dispersée autour du prix. Toutefois, ils sont sans biais :

Justification théorique : le théorème de convergence du LSM

Dans ce cadre, les réseaux de neurones jouent le rôle d'approximateurs universels : ils sont capables, à capacité suffisante, de représenter n'importe quelle fonction continue. Leur intérêt par rapport à la régression polynomiale utilisée dans le LSM classique réside dans leur résistance à la grande dimension. En effet, le nombre de monômes d'une base polynomiale explose de manière combinatoire en \( \binom{n+K}{K} \) avec la dimension \(n\), tandis que les réseaux de neurones apprennent leurs propres fonctions de base au lieu de les fixer a priori. L'approche du papier constitue ainsi l'extension naturelle du LSM au deep learning.

Les labels différentiels : la différentiation pathwise

Cette section présente la proposition centrale du papier : enrichir chaque exemple d'entraînement avec le gradient du label par rapport aux variables d'entrée, calculé le long du même chemin simulé. Ces dérivées trajectorielles, appelées différentielles pathwise, constituent une source d'information supplémentaire quasiment gratuite.

Exemple introductif : le call dans le cadre de Black-Scholes

Considérons le cas le plus simple. L'état est \( x^{(i)} = S^{(i)}_{T_1} \) et le label est le payoff du call sur le chemin \(i\), soit \( y^{(i)} = \big(S^{(i)}_{T_2} - K\big)^+ \). En appliquant la règle de dérivation des fonctions composées le long du chemin (avec \( S_{T_2} = S_{T_1} e^{-\sigma^2\tau/2 + \sigma\sqrt{\tau}\,\varepsilon} \), d'où \( \partial S_{T_2}/\partial S_{T_1} = S_{T_2}/S_{T_1} \)), on obtient :

Deux propriétés générales se dégagent déjà de cet exemple :

1. Efficacité du calcul : la différentielle se calcule pendant la simulation du chemin, par application de la règle de la chaîne, sans nécessiter de nouvelle simulation, contrairement à la méthode des différences finies. Il s'agit d'une différentiation adjointe ; sa version automatisée est l'AAD, présentée dans la partie suivante.
2. Absence de biais : \( \partial Y/\partial X \) est une variable aléatoire mesurable en \(T_2\), dont l'espérance conditionnelle à la date \(T_1\) vaut \( N(d_1) \), c'est-à-dire exactement le delta de Black-Scholes.

Le cas des payoffs discontinus et le lissage

Apport quantitatif de l'augmentation

Avec \(m\) exemples en dimension \(n\), le jeu de données augmenté contient \(m\) valeurs auxquelles s'ajoutent \(n \times m\) différentielles, soit une information considérablement enrichie, pour un surcoût de simulation limité à un facteur de 2 à 5 grâce aux propriétés de l'AAD. Par ailleurs, cette information est d'une nature différente : il s'agit de pentes, et non de points. Le modèle apprend ainsi la forme de la fonction de valorisation, et non plus seulement un nuage de valeurs.

import numpy as np

def simulate_dataset(m, S0=1.0, K=1.1, sigma=0.2, T1=1.0, T2=2.0, seed=0):
    rng = np.random.default_rng(seed)
    # --- etats a T1 : les inputs X (un par exemple) ---
    xi  = rng.standard_normal(m)
    S1  = S0 * np.exp(-0.5*sigma**2*T1 + sigma*np.sqrt(T1)*xi)
    # --- payoffs a T2 : les labels Y (UN chemin par exemple) ---
    tau = T2 - T1
    eps = rng.standard_normal(m)
    S2  = S1 * np.exp(-0.5*sigma**2*tau + sigma*np.sqrt(tau)*eps)
    Y   = np.maximum(S2 - K, 0.0)
    # --- labels differentiels Z = dY/dS1, pathwise (chain rule) ---
    # dY/dS1 = 1{S2>K} * dS2/dS1 = 1{S2>K} * S2/S1
    Z   = np.where(S2 > K, S2 / S1, 0.0)
    return S1.reshape(-1,1), Y.reshape(-1,1), Z.reshape(-1,1)

En production, les différentielles \(Z\) ne sont naturellement pas dérivées à la main : l'AAD les calcule automatiquement, pour des portefeuilles et des modèles arbitraires. C'est l'objet de la partie suivante.

La différentiation automatique adjointe (AAD)

Cette section présente la technique qui rend les labels différentiels quasiment gratuits en pratique. L'Automatic Adjoint Differentiation permet de calculer toutes les dérivées d'un calcul arbitraire, avec une précision analytique, pour un coût constant, c'est-à-dire indépendant du nombre de variables d'entrée.

Introduite en finance par l'article Smoking Adjoints de Giles et Glasserman (Risk, 2006), l'AAD repose exactement sur la même idée que la rétropropagation utilisée pour entraîner les réseaux de neurones, généralisée à un calcul quelconque. Le principe est le suivant : tout calcul peut se décomposer en une succession d'opérations élémentaires (additions, multiplications, fonctions usuelles), formant un graphe de calcul. On évalue d'abord ce graphe dans le sens direct, en mémorisant les résultats intermédiaires, puis on le parcourt en sens inverse en propageant les adjoints \( \bar u = \partial y / \partial u \), c'est-à-dire les dérivées du résultat final par rapport à chaque variable intermédiaire, par application systématique de la règle de la chaîne.

L'application de l'AAD aux simulations de Monte-Carlo

Appliquée à une simulation de Monte-Carlo, l'AAD travaille chemin par chemin, pour des raisons de mémoire et d'efficacité : elle produit les sensibilités du payoff dans chacun des scénarios simulés. Or, un rapport de risque classique n'exploite que la moyenne de ces différentielles pathwise, ce qui revient à écraser une grande partie de l'information disponible. Le differential machine learning exploite au contraire l'information complète : il apprend la valeur et les sensibilités en tant que fonctions de l'état, et non comme des nombres figés correspondant à l'état courant du marché.

import torch

def pathwise_dataset(m, S0=1.0, K=1.1, sigma=0.2, T1=1.0, tau=1.0):
    S1 = S0 * torch.exp(-0.5*sigma**2*T1 + sigma*T1**0.5*torch.randn(m))
    S1.requires_grad_(True)                    # on differencie wrt l'etat a T1
    eps = torch.randn(m)
    S2  = S1 * torch.exp(-0.5*sigma**2*tau + sigma*tau**0.5*eps)
    Y   = torch.clamp(S2 - K, min=0.0)        # payoff (lisse-le si discontinu !)
    # passe adjointe : TOUTES les sensibilites pathwise en une fois
    Z,  = torch.autograd.grad(Y.sum(), S1)     # Z[i] = dY_i / dS1_i
    return S1.detach(), Y.detach(), Z.detach()

L'écriture grad(Y.sum(), S1) est valide car le chemin \(i\) ne dépend que de \(S_1^{(i)}\) : la somme découple les chemins, et chaque composante du gradient correspond bien à une différentielle pathwise individuelle. En production bancaire, l'AAD s'applique directement au code C++ du moteur de valorisation (voir l'ouvrage Modern Computational Finance: AAD and Parallel Simulations, Savine, 2018).

Le réseau jumeau (twin network)

Pour pouvoir entraîner un modèle sur des différentielles, il faut que ce modèle soit capable de prédire des différentielles. Le réseau jumeau rend cette prédiction explicite : il s'agit du réseau d'origine, suivi de son image miroir, c'est-à-dire de sa propre rétropropagation, avec des poids partagés entre les deux moitiés.

Formulation mathématique

La passe avant correspond à un réseau de neurones classique à propagation directe, où \( g \) désigne la fonction d'activation et \( w_l, b_l \) les poids et biais de la couche \(l\) :

La passe arrière s'obtient en différenciant les équations (1) dans l'ordre inverse. On adopte la notation adjointe \( \bar z_l = \partial \hat y / \partial z_l \), et \( \circ \) désigne le produit de Hadamard (produit terme à terme) :

• Coût de calcul : environ deux fois celui d'une prédiction de valeur, quel que soit le nombre de sensibilités. On retrouve la propriété de coût constant de l'AAD, ce qui est naturel puisque la passe arrière du réseau n'est rien d'autre que de l'AAD appliquée au réseau lui-même.
• Contrainte sur l'architecture : pour entraîner le réseau jumeau, il faut rétropropager à travers une rétropropagation, ce qui exige des fonctions d'activation de classe \( C^1 \). La fonction ReLU est donc exclue, sa dérivée étant discontinue ; le papier retient la fonction softplus \( g(u)=\log(1+e^u) \), dont la dérivée est la sigmoïde. Plus généralement, la prédiction de dérivées d'ordre \(q\) requiert des activations de classe \(C^q\).
• La seconde moitié du réseau est activée par \( g' \) et n'introduit aucun paramètre supplémentaire : la cohérence entre les sensibilités prédites et les valeurs prédites est garantie par construction, et non apprise séparément.

import torch
import torch.nn as nn

class PricingNet(nn.Module):
    # architecture du papier : 4 couches cachees de 20 unites softplus
    def __init__(self, n_in, hidden=20, depth=4):
        super().__init__()
        layers, d = [], n_in
        for _ in range(depth):
            layers += [nn.Linear(d, hidden), nn.Softplus()]  # C^1 — jamais ReLU
            d = hidden
        layers += [nn.Linear(d, 1)]
        self.f = nn.Sequential(*layers)

    def forward(self, x):
        return self.f(x)

def twin_forward(net, x):
    """Evalue le reseau jumeau : valeur ET differentielles dy/dx."""
    x = x.requires_grad_(True)
    y = net(x)
    dydx, = torch.autograd.grad(
        y, x, grad_outputs=torch.ones_like(y),
        create_graph=True)   # <-- garde le graphe : on retropropagera
                              #     A TRAVERS cette retropropagation
    return y, dydx

L'argument create_graph=True est le point essentiel de cette implémentation : il rend la passe arrière elle-même différentiable, en l'inscrivant dans le graphe de calcul. L'optimiseur pourra ainsi rétropropager à travers la moitié verte du réseau, c'est-à-dire accumuler des dérivées secondes, sans qu'aucune ligne de code supplémentaire ne soit nécessaire.

La fonction de coût : une régularisation sans biais

Cette section présente les trois stratégies d'entraînement possibles dans ce cadre. La meilleure d'entre elles combine les erreurs sur les valeurs et les erreurs sur les dérivées, et se comporte comme une régularisation d'un genre nouveau, qui n'introduit aucun arbitrage entre biais et variance.

1. Entraînement sur les valeurs seules (deep learning classique)

D'après le théorème du cadre LSM, cette approche converge vers la bonne fonction de prix. Toutefois, la convergence est lente et le modèle surapprend le bruit des payoffs à taille de données finie.

2. Entraînement sur les dérivées seules

Un résultat remarquable mérite d'être souligné : les différentielles pathwise étant des estimateurs sans biais des vraies sensibilités, le même argument de projection \(L^2\) que pour les valeurs s'applique. L'approximation converge alors vers une fonction possédant toutes les bonnes dérivées, c'est-à-dire vers la vraie fonction de valorisation à une constante additive près. Cette constante se recale trivialement en fin d'entraînement, en posant \( c = \frac{1}{m}\sum_i \big( y^{(i)} - \hat f(x^{(i)}) \big) \).

3. Combinaison des deux termes (la version utilisée en production)

La pondération par \( 1/\lVert\bar x_j\rVert^2 \), où \( \lVert\bar x_j\rVert \) désigne la norme de la \(j\)-ième colonne de différentielles sur l'ensemble d'entraînement, permet d'agréger des sensibilités d'ordres de grandeur hétérogènes : chaque sensibilité contribue au coût à sa propre échelle. En pratique, les données sont par ailleurs normalisées, comme il est d'usage en apprentissage automatique : les entrées et les labels sont centrés et réduits, et les différentielles sont remises à l'échelle par le facteur \( \sigma_{x_j}/\sigma_y \).

Une régularisation sans biais

Le terme différentiel joue le rôle d'une pénalité de régularisation, au même titre que les pénalités ridge ou lasso utilisées classiquement pour limiter le surapprentissage. La différence fondamentale est résumée dans le tableau suivant :

def differential_loss(y_pred, y, z_pred, z, lam=1.0):
    mse_y = ((y_pred - y)**2).mean()
    w     = 1.0 / ((z**2).mean(dim=0) + 1e-8)   # ponderation 1/||z_j||^2
    mse_z = (w * (z_pred - z)**2).mean()
    return mse_y + lam * mse_z                      # lam=1 : quasi insensible

net = PricingNet(n_in=1)
opt = torch.optim.Adam(net.parameters(), lr=1e-3)   # + one-cycle LR dans le papier

for epoch in range(100):
    for xb, yb, zb in loader:            # donnees normalisees, mini-batches
        y_hat, z_hat = twin_forward(net, xb)
        loss = differential_loss(y_hat, yb, z_hat, zb)
        opt.zero_grad(); loss.backward(); opt.step()

Démonstration interactive : entraînement comparé des deux réseaux

Cette démonstration entraîne, directement dans le navigateur, deux réseaux strictement identiques (une couche cachée de 24 unités softplus, optimiseur Adam), à partir de la même initialisation et des mêmes données simulées. Le réseau classique n'apprend que sur les payoffs, tandis que le réseau différentiel apprend sur les payoffs et les deltas pathwise. Les résultats peuvent être comparés aux formules fermées de Black-Scholes, qui jouent ici le rôle de valeurs de référence.

Présentation des résultats du papier

Le papier illustre la méthode sur trois exemples de difficulté croissante, avec une architecture constante (4 couches cachées de 20 unités softplus, optimiseur Adam, taux d'apprentissage en cycle unique). Le jeu de données différentiel coûte 2 à 5 fois plus cher à simuler, et le réseau jumeau 2 fois plus cher à entraîner. En contrepartie, les erreurs sont divisées par un facteur de 10 à 100, pour des jeux de données nettement plus petits.

8.1. Option sur panier dans un modèle de Bachelier corrélé (dimension 7)

Le premier exemple est un call de maturité 1 an sur un panier de 7 actifs suivant des dynamiques \( dS_t = \sigma\, dW_t \) corrélées, avec un strike de 110. Il s'agit d'un cas d'école : la formule de Bachelier fournit la valeur exacte de référence, et surtout, le problème de valorisation est intrinsèquement unidimensionnel, puisque seul le niveau du panier détermine le prix. La question posée est donc la suivante : le réseau est-il capable de découvrir cette structure cachée à partir de données en dimension 7 ? Les enseignements sont les suivants :

• Le réseau jumeau entraîné sur 1 024 exemples surpasse le réseau classique entraîné sur 65 536 exemples, à la fois sur les valeurs et, de manière encore plus marquée, sur les deltas.
• La courbe prédite par le réseau jumeau est fine : le modèle a appris que le prix et les deltas sont une fonction déterministe du niveau du panier. Le réseau classique, à l'inverse, prédit des valeurs différentes pour des paniers quasiment identiques, ce qui traduit un surapprentissage des 7 dimensions.
• L'erreur de test du réseau jumeau est du même ordre que l'erreur de Monte-Carlo à nombre de chemins égal : l'objectif consistant à remplacer le Monte-Carlo imbriqué sans perte de précision est donc atteint. Avec 8 millions d'exemples, les deux réseaux convergent vers le même plancher d'erreur, imposé par leur capacité finie ; le réseau jumeau l'atteint cependant des centaines de fois plus rapidement.

8.2. Autocall worst-of sur 4 sous-jacents, volatilités locales corrélées

Le deuxième exemple porte sur un produit réel parmi les plus délicats à traiter : un autocall worst-of, qui cumule path-dépendance, barrières et digitales de grande taille à l'échéance finale, ces dernières étant explicitement lissées (mot-clé choose). La référence est ici un Monte-Carlo imbriqué, par nature très lent. Les données d'entraînement sont générées en environ 0,4 seconde dans Superfly, le système de production de Danske Bank.

8.3. Un netting set réel de Danske Bank

Le dernier exemple constitue le test le plus exigeant : un portefeuille de compensation (netting set) réel composé de swaps, de cross-currency swaps et de swaptions dans 10 devises, éligible aux calculs XVA et CCR. Le modèle utilisé, surnommé le Beast, est un modèle de Cheyette multi-facteurs non gaussien à 4 facteurs par devise, dont la dimension de Markov atteint 16 par devise, soit 169 variables d'entrée en incluant les taux de change, et plus de 1 000 en incluant les variables de path-dépendance. En réalité, la valeur du portefeuille ne dépend que de quelques combinaisons de ces variables, qu'il s'agit de découvrir dans les données. Or, l'extraction de tels facteurs est précisément ce que les labels différentiels facilitent, comme le montre la differential PCA présentée en partie 9.

Extensions de la méthode

Les appendices du papier montrent que le principe des labels différentiels s'étend naturellement à de nombreux contextes. Cette section en présente les principales déclinaisons.

9.1. Sorties multiples : prédiction de la Jacobienne

Lorsque le modèle doit prédire plusieurs valeurs simultanément (par exemple une nappe entière de prix de calls, dans l'esprit des travaux de Horvath et al.), les adjoints deviennent des dérivées directionnelles \( \bar x = \partial(y c^T)/\partial x \). En prenant comme condition au bord de la passe arrière la matrice identité \( \bar z_L = I \in \mathbb{R}^{n_L \times n_L} \), celle-ci produit la Jacobienne complète \( \partial y/\partial x \in \mathbb{R}^{n_L \times n} \). Le coût théorique est multiplié par \(n_L\), mais il se révèle en pratique sous-linéaire sur GPU grâce à la parallélisation des calculs.

9.2. Dérivées d'ordre supérieur : prédiction de la Hessienne

Le réseau jumeau ne « sait » pas qu'il prédit des dérivées : il s'agit pour lui de simples sorties. Rien n'empêche donc de le différencier une seconde fois. Les adjoints des adjoints, \( \bar{\bar x} = \partial(\bar x c^T)/\partial x \), fournissent alors la Hessienne, c'est-à-dire les gammas. Cette extension exige des activations de classe \( C^2 \), condition que satisfait la fonction softplus. Au total, on obtient 1 valeur, \(n\) deltas et \( n(n+1)/2 \) gammas pour un coût d'environ \(2n\) fois celui d'une valeur seule.

9.3. Differential PCA : l'extraction des facteurs de risque à partir des données

L'analyse en composantes principales (PCA) classique orthonormalise les variables d'entrée selon leur variance, mais ignore totalement leur pertinence, c'est-à-dire la manière dont elles affectent le label. Elle ne peut donc réduire la dimension que de manière prudente, au risque de supprimer une direction de faible variance mais de forte influence sur la valeur. L'idée du papier consiste à effectuer la PCA sur les labels différentiels : on recherche la rotation \(Q\) qui rend les dérivées directionnelles orthogonales :

Les vecteurs propres correspondent alors aux axes de pertinence, hiérarchisés : ce sont les facteurs de risque de la transaction. Les valeurs propres mesurent leur importance respective. Il devient ainsi possible de filtrer agressivement les directions associées à des valeurs propres négligeables, sans risque de perte d'information, ce que la PCA classique ne permet pas.

9.4. Differential regression : la régression régularisée sans biais

L'ensemble du cadre s'applique également à la régression linéaire classique sur des fonctions de base fixes \( \phi_j \), avec l'avantage de disposer d'une solution en forme fermée. L'équation normale ajustée s'écrit, en notant \( \phi_j \) la dérivée des fonctions de base par rapport à la \(j\)-ième variable d'entrée et \( \lambda_j = \lambda \lVert Y\rVert^2 / \lVert Z_j\rVert^2 \) :

Stabilisée par décomposition spectrale, cette régression surpasse la régularisation de Tikhonov (ridge), y compris lorsque celle-ci est optimisée par validation croisée, et ce sans consommer de données de validation, sans introduire de biais, et avec une insensibilité quasi totale au paramètre λ.

def differential_regression(phi, dphi, Y, Z, lam=1.0):
    """phi : (m,p) bases ; dphi : liste de n matrices (m,p) = d(phi)/dx_j ;
    Y : (m,) labels ; Z : (m,n) labels differentiels."""
    lam_j = lam * (Y**2).mean() / (Z**2).mean(axis=0)      # equilibrage
    A = phi.T @ phi + sum(lj * dj.T @ dj
                          for lj, dj in zip(lam_j, dphi))
    b = phi.T @ Y   + sum(lj * dj.T @ Z[:, j]
                          for j, (lj, dj) in enumerate(zip(lam_j, dphi)))
    # stabilisation spectrale : on inverse seulement les vp significatives
    D, P = np.linalg.eigh(A)
    Dinv = np.where(D > 1e-8 * D.mean() * len(D), 1.0/D, 0.0)
    return P @ (Dinv * (P.T @ b))

9.5. Architecture wide & deep : des garanties pour la production

L'entraînement d'un réseau de neurones est un problème d'optimisation non convexe : il n'existe aucune garantie d'atteindre le minimum global, ce qui est inacceptable en gestion des risques si le réseau est utilisé seul. Pour pallier cette difficulté, l'architecture wide & deep régresse la sortie à la fois sur la dernière couche cachée du réseau (partie deep, dont les fonctions de base sont apprises) et sur des fonctions de base fixes (partie wide, dans l'esprit du LSM classique). Cette construction fournit une garantie de pire cas : le résultat est au moins aussi bon que celui de la régression classique. C'est cette garantie qui autorise un entraînement entièrement automatique, sans supervision humaine, condition indispensable à un déploiement en production dans le régime online.

Synthèse et préparation de l'exposé

Plan d'exposé suggéré (15 minutes)

Questions probables (jury ou entretien) et éléments de réponse

Points essentiels à retenir

• « The derivatives of a good approximation are not always a good approximation of the derivatives. » Cette citation du papier résume la raison d'être du réseau jumeau.
• Le prix est l'espérance conditionnelle du payoff, et la sensibilité est l'espérance conditionnelle de la différentielle pathwise : deux espérances conditionnelles, deux familles de labels sans biais, et un seul et même cadre d'apprentissage.
• Le differential machine learning s'interprète comme de la data augmentation appliquée à la finance quantitative : on n'impose pas une préférence au modèle, on lui injecte de l'information vraie supplémentaire.

Références

• B. Huge & A. Savine, Differential Machine Learning, arXiv:2005.02347 (2020) — papier + 4 appendices (LSM, Differential PCA, Differential Regression, Wide & Deep) + notebooks TensorFlow.
• M. Giles & P. Glasserman, Smoking Adjoints: fast Monte Carlo Greeks, Risk (2006).
• F. Longstaff & E. Schwartz, Valuing American Options by Simulation (2001) ; J. Carrière (1996).
• A. Savine, Modern Computational Finance: AAD and Parallel Simulations, Wiley (2018).
• B. Huge & A. Savine, Axes that Matter: PCA with a Difference, Risk (2021), arXiv:2503.06707.
• Travaux ultérieurs sur les payoffs discontinus (likelihood ratio / hybrid), arXiv:2512.05301 (2025).