QuantGAN for Financial Time Series

Generating realistic synthetic price paths sounds like a natural fit for GANs, but plugging an off-the-shelf image-generation GAN into return data fails badly: image GANs use ordinary convolutions that treat neighboring pixels symmetrically, with no notion that time only flows one direction. Feed it a return series and it can "peek" at future values while generating the present, and it has no built-in reason to reproduce the specific statistical fingerprints — heavy tails, volatility clustering — that make a return series look financial rather than merely numeric. QuantGAN was built to fix both problems at once.

The analogy: writing a novel versus painting a mural

An image is like a mural — you can dab paint anywhere on the canvas in any order and the final picture doesn't care. A time series is like writing a novel: chapter 10 can only depend on chapters 1 through 9, never the reverse, and reading it out of order changes its meaning entirely. QuantGAN's generator is built from dilated causal convolutions — each output value is only ever a function of past inputs, never future ones — so it generates a path the way a novelist writes: strictly forward, one step building only on what came before.

The architecture: causality plus a widening reach

A causal convolution restricts each layer so that output at time $t$ only sees inputs at times $\le t$. Stacking such layers with dilation — skipping inputs at exponentially increasing steps, $1, 2, 4, 8, \dots$ — lets a stack of just a few layers reach far back in history without needing an equally deep, equally slow ordinary convolution stack:

$$h_t^{(l)} = \sum_{i=0}^{k-1} w_i \, h_{t - i \cdot 2^{l}}^{(l-1)}$$

In words: layer $l$'s output at time $t$ is a weighted sum of past layer outputs spaced $2^l$ steps apart, so as $l$ grows the effective history the network can see grows exponentially, while the number of parameters grows only linearly with depth. The generator and the (Wasserstein) critic are both built this way, applied to preprocessed log-returns rather than raw prices.

Worked example 1: how far back four layers reach

With dilations $2^0, 2^1, 2^2, 2^3 = 1,2,4,8$ and a kernel size of $2$ at each layer, the receptive field (how many past time steps affect one output) is $1 + \sum_l (k-1)\cdot 2^l = 1 + (1)(1+2+4+8) = 16$ steps. Doubling to eight layers, dilations up to $2^7=128$: receptive field $= 1 + (1+2+\dots+128) = 1+255=256$ steps — a 16x increase in reach from doubling the depth, which is exactly the exponential payoff dilation is built for; an ordinary (non-dilated) convolution stack would need 256 layers to match that reach with kernel size 2.

Worked example 2: checking the generated tails against real ones

Suppose real daily log-returns have excess kurtosis $\approx 4.5$ (fatter-than-normal tails; a Gaussian has excess kurtosis $0$), and a first GAN attempt using ordinary (non-causal, non-adversarially-tail-checked) generation produces synthetic returns with excess kurtosis $\approx 0.3$ — nearly Gaussian, a clear failure to reproduce the real market's fat tails. After training with a Wasserstein critic that, given enough samples, naturally penalizes exactly this kind of distributional mismatch, excess kurtosis on synthetic paths rises to $\approx 4.1$ — close to the real value of $4.5$. This kind of before/after kurtosis check (along with autocorrelation of squared returns, the standard fingerprint of volatility clustering) is the standard way QuantGAN output is validated, not visual inspection of a single path.

Compare the smooth paths this simple model produces against real markets: GBM paths have constant volatility and thin (log-normal) tails by construction — exactly the two properties QuantGAN's dilated, adversarially-trained generator is built to break away from, since real markets cluster volatility and fat-tail far more than GBM allows.

What this means in practice

Synthetic paths from QuantGAN-style models are used to stress-test strategies against more scenarios than history alone provides, and to augment training data for models that would otherwise overfit to a short real sample. Because the generator is causal, it can also be used to simulate forward from a real, partially-observed path — continuing a real history synthetically — which a non-causal generator architecturally cannot do.