Financial Features & Labeling

In most machine-learning tutorials the data shows up pre-chewed: here are your features X, here is your label y, go fit a model. Finance is crueler. Nobody hands you X and y — you manufacture both from a single dirty stream of prices, and the way you manufacture them decides whether your model learns anything real or just memorizes noise that will never repeat. This lesson is about that manufacturing process, and it is where most quant ML projects quietly die long before they reach a backtest.

Two problems lurk here, and they are both subtle enough that smart people get them wrong for years. The first: what do you feed the model? Raw prices are poison (we’ll see why), and the obvious fix — returns — throws away something precious. The second, and the one that ruins more strategies than any other: what is y? “The thing that goes up” sounds like an answer until you try to write it down. Let’s manufacture both, carefully.

Features must be stationary AND informative

Analogy. Imagine training a model to recognize “tall” by showing it people standing on a hill that keeps rising. It learns that tall means “head is around 6 feet above sea level” — and then totally fails the moment the ground moves. A raw price is that rising hill: the model latches onto absolute levels (the altitude) instead of the relationship you actually care about (the height of the person). You need to subtract the hill out.

Definition — stationarity. A time series is stationary when its statistical properties — mean, variance, autocorrelation — don’t change over time. Loosely: the future looks statistically like the past, so a pattern learned yesterday is still valid tomorrow. A random walk (each step is the last value plus an unpredictable shock, $P_t = P_{t-1} + \varepsilon_t$) is the canonical non-stationary series: its level wanders with no fixed mean and its variance grows without bound. Stock prices are very close to this. Feed them to a model and it learns levels that will never recur.

The classic fix is to difference the series — take changes instead of levels. The first difference of a price gives you returns:

$r_t = P_t - P_{t-1} \qquad \text{(or log returns } r_t = \ln P_t - \ln P_{t-1}\text{)}$

Returns are stationary: they hover around a fixed mean with a roughly stable spread, exactly the flat cloud a model can generalize from. Problem solved? Not quite — and here is the dilemma that makes financial ML genuinely hard.

The stationarity–memory dilemma

Differencing buys stationarity at a brutal price: it destroys memory. A return tells you what happened in one bar and nothing about the level the series has reached. But a lot of real signal lives in the level and its slow-moving structure — how far price has run from a moving average, whether it sits above or below a long-run equilibrium, the persistent component a mean-reversion or trend signal needs. Take the full first difference and you’ve thrown all of that out. You’re stationary and nearly memoryless — you optimized one thing to zero and the other thing to zero too.

This is a real trade-off, not a false dichotomy:

Definition — fractional differentiation. Instead of differencing a whole step (order $d = 1$, full returns) or not at all ($d = 0$, raw price), difference by a fractional order $d$ between 0 and 1. Formally, the differencing operator $(1 - B)^d$ — where $B$ is the backshift operator, $B P_t = P_{t-1}$ — is expanded as an infinite weighted sum of past values:

$\tilde{P}_t = \sum_{k=0}^{\infty} \omega_k \, P_{t-k}, \qquad \omega_k = (-1)^k \binom{d}{k} = \omega_{k-1}\,\frac{d - k + 1}{k}$

At $d = 1$ the weights collapse to $\{1, -1, 0, 0, \dots\}$ — that’s just $P_t - P_{t-1}$, the ordinary return. At $d = 0$ the weights are $\{1, 0, 0, \dots\}$ — the raw price, untouched. For $d$ in between, the weights decay slowly, so $\tilde{P}_t$ keeps a long, fading tail of past prices in memory while still being stationary. The recipe: find the smallest $d$ that passes a stationarity test (e.g. the ADF test), because the smallest $d$ keeps the most memory. That tiny $d$ — often around 0.3–0.5 — is the sweet spot.

Volatility-scaling features

One more transform you’ll use constantly: divide by recent volatility. A 1% move means something completely different in a sleepy market than in a screaming one. Scaling a feature (or a return) by a rolling estimate of volatility $\hat{\sigma}_t$ puts every observation on the same footing:

$\tilde{r}_t = \frac{r_t}{\hat{\sigma}_t}$

This is the same standardization idea as a z-score, applied through time. It keeps the magnitude of a feature comparable across calm and turbulent regimes, so the model isn’t fooled into thinking a turbulent day’s giant move is a stronger signal than a calm day’s tiny one. (Hold onto vol-scaling — it comes back with a vengeance when we set labeling barriers below.)

Worked example — why levels mislead

Take three days of price: 100 → 110 → 105. Look at it two ways.

A model fed the raw price column sees the numbers 100, 110, 105 — and if its training data only ever ranged from, say, 80 to 120, it builds rules anchored to that band (“around 105–110 the series tends to fall”). Re-run the stock after a 3-for-1 split, or five years later when it trades at 400, and those rules are gibberish — the level it learned never recurs. A model fed the returns column sees +10%, −4.5% — numbers that mean the same thing whether the stock is at 100 or 400, because they’re stationary. That’s the whole case for differencing. The only thing the returns view loses is where the price actually is — and that lost level is the memory fractional differentiation works to claw back.

The labeling problem (what is Y?)

Supervised learning needs a label — a y for every X. In an image classifier, y is obvious (“cat” / “dog”). In finance, you have to invent y, and the obvious invention is a landmine. This is the part nobody warns you about, and it’s responsible for more dead strategies than bad models ever were.

Definition — fixed-horizon labeling. The naive approach: look $h$ bars ahead, compute the return over that window, and label it by comparing to a fixed threshold $\tau$:

$y_t = \begin{cases} +1 & \text{if } r_{t,t+h} > \tau \\ -1 & \text{if } r_{t,t+h} < -\tau \\ \phantom{+}0 & \text{otherwise} \end{cases}$

In English: “buy if the stock is up more than $\tau$ after $h$ bars, sell if it’s down more than $\tau$, otherwise call it flat.” Clean, simple, and quietly broken in two ways.

Flaw 1 — it ignores the path. The label only looks at the endpoint return, $h$ bars later. But you don’t trade endpoints — you hold a position the whole way, with a stop-loss that can take you out. Consider a trade that drops 8% (blowing through your stop, ending the position in real life as a loss) and then, after you’ve already been stopped out, recovers to close +1% on day $h$. Fixed-horizon labeling cheerfully stamps it +1, a winner — a label your actual P&L would never have collected, because you were stopped out at the bottom. The model is now learning from outcomes that couldn’t happen.

Flaw 2 — a fixed threshold ignores time-varying volatility. A threshold $\tau = 2\%$ is enormous in a calm market (price barely moves 2% in $h$ bars, so almost everything gets labeled 0/flat) and trivial in a turbulent one (price routinely swings 5%, so almost everything trips the threshold). The same $\tau$ means different things in different regimes, so your labels are inconsistent across time — and remember, that inconsistency is exactly the non-stationarity we just worked to remove from the features, sneaking back in through the labels.

Worked example — fixed-horizon gone wrong

Set $h = 5$ days, $\tau = 2\%$. Two trades:

Trade A and Trade B get the same label (0), yet one was a disaster and the other a non-event. The fixed-horizon scheme can’t tell them apart because it never looked at the path — and in a higher-vol month a τ of 2% would have labeled both as noise while a τ of 0.5% would have labeled both as signals. The threshold is doing the deciding, and it’s the wrong size half the time. We need a labeling scheme that watches the path and scales with volatility. Enter the triple barrier.

The triple-barrier method

Analogy. Picture three exit doors around a trade the instant you enter it. A door above you (take profit), a door below you (stop loss), and a clock on the wall that forces you out when time’s up (max holding period). The label is simply which door you walk through first. That’s the triple-barrier method, and it fixes both flaws at once: it watches the whole path (whichever barrier is touched first wins) and it can scale the doors’ distances to volatility (so the doors mean the same thing in calm and chaos).

Definition. From each entry, set three barriers:

• Upper (profit-take) — a horizontal barrier above entry. Touch it → label +1.
• Lower (stop-loss) — a horizontal barrier below entry. Touch it → label −1.
• Vertical (max holding time) — a time limit $h$. If neither horizontal barrier is hit by then, the trade expires; label 0 (or, in a common variant, the sign of the return at expiry).

The label is the first barrier touched. Crucially, make the horizontal barriers volatility-scaled rather than fixed — e.g. set them at $\pm 2\hat{\sigma}_{\text{daily}}$, so they automatically widen in turbulent markets and tighten in calm ones. Now a “+1” means the same thing — the trade reached two standard deviations of profit before it lost two standard deviations or ran out of time — regardless of the regime. The fixed-threshold disease is cured.

$\text{upper} = P_0 \,(1 + u\,\hat{\sigma}), \quad \text{lower} = P_0\,(1 - \ell\,\hat{\sigma}), \quad \text{vertical at } t = t_0 + h$

Worked example — labeling one trade

Entry at $P_0 = 100$. Recent daily volatility $\hat{\sigma}_{\text{daily}} = 1.5\%$. Set barriers at $\pm 2\hat{\sigma}$ and a vertical of $h = 5$ days.

• Upper barrier = $100 \times (1 + 2 \times 0.015) = 100 \times 1.03 = \mathbf{103.0}$
• Lower barrier = $100 \times (1 - 2 \times 0.015) = 100 \times 0.97 = \mathbf{97.0}$
• Vertical = end of day 5.

Now watch a price path bar by bar:

The lower barrier is touched first, on day 3 → the label is −1. Notice that the price later rips to 104 on day 5 (well above the upper barrier), but it doesn’t matter one bit: you were stopped out on day 3, and the triple-barrier label honestly records that loss. A fixed-horizon labeler looking only at day 5 would have called this a screaming +1 winner — the exact mislabel we’re eliminating. Same path, opposite labels; only one of them matches what your account would actually have done.

Meta-labeling

So far we’ve decided which way to bet and labeled the outcome. Meta-labeling adds a second, sneakier model on top — and it’s one of the highest-leverage tricks in the financial-ML toolbox.

Analogy. Think of a sniper team. The spotter (the primary model) calls the target and the direction — “long, that one.” The trigger-puller (the meta-model) decides whether the shot is actually worth taking and how much to commit — “high confidence, full size” or “shaky, pass.” Splitting these two jobs lets each specialize: the spotter is allowed to be trigger-happy and call lots of targets, because a disciplined second filter decides which calls to act on.

Definition. Meta-labeling uses two stacked models:

1. A primary model (or even a simple rule) decides the side — long or short. It’s allowed to have low precision; it just needs to catch the real moves (high recall).
2. A secondary (meta) model decides whether to act on the primary’s call, and how big. It’s a binary classifier whose label is “was the primary call correct? (1/0)”, so its prediction is the probability the primary signal is right — a precision filter and a position-sizer in one.

The meta-model never decides direction — that’s the primary’s job. It only answers “should I take this bet, and with how much conviction?” This cleanly separates ‘which way’ from ‘how much,’ and it tends to lift precision and F1 (the harmonic mean of precision and recall) because it suppresses the primary’s false positives. Bonus: since the meta-model outputs a probability, you can size by confidence — bet bigger when it’s sure, smaller when it’s marginal.

A quick refresher on the metrics this improves, because they’re the whole point:

• Precision = of the trades you took, what fraction were right. (Few false positives.)
• Recall = of the real opportunities, what fraction you caught. (Few false negatives.)
• F1 = the harmonic mean of the two — punishes you for being lopsided.

Worked example — filtering false positives

Suppose your primary model is an aggressive trend rule that fires 100 long signals. It has high recall (it catches almost every real up-move) but lousy precision — only 40 of the 100 were genuinely good; the other 60 are false positives. Precision = 40/100 = 40%.

Now train a meta-model on those 100 signals, labeled 1 if the primary was right and 0 if wrong, and have it act only when its confidence clears a threshold. Say it correctly green-lights 35 of the 40 true winners and correctly vetoes 45 of the 60 false positives (acting on only 15 of them):

Of the 50 trades you now take, 35 are winners → precision = 35/50 = 70%, up from 40%. You threw away 5 real winners (recall drops a bit), but you also dodged 45 losing trades — and you can pour more capital into the high-confidence green-lights and a sliver into the marginal ones. Same primary signal, far cleaner book. That precision jump from 40% to 70%, bought without changing the direction model at all, is why meta-labeling is so prized.

Sample weighting & uniqueness

Here’s an assumption every off-the-shelf ML algorithm quietly makes and that financial labels quietly violate: that your training samples are IID — independent and identically distributed, each one a fresh, separate draw. With triple-barrier (or any horizon-based) labels, they are not even close, and ignoring it silently corrupts training.

The problem — overlapping label windows. Each label spans a window of future bars (from entry until a barrier is touched). If you label every bar, those windows overlap heavily: the label for Monday and the label for Tuesday both depend on, say, Wednesday’s and Thursday’s returns. The same return drives many labels. So the samples aren’t independent draws — they’re a tangle of shared outcomes, and a crowded, high-activity stretch of market gets its returns counted over and over. Naive training over-counts those crowded periods, letting a handful of overlapping events dominate the fit as if they were dozens of independent ones — the very same “phantom breadth” illusion that wrecks diversification, now poisoning your model’s training set.

The fix — weight by uniqueness. Down-weight each sample by how much its label-window overlaps with others. The cleanest measure is average uniqueness: at each point in time, count how many label windows are “live” (concurrency $c_t$); a sample’s uniqueness over its life is the average of $1/c_t$ across the bars it spans. A label that shares every one of its bars with one other label is only half unique, so it should carry about half the weight. Two refinements stack on top:

• Weight by absolute return (label informativeness). A label tied to a big move carries more information than one tied to a tiny wiggle, so weight by $|r|$ — let the meaningful outcomes pull harder on the fit.
• Time decay. Markets evolve, so older samples can be down-weighted toward (but usually not to) zero, letting recent regimes matter more without throwing the past away entirely.

Worked example — two overlapping labels

Two trades opened a day apart, each labeled over a 2-day window, so they share one day of returns:

Day 2’s return feeds both labels. Roughly, each label is unique on one of its two days and shared on the other, so its average uniqueness is about $\tfrac{1}{2}(1 + \tfrac{1}{2}) \approx 0.75$ on this toy timeline — and on the fully shared day each gets credit for only $1/2$ of that bar. The headline intuition the prompt wants: a return shared by two labels should be split ~0.5 / 0.5 between them, not double-counted. Weight the two samples down accordingly and the shared day stops voting twice. Scale this up to a real book where dozens of labels can be live at once, and unweighted training would let a single hot week stomp all over the loss function.

Putting it together

Manufacturing X and y is where financial ML is won or lost, long before any model is fit. On the feature side, raw prices are non-stationary poison and full returns are stationary but amnesiac, so you reach for fractional differentiation — the smallest differencing order $d$ that achieves stationarity, keeping maximal memory — and you vol-scale features so a move means the same thing in calm and chaos. On the label side, naive fixed-horizon labels ignore the path and ride a fixed threshold through a volatile world, so you switch to the triple-barrier method (first of upper/lower/vertical wins, barriers scaled to $\sigma$), optionally stack a meta-model to filter the primary’s false positives and size by confidence, and finally weight samples by uniqueness (plus $|r|$ and time decay) because overlapping label windows make your data anything but IID.

You can now build the inputs and the targets the right way — stationary-yet-remembering features, and honest, path-aware, vol-scaled labels with the proper weights. But there’s a final trap hiding in plain sight, and it’s the one that turns a “great” backtest into a real-money disaster: those overlapping labels don’t just bias the fit — they leak the future into your validation, so the model grades its own homework with the answer key open. Standard k-fold cross-validation, the technique everyone trusts, is quietly broken for financial data. Fixing it — with purging, embargoes, and an honest accounting of leakage — is the subject of the next lesson, Leakage & Purged Cross-Validation.