Research Review: "Parallel computing in finance for estimating risk-neutral densities through option prices"

Background: The "Research Review" series is a grouping of articles that review scientific publications on the topics of financial modeling, foundation mathematics, and parallel computing. It is meant to enrich the community with technical knowledge and provide clarity on topics that can create distrust in the markets

Paper being review: Ana M. Monteiro, António A.F. Santos, Parallel computing in finance for estimating risk-neutral densities through option prices Journal of Parallel and Distributed Computing, Volume 173, 2023, Pages 61-69, https://doi.org/10.1016/j.jpdc.2022.11.010

Introduction

Estimating options trading spreads is complicated and often very simplistic models are used for their computation efficiency. Adding complexity to the models incur a high computational cost. With developments from the hardware acceleration sector such as GPUS, FPGAs, and ASICS, computational complexity must be revisited and assess the trade offs.

This article demonstrates that the influence on GPU programming should center on aggressively applying massively parallel computing to solve complex, data-intensive optimization bottlenecks that were previously infeasible in sequential environments, particularly within financial modeling and risk management

Content Review

The specific ways this article should influence GPU programming include:

1. Prioritizing Computationally Intractable Problems

GPU programming should focus on turning sophisticated statistical estimation procedures—which are essential for dynamic decision-making but suffer from excessive computational times—into operational methods.

• Solving the Nonparametric Bottleneck:

  • The primary bottleneck addressed is the determination of optimal kernel bandwidths using a Cross-Validation (CV) criterion function in nonparametric estimation of risk-neutral densities (RNDs). In a sequential approach, finding these optimal bandwidth values for the thinner grid could take several days or even exceed two weeks in MATLAB.

    
    

• Enabling Real-Time Financial Analysis:

  • For risk management systems that rely on updated decision streams and need to incorporate intraday data, GPU-accelerated parallel computing is necessary to obtain results within time frames compatible with effective decision processes. Without modern computational techniques, using these statistical models with intraday data is not viable.

    
    

• Addressing Non-Convex Optimization:

  • Since the objective functions (like the CV surfaces) for defining optimal bandwidths are often not convex, gradient-based methods fail [8]. GPU programming should therefore support computationally intensive methods, like grid search optimization, which are required for reliable results in this context.

2. Embracing the "Embarrassingly Parallel" Structure

GPU programming efforts should recognize and exploit the structure of optimization problems that fall under the embarrassingly parallel category.

• Grid Search Parallelization:

  • The grid search used to find optimal bandwidths involves solving an enormous amount of independent sub-optimization problems [10]. For the most complex problem addressed, the algorithm launches $5,898,240$ threads in parallel, each evaluating a unique instance of the `estimCVElements` function (Algorithm 4) .

    
    

• Multi-Layer Parallelization:

  • The grid-search optimization itself constitutes the "outer layer" of the embarrassingly parallel problem, but calculating each grid element requires solving enormous amounts of constrained quadratic programming problems, which must *also* be solved in parallel.

3. Embodying Complex Mathematical Operations in Kernels

A significant influence on GPU programming is the technical necessity of developing code capable of solving complex mathematical problems within the constraints of a GPU thread.

• Kernel-Level Complexity:

  • The breakthrough highlighted is embodying complex mathematical problems, specifically a constrained quadratic programming problem, within the **GPU's basic computing structure, the kernel function**, which runs in a single thread.

    
    

• Code Development and Adaptation:

  • The development required adapting existing public C code (originally for constrained least-squares problems) to solve a constrained quadratic optimization problem, and further adapting this code to run within the NVIDIA® GPU devices using an Object Oriented Programming (OOP) framework.

    
    

• Flexibility and Scale:

  • GPU programming must be prepared to launch millions of complex coded threads, each solving a constrained optimization problem—a procedure that requires the most recent hardware.

4. Utilizing Modern Hardware Architectures

The article strongly encourages GPU programming to target and leverage the capabilities of state-of-the-art hardware.

• NVIDIA Framework Benchmark:

  • GPU code development, such as the CUDA code implemented in the study, should continue to use frameworks like NVIDIA's, which are benchmarks for scientific computing and low-level programming flexibility .

    
    

• Hardware Compatibility:

  • Programmers must utilize platforms like **Pascal, Volta, and Ampere** (such as the NVIDIA Tesla P100, V100, and RTX A5000) because only these recent hardware developments are compatible with the code complexity and big data environments necessary for these financial problems . The use of powerful devices, like the NVIDIA A100, is explicitly noted as capable of substantially reducing computational times further.

In essence, the article demonstrates a successful paradigm shift where GPU computing moves beyond simple parallelism to tackle highly complex optimization problems that integrate sophisticated statistical methods and massive datasets, thus justifying the efforts to develop new computational methods, algorithms, and code.

The optimal bandwidth values, denoted as $h_c$ (for call options) and $h_p$ (for put options), were determined by minimizing a tailored Cross-Validation (CV) criterion function (Equation 23) using a grid-search optimization approach.

These optimal values are crucial for the nonparametric estimation of risk-neutral densities (RNDs) and reflect the appropriate smoothing neighborhood necessary for the estimators. The most precise optimal values were obtained using the densest search area, referred to as the "thinner grid" ($256 \times 256$).

Application Notes

The optimal bandwidth values found for the two datasets (VIX and S&P500) based on the 256 x 256 matrix dimension are:

VIX Index Data

For the VIX index data, where the grid search interval for both $h_c$ and $h_p$ was $[0.75, 2.0]$, the optimal bandwidth values were determined as follows:

| Grid Dimension | Optimal $h_c$ (Call Bandwidth) | Optimal $h_p$ (Put Bandwidth) |

| :---: | :---: | :---: |

| 256 x 256 | 1.377 | 1.078 |

| 128 x 128 | 1.380 | 1.085 |

| 64 x 64 | 1.385 | 1.087 |

| 32 x 32 | 1.395 | 1.073 |

| 16 x 16 | 1.417 | 1.083 |

The minimum of the CV surface for VIX corresponded to **$h_c = 1.377$ and $h_p = 1.078$** .

S&P500 Index Data

For the S&P500 index data, where the grid search interval for both $h_c$ and $h_p$ was $[0.25, 1.25]$ [3], the optimal bandwidth values were determined as follows:

| Grid Dimension | Optimal $h_c$ (Call Bandwidth) | Optimal $h_p$ (Put Bandwidth) |

| :---: | :---: | :---: |

| 256 x 256 | **0.603** | **0.670** |

| 128 x 128 | 0.620 | 0.683 |

| 64 x 64 | 0.615 | 0.679 |

| 32 x 32 | 0.605 | 0.669 |

| 16 x 16 | 0.583 | 0.650 |

The minimum of the CV surface for S&P500 corresponded to **$h_c = 0.603$ and $h_p = 0.670$** .

These bandwidth values were used for the nonparametric estimation of the RNDs depicted in the study's figures. The need to use the computationally intensive grid search to find these values was justified because the objective function (CV surface) for the S&P500 data was shown to be **not convex**, meaning gradient-based optimization algorithms would likely fail to define meaningful results.

Executive Summary

This article's success in accelerating financial modeling demonstrates several critical takeaways that should significantly influence the direction of GPU programming, particularly in scientific computing and large-scale data analytics:

• Prioritize Solving Computationally Intractable Financial Bottlenecks:

  • GPU programming should focus on transforming sophisticated statistical estimation procedures—such as finding optimal kernel bandwidths for nonparametric risk-neutral density (RND) estimation using Cross-Validation (CV)—from infeasible processes into operational methods. Sequential approaches can take several days or even exceed two weeks for accurate results, making online decision-making impossible without GPU acceleration.

    
    

• Embed Complex Optimization within Kernels:

  • A major influence is the demonstration that GPU kernels (the basic computing structure running in a single thread) must be capable of solving **complex mathematical problems**, specifically constrained quadratic programming problems . This requires developing and adapting intricate code, such as the adaptation of public C code within an Object Oriented Programming (OOP) framework for NVIDIA CUDA, to run efficiently on the device.

    
    

• Exploit Multi-Layer Parallelization for Optimization:

  • GPU algorithms must be designed to recognize and leverage "embarrassingly parallel" structures, such as the grid search used for bandwidth selection. This grid search forms the "outer layer" of parallelization, while the calculation of each grid element requires solving enormous amounts of *further* constrained quadratic programming problems, which must also be solved in parallel.

    
    

• Justify Development Effort with Massive Speed-Ups:

  • The substantial computational burden associated with finding optimal bandwidth values justifies the effort to develop new computational methods, algorithms, and code [11, 17]. Empirical results show that parallel computing achieves highly significant run time reductions compared to sequential CPU approaches.

    
    

References

1. Ana M. Monteiro, António A.F. Santos, Parallel Journal of Parallel and Distributed Computing,

   Volume 173, 2023, Pages 61-69, https://doi.org/10.1016/j.jpdc.2022.11.010