🤖 machine learning

High-Quality Synthetic Financial Time-Series using a GAN-Diffusion Framework

This paper introduces CoMeTS-GAN, a quality-aware generative framework that integrates a Conditional GAN with diffusion models to produce high-fidelity synthetic financial time-series by effectively capturing stylized facts and inter-asset correlation structures.

Original authors: Giuseppe Masi, Andrea Coletta, Novella Bartolini

Published 2026-05-27

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Giuseppe Masi, Andrea Coletta, Novella Bartolini

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 a chef trying to teach a robot how to cook a perfect steak. The problem is, you only have a few real steaks to show the robot, and you can't let the robot practice on real meat every time because it might ruin the expensive ingredients. So, you decide to teach the robot to make synthetic steaks—fake ones that look, smell, and taste exactly like the real thing.

In the world of finance, "steaks" are stock market data (prices and trading volumes). Banks and researchers need huge amounts of this data to test their theories, but real data is often locked behind paywalls, privacy laws, or simply doesn't exist for rare, extreme market events.

This paper introduces a new "kitchen" (a computer framework) designed to cook up high-quality synthetic stock market data that is so realistic, it's hard to tell the difference between the fake and the real.

Here is how their "kitchen" works, broken down into simple steps:

1. The Problem: The "Lonely Stock" Mistake

Most previous attempts to fake stock data were like cooking individual ingredients in isolation. They might generate a fake price for Apple and a fake price for Microsoft, but they didn't pay attention to the fact that in the real world, these stocks often move together. If Apple jumps up, Microsoft often jumps up too. If they are generated separately, they might move in opposite directions, which breaks the illusion.

The authors wanted to create a system that understands relationships. If Coca-Cola goes up, Pepsi should probably go up too. If a tech stock crashes, a defensive stock might stay steady.

2. The First Chef: CoMeTS-GAN (The "Taste-Tester")

The authors first built a system called CoMeTS-GAN. Think of this as a two-person team:

The Generator (The Artist): This part tries to paint a picture of the stock market. It starts with random noise and tries to draw a graph that looks like real stock prices and volumes.
The Critic (The Strict Food Critic): This part looks at the painting and says, "Is this real?"

The Secret Sauce:
Usually, the Critic just checks if the lines look smooth. But in this paper, the Critic has a special superpower: it checks the relationships.

It looks at the fake data and calculates: "Do these two stocks move together the way they should?"
If the fake data shows Coca-Cola and Pepsi moving in opposite directions when they should be moving together, the Critic says, "Nope, that's fake!" and sends the Artist back to the drawing board.
This forces the Artist to learn not just how to draw a line, but how to draw a network of connected lines.

3. The Second Chef: The Diffusion Model (The "Sculptor")

The authors then took their strict Critic and gave it a new job. They introduced a second type of AI called a Diffusion Model.

Imagine a Diffusion Model is like a sculptor who starts with a block of noisy, messy clay and slowly chips away the noise to reveal a statue.
Usually, the sculptor works alone. But the authors realized their Critic (from the first step) was an expert at spotting "realism."
So, they let the Critic guide the sculptor. As the sculptor chips away the noise, the Critic whispers, "Hey, make sure these two stocks stay correlated!"
This creates a Quality-Aware Framework. The Diffusion Model does the heavy lifting of creating the data, while the Critic acts as a quality control manager, ensuring the final product respects the complex relationships between different stocks.

4. What Did They Prove?

The authors tested their "kitchen" in several ways:

The "Stylized Facts" Test: Real stock markets have specific quirks (like big price jumps happening more often than math predicts, or prices moving in clusters). Their fake data had all these quirks, just like the real thing.
The "Relationship" Test: They checked if the fake data kept the correct correlations. For example, if Coca-Cola and Pepsi usually move together 94% of the time, their fake data did the same. Other methods failed to keep this link strong.
The "What-If" Test: They asked, "What happens if we suddenly push the price of Coca-Cola up artificially?" Their system correctly adjusted the price of Pepsi to match the real-world reaction, showing it understands how the market reacts to shocks.
The "Big Party" Test: They tried to generate data for 30 different stocks at once (the whole Dow Jones Industrial Average). The system didn't crash; it successfully kept track of all the complex relationships between all 30 stocks simultaneously.

The Bottom Line

This paper presents a new way to generate fake financial data that is lightweight (fast to train) and smart (understands how different stocks influence each other).

By combining a "taste-testing" GAN with a "sculpting" Diffusion Model, and using the Critic to guide the process, they created a tool that can produce endless amounts of realistic market scenarios. This helps researchers and banks test their strategies without needing to risk real money or wait for rare market events to happen naturally.

In short: They built a machine that doesn't just fake stock prices; it fakes the entire ecosystem of the stock market, including how stocks talk to each other.

Technical Summary: High-Quality Synthetic Financial Time-Series using a GAN–Diffusion Framework

Problem Statement
Financial institutions increasingly rely on synthetic data to address data scarcity, privacy constraints, and the need for counterfactual market scenarios. However, existing general-purpose generative architectures struggle to reproduce the specific statistical properties of financial time series, known as "stylized facts" (e.g., fat-tailed distributions, volatility clustering). A critical limitation in current approaches is the failure to accurately model inter-asset correlation dynamics. While some models attempt to learn feature dependencies, they often neglect the simultaneous generation of multiple correlated assets, leading to synthetic data that lacks the realistic correlation structures essential for portfolio risk management and diversification analysis. Furthermore, many existing models are computationally expensive, generate only fixed-length sequences, or fail to capture the joint dynamics of price and volume.

Methodology
The authors propose a quality-aware generative framework that integrates a Conditional Wasserstein Generative Adversarial Network (C-WGAN) with Diffusion Models. The approach is structured in two main phases:

CoMeTS-GAN (Correlated Multivariate Time Series GAN):
- Architecture: The core is a C-WGAN consisting of a Generator ( $G$ ) and a Critic ( $C$ ). The Generator employs a series of temporal convolutional blocks with increasing dilation sizes and a final linear layer to produce multivariate time series (mid-prices and volumes) for $n$ correlated stocks. It utilizes auto-regressive generation to create arbitrarily long sequences.
- Conditioning: The model takes past time steps ( $\mathbf{x}_{past}$ ) and a noise vector ( $\mathbf{z}$ ) as input, augmented with time embeddings derived from sinusoidal positional encodings to capture temporal dynamics.
- Critic Design: The Critic evaluates the realism of generated samples through two distinct outputs:
  - $o_1$ : A standard realness score derived from convolutional and linear layers.
  - $o_2$ : A correlation score computed by a dedicated linear layer that processes the Pearson correlation coefficients of all pairs of mid-prices and volumes ( $\binom{2n}{2}$ pairs).
- Objective: The final Critic score is a weighted sum $o = o_1 + \alpha \cdot o_2$ . This forces the Generator to minimize the Wasserstein distance while explicitly learning to reproduce the cross-correlation structures of the training data.
Critic-Guided Diffusion Generation:
- The trained Critic from CoMeTS-GAN is repurposed as a guidance module for a pre-trained Diffusion Model (specifically DiffTime).
- Mechanism: During the diffusion sampling (denoising) process, the gradient of the Critic's output with respect to the input sample is used to steer the generation. The modified score function is defined as $\tilde{s} = s(\mathbf{x}_t, t) + w \cdot \nabla_{\mathbf{x}_t} D(\mathbf{x}_t)$ , where $w$ modulates the guidance strength.
- Function: This allows the diffusion model to leverage the GAN's learned understanding of correlation realism to enhance the quality of generated samples without retraining the diffusion model itself.

Key Contributions

CoMeTS-GAN Architecture: A lightweight C-WGAN designed specifically for multivariate financial time series that jointly generates prices and volumes. It introduces a novel cross-correlation distance metric within the Critic to enforce realistic inter-asset dependencies.
Critic-Guided Diffusion Strategy: A method to integrate a trained GAN Critic into state-of-the-art diffusion models. The Critic acts as a surrogate classifier, guiding the denoising process to enforce learned correlation structures, thereby creating a quality-aware generation pipeline.
Comprehensive Evaluation: The framework is validated against leading generative models (e.g., TimeGAN, COSCI-GAN, GT-GAN) on both synthetic benchmarks and real stock market data (including the DJIA index).
Counterfactual Simulation: The framework demonstrates the ability to simulate "what-if" scenarios, such as shifting correlation dynamics between assets (e.g., flipping the correlation between Coca-Cola and Pepsi from positive to negative) or reacting to price shocks in a way that preserves inter-asset dependencies.

Results

Stylized Facts: The generated data successfully replicates key financial stylized facts, including fat-tailed return distributions, aggregational normality, the absence of linear autocorrelation in returns, and volatility clustering. It also captures the positive correlation between trading volume and volatility.
Correlation Fidelity: Quantitative analysis using the cross-correlation distance and Wasserstein distance shows that CoMeTS-GAN significantly outperforms general-purpose models (like COSCI-GAN and GT-GAN) in preserving the correlation structures of real stock pairs (e.g., KO-PEP, NVDA-KSU).
Scalability and Efficiency: The model can generate arbitrarily long time series (up to 24 trading days) via auto-regression, a capability many existing models lack. Training is efficient (approx. 4 hours and 20 minutes) compared to complex alternatives like TimeGAN (approx. 39 hours).
Reactivity: In perturbation experiments, the model demonstrated the ability to propagate price shocks across correlated assets, adjusting the generation of non-perturbed stocks to maintain realistic correlation dynamics.
Diffusion Guidance: Applying the Critic as a guide to the DiffTime model substantially reduced the Wasserstein distance between synthetic and real correlation distributions, confirming that the GAN Critic effectively enhances the realism of diffusion-generated data.

Significance
The paper claims that its framework offers a lightweight, responsive solution for realistic stock market simulation that explicitly models inter-asset correlation structures. By combining the speed and domain-specific constraint handling of GANs with the high-fidelity sample quality of Diffusion Models, the authors demonstrate a pathway to generating high-quality synthetic financial data that overcomes the limitations of existing general-purpose architectures. The ability to reuse a trained GAN Critic to guide diffusion models suggests a flexible approach for enhancing generative models in specific domains without the computational cost of retraining large diffusion networks. The work aims to facilitate better risk assessment, portfolio construction, and counterfactual analysis in financial applications where data privacy and scarcity are constraints.