Unlocking the Edge: a Joint Embedder Approach to Volatility Prediction

Realized volatility remains a key ingredient in quantitative research and methods to generate better predictions are the subject of continuous effort, despite the challenges posed by its heavy-tailed nature and dependence on exogeneous input.

We examine recent academic work on realized volatility prediction through machine learning techniques, specifically jointly trained embedder and predictor neural networks that aim to (i) improve prediction accuracy by simultaneously learning an effective latent representation and (ii) provide flexibility in the prediction module by decoupling its architecture from that of the embedder. We compare this approach against some common baselines and incorporate it into the Unbiased Alpha proprietary technology (unba) alongside a simple signal to determine practical utility through a backtest. We use standard allocation, risk management and execution frameworks in the unba platform to complete the backtest set up. We end by considering open issues and directions for further improvement.

Volatility is a key measure of risk, and forecasting it is both practically important and (to some extent) more tractable than forecasting directional returns, because (i) future volatility depends on past volatility (volatility clustering / persistence), and (ii) many volatility models incorporate mean reversion rather than a persistent drift. Realized volatility (computed from high-frequency returns) is especially attractive because it is an observable proxy for latent (conditional / stochastic) volatility, and can be used directly in forecasting, risk budgeting and sizing rules.^[1]^[2]

Aside from a measure of uncertainty, volatility plays a key role across a broad range of investment approaches from conventional spot-driven equity and ETF strategies to structured volatility risk premia trades in options, and even to specialized instruments such as variance swaps that provide direct exposure to realized variance ^[3]. At the same time, realized volatility is challenging to model because its empirical distribution is typically strongly right-skewed and heavy-tailed, while many classical estimation procedures and loss functions behave best under roughly Gaussian residuals (or at least light-tailed errors).

Numerous modelling ideas try to address heavy tails and volatility dynamics, including: (i) stochastic volatility and jump(-diffusion) constructions used widely in derivatives modelling and risk, ^[4]^[5] (ii) self-excitation / endogeneity-based pictures where bursts of activity propagate through market microstructure and order flow, often modelled with Hawkes-type processes and their nonlinear extensions,^[6]^[7]^[8] and (iii) conditional heteroskedasticity models such as ARCH/GARCH and their many variants.^[9]^[10]^[11]

One naive idea when faced with strongly non-Gaussian behaviour is: “why not Gaussianise it!?” Advances in learned Gaussianising transforms through normalizing flows bring this closer to reality by learning an invertible transformation that reshapes the distribution in a data-driven way while keeping likelihood calculations tractable.^[12]^[13]^[14] In addition to this, a key framework is coupled embedder–predictor models where you simultaneously learn a neural-network-based embedding of your variable and a neural-network-based prediction head (ranging from MLP regression to neural ODEs^[15] for multi-horizon predictions). On the representation-learning side, “predict in latent space” architectures (joint-embedding predictive architectures) are being explored as a general pattern for learning useful representations while reducing the need to reconstruct fine-grained signals.^[16] Such approaches are also being evaluated for time-series prediction in finance, such as volatility. A concrete example, and the one we use as a primary focus of our examination, is a co-trained realized volatility forecasting setup where a normalizing flow transformation and an multi-layer perceptron (MLP) parametrisation of a HAR-style predictor are trained jointly, rather than choosing the transform first and the predictor second.^[17] We will implement this joint network as a daughter class of the deep learning models implemented in the unba pltaform, compare performance against a few baselines (LSTM, identity transform with MLP-HAR), and then incorporate it into a simple strategy: volatility-informed mean reversion. The unba platform and ecosystem provides a rich and flexible framework to develop strategies and components, perform backtests in realistic settings including execution timing, risk management and fees. Without going too much into optimising the signal, we will compare performance under “perfect information”, i.e., looking forward to the next day’s volatility directly instead of the forecast, which gives an upper bound on how much relevant performance our volatility-aware decision rule could capture.

Methodology

In terms of working through the implementation of the co-trained neural network (which we refer to as Flow-HAR hereafter), the focus for normalizing flows is the change of variables formula. ^[14]^[13] Let $x$ be a random variable with density $p_{X}$ and define an invertible, differentiable transformation

$[ z = f_theta(x), qquad x = f_theta^{-1}(z), ]$

then the density transforms as

$p_X(x) = p_Z!bigl(f_theta(x)bigr),abs{det bm{J}_{f_theta}(x)},$ $f_theta$

where $𝑱 f θ (x)$ $is the Jacobian of$ $f_{θ}$ at x. Equivalently, in log-space,

$log p_X(x)= log p_Z bigl(f_theta(x)bigr) + log abs{det bm{J}{ftheta}(x)}.$

In one dimension,

$\det 𝑱 f θ (x) = f_{θ}^{'} (x)$

Some linear algebra magic allows us to make Jacobian determinants easy (and cheap) to compute by choosing transformations whose Jacobians are triangular, now standardised through the use of the affine coupling layer.^[14]^[21]
Our running example (and the reference implementation we are borrowing intuition from) treats realized volatility as an observed scalar time series $(σ_{t}^{R V})_{t = 1}^{T}$ and introduces a learned monotone transformation

$z_t = f_theta(sigma^{RV}_t), qquad x_t = f_theta^{-1}(z_t),$

so that the transformed series is more Gaussian and easier to forecast. A concrete formulation is:

$hat z_{t+1} = y_beta(z_{t}),$

$hat sigma^{RV}_{t+1} = f(theta)^{-1}(hat z_{t+1}),$

where $y_{β}$ is the predictor (“head”) with parameters $β.$ This mirrors the co-training setup in^[17], where an HAR predictor is used after the flow transformation. ${\hat{σ}}_{t + 1}^{R V}$ is the predicted realized volatility, the latent representation of which, ${\hat{z}}_{t + 1}$ , is obtained from history and possibly conditioned on other input.

Latent state interpretation
Here, $z_{t}$ plays the role of a latent state: it is intended to be a better-behaved coordinate system for volatility dynamics, allowing the predictor to operate in a space where residuals are closer to homoscedastic Gaussian noise. In representation-learning language, $f (θ)$ is an embedder and $y_{β}$ is a predictor. Unlike typical “dimensionality reduction” embeddings, a normalizing flow is invertible and (dimension-preserving) information-lossless in principle, which can be attractive when we want to forecast and then map predictions back to the original scale.^[17]^[13]
The built-in prevention of the collapse of the latent representation to a constant, a common failure mode in some self-supervised approaches, is another attractive aspect of the invertible normalizing flow transformation.

Prediction and joint-training objective
For the prediction head we use an HAR-style structure (heterogeneous autoregressive), but implemented as an MLP on engineered features (or as a linear layer as a limiting case). The classical HAR-RV predictor uses daily/weekly/monthly realized volatility aggregates.
In our implementation, we allow $y_{β}$ (.) to be a small MLP operating on these aggregates (and possibly additional metadata / features), which keeps the predictor modular and separable from the embedder.
The key idea in the co-training approach is to learn $f (θ)$ and $y_{β}$ together, rather than choosing $f (θ)$ to match a pre-specified target distribution and only then fitting the predictor. Here we deviate from the work of Du and co-workers (Ref. [17]) and rely on a combination of log-likelihood matching and minimising the root mean square error of the inverse-transformed latents to yield an intuitively simpler objective function.

Comparison with baselines

We consider the following baselines in order to calibrate performance of the forecasting task independently. While this does not serve as a general ranking for these modeling frameworks, given the various bespoke performance improvements that can be applied to each, in basic configurations and when used on identical settings of lookback window length, batch size and learning rate on an identical next-step-prediction task, our comparison provides a baseline to determine effectiveness.

MLP-HAR (identity transform ablation)
This is essentially the prediction model without an explicit embedding step, i.e., the identity transform: $f (θ)$ ( $σ_{t}^{R V}$ ) = $σ_{t}^{R V}$ (or other fixed transforms), and the predictor $y_{β}$ is fit directly on the observed series (or its fixed transform). This serves as an ablation capturing “do we get anything from learning the transform?”

LSTM (Long Short-Term Memory)
A fairly standard out-of-the-box deep sequence model for time-series forecasting, used here as a general non-linear baseline. We treat it as a capacity-heavy benchmark that can, in principle, learn non-linear dependencies without explicit feature engineering, but may be harder to train robustly and may overfit if not carefully regularised.

Embedding-predicting with temporal convolutions + HAR head.
An embedding-predicting framework where a temporal convolution network (TCN) (or a TCN autoencoder) produces an embedding, followed by an HAR-like predictor head. This baseline is intended to test whether “any embedding helps” or whether invertibility / distributional control is important.

We observe that the flow transform does indeed improve out-of-sample prediction performance compared to our two baselines, as evident from a visual examination of Fig. 1 as well as the error estimates in Fig. 2. Crucially from a practical point of view, the Flow-HAR approach was significantly more effective at accurately forecasting high/low volatility days (we use a 75 percentile threshold) than the other methods, while the TCN representation tended to produce more variable predictions than either baseline.

Incorporating into a strategy

We describe a volatility-informed mean reversion strategy with the following rules:

if volatility rises above a threshold, expect strong mean reversion next step;
if volatility falls below a threshold, expect current trends to persist.

One simple way to operationalise this is to use the forecast ${\hat{σ}}_{t + 1}^{R V}$ as a regime switch:

where a single threshold has been used to gate the two regimes. In principle, such a signal could be refined with a separate low and high thresholds and a neutral band and could be replaced with rolling quantiles of predicted volatility; for the purposes of our demonstration we stick to the simplest rule. The alpha signal itself is a simple (scaled) difference of current price from a 20 day moving average, with the sign being inverted (mean-reversion) when the next day is expected to be high volatility and the sign being preserved if volatility is expected to be low (approximating trend).

We implement this strategy on the unba platform, completing the backtest with reasonable default settings for fees, order completion mechanics, and signal + allocation weight denoising. We begin by considering a basket of the following ETFs:

DBC(Commodities), GLD (Gold), IEF(US Treasuries, 7–10Y), IVV (US Equity, S&P~500), QQQ (US Equity, Nasdaq~100), QQQM(US Equity, Nasdaq~100), SHY (US Treasuries, 1–3Y), SLV (Silver), SPLG (US Equity, S&P~500), SPY (US Equity, S&P~500), SPYI(US Equity, Options Income), TLT(US Treasuries, 20+Y), USO (Oil), VOO (US Equity, S&P~500).

The backtest setup is complete (shown at the end) and we can now run our simulations.
In order to determine the practical benefit accrued from using this prediction model without overly optimising the signals and allocation framework, we compare performance under “perfect information” (using the true value of next-day volatility) vs using our prediction, i.e., we first directly take the look-forward true next day realized volatility to define the regime. We then train independent Flow-HAR models for each asset. The comparison is shown in Fig. 3 where we train the forecast model on historical data for the period starting 2016 and ending in 2023. The backtest itself is conducted on a held-out period consisting of the years 2024-2025.

Fig 3. Backtest comparison with forward looking RV values giving an estimate of “perfect information” performance (Left) vs. performance when using our RV predictions (Right).

Aside from the slightly sub-optimal situation of reusing backtest data, we get a clear indication that at key moments where volatility ramps up into a spike, the forecast provides enough prediction power for the signal to work, relative to the decisions under perfect information of future volatility.

Conclusions and outlook

A key benefit of such joint models is the simultaneous gain from (i) learning a regularised embedding tailored for forecasting (rather than for marginal distribution matching alone), (ii) modularising the forecasting framework so that the prediction head can be swapped (HAR, MLP, LSTM, neural ODE, etc.), and (iii) enabling conditioning on metadata / side information at either the embedder or predictor stage – which we intend to explore further with order flow, events and sentiment. The co-training perspective explicitly treats the transformation as part of the predictive model, not just preprocessing.

Going forward, there are several directions that seem especially promising: continuous-time long-horizon forecasting for path-dependent contexts using neural ODE-style predictors; prediction matching in latent alone rather than reconstructed target (JEPA-style objectives^[16]); investigating volatility spillover and multivariate structure (e.g., graph-based volatility models with vol-of-vol edge features^[26]; rank prediction vs score prediction (forecasting orderings or regimes rather than point forecasts).

Our signal is still “heavy beta”, being unable to mitigate some of the large drawdowns of 2025, limiting the final PnL of this strategy; nevertheless with the following PnL statistics, and considering the simplistic strategy we are not in a bad place.

References

T. G. Andersen, T. Bollerslev, F. X. Diebold, H. Ebens, Journal of financial economics 61, 43 (2001).
F. Corsi, Journal of financial econometrics 7, 174 (2009).
K. Demeterfi, E. Derman, M. Kamal, J. Zou, Goldman Sachs quantitative strategies research notes 41, 1 (1999).
R. C. Merton, Journal of financial economics 3, 125 (1976).
S. L. Heston, The review of financial studies 6, 327 (1993).
A. G. Hawkes, Biometrika 58, 83 (1971).
S. J. Hardiman, N. Bercot, J.-P. Bouchaud, The European Physical Journal B 86, 442 (2013).
A. Fosset, J.-P. Bouchaud, M. Benzaquen, The European Journal of Finance 28, 663 (2022).
R. F. Engle, Econometrica: Journal of the econometric society pp. 987–1007 (1982).
T. Bollerslev, Journal of econometrics 31, 307 (1986).
R. M. Leushuis, N. Petkov, Financial Innovation 12, 14 (2026).
D. Rezende, S. Mohamed, International conference on machine learning (PMLR, 2015), pp. 1530–1538.
G. Papamakarios, E. Nalisnick, D. J. Rezende, S. Mohamed, B. Lakshminarayanan, Journal of Machine Learning Research22, 1 (2021).
L. Dinh, J. Sohl-Dickstein, S. Bengio, arXiv preprint arXiv:1605.08803 (2016).
R. T. Chen, Y. Rubanova, J. Bettencourt, D. K. Duvenaud, Advances in neural information processing systems 31 (2018).
M. Assran, et al., Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (2023), pp. 15619–15629.
X. Du, K. Moriyama, K. Tanaka-Ishii, Proceedings of the Fourth ACM International Conference on AI in Finance (2023), pp.<br />418–426.
L. Dinh, D. Krueger, Y. Bengio, arXiv preprint arXiv:1410.8516 (2014).
A. Brini, G. Toscano, International Journal of Forecasting 41, 1093 (2025).

				
					signal = VolRegimeMRTrendSignal
signal_args = {'rv_col': 'Daily_RV_next','reversion_col': 'Adjclose_minus_ma20','neutral_band': 0.2}

allocator = SigOverOnePlusVolAllocator
allocator_args = { "logvol_col": "Daily_RV_next","portfolio_leverage": 1.0,"full": False}

# --- execution / transaction cost assumptions ---
exchange_args = dict(
    balance=1_000_000,
    # Execute market orders at next bar Open (daily bars)
    checkprice="Open",
    # Shares
    default_cs="1",qstep="1",minq="1",ticksize="0.01",
    # Spread model: "default" means spread is in ticks and multiplied by ticksize
    spread_method="default",spread="2",  # 2 ticks * $0.01 = $0.02 total spread
    # Commissions / fees:
    # 1) bps on traded notional (e.g. 2 bps)
    # 2) optional per-share commission (e.g. $0.005/share)
    fee_models=["dollar", "lot"],
    fee_kwargs=[{"fee": 0.0002, "dft": 0.0002},   # 2 bps
        {"fee": 0.005,  "dft": 0.005},    # $0.005 per share ],
)
bt_start = pd.Timestamp('2024-01-01')
bt_end   = pd.Timestamp('2026-01-25')
dc_bt_sub = initialize_data_object(
    etf_df_sub,pricecol="Adjclose",sanitize=False,
    update_ticker_info=False
)
n_points_sub = len(dc_bt_sub)

lb = 20

rms = [
    IgnoreSmall,        # signal-side: ignore tiny signals
    AdjustWeights,      # allocator-side: zero dust weights
]
rms_args = [dict(absmin=0.1, close=False),
    dict(min_w=0.005, mask=np.NaN)]

ems_args = dict(leverage=1, min_delta=0.02)

btres_sub_upper = unbt.backtest(
    data=dc_bt_sub,
    signal=signal,
    signal_args=signal_args,
    allocator=allocator,
    allocator_args=allocator_args,
    ems_args=ems_args,
    datapool_args={"lookback": safe_lb_sub, "pricecol": "Adjclose"},
    lookback=safe_lb_sub
)

Volatility is a core object in markets: it governs risk and is traded, directly or indirectly, across a wide range of instruments. Forecasting realized volatility is challenging due to its heavy-tailed behavior, yet it remains partially predictable thanks to persistence and regime structure. In this post we dive into recent advances in jointly trained embedder–predictor neural networks to explore a promising way forward, and evaluate their practical usefulness in a simple backtest setting.