🤖 machine learning

A Zeroth-Order Deep Learning Method for Fully Nonlinear Parabolic Partial Differential Equations with Unknown Coefficients

This paper introduces a fully model-free, zeroth-order deep learning method that solves high-dimensional fully nonlinear parabolic PDEs with unknown coefficients by using perturbed Monte Carlo trajectories to estimate derivatives, thereby avoiding the instability of automatic differentiation and the need for explicit dynamics knowledge while providing rigorous non-asymptotic error bounds.

Original authors: Yanwei Jia, Du Ouyang, Huyên Pham, Xun Yu Zhou

Published 2026-06-25

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Yanwei Jia, Du Ouyang, Huyên Pham, Xun Yu Zhou

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to predict the weather, the movement of a stock market, or the flow of traffic in a massive city. In the world of mathematics, these problems are described by complex equations called Partial Differential Equations (PDEs).

Usually, to solve these equations, you need to know the exact "rules of the game" (the coefficients) and you need to calculate how fast things are changing (derivatives). But in the real world, often we don't know the rules. We only have a "Black Box": a machine that takes an input (like "start here") and gives us an output (like "here is where the car ended up"), but we have no idea how it got there.

This paper introduces a new way to solve these "Black Box" math problems using Artificial Intelligence (Deep Learning), specifically designed to handle high-dimensional complexity (many variables at once) without needing to know the underlying rules.

Here is the breakdown of their method using simple analogies:

1. The Problem: The "Guess and Check" Trap

Most current AI methods for solving these equations work like this:

The AI guesses the solution (the weather pattern, the stock price).
It then tries to calculate how fast that solution is changing (the derivative) using a mathematical tool called "automatic differentiation."
The Flaw: If the AI's guess is slightly off, the calculation of the "change" becomes wildly inaccurate. It's like trying to measure the speed of a car by looking at a blurry photo of its position; a tiny blur in the photo leads to a huge error in the speed calculation. In high dimensions, this error explodes, making the solution unstable.

2. The Solution: "Representing-Then-Learning"

The authors propose a completely different strategy called "Representing-Then-Learning."

Instead of guessing the answer and then trying to figure out the speed, they first figure out what the speed should look like using a clever trick, and then teach the AI to match that.

The Analogy: The Blind Taste Test
Imagine you are a chef trying to learn the perfect recipe for a soup, but you can't see the ingredients or the recipe book (the Black Box).

Old Way: You taste the soup, guess the recipe, and then try to calculate how much salt you would have added if you changed the recipe. This is hard and prone to error.
The New Way (ZOD): You take a spoonful of the soup. Then, you take a tiny pinch of salt and add it to a second spoonful. You taste both.
- If the second spoonful tastes much saltier, you know the "sensitivity" to salt is high.
- If it tastes the same, the sensitivity is low.
- You do this by adding tiny amounts of salt (perturbations) and seeing how the taste (the output) changes. You don't need to know the chemical formula of the salt; you just need to observe the change in taste.

In the paper, this is called Zeroth-Order Derivative (ZOD) Estimators. They don't calculate the derivative mathematically; they estimate it by looking at how the output changes when they slightly nudge the input.

3. The Two Types of "Simulators"

To make this work, the paper defines two ways to interact with the Black Box, which they call Simulators:

The Weak Simulator (The Random Dice): Every time you ask the simulator a question, it rolls a new set of dice. If you ask "What happens if I start at point A?" and then "What happens if I start at point A + a tiny bit?", the simulator uses completely different random paths for each. This makes it hard to compare the two results because the "noise" (the dice rolls) is different.
The Strong Simulator (The Fixed Script): This is the "superpower" version. When you ask the two questions above, the simulator uses the exact same random path (the same dice roll) for both, only changing the starting point slightly.
- Why this matters: Because the random noise is identical, when you subtract the two results, the noise cancels out perfectly. You are left with a very clear picture of how the starting point affected the outcome. The paper shows that using this "Strong Simulator" makes the learning much faster and more accurate.

4. The Training Process: Three Brains, One Goal

The AI doesn't just learn the answer (the Value). It trains three separate neural networks simultaneously:

The Value Network: Learns the main answer (e.g., the final stock price).
The Gradient Network: Learns the first derivative (how fast it's changing).
The Hessian Network: Learns the second derivative (how the speed of change is changing).

Instead of asking the Value Network to "figure out" the other two, the system generates "targets" for the Gradient and Hessian networks using the ZOD trick (the taste test analogy). The networks are then trained to match these targets directly.

5. The Results

The authors tested this on difficult math problems that are usually impossible to solve with standard methods because they are too complex (high-dimensional) or the rules are unknown (Black Box).

Accuracy: Their method learned the "speed" (derivatives) much better than traditional methods. In one test, the traditional method was 10 times worse at guessing the second derivative (the Hessian) than their method.
Stability: Because they didn't rely on calculating derivatives from a messy guess, the method didn't crash or become unstable.
Efficiency: They found that having access to the "Strong Simulator" (where the random noise is fixed) made the learning process significantly more efficient.

Summary

Think of this paper as a new way to teach a robot to drive a car in a foggy, unknown city.

Old way: The robot guesses the road, then tries to calculate the steering angle mathematically, often crashing because the math is too sensitive.
New way: The robot gently nudges the steering wheel left and right, observes how the car's path changes, and learns the steering rules directly from those nudges. It does this for the speed and the acceleration simultaneously.

The paper proves mathematically that this "nudge and observe" approach works, even when the city is huge and the rules are a mystery, provided you can run the simulation with a "fixed script" (Strong Simulator) to cancel out the fog.

Technical Summary: Zeroth-Order Deep Learning for Fully Nonlinear Parabolic PDEs with Unknown Coefficients

Problem Statement
The paper addresses the challenge of solving high-dimensional, fully nonlinear parabolic partial differential equations (PDEs) where the underlying operators and coefficient functions are unknown ("black-box"). These equations arise in scientific machine learning, continuous-time reinforcement learning (specifically Hamilton–Jacobi–Bellman equations with unknown parameters), and complex physical systems like fluid turbulence.

Existing deep learning solvers face two primary limitations in this context:

Residual-based methods (e.g., PINNs, Deep Galerkin): These rely on automatic differentiation (auto-diff) to evaluate differential operators. In high dimensions, this leads to optimization instability and the amplification of derivative errors. Furthermore, they typically follow a "learning-then-differentiating" paradigm, where derivatives are computed post-hoc from a learned value function, offering no theoretical guarantee that the derivatives converge to the true values.
Probabilistic methods (e.g., Deep BSDE, DBDP): These exploit stochastic representations (Feynman–Kac formulas) but generally require explicit knowledge of the PDE coefficients to define the underlying stochastic differential equations (SDEs). They are often restricted to PDEs linear in the Hessian and fail for fully nonlinear cases or black-box environments where coefficients are inaccessible.

The authors aim to develop a model-free, data-driven approach that solves these PDEs and simultaneously learns the solution, its gradient, and its Hessian without knowledge of the operator's functional form or its derivatives.

Methodology: Representing-Then-Learning
The proposed method adopts a "representing-then-learning" paradigm, distinct from the conventional "learning-then-differentiating" approach. The core components are:

Simulator Framework: The method assumes access to a "simulator" that generates stochastic trajectories based on the PDE's infinitesimal generator. Two settings are defined:
- Weak Simulator: Returns independent trajectories for each query (i.i.d. Brownian motions).
- Strong Simulator: Returns a family of trajectories driven by the same underlying Brownian motion for a set of initial states (fixed "random seed"). This allows for variance reduction via correlation.
Approximate Value Iteration: The nonlinear PDE is solved via a sequence of linear PDEs. At each iteration $n$ , the nonlinear source term $f$ is evaluated using the current approximations of the value ( $V_n$ ), gradient ( $G_n$ ), and Hessian ( $H_n$ ). This reduces the problem to a policy evaluation task solvable via the Feynman–Kac formula.
Zeroth-Order Derivative (ZOD) Estimators: Instead of computing derivatives via auto-diff, the method constructs stochastic estimators for the gradient and Hessian using only function evaluations at perturbed points.
- One-Point Estimators: Use function values at $x + \epsilon Z$ to estimate derivatives. These are biased but have unbounded variance as the perturbation $\epsilon \to 0$ in the weak simulator setting.
- Multi-Point Estimators: Use symmetric differencing (e.g., $f(x+\epsilon Z) - f(x-\epsilon Z)$ ). In the strong simulator setting, these estimators achieve bounded variance as $\epsilon \to 0$ due to the cancellation of correlated noise, whereas they do not offer this benefit in the weak simulator setting.
Composite Loss Function: The algorithm jointly trains three neural networks ( $V, G, H$ ) to minimize a composite loss:
- Value Loss: Minimizes the mean squared error between the network output and the stochastic reward (terminal condition + integral of source term).
- Derivative Losses: Minimizes the distance between the gradient/Hessian networks and their respective ZOD targets derived from perturbed trajectories. Crucially, the source term $f$ in the reward is evaluated using the explicit outputs of $G$ and $H$ , not their auto-differentiated counterparts.

Key Contributions

Model-Free Framework for Black-Box PDEs: The paper introduces a rigorous framework for solving fully nonlinear PDEs where coefficients are unknown, relying solely on trajectory data from simulators.
ZOD as Learning Targets: It proposes using ZOD estimators as direct targets for training derivative networks. This "representing-then-learning" approach avoids the error propagation inherent in differentiating imperfect value approximations.
Bias-Variance Analysis of ZOD in PDEs: The authors characterize the unique bias-variance tradeoff of ZOD estimators in the context of PDE solving. They demonstrate that while multi-point ZODs reduce variance in optimization, their efficacy in PDE solving is strictly dependent on the availability of a strong simulator to induce correlation between perturbed trajectories.
Theoretical Guarantees in Sobolev Space: The paper provides the first non-asymptotic error analysis for model-free PDE learning in (weighted) Sobolev spaces up to second-order derivatives. The total error is decomposed into:
- Discretization error ( $O(N^{-1})$ ).
- Approximation error (neural network expressivity).
- Statistical error (sample complexity).
- ZOD bias ( $O(\epsilon^4)$ ).
The analysis establishes sample complexity bounds showing that under a strong simulator, the error scales as $O((N^{-1} + P(d)B^{-1/2})^{1/2})$ , whereas under a weak simulator, the scaling is worse due to the $\epsilon^{-4}$ variance blow-up.

Results
Numerical experiments validate the method on linear, semilinear, and fully nonlinear PDEs in moderate to high dimensions (up to $d=20$ ):

Linear PDE (Regression): Compared to a standard "learning-then-differentiating" approach (NN-autodiff), the ZOD method achieved significantly lower errors in gradient and Hessian approximations (outperforming by at least 3x), despite similar value function accuracy. The auto-diff approach failed to capture local peaks and troughs in derivatives.
Semilinear & Fully Nonlinear PDEs: The ZOD method was compared against Deep Picard Iteration (DPI), a state-of-the-art model-based method.
- ZOD converged faster and achieved lower errors in value and gradient.
- Most notably, ZOD drastically outperformed DPI in Hessian accuracy (e.g., reducing Hessian error by an order of magnitude in the fully nonlinear case). This is attributed to the dedicated Hessian network and second-order ZOD objective, whereas DPI relies on double auto-differentiation of the value network.
- The method demonstrated robust performance with the strong simulator, confirming the theoretical advantage of variance reduction.

Significance and Claims
The paper claims to provide a fully model-free algorithm applicable to black-box environments where PDE coefficients are unknown. Its primary significance lies in:

Theoretical Rigor: Establishing convergence and sample complexity for learning solutions and their derivatives up to the second order in Sobolev spaces for fully nonlinear PDEs, a gap in existing literature.
Practical Stability: Demonstrating that explicitly learning derivatives via ZOD targets is more stable and accurate than relying on automatic differentiation of learned value functions, particularly for high-order derivatives.
Simulator Awareness: Highlighting that the efficiency of simulation-based learning is fundamentally tied to the nature of the data-generating mechanism (weak vs. strong simulators), offering a new perspective on algorithm design for scientific machine learning.

The authors note that while the method is model-free regarding the PDE coefficients, it assumes the PDE structure (linear second-order operator plus nonlinear source) is known, and it does not attempt to learn the PDE operator itself (distinguishing it from operator learning approaches).