Source-linked AI summary
Deep learning-based numerical methods for high-dimensional parabolic partial differential equations and backward stochastic differential equations
Weinan E, Jiequn Han, Arnulf Jentzen
TL;DR
High-dimensional nonlinear PDEs are difficult because computational complexity can grow exponentially with dimension. The paper proposes a deep BSDE solver that casts the PDE–BSDE relation as a reinforcement-learning problem and approximates the gradient policy with neural networks. Numerical experiments demonstrate the method on 100-dimensional nonlinear PDEs from physics and finance, including Allen-Cahn, Hamilton-Jacobi-Bellman, and financial-derivative pricing models.
Problem
High-dimensional PDEs pose a computational challenge because algorithmic complexity can grow exponentially with dimension.
Method
The method uses the nonlinear Feynman-Kac connection to formulate PDEs as BSDE-based stochastic-control problems, treating the solution gradient as a policy approximated by neural networks.
Results
Numerical experiments illustrate the efficiency and accuracy of the algorithms on several 100-dimensional nonlinear PDEs from physics and finance.
Takeaways & Limitations
The deep BSDE solver provides a practical numerical approach for the paper's high-dimensional nonlinear PDE examples, including Allen-Cahn, Hamilton-Jacobi-Bellman, and financial-derivative pricing models.
Takeaways & Limitations
The presentation restricts the initial derivation to semilinear heat equations, while one reported exact-solution benchmark replaces the exact value with a branching-diffusion estimate.
Abstract
from arXiv · showhide
We propose a new algorithm for solving parabolic partial differential equations (PDEs) and backward stochastic differential equations (BSDEs) in high dimension, by making an analogy between the BSDE and reinforcement learning with the gradient of the solution playing the role of the policy function, and the loss function given by the error between the prescribed terminal condition and the solution of the BSDE. The policy function is then approximated by a neural network, as is done in deep reinforcement learning. Numerical results using TensorFlow illustrate the efficiency and accuracy of the proposed algorithms for several 100-dimensional nonlinear PDEs from physics and finance such as the Allen-Cahn equation, the Hamilton-Jacobi-Bellman equation, and a nonlinear pricing model for financial derivatives.
1 Introduction
High-dimensional PDE algorithms face exponential complexity from the curse of dimensionality, motivating approaches that use deep learning and a PDE–BSDE connection.
- The curse of dimensionality makes algorithmic complexity for PDEs grow exponentially as the number of dimensions increases.
- Existing methods address selected high-dimensional cases, including linear parabolic PDEs, inviscid Hamilton-Jacobi equations, and some nonlinear parabolic PDEs.
- For semilinear heat equations, one prior Feynman-Kac-based method has complexity O(dε^-4), where d is dimension and ε is required accuracy.
- Deep learning has performed effectively on several high-dimensional machine-learning problems, but theoretical support for overcoming the curse of dimensionality is absent.
- The paper formulates high-dimensional PDEs as learning problems by connecting nonlinear parabolic PDEs with BSDEs.
2 Main ideas of the algorithm
The proposed deep BSDE solver reformulates nonlinear parabolic PDEs as stochastic-control and reinforcement-learning problems, then learns the solution gradient with neural networks.
- Nonlinear parabolic PDEs are reformulated through the nonlinear Feynman-Kac formula as stochastic-control problems.
- In the reinforcement-learning analogy, the PDE gradient serves as the policy, while the stochastic process derived from the PDE serves as the value function.
- The policy is approximated with a deep neural network, while approximations of the PDE solution are computed recursively from the learned gradient approximation.
- The presentation uses terminal-value problems, which can be transformed into initial-value problems, and introduces the general solver after a semilinear heat-equation derivation.
- The method minimizes a squared terminal-condition error using stochastic gradient methods to estimate network parameters and approximate u(0, ξ) and its spatial gradient.
3 Details of the algorithm
The general framework discretizes forward stochastic dynamics and supports neural-network gradient approximations alongside multiple stochastic optimization, normalization, and SDE-discretization choices.
- The specific algorithm uses time points 0 = t0 < t1 < . . . < tN = T and plain stochastic gradient descent with constant learning rate γ, without mini-batches or batch normalization.
- The framework defines parameterized processes and update mappings that produce approximations of the PDE and BSDE quantities across discretized time steps.
- The general framework allows different forward-SDE discretizations to be incorporated into the deep BSDE solver.
- It supports stochastic gradient descent with or without mini-batches and Adam with mini-batches as stochastic approximation algorithms.
- Batch normalization can be incorporated through approximated means and standard deviations in the stochastic-process dynamics.
4 Examples for nonlinear partial differential equations (PDEs) and nonlinear backward stochastic differential equations (BSDEs)
The examples apply the deep BSDE solver with neural-network approximations, batch normalization, and Adam mini-batch optimization to high-dimensional nonlinear PDEs. Reported experiments include 100-dimensional Allen–Cahn and HJB problems, with low relative L1-approximation errors achieved in measured runtimes.
- 4 Examples for nonlinear partial differential equations (PDEs) and nonlinear backward stochastic differential equations (BSDEs): The examples use the general deep BSDE solver with Adam optimization and mini-batches containing 64 samples per iteration.Batch normalization is also employed in the neural networks.
- 4 Examples for nonlinear partial differential equations (PDEs) and nonlinear backward stochastic differential equations (BSDEs): Each of the N−1 fully connected networks has four layers, two hidden layers of width d+10, and d-dimensional input and output.Rectifier activations and batch normalization are used after matrix multiplications and before activation.
- 4.2 Allen-Cahn equation: The Allen–Cahn experiment solves a 100-dimensional PDE with cubic nonlinearity and compares solver estimates against a branching-diffusion reference value.The reference value used for u(0,ξ) is 0.052802.
- 4.2 Allen-Cahn equation: 0.0030 relative L1-approximation error is achieved for PDE (35) after 4000 iterations in 595 seconds.The reported approximation is UΘ4000≈u(0,ξ).
5 Appendix A: Special cases of the proposed algorithm
The appendix instantiates the general deep BSDE solver with alternative optimizers, update functions, and state-transition choices. These special cases produce implementable approximations of PDE solutions under suitable further hypotheses.
- The appendix provides special choices for ψ_m, Ψ_m, and Υ within the general deep BSDE solver framework.Examples 5.1–5.4 vary optimization-related functions and the state-transition map.
- Example 5.1: Example 5.1 uses ϱ = ρ, Ψ_m(x, (ϕ_j)_j∈N) = ϕ_1, and ψ_m(x) = γ_m x.
- Example 5.2: The Adam optimizer can be employed in conjunction with the deep BSDE solver.
- Example 5.3: In Example 5.3, U_Θ^m is considered an approximation of u(0,ξ) for sufficiently large m under suitable further hypotheses.
- Example 5.4: Example 5.4 uses the Euler-type transition Υ(s,t,x,w) = x + μ(s,x)(t − s) + σ(s,x)w.Under suitable further hypotheses, U_Θ^m is considered an approximation of u(0,ξ).
6 Appendix B: Python and Matlab source codes
The source-code appendix provides Python/TensorFlow and Matlab implementations of the deep BSDE solver and related numerical methods. The code constructs, trains, evaluates, and records neural-network approximations and comparison estimates.
- Python implementation: The Python implementation defines a fully connected neural-network model and a training routine for the Allen-Cahn deep BSDE solver.
- Python implementation: The network stacks subnetworks across time steps and performs forward updates using simulated state increments and neural outputs.
- Matlab implementations: Matlab code implements a branching diffusion method based on M = 10^7 independent realizations and reports an estimated L2-approximation error.The code also reports the branching estimate and its estimated standard deviation.