💰 quantitative finance

Generating Financial Time Series by Matching Random Convolutional Features

This paper introduces SOCK, a fully differentiable random convolutional feature map that enables generative models to produce realistic financial time series by matching feature representations, thereby outperforming existing signature-based and diffusion baselines in small-sample scenarios.

Original authors: Konrad J. Mueller, Nikita Zozoulenko, Ben Wood, Thomas Cass, Lukas Gonon

Published 2026-06-04

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Konrad J. Mueller, Nikita Zozoulenko, Ben Wood, Thomas Cass, Lukas Gonon

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 master chef trying to teach a robot how to cook a perfect dish. The problem? You only have one single recipe and one single plate of food to show the robot. You don't have a library of thousands of dishes to learn from.

If you try to teach the robot by simply saying, "Make it look exactly like this one plate," the robot will likely just memorize that specific plate. It won't learn the flavor or the texture; it will just copy the picture. This is called "overfitting," and in the world of finance, it's a disaster. If a robot learns to memorize one day's stock market history, it can't predict what might happen tomorrow.

This paper introduces a new way to teach the robot: SOCK.

The Problem: The "Signature" Trap

Previously, scientists tried to teach robots using a method called "Signatures." Think of a signature as a very detailed, mathematical fingerprint of the food's history. It tracks every twist and turn the ingredients took.

The Issue: With only one plate of food, the signature method gets too confused. It tries to memorize the specific crumbs on the plate rather than learning the general taste. It's like trying to recognize a person's face by counting every single freckle on just one photo; if the lighting changes, you can't recognize them anymore.

The Solution: The "SOCK" Method

The authors created a new tool called SOCK (SOft Competing Kernels). To understand how it works, let's use a new analogy: The Blind Taste Test.

Instead of asking the robot to memorize the whole dish, the authors give the robot a set of random, blind taste testers (these are the "random convolutional features").

The Random Testers: Imagine you have a bag of 1,000 different, random flavor probes. Some taste for "spiciness," some for "sweetness," some for "crunch," but they are all slightly different and random.
The Competition: You feed the real dish (the real stock market data) and the robot's fake dish to these testers. The testers don't just say "good" or "bad." Instead, they compete. They ask, "Which dish tastes more like this specific random flavor?"
The "Soft" Vote: In older methods, the testers would shout, "Winner!" (a hard decision). This is like a referee making a sudden call that the robot can't learn from. SOCK uses a "soft" vote. It's like the testers saying, "The real dish was 80% spicy, and the robot's dish was 75% spicy." Because this is a smooth, gradual number, the robot can learn exactly how to adjust its recipe to get closer to the real one.

Why "SOCK" is Special

The paper claims that SOCK is a "superpower" for three main reasons:

It's Differentiable (The Smooth Path): Old random testers (like the "Rocket" method) were like a light switch: on or off. You couldn't smoothly adjust the robot's cooking based on that. SOCK is like a dimmer switch. It gives a smooth signal that tells the robot exactly how to tweak its next move to make the fake data look more real.
It's Random but Reliable: Because the testers are random, the robot can't just memorize one specific test. It has to learn the true essence of the data to pass any random test thrown at it. The paper shows that by constantly changing the testers during training, the robot learns much better.
It Works on "One-Shot" Data: This is the big win. The paper tested this on financial data where they only had one single historical path (like 8 years of daily stock prices). Even with this tiny amount of data, the SOCK-trained robot was better at generating realistic future scenarios than the old "Signature" methods or the newer "Diffusion" methods.

The Results: What Did They Find?

The authors tested their method on two types of challenges:

Generating Fake Data (The Cooking Test):
- They asked the robot to predict future stock prices based on the past.
- Result: The SOCK robot created fake stock paths that looked and behaved almost exactly like the real ones. It captured the "wiggles," the "spikes," and the "long tails" (rare, extreme events) much better than the competition.
- Analogy: If the real stock market is a bumpy rollercoaster, the old robots made a smooth, boring slide. The SOCK robot built a rollercoaster that felt just as thrilling and unpredictable as the real thing.
Telling Real from Fake (The Detective Test):
- They also tested if SOCK was good at spotting the difference between real and fake data (a task called "classification").
- Result: SOCK was a top-tier detective. It could distinguish real time series from fake ones better than almost any other existing method, even though it was designed primarily for making fake data.

The Bottom Line

The paper argues that when you have very little data (like a single history of stock prices), you shouldn't try to memorize the data. Instead, you should use SOCK: a system that uses a constantly changing, random set of "flavor probes" to gently guide a generator toward the truth.

It's like teaching a child to draw a horse not by showing them one perfect picture to copy, but by giving them a thousand different, slightly blurry sketches and asking them to find the common "horse-ness" in all of them. The result is a robot that understands the spirit of the data, not just the pixels.

Technical Summary: Generating Financial Time Series by Matching Random Convolutional Features

Problem Statement
The generation of realistic financial time series is fundamentally challenged by data scarcity. In many financial applications, such as risk estimation or policy optimization, training data is often limited to a single historical path (e.g., eight years of daily trading data yielding ~2,000 points). Under such constraints, adversarial training methods (like GANs) frequently fail due to overfitting, where the discriminator memorizes the limited training samples rather than learning the underlying distribution. While recent non-adversarial approaches train generators to minimize the discrepancy between feature representations of real and generated data, existing methods rely on path signatures. Although theoretically grounded in rough path theory, truncated signatures often fail to capture relevant time series properties at tractable depths, particularly on small-sample classification tasks where random convolutional features (e.g., Rocket, Hydra) have empirically outperformed them. Furthermore, existing random convolutional feature maps are non-differentiable, preventing their direct use in supervising generative model training via gradient descent.

Methodology
The authors propose a framework for conditional time series generation where a generator produces future paths conditioned on the most recent $q$ observations. The core methodology involves training the generator by matching the expected statistics of random convolutional features between real and generated paths.

Objective Function: Instead of a fixed feature map, the generator is trained to minimize the mean squared error between the expected feature vectors of real paths and generated paths, averaged over a distribution of random feature maps:
$\min_\theta \mathbb{E}_{\psi \sim \Pi} \left[ \left\| \mathbb{E}_t [f_\psi(x^-_t \oplus x^+_t)] - \mathbb{E}_{t, \hat{x}^+_t \sim p_\theta} [f_\psi(x^-_t \oplus \hat{x}^+_t)] \right\|^2_2 \right]$
Here, $x^-$ is the conditioning history, $x^+$ is the realized future, and $\hat{x}^+$ is the generated future. The feature map $f_\psi$ is resampled during training to prevent the generator from exploiting a single fixed representation.
SOCK (SOft Competing Kernels): To enable this approach, the authors introduce SOCK, a fully differentiable random convolutional feature map. SOCK adapts the "Hydra" architecture but modifies it for generative modeling:
- Preprocessing: The input path is augmented (e.g., with integrated or differenced paths), normalized, and randomly projected.
- Grouped Random Convolutions: The path is convolved with random kernels across grouped channels. Unlike Hydra's channel-wise kernels, SOCK uses a group width of $W=2$ to capture inter-channel dependencies.
- Differentiable Pooling: Standard Hydra uses non-differentiable operations (argmax/argmin) to count kernel "wins." SOCK replaces this with soft competitions using a softmax function over kernel responses at each time step. The final features are derived from the temporal statistics of these win probabilities (e.g., standard deviation of win probabilities, termed "soft-deviation"), ensuring the entire pipeline is differentiable with respect to the input path.

Key Contributions

Random Convolutional Feature Matching for Conditional Generation: The paper demonstrates that matching random convolutional features is a viable and effective strategy for training conditional generators in low-data regimes, offering an alternative to signature-based matching.
Differentiable Random Features (SOCK): The introduction of SOCK, which bridges the gap between the high expressiveness of random convolutional features and the requirements of gradient-based generative training.
Empirical Validation: The authors provide extensive evaluation on both synthetic and real financial datasets, showing that SOCK-based generators consistently outperform signature-based and diffusion-based baselines.

Results
The authors evaluated their method on five synthetic datasets (spanning autoregressive, skewed, heavy-tailed, and long-memory processes) and seven real financial datasets (covering equities, indices, FX, and crypto).

Generative Fidelity: Generators trained with SOCK features achieved the best average rank (1.49) across all dataset-metric pairs, outperforming randomized signatures (rSig, rank 2.80), truncated signatures (Sig), and Diffusion-TS (DTS).
Specific Metrics: SOCK excelled in reproducing marginal distributions (CVM), autocorrelation structures (including oscillatory and anti-persistent patterns), and tail-risk scenarios (PnL tails). Notably, on the TGH dataset (heavy tails) and FGN (long memory), SOCK significantly outperformed baselines.
Discriminative Tasks: In two-sample hypothesis testing and time series classification (UCR repository), SOCK matched or outperformed existing state-of-the-art feature maps (including Hydra and MultiRocket), validating its expressiveness as a feature extractor.

Significance and Claims
The paper claims that SOCK provides a robust, differentiable alternative to path signatures for training generative models in data-scarce financial environments. By leveraging the empirical success of random convolutional features in classification and adapting them for generation via soft competitions, the method avoids the overfitting pitfalls of adversarial training and the representational limitations of truncated signatures. The authors emphasize that this approach is particularly suited for practical financial applications where only a single historical path is available for training, and future paths must be generated conditionally on recent observations. They note that while the generator architecture used was deliberately simple, the improvements stem primarily from the feature matching strategy. The work suggests that random convolutional feature matching is a promising direction for both generative modeling and discriminative time series analysis.