Abstract

WaveGAN is the first end-to-end build of the wavelet-and-GAN idea proposed earlier in this series. Rather than forecasting prices directly in the time domain, it converts each price-derived window into a structured wavelet-history tensor and learns a conditional mapping from an observed tensor to a future one. Across 30-, 60-, and 128-minute horizons on BTCUSDT minute data, the trained model improves substantially over an identity-style baseline in the wavelet domain, with the strongest result at 30 minutes and a clean, interpretable decay as the horizon grows.

This report is the experiment that follows the Trading AI Proposals: it takes that page's premise — that Bitcoin's minute-to-minute change keeps an exploitable, near-invariant structure — and tests whether a conditional GAN can actually learn it. The full generator and discriminator are documented in the Wavelet GAN Trading Prototype; here the focus is the build, the protocol, and the measured results.

Short-horizon financial extrapolation is difficult because the source signal is noisy and shifts across multiple time scales at once. WaveGAN reframes the problem by moving prediction into the wavelet domain rather than asking a network to forecast a future price sequence directly. Each training example pairs an observed wavelet-history tensor with the corresponding future tensor, so the model learns structure across scale and time together.

Mechanically, WaveGAN pairs a dual-tree complex wavelet representation with a conditional generator–discriminator inspired by the pix2pix family of image-to-image translation models: an encoder–decoder generator with skip connections, and a discriminator that pushes the generated future tensor toward the statistics of the target domain. The decisive choice is representational — interleaving real and imaginary coefficient channels and preserving geometry across wavelet levels turns the task into structured conditional translation rather than pointwise regression. The rationale for that representation lives in the proposal, and the layer-by-layer architecture in the prototype; this page does not repeat them.

The study evaluates three prediction lengths — 30, 60, and 128 minutes — on BTCUSDT minute data. The goal is not to claim a complete trading system, but to test whether a conditional GAN can learn a meaningful transformed-domain mapping whose quality degrades in an interpretable way as the forecast range increases.

The experiments use BTCUSDT minute-level data partitioned into weekly shards, then convert raw windows into paired input–output wavelet-history tensors. The default configuration uses a 256-minute window and produces 1000 paired samples for each horizon. Training runs with Adam-based optimization, a batch size of 1, a 20% holdout split, and early stopping on validation RMSE.

• Prediction lengths evaluated: 30, 60, and 128 minutes.
• Framework: MATLAB with Deep Learning Toolbox and Wavelet Toolbox.
• Artifacts generated: checkpoints, evaluation summaries, and report-ready PNG figures.

Each window is transformed through a moving-window complex wavelet pipeline and interpolated to a fixed tensor shape that preserves temporal context, wavelet level, and complex-coefficient structure. The generator can then treat the result as a conditional, image-like input, which is what lets it reason jointly about coarse and local transformed-domain behaviour. The figures below show the structured tensor the network actually receives.

The geometry is not decoration; it is the signal representation that makes transformed-domain extrapolation feasible in the first place.

Because the model predicts future wavelet-history tensors rather than time-domain prices, evaluation is performed in the wavelet domain. Each run saves checkpoints, restores the best validation state, and evaluates on a 20% holdout. A deliberately simple identity-style baseline is computed by treating the observed input tensor as if it were the future tensor — a direct test of whether the model has learned a genuinely future-oriented mapping rather than merely preserving visible structure.

With 1000 generated samples per horizon and a 20% holdout, each experiment evaluates 200 held-out samples, so the reported metrics summarize a full training-and-selection pipeline rather than a single cherry-picked example.

WaveGAN beats the identity baseline at all three horizons, but the task becomes steadily harder as the forecast length grows. The 30-minute experiment is the strongest result; the 128-minute experiment still improves over baseline but with visibly reduced stability and fidelity.

Horizon	Mean RMSE	Median RMSE	Std. RMSE	Baseline RMSE	Improvement
30	0.1885	0.1864	0.0217	0.3828	50.76%
60	0.2432	0.2436	0.0210	0.3916	37.91%
128	0.2799	0.2827	0.0228	0.3722	24.79%

The 30-minute experiment is the strongest case: lowest holdout RMSE, largest gain over baseline, and the cleanest optimization behaviour. The qualitative comparison stays close to the reference structure while the validation curve drops quickly and stabilizes near its best recorded value.

At 60 minutes the model is still clearly better than the carry-forward baseline, but the task is visibly harder: errors broaden, the validation curve settles into a wider plateau, and the prediction is less precise than at 30 minutes. It still captures recognizable transformed-domain structure rather than collapsing to noise or trivial copying.

The 128-minute horizon is the hardest case. The model still improves over the identity baseline — predictive value remains — but the gain is materially smaller and training is less forgiving. This supports the core claim while making its limits explicit: transformed-domain forecasting stays possible, but fidelity drops as the horizon extends.

The experiments support a narrow but defensible claim: recent wavelet-history structure carries enough information for a conditional GAN to predict future tensors better than a naive identity-style baseline. The strongest evidence is the 30-minute case, where both the metrics and the qualitative figures indicate stable transformed-domain learning.

The limits are equally clear. Performance degrades steadily with horizon length, and the 128-minute case is notably less stable than the shorter runs. The representation helps, but it does not erase the underlying difficulty of forecasting a highly variable signal further into the future. Two caveats bound the result: the metrics are single-run point estimates, and a low wavelet-domain RMSE is not yet a claim about time-domain price accuracy — let alone profitability.

• Repeat each experiment across multiple random seeds and report uncertainty intervals rather than single-run point estimates.
• Compare WaveGAN against stronger baselines, including direct convolutional regressors and classical forecasting methods.
• Ablate the representation itself — scaling, holdout construction, tensor layout, and horizon length.
• Add an inverse-transform stage so transformed-domain success can be measured against time-domain forecasting quality.

Several of these were taken up directly in the Wavelet Feature Forecasting Study (Part 4), which rebuilds the comparison with matched baselines, ridge regression, and residual TCNs under fixed chronological splits — and finds that, under those stricter controls, the simple baselines win. Read alongside this report, that later result is a useful corrective: the wavelet-domain gain here is real, but it does not survive a more demanding, leakage-controlled, return-domain evaluation.

1. Load the default configuration and build experiment runs for 30-, 60-, and 128-minute prediction lengths.
2. Generate processed MATLAB datasets from BTCUSDT minute shards if cached data is not already present.
3. Sample raw price-derived windows, compute dual-tree complex wavelet histories, and assemble paired input–output tensors.
4. Train a first-stage conditional GAN for each horizon using grouped convolutions, Adam-based optimization, and combined adversarial and reconstruction losses.
5. Save checkpoints, validation histories, and resolved run configurations for each horizon.
6. Evaluate the best checkpoint on holdout data and compare against the identity-style baseline.
7. Write per-run metrics to an experiment summary and export report-ready figures.