Extracted main text — title through conclusion, appendix excluded. This is what our citation measures are computed over, published so the extraction can be checked by eye.
59,470 characters · 21 sections · 40 citation commands
Deep self-consistent learning of local volatility
\noindentKeywords: Local volatility, deep self-consistent learning, Dupire PDE.
\baselineskip0.7cm
An option is a financial contract that gives options holders the right but not the obligation to buy (a call option) or to sell (a put option) an asset, e.g. stocks or commodity, for a predetermined price (strike price) on a predetermined date (maturity). To acquire today the right to buy or sell an asset in the future, a premium, namely the option price, must be paid to the option writers. The standard approach to model option prices is based on the Black-Scholes formula, which assumes a constant local volatility surface and therefore applies only to situations where the stock prices process follows a geometric Brownian motion. However, the market price data of underlying assets typically invalidate the assumptions of standard Brownian motion, hence a more sophisticated model than the Black-Scholes formula is required. Among alternatives, we consider an asset price process expressed in a local volatility model as
where $S_t$ denotes the stock price at the time $t \in \mathbb{R}_{+}$, and $(B_t)_{t\in {\mathord{\mathbb R}}_+}$ is a standard Brownian motion. For simplicity, we assume a zero dividend yield and a constant risk-free interest rate $r$. Rather than taking a constant value as in the canonical Black-Scholes equation, in Eq. (ref), the local volatility $\sigma(S_t, t)$ is a deterministic function of the underlying asset price $S_t$ and of time $t$, satisfying the usual Lipschitz conditions. Without introducing additional sources of randomness, the local volatility model is the only complete and consistent model that allows hedging based on solely the underlying asset, cf. Appendix A1 in Bennett14; and it is used for daily risk management in most investment bank production systems.
The practical implementation of such a stochastic volatility model in option pricing requires to solve the challenging problem of calibrating the local volatility function to the market data of option prices. Given $\pi(K,T)$ a family of option prices with strike prices $K>0$, maturities $T>0$, and underlying asset price $S_0=x$, the Dupire formula dupire,derman-kani
brings a solution to this problem by constructing an estimator of the local volatility as a function of strike price $K$ and maturity $T$ values, i.e. Eq. (ref) matches the stock's volatility $\sigma (S_t, t)$ when the underlying stock price $S_t$ is at the level $K$ at time $T=t$.
The numerical estimation of local volatility using Eq. (ref), involves evaluating partial derivatives, which is classically achieved using the finite difference method. More efficient methods have been introduced using spline functions, see e.g. Chapter 8 in Achdou05, where local volatility is first approximated as the sum a piecewise affine function satisfying a boundary condition and a bi-cubic spline function. Then, the model parameters are determined by minimizing the discretized Dupire's equations dupire at selected collocation points via Tikhonov regularization. Thereafter, Tikhonov regularization has been applied to the calibration of local volatility in a trinomial model in Crepey02.
Alternative to calibrating local volatility using parameterized functions, neural networks are known being able to approximate any arbitrary nonlinear function with a finite set of parameters Gorban98,Winkler17,Lin18. By exploiting this property, Chataigner et al. Chataigner20 advocated to parameterize the market option prices $\pi(K, T)$ using neural networks, which allow for the computation of the derivatives in Eq. (ref) by automatic differentiation Baydin17.
In addition, for Dupire's formula to be meaningful, one must ensure that the argument in the square root is positive and remains bounded in (ref), which can be achieved under a no arbitrage condition for the quoted option prices. In Chataigner20, additional constraints are imposed in order to ensure that the market option prices are well fitted, in which case an approximation of derivatives of the option price is then substituted into Eq. (ref) to calibrate the local volatility.
In this case, the quality of the reconstructed local volatility surface depends on the resolution and quality of the quoted market option prices at given strike-maturity pairs. Hence, instead of using market option price, Chataigner et al. Chataigner21 proposed subsequently, to use the implied volatility surface for the calibration of local volatility, leading to an improved performance. It is, however, important to note that, when fitting option prices or implied volatilities using neural networks, one assumes that the data are noise free. Except for those that violate the arbitrage-free conditions, the proposed methods in Chataigner20,Chataigner21 are not able to filter out noises in the data.
In this work, we follow the approach of WangZhe22, and calibrate the local volatility surface from the observed market option prices in a self-consistent manner. Going beyond merely fitting option prices using neural networks, we rely on recent studies on physics-informed machine learning Rassi19,Rackauckas20,Karniadakis21,WangZhe22 which have shown that the inclusion of the residue of an unknown, underlying governing equation as a regularizer can not only calibrate the unknown terms in the governing equations, but also bring correction to the data by filtering out noises that are not characterized by the equation.
For this, we approximate both the market option prices and the squared local volatility using deep neural networks. By requiring $\pi(K, T)$ to be a solution to the Dupire equation subjected to given initial and boundary conditions to be discussed in Section (ref), we regularize $\pi(K, T)$ and determine the unknown $\sigma(K, T)$ self-consistently. Since the resulting $\pi(K, T)$ and $\sigma(K, T)$ are continuous and differentiable functions of $K$ and $T$, we can evaluate Dupire's equation locally on a uniformly sampled $(K, T)$ from the support of Dupire's equation. Unlike previous approaches, where constraints were imposed on fixed strike-maturity pairs, a successive re-sampling enables us to regularize the entire support. In addition, the positiveness of $\sigma(K, T)$ is ensured by a properly selected output activation function of the neural network, hence it is everywhere well defined. Finally, we mitigate the risk of arbitrage opportunities by penalizing a loss as soft constraints. In this way, local volatility is estimated by construction as a smooth surface instead of applying automatic differentiation to neural option prices. In addition, noise in market data is filtered out from the constraint imposed by Dupire's equation. A TensorFlow implementation of our algorithm is available at https://github.com/ameirtheshaa/LocalVolatility.
The rest of the paper is organized as follows. In Section (ref) we review background knowledge on Dupire's equation and arbitrage-free conditions, followed by a comment on market data. After rescaling and reparameterization of market option prices in Section (ref) and a discussion of neural ansatz and loss functions in Section (ref), our deep self-consistent algorithm is summarized and discussed in Section (ref). The proposed method is first tested on synthetic datasets in Section (ref), and then applied to market option prices in Section (ref) where, as an ablation study, we compare our results with those obtained without including the residue of Dupire's equation as a regularizer. Finally, the advantages and limitations of our method are discussed in Section (ref), where conclusions are drawn.
Denoting by $\pi^c(K,T)$ and $\pi^p(K,T)$ the prices for European call and put options
the relation between the market option price and the local volatility is established explicitly by Dupire's equation dupire
subject to the initial conditions
and to the boundary conditions
respectively for call and put options. We refer the reader to Chapter 1 in Itkin20 or Proposition 9.2 in privaultbkf2 for derivations of Dupire's equation, and to Chapter 8 in Achdou05 for a discussion of initial and boundary conditions. From their definitions (ref), we note that the prices of European options are nonnegative, with the prices of call options being always less than the value of the underlying asset; while the prices of the put options being always less than the present value of the strike price, leading to the lower and upper bounds
A static arbitrage is a trading strategy that has zero initial cost and constantly non-negative value afterwards, representing a risk-free profitable investment. Under the assumption that economic agents are rational, arbitrage opportunities, if they ever exist, will be instantaneously exploited until the market is arbitrage free. Therefore, as a prerequisite, the absence of arbitrage opportunities is a fundamental principle underpinning the modern theory of financial asset pricing. An option price surface is free of static arbitrage if and only if
Next, we consider both calendar spread and butterfly arbitrages that can be created with put options as well as call options, cf. Sec. 9.2 in Hull03 for details. Calendar spread arbitrages are created by buying a long-maturity put option and selling a short-maturity put option , and their absence can be characterized in the continuous limit by the condition
On the other hand, butterfly arbitrages can be created by buying two options at prices $K_1$ and $K_3$, with $K_3 > K_1$; and selling two options with a strike price, $K_2 = (K_1 + K_3)/2$. In the continuous limit, the absence of butterfly arbitrage is formulated as
Market option prices are observed on $N$ discrete pairs of strike price and maturity values, leading to triplets $(\pi_i, K_i, T_i)$ with $i = 1, ..., N$. In practice, to secure a transaction, two option prices are quoted in the market, a bid price and an ask price, and there is no guarantee that the mid-price $\pi_i$ between the bid and ask prices is arbitrage-free Ackerer20. Moreover, the observed bid and ask prices may not be updated timely, hence not actionable, leading to additive noise to the market data. Lastly, market option prices are not evenly quoted over a plane spanned by $K$ and $T$: the market data are usually dense close to the money; whereas sparse away from the money. Canonical methods often lack the ability to interpolate option prices and calibrate the associated local volatility without quotes, agilely. Therefore, a validation, a correction, and an interpolation to the market data are required.
Consequently, the main challenge when calibrating the local volatility is twofold. First, given limited observations of unevenly distributed option prices quoted on discrete pairs of strikes and maturities, the calibrated local volatility should span a continuous domain. Second, the corresponding option prices should preclude any arbitrage opportunities. Our objective is, therefore, to construct from observed market option prices a self-consistent approximation for both $\sigma(K,T)$ and $\pi(K,T)$ in the sense that the calibrated local volatility will generate an arbitrage-free option price surface that is in line with the market data up to some physics-informed corrections.
In this section, a change of variable and a rescaling is applied to Dupire's equation (ref) to ensure that the terms in the scaled Eq. (ref) below are of order of unity, so that no term is dominating over the others during the minimization. For this, we use the change of variables
by picking sufficiently large $K_\text{max} = \text{max}(K)$ and $T_\text{max} = \text{max}(T)$. Letting
denote the squared local volatility, the Dupire equation ((ref)) can be rewritten as
subject to the rescaled initial and boundary conditions
for call option prices, and
for put option prices, as well as the inequality constraints (ref). We note the conditions
and
for the absence of strike and calendar arbitrage opportunities respectively, see, e.g. \S2.2.2 of bergomi.
Market option prices are observed at discrete strike-maturity pairs, whereas it is favorable to have an option price and a local volatility that span continuous surfaces over the extended regimes of strike price and maturity. To obtain a continuous limit, we propose to model both the option price and the local volatility using neural networks. The associated neural network ansatz and the corresponding loss functions are detailed below.
As option prices may vary dramatically against strike prices, we model the option price surface as an exponential function where the exponent is approximated using a neural network, whose model parameters $\boldsymbol{\theta}$ are learned from the market data. We consider the neural ansatz
and
for call and put option prices, respectively. At the practical infinity $k=1$ and at $k=0$, the boundary conditions for call (ref) and for put (ref) options are satisfied by construction. Here, a softplus function, $\text{softplus}(x) := \log(1 + e^x)$ is selected to be the activation function at the output layer of neural networks, so that the inequality constraints (ref) are always satisfied.
Unlike for option prices, the variation of local volatility is relatively small, hence we model it using the neural network
with a softplus activation function at the output layer, so that ${\eta}_\theta (k, t)$ is non-negative by construction. By modeling the squared local volatility using a neural network we also ensure the smoothness of local volatility, therefore mitigating numerical instabilities.
Throughout the paper, we use the same neural network architecture for $\mathcal{N}_{c}$, $\mathcal{N}_p$ and $\mathcal{N}_{\eta}$. The network consists of three residual blocks He16, where the residual connection is used around two sub-layers made of $64$ neurons and regularized with batch normalization Ioffe15 per layer. The model parameters of neural networks $\boldsymbol{\theta}_c$ (or $\boldsymbol{\theta}_p$) and $\boldsymbol{\theta}_\eta$ are determined by minimizing properly designed loss functions to be discussed in Section (ref). Since evaluating loss functions associated with the arbitrage-free conditions and with the Dupire equations requires computing successive derivatives, the $\tanh$ activation function is selected for hidden network layers.
Given $N$ market data triplets $(\pi_i, K_i, T_i)$ with $i = 1, ..., N$, we transform $K_i$ and $T_i$ using Eq. (ref), leading to $({\pi}_i, k_i, t_i)$, and consider the following loss functions.
In addition, the initial condition provides reference option prices on collocation points sampled on the line $T=0$, equivalent to the quoted market option prices. A successive re-sampling then covers the entire support domain $\Omega$, ensuring that both the arbitrage-free condition and the Dupire equation are everywhere satisfied. This not only avoids the need to design an adaptive mesh for Dupire's equation as in Achdou05, but also mitigates overfitting that can be due to the uneven distribution of scarce data. Computing loss functions $L_\text{arb}$ and $L_\text{dup}$ involves evaluating differential operators, which is conveniently achieved by automatic differentiation Baydin17.
Finally, the joint minimization of
where $\lambda_\text{ini}, \lambda_\text{arb}, \lambda_\text{dup} \in \mathbb{R}_+$, with respect to $\boldsymbol{\theta}_c$ (or $\boldsymbol{\theta}_p$) brings correction to the observed market data, by filtering out noises that may lead to arbitrage opportunities or violate the price dynamics underpinned by the scaled Dupire's equation. Without loss of generality, we take $\lambda_\text{ini} = \lambda_\text{arb} = 1$, reducing the number of hyper parameters to one: $\lambda_\text{dup} = \lambda \in \mathbb{R}_{+}$.
On the other hand, the minimization of $L_\text{dup}$ with respect to $\boldsymbol{\theta}_\eta$ ensure consistency between the local volatility function estimate and the parameterized option price. In this sense, the proposed method is self-consistent. To assess the robustness of the proposed self-consistent method, various values of $\lambda$ are considered in Section (ref) as an ablation study.
Based on the deep self-consistent learning method discussed above, Algorithm (ref) outlines a computational scheme for the calibration of local volatility. At variance with usual approaches where the derivatives of the option price are first approximated to calibrate the local volatility using Dupire's formula (ref), this algorithm approximates both the option price and the local volatility using neural networks.
The training of neural networks is a non-convex optimization problem which does not guarantee convergence towards the global minimum, hence regularization is required and provided via the residue of the scaled Dupire equation in the term $L_\text{dup}$. The joint minimization of $L_\text{fit}$ arising from the deviation of the parameterized option price to the market data, $L_\text{ini}$ due to the initial conditions, $L_\text{arb}$ linked with the arbitrage-free conditions, and $L_\text{dup}$ seeks a self-consistent pair of approximations for the option price and for the underlying local volatility, and to exclude local minima that violate these constraints.
Moreover, in practice, strike-maturity pairs with quoted option prices are usually unevenly distributed Ackerer20,Chataigner21, hence a direct minimization of loss functions evaluated on the quoted strike-maturity pairs may yield large calibration errors of local volatility at locations where the measurement is scarce. On the other hand, being continuous functions, neural networks allow for a mesh-free discretization of Dupire's equation by uniformly sampling collocation points from $\Omega$ at each iteration, therefore improving calibration from scarce and unevenly distributed data. Lastly, since both option price and squared local volatility are approximated using neural networks, the smoothness of the option price and local volatility surface are guaranteed, while positiveness is ensured by a proper choice of output activation functions. As a result, the numerical instabilities associated with the calibration of local volatility using the Dupire formula (ref) are less likely to occur.
In this section, we test our self-consistent method, first on synthetic option prices in Section (ref), and then on real market data in Section (ref). We start the training with an initial learning rate $10^{-3}$, which is divided by a decaying factor $1.1$ every $2,000$ iterations. On a workstation equipped with an Nvidia RTX 3090 GPU card, each iteration takes less than $0.01$ second. The total number of iterations is capped at $30,000$ such that the overall computational time is compatible with that in Chataigner20,Chataigner21, enabling a fair comparison. Figure (ref) presents a typical graph of loss functions $L_{\rm ini}$, $L_{\rm dup}$ and $L_{\rm arb}$ observed in the following experiments as the number of iterations increases.
Figure (ref) presents a heatmap of the function $f_\text{arb}$, showing the no-arbitrage violations at various collocation points.
Synthetic option prices are generated as Monte Carlo estimates of Eq. (ref) for European call options at given strike-maturity pairs $(K_i, T_i)$. Here, the asset price paths $S_t$ are obtained by simulating the local volatility model (ref) with $r = 0.04$ and
making it possible to assess the validity of the calibrated local volatility by comparison with the closed-form expression of $\sigma(x,t)$. The price trajectories are obtained by simulating Eq. (ref) for $10^6$ times from a single initial condition $S_0 = 1,000$ for the period $t = [0, 1.5]$ and with a time step $\mathrm{d} t = 0.01$.
To begin with, we price European call options on a mesh grid consisting of evenly spaced $10$ points for the $[0.3, 1.5]$ $T$-period and $20$ points in the $[500, 3000]$ $K$-interval, respectively. That is, the dataset consists of $10 \times 20$ option prices quoted at the corresponding strike-maturity pairs, leading to the triplet $(\pi^c_i, K_i, T_i)$ with $i = 1, ..., 200$. The exact local volatility surface, the simulated price trajectories by numerically integrating the local volatility model, and the synthetic call option price surface are visualized in Figure (ref).
After $\boldsymbol{\theta}_{c}$ and $\boldsymbol{\theta}_{\eta}$ are determined, the parameterized option price and calibrated local volatility are recovered from Eqs. (ref) and (ref). Thereafter, we substitute the calibrated neural local volatility into Eq. (ref), forming a neural local volatility model, whose solution, in turn, gives the synthetic stock prices, from which the option price can then be recovered using Monte Carlo estimates of Eq. (ref), completing a control loop for model assessment. The calibrated local volatility, the simulated price trajectory by numerically integrating the neural local volatility model with a pre-sampled sequence of the Brownian motion $(B_t)$, and the relative errors of calibrated local volatility with respect to the exact expression (ref) are shown in Figure (ref).
For $\lambda_\text{dup} = 0$, the parameterized option price is not regularized by a priori physics information encoded in Dupire's equation, reducing the self-consistent calibration of local volatility to a one-way approach. In both cases $(a)$-$(b)$ the parameterized option prices are regularized by the arbitrage-free conditions as in previous works Ackerer20,Chataigner20,Chataigner21. On the other hand, exploiting self-consistency by the inclusion of $L_\text{dup}$ as a regularizer improves significantly the calibrated local volatility surface.
To explore the small data limit of the proposed method, we present in Figure (ref) the calibrated local volatility surface from a scarce dataset consisting of $3 \times 6$ option prices quoted on a linearly spaced grid $(K,T) \in [500, 3000] \times [0.3, 1.5]$.
It is observed that the use of self-consistency effectively compensates for the lack of data, validating the proposed method in the small data limit. Indeed, neural networks are essentially nonlinear functions. Given discrete pairs of inputs and outputs, such a mapping function is not uniquely determined. To ensure that the obtained neural networks can be generalized, one needs to go through the entire domain of definition of neural networks, calling for big data. Alternatively, incorporating a priori physics information, completely or partially known, into the learning scheme can regularize neural networks at places where there is no data, allowing one to benefit from recent advances in deep learning without big data.
To investigate the sensitivity of the proposed method with respect to $\lambda_\text{dup}$, we consider a sequence of values in the range $\lambda_\text{dup} = [0, 4]$. We quantify the accuracy of our self-consistent method by the root mean squared error (RMSE) for the parameterized option price and the RMSE for the calibrated local volatility, which is less relevant due to the non-uniqueness of the solution to such calibration problems. Here, independent of the training dataset, RMSEs are computed on a different testing grid consisting of a linearly spaced $256 \times 256$ collocation points in $[K, T] \in [500, 3000] \times [0.3, 1.5]$. We perform three independent runs for each case and the averaged results are summarized in Table (ref).
It is observed that, when increasing $\lambda_\text{dup}$ from $0$, the RMSEs for the calibrated volatility and the repriced option price first decrease then increase, indicative the existence of an optimal $\lambda_\text{dup}$. The value of optimal $\lambda_\text{dup}$ seems to be dependent on the size of dataset and its determination is out of the scope of this paper, hence left for future work. The decreased RMSEs for any reasonably chosen $\lambda_\text{dup} \neq 0$ support the inclusion of $L_\text{dup}$ for regularizing the parameterized option price. With randomly initialized $\boldsymbol{\theta}_\eta$, the corresponding Dupire equation forms essentially a wrong a priori for the measured data. During the training, a joint minimization of $L_\pi$ with respect to $\boldsymbol{\theta}_c$ and of $L_\text{dup}$ with respect to $\boldsymbol{\theta}_\eta$ yields a self-consistent pair of parameterized option price that provides an optimized description for the measured data, initial and boundary conditions, arbitrage-free conditions, and the underlying Dupire's equation; as well as the calibrated local volatility that matches, upon a physics-informed correction, the price dynamics of the observed data. Assigning a too small weight leads to unregularized parameterization, whereas a large $\lambda_\text{dup}$ slows down the minimization, resulting in an increased calibration error with a fixed number of iterations.
In the case of market option prices, since the exact local volatility is not available, the assessment is performed by computing the reprice error. More specifically, we replace $\sigma(x,t)$ in Eq. (ref) by the calibrated one
and generate synthetic asset price paths via numerically integrating the neural local volatility model. The option is then repriced at given strike-maturity pairs using Monte Carlo estimates of Eq. (ref) and, eventually, compared with the market call (or put) option prices.
To perform a comparison with the literature Crepey02,Chataigner20, we take the daily dataset of DAX index European call options listed on the $7$-th, $8$-th, and $9$-th, August 2001. The spot prices for the underlying assets are $S_0 = 5752.51, 5614.51, 5512.28$, respectively, with $217$, $217$, and $218$ call options quoted at differential strike-maturity pairs and $r = 0.04$. The calibrated local volatility surfaces with and without the inclusion of $L_\text{dup}$ as a regularizer are shown in Figure (ref).
It is observed that, comparing with the case $\lambda_\text{dup} = 0$, the inclusion of $L_\text{dup}$ achieves more stability of the local volatility surfaces over successive days. However, to determine whether the variations that we observe in Figure (ref) $(b)$ are linked with overfitting, we resort to the quantitative analysis below.
As in Chataigner20, we assess the calibration of local volatility by computing the reprice RMSEs and the results are summarized in Table (ref).
Our numerical results are averaged over three independent runs. The unregularized calibration, i.e. $\lambda_\text{dup} = 0$, leads to relatively large reprice RMSEs, evidencing that the observed variations of local volatility surface over successive days in Figure (ref) are indeed due to overfitting. On the other hand, compared with previous works using Tikhonov regularization Crepey02 and with regularizer that impose positiveness and boundedness of the local volatility Chataigner20, the inclusion of $L_\text{dup}$ as a regularizer reduces significantly the reprice RMSEs, leading to the best results. This, therefore, asserts quantitatively the effectiveness of the proposed self-consistent approach.
In our second application to market data, we use the same dataset, i.e. SPX European put options listed on 18th May 2019, as in Chataigner21. The put options are quoted on maturities $T \in [0.055, 2.5]$ and with various strike prices $K \in [1150, 4000]$. Spot price of the underlying is $S_0 = 2859.53$ and $r = 0.023$. Following Chataigner21, the dataset is split into a training dataset and a testing dataset consisting of $1720$ and $1725$ market put option prices, enabling a comparison. The calibrated local volatility surfaces for the cases $\lambda_\text{dup} = 0$ and $\lambda_\text{dup} = 1$, as well as their relative difference are shown in Figure (ref). It is observed that a numerical singularity developed around $K=3000$ for the case $\lambda_\text{dup} = 0$ is suppressed with the inclusion of $L_\text{dup}$ as a regularizer.
Next, on the testing dataset, we evaluate the interpolation and reprice RMSEs of the option prices with and without the inclusion of $L_\text{dup}$ as a regularizer. We then compare our results with published benchmarks obtained using the surface stochastic volatility inspired (SSVI) model, the Gaussian process (GP), as well as the implied volatility (IV) based and price based neural network methods, see Chataigner21 for details. In Table (ref), the RMSEs are evaluated on the testing grid and our results shown are averaged over three independent runs.
With $\lambda_\text{dup} = 1$, our proposed method achieves the lowest reprice RMSEs on the testing dataset, confirming the significance of the proposed self-consistent approach. We note that the Gaussian process, which achieves the lowest interpolation error among all methods, results in the highest reprice RMSEs. This can indicate that the market data of the put option prices contain a significant amount of noise, which may be linked to the singular behavior observed in Figure (ref)$(b)$, leading eventually to the high reprice RMSEs in Table (ref). Consequently, compared with the case $\lambda_\text{dup} = 0$, a simultaneous increase in interpolation RMSE and decrease in reprice RMSEs in the case $\lambda_\text{dup} = 1$ may imply a physics-informed correction to the market data via self-consistency.
In this work, we introduce a deep learning method that yields the parameterized option price and the calibrated local volatility in a self-consistent manner. More specifically, we approximate both the option price and the local volatility using deep neural networks. Self-consistency is established through Dupire's equation in the sense that the parameterized option price from the market data is required to be a solution to the underlying Dupire's equation with the calibrated local volatility. Consequently, by exploiting self-consistency, one not only calibrates the local volatility surface from the market option prices, but also filters out noises in the data that violate Dupire's equation with the calibrated local volatility, going beyond classical inverse problems with regularization.
The proposed method has been tested on both synthetic and market option prices. In all cases, the proposed self-consistent method results in a smooth surface for the calibrated local volatility, with the reprice RMSEs are lower than that obtained either by the canonical methods or the deep learning approaches Crepey02,Achdou05,Chataigner20,Chataigner21. Moreover, the reprice RMSEs are relatively insensitive to the regularization parameter $\lambda_\text{dup} > 0$, showing the robustness of our algorithm. Being continuous functions, the neural networks provide full surfaces for the parameterized option price and for the calibrated local volatility, at variance with discrete nodes using the canonical methods. However, incorporating the residue of Dupire's equation as a regularizer requires one to solve a two-dimensional partial differential equation at each iteration, leading to increased computation time. This drawback, however, can be mitigated by distributing the training task on multiple GPUs.
Although option prices may vary dramatically due to the price dynamics of the underlying assets, it is observed from Figure (ref) that the variation of the local volatility surface over successive days remains small. Therefore, instead of starting from random initial parameters, initiating the training from converged solutions of the previous day can lead to a substantial reduction in computation time, see WangZhe21 for a case study.
Zhe Wang would like to thank supports from Energy Research Institute@NTU, Nanyang Technological University, where part of the work was performed.
\def\polhk#1{\setbox0=\hbox{#1}{\ooalign{\hidewidth \lower1.5ex\hbox{`}\hidewidth\crcr\unhbox0}}} \def\polhk#1{\setbox0=\hbox{#1}{\ooalign{\hidewidth \lower1.5ex\hbox{`}\hidewidth\crcr\unhbox0}}}