Paper summary: GJR-GARCH neural-network option pricing

Think of GARCH as QuantLib's GARCHModel: each day's variance is a weighted combination of long-run variance, yesterday's squared return, and yesterday's variance. Formally:

sigma^2_t = omega + alpha * epsilon^2_{t-1} + beta * sigma^2_{t-1}

This is symmetric: a +2% return and a -2% return produce the same next-day variance. That contradicts observed equity behaviour, where bad news raises vol more than equally-sized good news ("leverage effect").

GJR-GARCH (Glosten-Jagannathan-Runkle) adds one term:

sigma^2_t = omega + alpha * epsilon^2_{t-1}
                  + gamma * epsilon^2_{t-1} * I{epsilon_{t-1} < 0}
                  + beta * sigma^2_{t-1}

The indicator I{eps < 0} fires only on negative shocks. When gamma > 0, negative returns amplify the next-day variance by an extra gamma * epsilon^2 on top of the symmetric alpha term. This is the discrete-time counterpart of the Heston model's negative correlation parameter (rho < 0): in Heston, price drops and vol spikes are correlated continuously; in GJR-GARCH, the asymmetry is baked into the daily variance update rule.

Innovations are drawn from a skewed Student-t, so the model captures fat tails (nu) and return skewness (lambda) in addition to vol clustering.

The combined persistence coefficient is:

kappa = alpha + beta + gamma * p_minus

where p_minus = E[z^2 * I{z<0}] depends on the shape parameters (nu, lambda). Covariance stationarity requires kappa < 1. As kappa approaches 1 the unconditional variance diverges — this is the hardest corner of the parameter space for the surrogate.

Raw (omega, alpha, gamma, beta, sigma_0^2) contain a scale redundancy. The paper removes this by working in a "Dimensionless Reduced Form" (DRF):

1. Compute unconditional variance v = omega / (1 - kappa).
2. Express every variance in units of v: (sigma_0')^2 = sigma_0^2 / v.
3. Replace omega with 1 - kappa (redundant given alpha, gamma, beta).

The six-dimensional DRF input vector is: (alpha, gamma*p_minus, beta, (sigma_0')^2, nu, lambda).

Terminal returns are further standardised by exact cumulative variance, placing maturities on a common scale. Skipping this normalisation would force the network to learn a scale-dependent function and would produce arbitrage inconsistencies.

Think of the surrogate as a precomputed and interpolated vol surface, but for the full nonlinear GARCH pricing function rather than a flat Black-Scholes grid. Where a vol surface stores (strike, maturity) → implied vol and interpolates between nodes, the MDN stores (GARCH params, maturity) → terminal return density and evaluates it exactly.

The network f_MDN takes (theta_DRF, T) as inputs and outputs the parameters of a Gaussian mixture:

Input:  (alpha, gamma*p_minus, beta, (sigma_0')^2, nu, lambda, T)
           7 scalar inputs, plus engineered features

Network: tapered trunk [512, 256, 128] hidden units, GELU activations
          ~220,000 trainable parameters

Output:  K Gaussian components (paper uses K=128 for best accuracy):
          - weights  w_i  (via softmax over K logits)
          - means    mu_i (linear)
          - std devs sigma_i (via softplus, lower-bounded by sigma_min)

Given the mixture, each component i prices as a standard Black call:

F_i     = F_0 * exp(mu_i' + 0.5 * sigma_i^2)
sigma_i_hat = sigma_i / sqrt(T)
C       = sum_i  w_i * Black(F_i, K, sigma_i_hat, r, T)

A single drift correction delta keeps the mixture mean equal to the risk-free forward (no-arbitrage constraint). Greeks follow analytically from the same sum-of-Black formula.

For a full vol surface (say, 300 option quotes) that is ~1.4 ms CPU or ~0.1 ms GPU.

The MDN is trained once, offline, on a large Monte Carlo dataset:

• 131,000 parameter cases drawn from a Sobol low-discrepancy sequence.
• 10^7 paths per case, 1000 daily steps per path.
• 50-120 maturity samples per case → ~7.5 million (params, maturity, density) triples.
• Stored in quantile format: 512 quantile levels per density curve.
• Published on Hugging Face Hub as simu-ai/garch_densities.

When training data comes from Monte Carlo, there is a fundamental lower bound on training-label quality. For an empirical CDF evaluated over a 512-point quantile grid with N paths, the root-mean-square CDF error cannot be driven below:

L_min = sqrt(1 / (6 * N))

At N = 10^7: L_min = 1.29e-4.

This is a mathematical fact about sampling noise, independent of the model or network. No amount of extra training or larger networks can beat this floor — only more Monte Carlo paths per training case can.

Once capacity bias and coverage variance are driven below label noise, the surrogate is "as accurate as the training data allows."

The best model reaches CDF RMSE = 1.38e-4, a ratio of 1.07 against the floor of 1.29e-4. In absolute option-price terms:

• CDF RMSE of 1.4e-4 translates to sub-basis-point pricing error for most moneyness/maturity combinations.
• The worst regions are near-nonstationary parameters (kappa → 1) and very short maturities (T = 1, 2, 3 days), where 99th-percentile error reaches 4-6× the floor.

The error bound is certified at training time, not at inference time. The guarantee is: if you use this trained network on a parameter vector drawn from the same distribution as the training set, your option price will differ from a 10^7-path Monte Carlo run by no more than approximately 2-3 standard deviations of the noise floor. This is weaker than a worst-case bound but much stronger than typical neural surrogate claims ("we tested on a holdout set").

The direct output is a Gaussian mixture with K components: (w_i, mu_i, sigma_i) for i=1..K. Derived outputs:

1. Sample a distribution of realistic GJR-GARCH parameter vectors — drawn from historical calibrations to real equity or FX data.
2. For each parameter vector, call the MDN to get a full implied-vol surface at the desired strike and maturity grid.
3. Format the output as ORE market data quote keys and populate marketdata.csv (or the in-memory equivalent).

• Speed: a full 10×10 vol surface via matched-accuracy Monte Carlo takes ~480 seconds on single thread. The MDN does the same surface in ~1 ms.
• Consistency: the MDN produces smooth, arbitrage-free surfaces (no calendar spread or butterfly arbitrage from MC noise).
• Differentiability: the MDN is differentiable w.r.t. GARCH parameters, enabling gradient-based scenario design.
• Reproducibility: no random seed management; identical parameters produce identical output.

• The distribution of realistic parameter vectors must be chosen carefully.
• The physical/risk-neutral distinction applies: synthetic surfaces for option pricing must use risk-neutral parameters.