Everyone's AI

Learn / Paper review / Core architecture & algorithms / CPAL2026 / AlphaFormer: End-to-End Symbolic Regression of Alpha Factors with Transformers

AlphaFormer: End-to-End Symbolic Regression of Alpha Factors with Transformers

In quant practice, alpha factors still sit awkwardly between hand-crafted formulas and black-box models. AlphaFormer pre-trains a Transformer on synthetic time series, then—given new market data—emits interpretable symbolic formulas end-to-end. This article dissects the linear alpha pool, IC-based metrics, and PPO-style stabilization line by line.
PDFOpen original PDF
[Abstract & introduction] Three-line summary + problem statement
Three-line summary
- ① Fatal limitation of prior work: GP- or RL-based symbolic regression must restart search from scratch on every new dataset, barely reusing learned “formula grammar.” It is like reinventing the recipe every morning.
- ② Limits of classical tools: Tree boosters and LSTMs predict well but stay black boxes; fully manual factor design cannot scale the enormous search space.
- ③ Core idea: AlphaFormer pre-trains a Transformer on diverse synthetic price paths, then, given real XtX_t, instantly generates RPN-style alpha formulas—a chef who practiced in many fake kitchens before cooking in a new one.
Analogy: recipe-randomizing robot vs. master chef with grammar in muscle memory
Legacy symbolic search is a robot that re-samples spice ratios from scratch whenever the “kitchen” (market) changes. AlphaFormer pre-trains on synthetic kitchens, learns composition rules, then, seeing real ingredients XtX_t, plates a formula (alpha factor) on the spot—interpretable without giving up predictive pressure.
### [Background] Concepts you truly need
Read each item as definition → intuition → role in this paper so the later formulas feel motivated, not arbitrary.
- Alpha factor
Plain-language definition first: Fix a single day (time tt) and suppose we care about SS stocks. Each stock has dd numbers (e.g. close, volume, recent returns). An alpha factor is a rule that reads everything at once and prints one “relatively more attractive?” score per stock. The SS scores form a vector ztz_t.
Picture a table: SS rows (one stock per row) × dd columns (one feature type per column). Call the full input XtX_t; then Xt∈RS×dX_t \in \mathbb{R}^{S \times d} means “that day’s stock count × numbers per stock.” The output zt∈RSz_t \in \mathbb{R}^S means component ii = score for stock ii.
Intuition: This is not “track one stock through time only.” It is line up many stocks on the same day and ask who ranks higher today—the cross-section. Long–short and ranking portfolios read those scores to choose longs, shorts, and weights.
In this paper: The generator’s end product is an interpretable symbolic formula implementing such a factor—this definition is our starting point.
- Symbolic regression
Definition: Search for an explicit operator tree (e.g. `mean(close, 20d)`), not only numeric weights.
Intuition: Prefer a human-readable recipe over a black box—important for compliance and risk narratives even though the search space is huge.
In this paper: Contrasts with GP/RL pipelines that cold-start symbolic search on every new dataset.
- RPN (reverse Polish notation)
Definition: Infix (human) sketch: `mean(close, 20d)` = 20-day average of close. The model emits the same meaning as a left-to-right token stream: `close`, then `20d`, then operator `mean`, then delimiter `end` (closes this sub-formula chunk). Those are vocabulary tokens in order, not a programming-array literal—avoid reading `[volume, 20d, mean, end]`-style brackets as data-structure syntax. A stack fixes evaluation order without parentheses.
Intuition: Matches how Transformers autoregress tokens left-to-right.
In this paper: The model emits alpha formulas as RPN token sequences, not as infix math text.
- IC (information coefficient)
Definition: Typically the daily Pearson correlation between predicted scores and realized labels (forward returns).
Intuition: A daily report card on whether predicted ranks line up with realized ranks; Rank IC stresses ordering and is less swayed by outliers.
In this paper: IC is the quality signal for pooling and (optionally) RL-style fine-tuning.
- Synthetic data
Definition: Pre-train on time series fabricated by generative models (GRU, Transformer, diffusion, etc.), often ensembled for diversity.
Intuition: Real tape is noisy and label-scarce; synthetics provide a practice gym to learn operator grammar before touching live markets.
In this paper: Enables grammar pre-training + lighter adaptation on real XtX_t.
[Proposed method] Core formulation dissected
1) Alpha pool — mix many formulas
Given mm candidate factors fkf_k, aggregate linearly:
zt=g(Xt)=∑k=1mwk fk(Xt)z_t = g(X_t) = \sum_{k=1}^{m} w_k\, f_k(X_t)
- Intuition: each fkf_k is a “chef”; wkw_k is vote weight; gg is the ensemble head over the pool.
2) Learning pool weights — accelerator vs. L1 brake
L(w)=1ST∑t=1T∥g(Xt)−yt∥22+λ∥w∥1\mathcal{L}(w) = \frac{1}{ST} \sum_{t=1}^{T} \big\| g(X_t) - y_t \big\|_2^2 + \lambda \|w\|_1
- First term (accelerator): yty_t is the label vector (e.g. forward return). Minimize mean squared error over stock×time mass STST.
- λ∥w∥1\lambda\|w\|_1 (brake / scissors): L1 pushes many wkw_k to exact zeros, pruning useless factors for a sparse, interpretable pool.
3) IC as daily taste test — average correlation
σˉ(g(X),y)=1T∑t=1Tσ(g(Xt),yt)\bar{\sigma}(g(X), y) = \frac{1}{T} \sum_{t=1}^{T} \sigma\big(g(X_t), y_t\big)
σˉrank(g(X),y)=1T∑t=1Tσrank(g(Xt),yt)\bar{\sigma}_{\mathrm{rank}}(g(X), y) = \frac{1}{T} \sum_{t=1}^{T} \sigma_{\mathrm{rank}}\big(g(X_t), y_t\big)
- σ\sigma is Pearson; σrank\sigma_{\mathrm{rank}} is rank correlation—robust when you care about ordering more than raw magnitudes.
4) PPO to stabilize the generator — clipping + value head
L(θ,ϕ)=LCLIP(θ)+η Lvalue(ϕ)\mathcal{L}(\theta, \phi) = \mathcal{L}^{\mathrm{CLIP}}(\theta) + \eta\, \mathcal{L}^{\mathrm{value}}(\phi)
LCLIP(θ)=− E^[min⁡(rt(θ) A^t, clip(rt(θ),1−ϵ,1+ϵ) A^t)]\mathcal{L}^{\mathrm{CLIP}}(\theta) = -\, \hat{\mathbb{E}}\Big[ \min\big( r_t(\theta)\,\hat{A}_t,\ \mathrm{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon)\,\hat{A}_t \big) \Big]
Lvalue(ϕ)=∥Vϕ(D,P)−r∥22\mathcal{L}^{\mathrm{value}}(\phi) = \big\| V_\phi(\mathcal{D}, \mathcal{P}) - r \big\|_2^2
- rt(θ)r_t(\theta) (ratio): new-policy / old-policy probability ratio; clipped to [1−ϵ,1+ϵ][1-\epsilon,1+\epsilon] so updates stay smooth—a seat belt on policy steps.
- A^t\hat{A}_t: advantage—how much better than baseline; in this paper’s story, tied to IC-based reward after pool refresh minus value estimate.
- VϕV_\phi: critic predicting expected return from data D\mathcal{D} and pool state P\mathcal{P}; Lvalue\mathcal{L}^{\mathrm{value}} fits observed reward rr.
- η\eta: balances actor vs. critic losses.
How to read the symbols (same section)
Every symbol that appears in the four blocks above, in definition → role order—no separate glossary card.
- XtX_t, SS, dd: XtX_t is the feature tensor at time tt; shaping Xt∈RS×dX_t\in\mathbb{R}^{S\times d} means SS stocks and dd features per stock.
- ztz_t: in RS\mathbb{R}^S; entry ii is the alpha score for stock ii.
- fkf_k, mm, wkw_k, gg: fk(Xt)f_k(X_t) is the score vector from candidate formula kk; mm counts candidates in the pool; wkw_k is how much we trust that formula; g(Xt)g(X_t) is the linearly mixed final predictor.
- yty_t, TT, STST, ∥⋅∥22\|\cdot\|_2^2: yty_t is the label vector (e.g. forward return) at tt. TT is the number of days in the fit; SS is universe size; STST is stock-day cells, so dividing by STST averages error over the full panel. ∥v∥22\|v\|_2^2 is the sum of squared components of vv.
- λ\lambda, ∥w∥1\|w\|_1: ∥w∥1=∑k=1m∣wk∣\|w\|_1=\sum_{k=1}^m|w_k|. Raising λ\lambda pushes more wkw_k to exact zero, pruning factors (Lasso).
- σ\sigma, σrank\sigma_{\mathrm{rank}}, σˉ\bar{\sigma}, σˉrank\bar{\sigma}_{\mathrm{rank}}: per-day Pearson vs rank correlation between g(Xt)g(X_t) and yty_t; the overbar averages over TT days to smooth daily noise.
- θ\theta, ϕ\phi, PPO: θ\theta parameterizes the policy (Transformer) that samples tokens; ϕ\phi parameterizes the critic. rt(θ)r_t(\theta) is the new-policy / old-policy probability ratio for the taken action; ϵ\epsilon sets the clip interval [1−ϵ,1+ϵ][1-\epsilon,1+\epsilon]. A^t\hat{A}_t is advantage (how much better than average). Vϕ(D,P)V_\phi(\mathcal{D},\mathcal{P}) estimates expected return given data D\mathcal{D} and pool state P\mathcal{P}; Lvalue\mathcal{L}^{\mathrm{value}} matches that estimate to realized reward rr. η\eta weights the value loss against the policy loss.
One-sentence read
Pre-train grammar on synthetics, generate RPN formulas, linearly pool with Lasso, score with IC, and fine-tune generation with clipped PPO—that is the full loop.
[Toy walkthrough] Mental simulation—step-by-step
To connect each formula above to something concrete, imagine a toy market with only three stocks on one day tt. Numbers are illustrative, not real quotes.
Setup: Stocks A, B, C. The generator already proposed m=3m=3 symbolic factors f1,f2,f3f_1,f_2,f_3. Each fkf_k outputs one score vector in R3\mathbb{R}^3 (one score per name). Example:
f1=(1, 0, −1),f2=(0.5, 1, 0),f3=(0.2, −0.3, 0.1)f_1=(1,\,0,\,{-}1),\quad f_2=(0.5,\,1,\,0),\quad f_3=(0.2,\,{-}0.3,\,0.1)
(entries are (A,B,C)(A,B,C) in order).
1) Linear alpha pool—weighted blend
With weights w=(0.5, 0.3, 0.2)w=(0.5,\,0.3,\,0.2), the pooled score is zt=0.5f1+0.3f2+0.2f3z_t=0.5f_1+0.3f_2+0.2f_3. For stock A:
zt,A=0.5⋅1+0.3⋅0.5+0.2⋅0.2=0.69.z_{t,A}=0.5\cdot1+0.3\cdot0.5+0.2\cdot0.2=0.69.
Similarly zt,B=0.24z_{t,B}=0.24, zt,C=−0.48z_{t,C}={-}0.48. So each name’s score is one weighted mix of the three factor rows—the vector ztz_t is the cross-sectional ranking input for that day.
2) Labels, MSE, and what L1 does
Let yty_t be realized forward returns (same length as ztz_t). The first loss term is roughly average squared error between ztz_t and yty_t over many stock-days—if predictions are wrong, gradient descent nudges ww.
The λ∥w∥1\lambda\|w\|_1 term pushes small or redundant weights toward exact zero, which drops whole factors from the pool—like removing a sauce that no longer helps once you taste the full blend.
3) IC—a one-day “ranking exam”
If predicted ranks from ztz_t line up with return ranks from yty_t, the daily Pearson correlation σ(g(Xt),yt)\sigma(g(X_t),y_t) moves positive. Say 0.080.08 means “a decent day.” Comparing monthly/rolling means σˉ\bar{\sigma} near 0.02 vs 0.06, the latter is materially healthier after smoothing noise.
4) PPO—intuition in one step
The policy proposes a new token sequence (a new formula), which changes the pool and IC; that improvement can be turned into reward rr. The ratio rt(θ)r_t(\theta) measures how aggressively the new policy changes action probabilities vs the old one; clipping caps that ratio so one update cannot jerk the policy too hard. That is what stabilizes learning.
5) Inference / deployment
After pre-training (and optional light RL), you mostly forward-pass new XtX_t to obtain formulas—not restart a giant GP symbolic search every batch. That is why latency drops vs cold-start mining.
One line: Pool = mixer; L1 = trash unused factors; IC = daily rank exam; PPO = seat belt on policy updates.
[Experiments & results]
- Search efficiency: Strong baselines need far more candidate factors; AlphaFormer reaches top-tier IC / Rank IC on CSI300 & CSI500 with ~one-third the generation budget in the paper’s story—not a wider needle, but a steadier hand.
- Inference efficiency: No massive online parameter re-fit during inference—important for near-real-time stacks.
- Generalization: Ensembling multiple generative architectures for synthetics boosts IC; China-pretrained models zero-shot to US S&P 500 still compete—suggesting partial transfer of time-series / operator grammar, not only venue noise.
Practical read: If you want interpretable factors under GPU-hour budgets, “synthetic pre-train + bounded RL fine-tune” is an attractive MLOps compromise.
[Conclusion & limitations]
Takeaways for practitioners (≤3)
1. White-box signals: RPN / operator trees are easy to share with risk as literal formulas.
2. Lower search tax: Grammar compression means less cold-start symbolic search on every new tape.
3. End-to-end story: generate → pool → IC → (optional) PPO keeps pipelines short and reproducible.
Limitations / future work
- Hardware: GPU-centric training & inference may exclude CPU-only legacy stacks.
- Regimes: Impressive zero-shot transfer still may need retrain or domain adaptation after structural breaks.
- Labels: IC is only as honest as your forward-return definition and leakage controls.

Visualization plan: chaotic search vs. controlled generation

Left: a search-space scatter of trials plus a jagged path that barely approaches the IC goal—cold-start symbolic mining. Right: a single pipeline—synthetic series → pre-training → tokenized formula generation → IC/pool—for AlphaFormer’s end-to-end story.

Legacy: GP / RL symbolic search

Each new dataset restarts wide exploration; many candidates still yield noisy IC paths.

Cumulative gainICTrial 1Trial NRandom searchOver-exploration

Proposed: AlphaFormer

Grammar from synthetics; fewer generations lift IC steadily and zero-shot transfer is plausible.

Few factors, high ICCumulative gainICPre-trained gen.Trial 1Trial N
AlphaFormer reframes “restart symbolic search every market” as grammar pre-training + safely clipped RL fine-tuning. Pool, L1, IC, and PPO play roles like mixer, scissors, judges, seat belt. Respect GPU dependence and label hygiene when you pilot.