Financial Foundation Models: Pretrained Forecasts Versus Tradable Signals and Cost-Aware Baselines
Original discrete-time architecture mapping pretrained foundation model regime probabilities to cost-penalized tradable portfolio weights via column-stochastic operators, synthetic Markov traces, unit-consistent derivations, and a walk-forward protocol, specified but not run, that contrasts forecast baselines under causal decision clocks.
| Section | Sources cited | Equations | Code listings |
|---|---|---|---|
| 1. Specify the decision clock before fitting the state transition | 1 | 0 | 0 |
| 2. Extract tradable signals from pretrained forecast distributions | 2 | 0 | 0 |
| 3. Project regime probabilities onto asset weights with an explicit linear operator | 8 | 1 | 0 |
| 4. Specify walk-forward validation of pretrained forecasts against cost-aware baselines | 9 | 0 | 0 |
| 5. Derive quadratic risk and cost penalties with dimensional consistency | 3 | 1 | 0 |
| 6. Document structural assumptions failure modes and risk controls | 4 | 0 | 0 |
| 7. Reproduce a fully specified four-state synthetic trace | 7 | 0 | 1 |
| 8. Evaluate chronological conservation laws across regime updates | 6 | 0 | 0 |
| 9. Calibrate risk-aversion scalars to unit-consistent objective functions | 5, 10 | 1 | 0 |
01 /Specify the decision clock before fitting the state transition
The decision clock is defined as a discrete sequence of timestamps t indexed in integer seconds using fixed 300 second buckets that govern all updates to regime probabilities extracted from foundation model embeddings. Before fitting any state transition the clock restricts the information set to strictly causal observations up to the current bucket end. This directive removes lookahead bias when processing pretrained forecast distributions and ensures all derived tradable signals respect identical temporal resolution. Explicit indexing over the clock domain avoids dimensional mismatch between forecast horizons in seconds and execution latency terms measured in the same units.
Reference [1] documents a taxonomy of financial foundation models across language time-series and visual modalities reviewing architectures training methodologies and datasets. Its reported results apply to its dataset/simulation; our independent formulation below derives an original discrete-time recurrence for regime probability updates that operates independently of any cited model or proprietary notation.
With the clock fixed at 300 second granularity the state transition matrix A of dimension K by K with K equal to 4 is estimated via normalized counts over a rolling window of 64 prior buckets. Each estimated probability remains dimensionless and the resulting column-stochastic matrix maps previous regime vectors p_t in Delta^{K-1} to updated ones while preserving summation to unity at every step. This ensures that downstream projection operators inherit consistent dimensionless units across the entire pipeline from forecast to weight. The program in the trace section fits nothing: it applies a specified for 512 steps in exact rational arithmetic, and every resulting probability vector sums to one.
Omitting explicit clock specification before transition fitting invites inconsistent temporal aggregation that corrupts the mapping from pretrained forecasts to tradable signals. The chosen bucket size balances computational tractability against the need to capture intraday dynamics relevant to foundation model outputs. All subsequent cost penalties and risk terms are therefore indexed against this clock, and each is stated with its unit. Nothing in this article tests the design in live trading.
02 /Extract tradable signals from pretrained forecast distributions
Pretrained forecast distributions supplied as quantile or mean predictions over future clock buckets are converted into tradable signals by subtracting a cost-aware random-walk baseline and thresholding the residual at a level calibrated to transaction costs in basis points of traded notional. The resulting signal is a signed dimensionless scalar per asset that indicates desired weight deviation from current holdings. Because the baseline already embeds expected costs the extracted signal is guaranteed to be economically non-trivial only when the pretrained component exceeds the friction threshold. This extraction step explicitly decouples raw statistical forecasts from tradable intent under the causal clock.
The residual computation employs a finite look-back of 20 buckets to estimate the baseline drift in normalized return units of basis points per bucket. Each extracted signal is then scaled by a dimensionless liquidity factor per asset, so that the final command remains a dimensionless weight deviation before projection. This produces a vector of tradable intents that can be directly fed into the subsequent probability projection stage without unit conversion errors. Thresholding does not preserve a zero cross-sectional mean, so a command that must be market neutral needs an explicit re-centering step.
Reference [2] documents introduction of a decoder-only transformer trained on over 20 billion financial time points with point-quantile loss and mixture-of-experts layers for zero-shot forecasting. Its reported results apply to its dataset/simulation; our independent formulation below converts such forecast outputs into cost-penalized tradable signals using an original residual operator that incorporates explicit transaction cost baselines.
Failure to subtract a properly cost-adjusted baseline before signal extraction produces spurious commands that erode performance once real execution frictions are applied. The threshold of 3 basis points is an illustrative assumption, not a measured slippage figure; it is set so that deviations smaller than the assumed friction do not trigger rebalancing. This step therefore forms the critical bridge between pretrained statistical accuracy and actual tradable value while maintaining full dimensional consistency across all operators.
03 /Project regime probabilities onto asset weights with an explicit linear operator
Regime probabilities p_t residing in the K-1 simplex with K equal to 4 are mapped to non-negative portfolio weights w_t in the N-1 simplex with N equal to 5 via an original column-stochastic matrix M of dimension N by K whose columns each sum to unity and represent regime-specific target allocations in dimensionless units. The linear operator w_t equals M times p_t guarantees that the output weights remain non-negative and sum exactly to one for any valid probability vector supplied at each clock tick. All quantities are dimensionless. This formulation never conflates the K-dimensional probability space with the N-dimensional asset space without the explicit bridging matrix.
The columns of are four distinct target portfolios, one per regime; in the program they are specified by hand and are not the output of an optimization. Because M is column-stochastic the convex combination induced by p_t automatically satisfies the budget constraint without requiring a separate normalization step at any decision point. Dimensional analysis confirms that the mapping preserves the unitless character of both input probabilities and output weights. This operator therefore serves as a deterministic and algebraically verifiable bridge between latent regime inference and executable allocations.
Reference [8] documents benchmarking of pretrained time-series foundation models against train-from-scratch baselines on daily equity return forecasting using rolling-origin evaluation. Its reported results apply to its dataset/simulation; our independent formulation below employs an original column-stochastic projection matrix that converts regime probabilities produced by any such model into tradable portfolio weights under explicit cost constraints.
Use of a non-negative column-stochastic matrix rather than an arbitrary linear transform prevents negative weights and guarantees conservation of total allocation at every clock tick. The explicit construction allows closed-form differentiation with respect to regime probabilities enabling gradient-based calibration of upstream foundation model embeddings. This projection step completes the transformation from pretrained forecasts into fully tradable signals ready for cost-aware objective evaluation.
Author's original illustrative formulation. ( assets, weights dimensionless), ( regimes, probabilities dimensionless), column-stochastic matrix (each column sums to 1, dimensionless).
04 /Specify walk-forward validation of pretrained forecasts against cost-aware baselines
Chronological walk-forward folds are constructed by advancing the decision clock in non-overlapping 20 bucket test windows while expanding the training horizon up to the start of each test period. Within each fold pretrained foundation model forecasts are converted to tradable signals via the previously defined projection and evaluated against a static cost-aware baseline that rebalances only when cumulative expected slippage falls below a 5 basis point threshold. The benchmark explicitly penalizes turnover using quadratic and linear cost terms expressed in basis points. Performance is assessed solely by whether the dynamic signals produce higher net per-decision utility in basis points than the static baseline.
The benchmark uses the same explicit rate convention as the objective: linear and quadratic execution costs per decision are divided by the bucket duration tau before comparison with expected-return and covariance rates. The dimensionless scalar lambda_q scales Delta w transpose Gamma Delta w, with Gamma measured in basis points per bucket per squared weight fraction. Every additive component then carries basis-points-per-bucket units; multiplying by tau gives basis-point utility for that decision. Across folds the pretrained route is compared with the static baseline under identical cost conventions without claiming any specific numeric superiority.
Because the folds respect the causal decision clock no future information leaks into signal generation or weight projection. The static baseline is recomputed at each step using only information available up to the fold start guaranteeing a fair and reproducible contrast between pretrained and naive approaches. This section specifies the protocol and nothing more: the program in this article runs no folds, no forecasts and no baseline strategy. Its only link to the benchmark is one decision, scored once for holding the current weights and once for moving to the projected ones.
Reference [9] documents continued pre-training of a patched decoder-only time-series foundation model to support few-shot in-context examples via separator tokens achieving performance parity with supervised fine-tuning on unseen datasets. Its reported results apply to its dataset/simulation; our independent formulation specifies walk-forward folds of pretrained forecasts against cost-aware baselines and does not run them.
05 /Derive quadratic risk and cost penalties with dimensional consistency
Use a 300-second bucket as the time unit, so the decision duration tau equals one bucket. For a bucket return vector R in basis points define mu = E[R]/tau and Sigma = Cov(R)/tau, a covariance rate rather than the covariance of a return rate. Thus mu has units bps/bucket, Sigma has units bps squared/bucket, and lambda_r has units 1/bps. Weights and Delta w are dimensionless fractions of notional. Define execution-cost rates c = C/tau and Gamma = G/tau, where C and G are per-decision linear and quadratic cost coefficients in bps per unit and squared unit weight change respectively. With dimensionless lambda_q every term in U has units bps/bucket; tau U is per-decision penalized utility in bps.
Reference [3] documents training of a 50 billion parameter autoregressive model on a 363 billion token financial corpus augmented with general text producing superior performance on financial tasks while retaining general capabilities. Its reported results apply to its dataset/simulation; our independent formulation below derives quadratic risk and transaction cost penalties with explicit risk-aversion scalars that enforce dimensional homogeneity across all objective components.
The quadratic transaction penalty lambda_q times Delta w transpose Gamma Delta w uses Gamma entries in basis points per bucket per squared weight fraction. The corresponding linear rate c has basis points per bucket per unit weight fraction. Multiplying either form by tau recovers the cost of that decision in basis points. This explicit division by the bucket duration keeps execution costs commensurable with expected-return and covariance rates. Changing the clock requires re-estimating return and covariance inputs and amortizing decision costs over the new duration; dimensional consistency alone does not imply invariant trading behavior.
Dimensional consistency follows from expressing returns in basis points and weights as fractions of notional. At fixed weights increasing lambda_r increases the risk penalty, while increasing lambda_q increases the quadratic execution penalty. Neither observation guarantees lower turnover: an optimizer may rebalance more to reduce risk, and a projection w = M p that is independent of these scalars does not change at all. Turnover response therefore requires a separately specified decision rule and chronological measurement. The column-stochastic projection preserves weight non-negativity and unit sum independently of these utility coefficients.
Author's original illustrative formulation. For bucket return R in bps and duration tau, mu = E[R]/tau has bps/bucket and Sigma = Cov(R)/tau has bps squared/bucket. Lambda_r has 1/bps; c = C/tau and Gamma = G/tau are execution-cost rates in bps per bucket per unit and squared unit weight respectively; lambda_q is dimensionless. Every term of U has bps/bucket, so tau U has bps. Sigma is not Cov(R/tau).
06 /Document structural assumptions failure modes and risk controls
The architecture assumes that the four synthetic regimes are Markovian with respect to the 300 second decision clock and that the column-stochastic projection matrix M remains fixed across all walk-forward folds. It further assumes that pretrained forecast distributions are correctly calibrated to the same clock and that transaction costs are the sum of a term linear in absolute weight changes and a term quadratic in weight changes, measured as fractions of notional. These assumptions simplify the algebra yet must be stress tested against non-stationary drift in regime transition probabilities over longer horizons.
Primary failure mode occurs when regime persistence drops below a critical threshold causing the probability vector p_t to oscillate and induce excessive turnover that overwhelms the cost penalty terms. Another failure arises if the pretrained quantiles are miscalibrated producing biased residuals that systematically deviate from zero mean after baseline subtraction. Risk controls include a hard turnover gate that overrides the optimizer whenever absolute weight change exceeds 0.25 and a variance inflation factor monitor that widens lambda_r when synthetic trace entropy exceeds a preset threshold.
Reference [4] documents pre-training of an 8 billion parameter model on 52 billion tokens of financial text tabular and time-series data followed by instruction tuning on 573 thousand examples yielding strong zero-shot and few-shot results. Its reported results apply to its dataset/simulation; our independent formulation below documents structural assumptions failure modes and risk controls for an original regime-projection architecture that converts such pretrained outputs into cost-aware tradable signals.
Two further controls are proposed. Like the gate and the monitor above, they are not part of the program in this article. The first would log the condition number of the projection matrix at every clock tick and abort live execution if it exceeds 100. The second would run a synthetic oracle that knows the true regime state in parallel, as a reference utility for the learned system. Such controls can flag a violated modeling assumption; they do not guarantee that it is caught before it produces a loss.
07 /Reproduce a fully specified four-state synthetic trace
A four-state Markov chain is instantiated with a column-stochastic transition matrix of dimension 4 by 4 that has on the diagonal and elsewhere. Like every stochastic matrix, has the eigenvalue 1; its eigenvector here is the uniform vector , the stationary distribution. The matrix maps any vector whose entries sum to zero to 0.6 times itself, so the other three eigenvalues equal 0.6 and the deviation of from shrinks by that factor at every step. Starting from the program advances the regime probabilities for 512 steps of the 300 second clock, without sampling regime labels or prices.
The program uses a single 5-dimensional expected-return vector for all regimes and the diagonal covariance rate , in the units of the fifth section. The cost inputs are , and , and utilities are scored with . All of these values are invented for the example. The trace contains no noise: it is the deterministic sequence with , so the program prints the same output on every run.
The trace drives the transition recurrence and the linear projection operator in lockstep. At each step the program compares componentwise with the closed form ; the two agree exactly, and after 512 steps the L1 distance from is 1.036e-114. The program also scores the first decision with the cost-penalized utility. Holding scores 4.7428 basis points per bucket. Moving to scores 4.630928 before costs and 4.556528 after a linear cost of 0.064 and a quadratic cost of 0.0104. These figures follow from invented inputs and are not a performance result. The program has no learned filter and no latent state, so it says nothing about convergence to a Bayes-optimal posterior.
Reference [7] investigates what autoregressive transformers learn on controlled synthetic limit order books. Its findings apply strictly to its synthetic order-flow message experiments; our four-state Markov trace above is constructed independently at a 300-second decision clock to verify our column-stochastic projection operator M.
# Synthetic unit-check fixture; illustrative only, no live market data or performance claims.
from fractions import Fraction
def tenths(row):
return [Fraction(value, 10) for value in row]
def apply(matrix, vector):
return [sum(a * x for a, x in zip(row, vector)) for row in matrix]
def dot(u, v):
return sum(a * b for a, b in zip(u, v))
def gap(u, v):
return sum(abs(a - b) for a, b in zip(u, v))
def zero_cost(x, risk_aversion): # Eq. 5.1 without a trade, with Sigma = sigma I
return dot(mu, x) - risk_aversion * sigma * dot(x, x)
# Column k of M holds the target weights of regime k; column k of A, the next-regime probabilities.
M = [tenths(row) for row in [[5, 1, 2, 2], [1, 5, 1, 3], [2, 2, 5, 1], [1, 1, 1, 3], [1, 1, 1, 1]]]
A = [tenths(row) for row in [[7, 1, 1, 1], [1, 7, 1, 1], [1, 1, 7, 1], [1, 1, 1, 7]]]
p, steps = [tenths([4, 3, 2, 1])], 512
mu, sigma, lambda_r = [8, -4, 12, 2, 6], 25, Fraction(2, 25) # bps/bucket, bps^2/bucket, 1/bps
cost, gamma, lambda_q = 2, 50, Fraction(1, 2) # c = cost (1, ..., 1), Gamma = gamma I
uniform, rho = [Fraction(1, len(A))] * len(A), A[0][0] - A[0][1]
cols = [list(col) for col in zip(*M)]
assert all(sum(col) == 1 for col in cols + list(zip(*A))) and apply(A, uniform) == uniform
w, turnover = [apply(M, p[0])], []
for t in range(1, steps + 1):
p.append(apply(A, p[t - 1]))
w.append(apply(M, p[t]))
turnover.append(gap(w[t], w[t - 1]))
assert p[t] == [s + rho ** t * (x - s) for s, x in zip(uniform, p[0])]
assert turnover[-1] == rho ** (t - 1) * turnover[0]
assert turnover[-1] <= gap(p[t], p[t - 1])
deviation = sum(abs(sum(x) - 1) for x in p + w)
assert deviation == 0 and min(min(x) for x in p + w) >= 0
assert all(dot([m + 3 for m in mu], x) == dot(mu, x) + 3 for x in w)
mu_regime = [dot(mu, col) for col in cols] # M^T mu
sigma_regime = [[sigma * dot(a, b) for b in cols] for a in cols] # M^T Sigma M
lambda_cal = dot(mu_regime, p[0]) / dot(p[0], apply(sigma_regime, p[0])) # Eq. 9.1
residual = zero_cost(w[1], lambda_cal)
assert zero_cost(w[0], lambda_cal) == 0 and residual != 0
dw, dp = [b - a for a, b in zip(w[0], w[1])], [b - a for a, b in zip(p[0], p[1])]
linear, quadratic = cost * turnover[0], lambda_q * gamma * dot(dw, dw)
assert linear == 2 * cost * sum(x for x in dw if x > 0) # dw sums to zero: buys equal sells
assert sigma * quadratic == lambda_q * gamma * dot(dp, apply(sigma_regime, dp)) # regime space
hold, move = zero_cost(w[0], lambda_r), zero_cost(w[1], lambda_r) - linear - quadratic
assert move < zero_cost(w[1], lambda_r) - linear < zero_cost(w[1], lambda_r) < hold
print(f"RESULT trace_steps = {len(turnover)}")
print(f"RESULT total_simplex_deviation = {deviation}")
print(f"RESULT contraction_factor = {float(rho)}")
print(f"RESULT end_distance = {float(gap(p[steps], uniform)):.3e}")
print(f"RESULT first_probability_change = {float(gap(p[1], p[0]))}")
print(f"RESULT max_turnover = {float(max(turnover))}")
print(f"RESULT reference_weights = {[float(x) for x in w[0]]}")
print(f"RESULT lambda_calibrated = {float(lambda_cal):.6f}")
print(f"RESULT residual_after_one_step = {float(residual):.6f}")
print(f"RESULT utility_hold = {float(hold)}")
print(f"RESULT utility_move_before_costs = {float(zero_cost(w[1], lambda_r))}")
print(f"RESULT linear_cost = {float(linear)}")
print(f"RESULT quadratic_cost = {float(quadratic)}")
print(f"RESULT utility_move = {float(move)}")
print("OK")CAPTURED OUTPUT15 LINES · 10 ASSERT STATEMENTS, 1543 EVALUATIONS PASSED · RUN NOV 13, 2026 · SHA-256 ed417f2ec7fb…
RESULT trace_steps = 512 RESULT total_simplex_deviation = 0 RESULT contraction_factor = 0.6 RESULT end_distance = 1.036e-114 RESULT first_probability_change = 0.16 RESULT max_turnover = 0.032 RESULT reference_weights = [0.29, 0.24, 0.25, 0.12, 0.1] RESULT lambda_calibrated = 0.909886 RESULT residual_after_one_step = -0.027556 RESULT utility_hold = 4.7428 RESULT utility_move_before_costs = 4.630928 RESULT linear_cost = 0.064 RESULT quadratic_cost = 0.0104 RESULT utility_move = 4.556528 OK
Standard output of the program above, captured when it was run in the journal's sandbox on Nov 13, 2026. The SHA-256 of the program text shown here equals the hash stored with that run. All inputs are synthetic.
08 /Evaluate chronological conservation laws across regime updates
At every clock tick the updated regime probability vector is required to sum exactly to one after application of the transition matrix; a column-stochastic matrix needs no normalization step for this. The program evaluates this conservation law in exact rational arithmetic, with no floating-point tolerance. It adds the absolute deviations from one over every probability vector and every weight vector of the trace, the starting point included, and the total it prints is 0. In the same pass every probability and every weight is required to be non-negative, so each vector lies on its simplex.
Reference [6] documents a mixture-of-experts time-series language model with independently trained low-rank adapters for forecasting context-conditioned prediction and temporal reasoning achieving top ranks on multiple public benchmarks. Its reported results apply to its dataset/simulation; our independent formulation below evaluates chronological conservation laws for an original synthetic trace and column-stochastic projection that converts regime probabilities into portfolio weights.
A second invariant concerns the objective. Adding the same constant to every expected return raises the return term by exactly that constant for any weight vector that sums to one, so the ranking of budget-feasible portfolios is unchanged. This holds for any risk and cost terms that do not depend on ; a rescaling of has no such property. The program shifts every expected return by 3 basis points per bucket and requires the return term to rise by exactly 3 at every weight vector of the trace.
The projection also bounds turnover. Because is column-stochastic, the L1 change in weights cannot exceed the L1 change in probabilities, and the program requires this at every step. The first step changes the probabilities by 0.16 and the weights by 0.032; turnover then decays by the factor 0.6 per step, so 0.032 is its maximum, below the 0.25 threshold of the turnover gate. The program needs only the fractions module of the Python standard library. The L1 bound is a property of and holds for any two probability vectors, whichever model supplies them; it says nothing about forecast quality.
09 /Calibrate risk-aversion scalars to unit-consistent objective functions
For a fixed projected weight vector w = M p with positive variance rate, solve the zero-cost breakeven condition mu transpose w = lambda_r times w transpose Sigma w. The ratio below has units (bps/bucket)/(bps squared/bucket) = 1/bps under the covariance-rate definition. It defines a nonnegative illustrative risk-aversion value only when expected return is nonnegative; a negative numerator does not justify a negative risk penalty. This equality calibrates one specified reference portfolio, not every portfolio or regime. Freeze that reference and its inputs using training data before applying its value in any held-out fold.
After fixing a reference calibration, held-out synthetic segments can compare objective values under explicitly stated weights and costs. With positive variance rate the risk penalty grows linearly in lambda_r at fixed weights, but no monotonic turnover claim follows. In the supplied projection fixture the weights depend only on M and p, so varying lambda_r changes their assessed utility rather than the weights themselves. The program computes the ratio in regime space, from and , and obtains 0.909886 per basis point at the reference , not the trace section's assumed . In asset space at the expected-return and risk rates then cancel exactly. One step later, at , the frozen value leaves a zero-cost utility of basis points per bucket.
The calibration is an algebraic equality at the reference portfolio, not a first-order optimality condition or an empirically fitted trading rule. It is valid for any positive-semidefinite covariance rate with a strictly positive denominator; diagonal covariance merely simplifies the supplied fixture. A zero denominator leaves the ratio undefined and requires separate handling. Both numerator and denominator must use the same bucket duration, so their time units cancel. Subsequent changes to weights or estimates generally break the original equality and require a separately stated calibration policy.
Reference [5] outlines open-source financial language model pipelines and Reference [10] introduces a multivariate time-series model using learning primitives. Their evaluations apply to their respective text and multivariate benchmarks; our closed-form risk-aversion calibration in the equation below is an independent algebraic rule for our synthetic four-state trace.
Author's original illustrative formulation. For fixed w = M p, mu = E[R]/tau in bps/bucket and Sigma = Cov(R)/tau in bps squared/bucket; M and p are dimensionless. If w^T Sigma w > 0, the ratio has units 1/bps and equates expected-return and risk rates at that portfolio with transaction costs set to zero. A nonnegative lambda_r also requires mu^T w >= 0.
Research is complete only when the assumptions, experiment, and limitations can be reconstructed.
This perspective is research commentary. It does not constitute investment advice or evidence of live strategy performance. Experimental methods require project-specific testing. Equations and code illustrate research formulations, not measured live returns.