3.14.4 Deep BSDE & Deep Galerkin Solvers

Basic Prerequisites: 03 · BSDEs & Nonlinear Feynman–Kac and Deep Learning for Sequences.

---

1. Intuition & Practical Objective

Pages 02–03 produced the object: a semi-linear PDE, equivalently a BSDE, whose solution is a pair $(u,\nabla u)$ - the price and the hedge. Page 04 is about computing it when the dimension is too large for a grid and the payoff too non-linear for a closed form. There are two complementary algorithms, and they solve the same equation from opposite ends:

	Deep BSDE (E–Han–Jentzen 2017)	Deep Galerkin / DGM (Sirignano–Spiliopoulos 2018)
what is minimised	the terminal mismatch $\mathbb{E}[(\xi -Y_T^{\theta }{)}^2]$	the PDE residual $\Vert {\partial }_t{u}_{\theta }+L{u}_{\theta }+f(\cdot ){\Vert }^2$ (+ terminal penalty)
how the equation is used	integrated forward along simulated paths	differentiated at sampled collocation points
what the network outputs	$Z_t\approx {\sigma }^{\top }\nabla u$ (the hedge) at each step	$u_{\theta }(t,x)$ (the value) directly
strengths	low dimension per step, hedging-native, no second derivatives	mesh-free, handles free boundaries and irregular domains, gives $u$ everywhere
weaknesses	needs a good $Z$-architecture; pain at the terminal layer	residual needs $u_{xx}$ (second derivatives of a network), harder to train

The one-sentence essence:

Both methods replace the unknown function by a neural network and the equation by a Monte-Carlo loss; Deep BSDE parametrises the control $Z$ and enforces the terminal condition, Deep Galerkin parametrises the value $u$ and enforces the differential equation - and they exist because the classical curse of dimensionality (grid cost $\sim N^d$) is not shared by Monte Carlo or by gradient-based function approximation.

Four things to carry out of this page:

1. The loss is the whole algorithm. Deep BSDE’s loss is only the terminal mismatch - the dynamics are imposed by construction through the forward recursion $Y_{i+1}=Y_i+f\Delta t+Z_i\Delta W_i$. That is why it is often described as “a BSDE solved forward”: there is no residual to estimate, hence no second derivatives, hence no discretisation of a differential operator.
2. The trainable objects are the hedge, not the price. The initial value $Y_0={\theta }_0$ is a single scalar; everything else is $Z_t^{\theta }$. A solver that recovers the price but not the hedge has trained the 1-dimensional part of the problem and failed the infinite-dimensional part (§3 shows the price converging to $0.4\%$ while the hedge needs the same iterations to reach $0.2\%$).
3. Deep BSDE is not inherently “deep”. The “deep” is in the time direction: the network is applied at each of $N$ time steps with shared or step-specific weights, so the composite map is $N$ layers deep. The per-step architecture is often shallow - a linear combination of a few features already reproduces Black–Scholes (§3).
4. Dimension is the motivation. For $d=100$ a finite-difference grid needs $\sim N^{100}$ nodes; the Deep BSDE of Han–Jentzen–E reaches $d=100$ with a handful of networks because the Monte Carlo error is dimension-free and the network represents the function compactly. This is the commercial argument for the method, and it applies to hedging (baskets, multi-factor models) exactly as it applies to pricing.

The practical objective: write down both loss functions, implement the Deep BSDE forward scheme with a from-scratch optimiser, understand why the terminal-mismatch loss contains no differential operator, and know the DGM residual’s shape well enough to sanity-check it.

---

2. Mathematical Ground Truth & Derivations

2.1 The Deep BSDE loss (terminal-mismatch form)

Discretise $[0,T]$ into $N$ steps, $0=t_0<\cdots <t_N=T$, $\Delta t=T/N$, $\Delta W_i=W_{t_{i+1}}-W_{t_i}$. Parametrise

$$Z_i^{\theta }={\phi }_i(X_{t_i};{\theta }_i),Y_0^{\theta }={\theta }_0(\text{a scalar}),$$

and define $Y$ by the forward recursion (this is the whole trick - the backward SDE is turned into a forward one by treating $Y_0$ as the unknown):

$$\boxed{Y_{i+1}^{\theta }=Y_i^{\theta }+f(t_i,Y_i^{\theta },Z_i^{\theta })\Delta t+Z_i^{\theta }\Delta W_i,i=0,\dots ,N-1}$$

and train by the only loss available,

$$\boxed{{\theta }^{\star }=\arg \underset{\theta }{\min }\mathbb{E}\left[\right(\xi -Y_N^{\theta }{)}^2]}$$

(E–Han–Jentzen 2017; E–Han–Jentzen 2018, PNAS). Why this is legitimate:

• The dynamics are exact by construction. Whatever $\theta$ is, the path $(Y_i^{\theta })$ satisfies the discretised BSDE; only the terminal condition $Y_N=\xi$ can fail. Minimising the terminal mismatch therefore forces the discretised solution, and at the optimum $Y_0^{\theta }$ approximates $Y_0$ and $Z_i^{\theta }$ approximates $Z_{t_i}$.
• No derivatives of the network appear. The loss contains no $u_{xx}$; the drift of $Y$ is the driver, which is known. This is why Deep BSDE is easy to train relative to DGM.
• The hedge comes for free. $Z_t={\sigma }^{\top }\nabla u$: the network is the hedge (in diffusive units). Deep BSDE is a hedging algorithm that happens to price.
• Variance reduction is essential. The gradient of the loss is an expectation over paths, so the Monte-Carlo error of the gradient is the training noise; antithetic sampling, common random numbers across iterations and batch-size control are what make it converge (see NM · 04 Variance Reduction).

2.2 The Deep Galerkin loss (residual form)

Parametrise the value directly, $u_{\theta }(t,x)$, and minimise the PDE residual on collocation points plus a terminal penalty,

$$\boxed{\mathcal{L}(\theta )=\underset{\text{interior equation}}{\underbrace{\Vert {\partial }_t{u}_{\theta }+L{u}_{\theta }+f(t,u_{\theta },{\sigma }^{\top }\nabla u_{\theta }){\Vert }_{\text{collocation}}^2}}+\lambda \underset{\text{terminal condition}}{\underbrace{\Vert u_{\theta }(T,\cdot )-g{\Vert }_{\text{boundary}}^2}}}$$

(Sirignano–Spiliopoulos 2018). Because the residual is evaluated by sampling $(\Omega \times [0,T])$, the method needs no mesh - the same reason Monte Carlo beats finite differences in high dimension - but it demands second derivatives of the network ($Lu$ contains ${\nabla }^{2}u$), which are available by autodiff but noisy, and it must be trained to satisfy the terminal condition and the interior simultaneously (a balance that the weight $\lambda$ controls).

2.3 The LSMC baseline (what the networks replace)

Before either method there was least-squares Monte Carlo (Longstaff–Schwartz 2001 for American options; Gobet–Lemor–Warin 2005 for BSDEs):

$${\hat{Y}}_{t_i}=\mathbb{E}[Y_{t_{i+1}}\mid X_{t_i}]+f\Delta t\text{estimated by regressing }{Y}_{t_{i+1}}\text{ on a basis of }{X}_{t_i},{\hat{Z}}_{t_i}=\mathbb{E}\left[Y_{t_{i+1}}\frac{\Delta W_i}{\Delta t}\right|X_{t_i}].$$

The $Z$-estimator is exact for the discretised problem: since $\Delta W_i\perp {\mathcal{F}}_{t_i}$ and $\mathbb{E}[\Delta W_i^2]=\Delta t$, the martingale representation of $Y$ gives $\mathbb{E}[Y_{t_{i+1}}\Delta W_i/\Delta t\mid {\mathcal{F}}_{t_i}]=Z_{t_i}+O(\Delta t)$. The three methods then differ only in the function class used for the conditional expectation:

method	function class for $E[Y_{t_{i+1}}\mid X_{t_i}]$
LSMC (vanilla)	a fixed basis (polynomials, payoff functions)
LSMC + regression trees	trees / boosting (Longstaff–Schwartz’s own suggestion)
Deep BSDE	a neural network, in the time-direction stack
Deep hedging	a neural network, applied to the risk measure over whole paths

This table is the cleanest way to see the whole family: the algorithms differ in what they plug into the regression slot, and in what they regress.

---

3. Computational Implementation - Deep BSDE trained from scratch, and the DGM residual

We implement the Deep BSDE forward scheme with a frozen-feature $Z$-net - a one-hidden-layer network whose nonlinearities are fixed (1, u, u², tanh), leaving only the output weights trainable - so that the exact gradient is available in closed form and full-batch SGD needs no autodiff. That keeps the whole algorithm standard-library. We then verify the DGM residual loss on the same PDE with a one-parameter hypothesis class.

Reading the output.

• The Deep BSDE converges to the right price and the right hedge. Loss falls $161.97\to 16.61$; the price $Y_0$ goes from the initial guess $7.0000$ to $7.9336$ (Black–Scholes $7.9656$, a $0.4\%$ gap) and the hedge from $\delta =0.025$ (a deliberately wrong start) to $0.5408$ (Black–Scholes $0.5398$, $0.2\%$). By iteration $20$ both are essentially converged - the residual gap is the SGD step size, not a bias.
• The floor of the loss is the discretisation, not the optimiser. The loss bottoms out near $16.6$, i.e. an RMS terminal mismatch of $\sqrt{16.6}\approx 4.1$ - the same order as the 4-step discrete-hedging error of 05 · Failure Modes & Practice ($\mathrm{SD}=3.32$ at $N=4$). A Deep BSDE loss that stops decreasing at a positive value is not a bug: it is the model’s own residual. This is the single most misread output of the whole method.
• The DGM residual has the right shape and the right minimiser. The residual loss is $V$-shaped with an interior zero at $\theta =0.200$, exactly the true $\sigma$: the loss drops from $14.17$ ($\theta =0.10$) to $0.137$ ($\theta =0.19$), bottoms at $\theta =0.20$ with residual $2.55\times 10^{-7}$ (finite-difference noise only), and rises again to $9.64$ at $\theta =0.28$. Note the asymmetry: the loss is larger and rises faster on the low-$\theta$ side, because the residual is $\propto ({\sigma }^2-{\theta }^2)$ - a useful reminder that a DGM loss is a quadratic form in the wrong parameter, and the network must find its minimum, not its “flat” region.
• The $Z$-net matters more than the $Y$-scalar. Sixteen of the seventeen trainable parameters sit in the $Z$-net ($4$ time steps $\times 4$ features); the price is one scalar. Everything in the convergence curve after iteration 3 is the hedge being refined. This is the algorithmic counterpart of the LSMC asymmetry of page 03.

---

4. Failure Modes & First-Principles Breakdowns

1. Reading the loss floor as a training failure. As above: a positive terminal-mismatch loss at the optimum is the discretisation residual. The correct diagnostic is whether the loss equals the model’s own $\sqrt{\Delta t}$ hedging error, not whether it reaches zero.
2. Not realising that with $f=0$ the price is pinned by the mean and all the learning is in $Z$. Since $Z_i$ is ${\mathcal{F}}_{t_i}$-measurable and $\Delta W_i$ is independent of ${\mathcal{F}}_{t_i}$, $\mathbb{E}[Z_i\Delta W_i]=0$, so $\mathbb{E}[Y_N^{\theta }]=Y_0^{\theta }$ for any $Z$-net. Minimising $\mathbb{E}[(\xi -Y_N^{\theta }{)}^2]$ then forces $Y_0^{\theta }\to \mathbb{E}[\xi ]$ (the mean-matching condition) and the $Z$-net can only reduce the variance of the mismatch. So in the linear case Deep BSDE is variance-optimal hedging by variance reduction, and a solver that converges to the right price has proved almost nothing about the hedge. (For $f\ne 0$ the driver term breaks the mean-decoupling and $Y_0$ does depend on the strategy - another reason the entropic/quadratic case is genuinely more interesting than Black–Scholes.)
3. Training the price and calling it a hedge. $Y_0$ is one parameter; validate $Z$ against a known hedge - Black–Scholes in the complete-market limit, the BSDE $Z$ in an exactly-solvable case (page 03), or a finite-difference delta of an independently computed price. The price is not evidence about the strategy.
4. Architecture mismatch between the $Z$-net and the true hedge. The hedge is a function of the state; a $Z$-net that does not see the state (e.g. $Z_i$ a per-step constant) can never learn a delta that varies with moneyness. In the hub code the features are $(1,u,u^2,\tanh )$ in $u=X/S_0$ - chosen because the Black–Scholes delta is a smooth sigmoid-like function of $u$. A feature set that cannot represent the true $\nabla u$ produces a bias, not noise.
5. Learning rate as a landmine. 05 · Failure Modes & Practice shows the identical loss and data converging at $\mathrm{lr}=0.30$ and exploding at $1.50$; the stability threshold scales with the largest eigenvalue of the Monte-Carlo design matrix, which grows with the number of paths and the magnitude of the $Z$-features. There is no “safe default” - the learning rate must be tuned per problem, and the loss curve must be watched.
6. Ignoring the SGD noise floor. Full-batch SGD on a Monte-Carlo loss has gradient noise $\propto 1/\sqrt{n_{\text{paths}}}$. Small learning rates stall above the true optimum; large rates bounce around it. The observable is the variance of the loss across the last iterations, not its mean.
7. Using Deep Galerkin where Deep BSDE is appropriate (and vice versa). DGM needs ${\nabla }^2{u}_{\theta }$: for a rough value function (digital payoffs at the money, barriers, early exercise) the second derivative is singular and the residual loss diverges. Deep BSDE integrates along paths and never differentiates the value - better for non-smooth payoffs. Conversely, DGM gives a function $u(t,x)$ for all $(t,x)$ and handles free boundaries naturally, which is why it is the method of choice for American options and PDE formulations.
8. Assuming dimension-freeness means accuracy-freeness. Monte Carlo error is dimension-free in rate, not in constant: for a $d$-dimensional problem the variance of the terminal mismatch grows with $d$ (a basket option has more residual risk), so the path count needed for a fixed accuracy grows. The correct claim is ”$O(n^{-1/2})$ in any dimension”, not “equally accurate in any dimension”.
9. Forgetting the barrier/terminal treatments. Deep BSDE samples paths forward: a barrier or early-exercise feature must be encoded in the terminal condition or in the driver, and a naive implementation prices a different contract. DGM encodes it as a boundary penalty. In both cases the encoding error is silent.

---

5. References

• E, W., Han, J., Jentzen, A. (2017), Deep learning-based numerical methods for high-dimensional parabolic partial differential equations and backward stochastic differential equations, Communications in Mathematics and Statistics 5(4), 349–380
• Sirignano, J. & Spiliopoulos, K. (2018), DGM: a deep learning algorithm for solving partial differential equations, Journal of Computational Physics 375, 1339–1364
• Pham, H., Warin, X., Germain, M. (2020), Neural networks-based backward scheme for fully nonlinear PDEs, SN Partial Differential Equations and Applications 2(16)
• Longstaff, F. & Schwartz, E. (2001), Valuing American options by simulation: a simple least-squares approach, Review of Financial Studies 14(1), 113–147
• Buehler, H., Gonon, L., Teichmann, J., Wood, B. (2019), Deep Hedging, Quantitative Finance 19(8), 1271–1291
• Beck, C., Becker, S., Cheridito, P., Jentzen, A., Neufeld, A. (2019), Deep splitting method for parabolic PDEs; Beck, C., E, W., Jentzen, A. (2019), Machine learning approximation algorithms for high-dimensional fully nonlinear PDEs and second-order BSDEs

---

6. Connected Graph Bridges

• Back: 03 · BSDEs & Nonlinear Feynman–Kac · 02 · Convex Risk & the Objective
• Forward: 05 · Failure Modes & Practice · 06 · Advanced Extensions · Index Hub
• Numerics: Numerical Methods · NM · 03 Monte-Carlo Pricing · NM · 04 Variance Reduction · NM · 04 Numerical Optimization · C&O · 05 Gradient & Newton Methods
• PDE / boundary cases: American Options & Optimal Stopping · American · 04 Free Boundary & Complementarity · NM · 02 Finite-Difference Methods
• ML: Deep Learning for Sequences · Reinforcement Learning for Trading · RL · 04 Policy Gradient & Actor-Critic · Financial ML Pitfalls & Low SNR