🔢 mathematics

Encoded Forward Backward Stochastic Neural Network for High-Dimensional Backward Stochastic Differential Equations and Parabolic Partial Differential Equations

This paper proposes an encoded Forward Backward Stochastic Neural Network (FBSNN) that utilizes tensor-based input encoding and convolutional layers to improve the efficiency and accuracy of solving high-dimensional Backward Stochastic Differential Equations and associated parabolic Partial Differential Equations, as validated by Black-Scholes-Barenblatt and Hamilton-Jacobi-Bellman benchmarks.

Original authors: Zhao Zhang, Zhuopeng Hou

Published 2026-04-29

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Zhao Zhang, Zhuopeng Hou

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 future path of a chaotic storm. In the world of mathematics and finance, this "storm" is represented by something called a Backward Stochastic Differential Equation (BSDE). These equations are incredibly useful for things like pricing complex financial options or managing risk, but they are notoriously difficult to solve, especially when you have to track hundreds of different variables at once (like the price of 100 different stocks simultaneously). This is known as the "curse of dimensionality"—the more variables you add, the harder the problem becomes for traditional computers.

In recent years, scientists have started using Artificial Intelligence (Deep Learning) to solve these problems. Think of a standard AI approach (called "Vanilla FBSNN") as a student trying to learn a massive textbook by reading every single word one by one, line by line. It works, but it's slow and requires a lot of memory to remember every detail.

The New Idea: Turning Data into a Picture

The authors of this paper, Zhao Zhang and Zhuopeng Hou, proposed a clever new way to teach the AI. Instead of feeding the computer a long list of numbers (like a spreadsheet), they decided to encode that data into a format that looks like an image.

Here is the analogy:

The Old Way (Vanilla FBSNN): Imagine trying to describe a city to a friend by listing every street name and building number in a long, boring text file. The friend has to read the whole list to understand the layout.
The New Way (Encoded FBSNN): Instead of a list, you hand your friend a map (an image). They can instantly see the patterns, the neighborhoods, and how the streets connect because their brain (or in this case, a Convolutional Neural Network) is designed to process pictures.

How It Works

Encoding: The researchers take the time (when the event happens) and the space (where the variables are) and wrap them up into a "tensor." Think of this as taking a flat sheet of paper and folding it into a 3D block that has multiple layers (channels), just like a color image has Red, Green, and Blue layers.
The CNN (Convolutional Neural Network): They use a special type of AI brain designed for images (CNNs) to read this "math map." Because CNNs are great at spotting patterns in images (like recognizing a cat in a photo), they are also surprisingly good at spotting patterns in these complex mathematical "maps."
Efficiency: Because the AI can look at the whole "picture" at once and share its learning across the image (a concept called "weight sharing"), it learns much faster and needs fewer "neurons" (brain cells) to get the job done.

The Results: Faster and Smarter

The team tested their new "Encoded FBSNN" against the old "Vanilla" method using two famous, difficult mathematical puzzles:

The Black-Scholes-Barenblatt Equation: A complex model used for pricing financial options when the market is uncertain.
The Hamilton-Jacobi-Bellman Equation: A model used for finding the best strategy in a game of chance with many variables.

What they found:

Speed: The new method reached a high level of accuracy in about one-third of the time (or training steps) it took the old method.
Accuracy: The new method made fewer mistakes. In one test, it was over 40% more accurate; in another, it was more than 100% more accurate than the old method.
Cost: It required less computer power to achieve these results.

The Bottom Line

The paper claims that by simply changing how we feed data into the AI—turning a list of numbers into a structured "image"—we can solve very difficult, high-dimensional math problems much faster and more accurately. It's a simple upgrade to the existing tools that lets modern AI do its job more efficiently, without needing to invent entirely new mathematical theories.

Note: The paper focuses strictly on solving these mathematical equations and does not claim to have applied this to specific clinical treatments or new financial products beyond the benchmark tests mentioned.

1. Problem Statement

The paper addresses the challenge of solving high-dimensional Backward Stochastic Differential Equations (BSDEs) and the corresponding semilinear parabolic Partial Differential Equations (PDEs).

Context: BSDEs provide probabilistic solutions to PDEs via the nonlinear Feynman-Kac formula. However, traditional numerical methods (like finite difference or Monte Carlo) suffer from the "curse of dimensionality," becoming computationally intractable as the spatial dimension increases.
Current Limitations: Recent deep learning approaches, specifically DeepBSDE and FBSNN (Forward Backward Stochastic Neural Network), have shown promise. However, these methods typically rely on Fully Connected Networks (FCNs) where each input dimension (time and space) is represented by a single neuron.
- FCNs often struggle to capture spatial and temporal correlations efficiently in high dimensions.
- They require a large number of trainable parameters, leading to overfitting and slower convergence.
- In some variants (like DeepBSDE), the network must be retrained for different time snapshots, whereas FBSNN shares weights but still uses inefficient FCN structures.

2. Methodology

The authors propose a novel Encoded FBSNN algorithm that replaces standard FCNs with Convolutional Neural Networks (CNNs) by transforming input data into an image-like tensor format.

A. Theoretical Basis

The method solves the decoupled FBSDE system:
$\begin{aligned} dX_t &= \mu(t, X_t)dt + \sigma(t, X_t)dW_t \\ dY_t &= -f(t, X_t, Y_t, Z_t)dt + Z_t dW_t \end{aligned}$
where $Y_t = u(t, X_t)$ and $Z_t = \nabla u(t, X_t)\sigma(t, X_t)$ . The goal is to approximate the function $u(t, x)$ using a neural network $u_\Theta$ .

B. The Encoded FBSNN Algorithm

The core innovation lies in encoding the input $(t, X_t)$ into a tensor structure suitable for CNNs:

Temporal Encoding:
- The scalar time coordinate $t$ is transformed using sine-cosine positional encoding (similar to Transformers).
- This enriches the time-series features, converting $t$ into a vector which is then reshaped into a matrix.
Spatial Encoding:
- The high-dimensional spatial vector $X_t$ (e.g., 100 dimensions) is reshaped into a matrix.
- To increase dimensionality and feature richness, linear interpolation is applied to upsample the matrix (e.g., from $10 \times 10$ to $20 \times 20$ ).
Tensor Construction:
- The encoded time matrix and spatial matrix are concatenated to form a 2-channel tensor (analogous to an RGB image with 2 channels).
- This tensor serves as the input to the CNN.
Network Architecture:
- The model uses a compact CNN structure with two convolutional blocks (involving Conv2d, Batch Normalization, Activation, and Pooling) and a linear output block.
- Advantages: CNNs utilize local connectivity and weight sharing, significantly reducing the number of trainable parameters compared to FCNs. This mitigates overfitting and creates a smoother optimization landscape.
Loss Function:
- The training minimizes a composite loss function:
  $L = \alpha_1 L_{BSDE} + \alpha_2 L_T + \alpha_3 L_G$
- $L_{BSDE}$ : Residual of the discretized BSDE equation (using Euler-Maruyama scheme).
- $L_T$ : Terminal condition error ( $|u(T, X_T) - g(X_T)|^2$ ).
- $L_G$ : Terminal gradient error ( $|\nabla u(T, X_T) - \nabla g(X_T)|^2$ ).
- Gradients are computed via Automatic Differentiation (AD) within the computational graph.

3. Key Contributions

Novel Encoding Strategy: Introduces a method to encode scalar time and high-dimensional spatial vectors into multi-channel tensors, enabling the use of CNNs for BSDE approximation.
Efficiency via CNNs: Demonstrates that CNNs are superior to FCNs for this specific problem type due to parameter efficiency and the ability to capture spatial-temporal correlations.
Balanced Feature Learning: The encoding mechanism ensures that temporal and spatial features are balanced in dimension, preventing the network from biasing toward one type of input.
End-to-End Differentiability: The encoding block is integrated into the computational graph, allowing gradients to flow back through the encoding process during back-propagation.

4. Experimental Results

The algorithm was validated on two high-dimensional benchmark cases (100 dimensions):

A. Black-Scholes-Barenblatt (BSB) Equation

Setup: 50 time steps, 5,000 sample trajectories.
Performance:
- Convergence: Encoded FBSNN reached a lower training loss in ~3,000 epochs, whereas Vanilla FBSNN required ~12,000 epochs.
- Accuracy: Encoded FBSNN achieved a test relative error of 0.61%, compared to 1.03% for Vanilla FBSNN.
- Cost: Encoded FBSNN was faster (16.2 min vs. 21.4 min) and achieved a >40% increase in prediction accuracy.

B. Hamilton–Jacobi–Bellman (HJB) Equation

Setup: Stochastic optimal control problem in 100D.
Performance:
- Convergence: Encoded FBSNN converged significantly faster.
- Accuracy: Encoded FBSNN achieved a test relative error of 0.21%, compared to 0.44% for Vanilla FBSNN.
- Improvement: The encoded method showed >100% increase in accuracy with fewer epochs and lower computational cost.

C. Ablation Study

A "Reshaped FBSNN" (where inputs were simply reshaped without the specific encoding/interpolation) performed worse than the full Encoded FBSNN, confirming that the specific encoding strategy (sine-cosine + interpolation) is crucial for performance.

5. Significance

Scalability: The method offers a scalable solution for high-dimensional PDEs, a critical bottleneck in fields like mathematical finance (option pricing with uncertainty) and stochastic control.
Paradigm Shift: It bridges the gap between image processing techniques (CNNs) and stochastic differential equations, suggesting that treating spatiotemporal data as "images" is a powerful heuristic for solving BSDEs.
Practicality: The algorithm provides a simple yet effective extension to existing FBSNN frameworks, requiring minimal architectural changes (just the encoding layer) while delivering substantial gains in speed and accuracy.
Reproducibility: The authors have made the code publicly available, facilitating further research and application in the field.

In conclusion, the Encoded FBSNN represents a significant advancement in deep learning for scientific computing, proving that leveraging the inductive biases of CNNs through intelligent input encoding can drastically improve the efficiency of solving high-dimensional stochastic problems.