From ML Signal to Portfolio

You have spent five lessons building a machine-learning model that does not lie to you. You labeled returns without leaking the future (triple-barrier, meta-labels), you cross-validated in a way time series can’t game (purging, embargo, combinatorial purged CV), you haircut your Sharpe for the hundreds of configs you secretly tried (the deflated Sharpe ratio), and you measured which features actually matter (MDI/MDA). Congratulations: you own a forecast.

A forecast is not a strategy. It is a column of numbers — a probability, an expected return, a rank — and the market does not accept columns of numbers as orders. Somewhere between “the model says +0.6% next week” and “the broker fills 12,000 shares” lives an entire second discipline: portfolio construction. This is where ML quants quietly bleed out, because the model that looked brilliant in a notebook gets sized badly, combined badly, traded too fast, and watched too loosely — and the edge evaporates on the way to the exchange. This lesson is the bridge from a clean prediction to a live, honest position, and it leans hard on the stat-arb pipeline you already met. The enemy, one last time, is overfitting — and it doesn’t stop at the model. It follows you all the way to the fill.

From prediction to position

Analogy. Your model is a weather app that says “62% chance of rain.” You don’t respond by staying home forever (full conviction) or ignoring it (no conviction) — you grab an umbrella proportional to how wet you’d get and how sure the app is. Position sizing is the umbrella: it translates a probability into how much you’re willing to lose if it’s wrong.

Definition. A position is a signed dollar (or risk) weight $w_i$ on each asset $i$. The model hands you an alpha forecast $\hat{\alpha}_i$ — your best guess of asset $i$‘s excess return, or a probability, or a rank. The sizing rule is the function that maps forecast → weight. Five rules cover almost everything you’ll do in practice:

• Proportional-to-forecast. $w_i \propto \hat{\alpha}_i$. Bigger predicted return, bigger position. Simple, but it trusts the magnitude of a noisy forecast — dangerous when the model’s level is poorly calibrated (which ML models often are).
• Cross-sectional rank → dollar-neutral long/short. Throw away the magnitudes, keep only the ordering. Rank all names, go long the top decile / short the bottom decile, equal dollars each side. Robust to miscalibration — you only need the model to rank, not to predict levels. This is the stat-arb default.
• Confidence-scaled (meta-label sizing). Size by the model’s probability of being right. A meta-label probability $p_i$ becomes a position like $w_i \propto (p_i - 0.5)$ or a calibrated bet fraction. High-confidence calls get more capital; coin-flip calls get almost none.
• Risk-budgeted. Scale each position so it contributes equal risk (volatility), not equal dollars: $w_i \propto \hat{\alpha}_i / \sigma_i$. A volatile name gets a smaller dollar weight for the same risk bite.
• Kelly-lite cap. The Kelly criterion says bet a fraction proportional to edge-over-variance — but full Kelly is brutally aggressive and assumes you know your edge exactly (you don’t). Practitioners use fractional Kelly (a half or quarter) and a hard per-name cap so one overconfident forecast can’t blow up the book.

Worked example — meta-label probabilities to a beta-neutral book. Your model scores six stocks with the probability that a long trade hits its profit target. Rank them, long the top two, short the bottom two, equal dollars ($100 a side, $50 per name), then check the market exposure:

Dollar-neutral? Yes — $100 long, $100 short. But beta-neutral? No. Long-side beta exposure $= 50(1.4) + 50(0.9) = 115$ $ of “market.” Short-side $= 50(0.8) + 50(1.2) = 100$ $. Net market exposure $= 115 - 100 = +15$ $ of beta — a hidden long tilt. To neutralize, scale the legs so $\sum_{\text{long}} w_i\beta_i = \sum_{\text{short}} w_i\beta_i$: shrink the long leg or grow the short until the betas match. A “dollar-neutral” book that isn’t beta-neutral is secretly a small directional bet that shows up on the worst possible day — exactly the trap from the relative-value lesson, now wearing an ML costume.

When to use it

Rank-based dollar/beta-neutral construction is the workhorse when your model is a cross-sectional stock picker and you don’t trust its magnitudes — which is most ML signals. Reach for confidence-scaled or risk-budgeted sizing when you’ve genuinely calibrated the model and want to express conviction. Save Kelly-lite for when you have a defensible estimate of edge and variance — and even then, cap it, because a model that’s wrong about its own edge will size you straight into a drawdown.

Combining ML alphas via the breadth engine

Analogy. One ML signal is a single slightly-loaded die — barely better than fair. The whole quant business is rolling many dice, of different shapes, across thousands of names, and adding them up. The noise in each cancels; the sliver of truth in each reinforces. A single ML model is never the strategy; it’s one die in the cup.

The Fundamental Law, again. From the stat-arb course: your information ratio is your skill per bet times the square root of how many independent bets you make.

$\text{IR} \approx \text{IC} \cdot \sqrt{\text{breadth}}$

Here IC (information coefficient) is the correlation between your forecast and the realized return — for a single ML signal it’s humblingly small, typically 0.02 to 0.05. Anything above ~0.10 out-of-sample should make you suspect leakage, not genius. Breadth is the number of independent bets per period. A lone ML signal with IC = 0.03 traded on one bet is worthless; the same signal across 500 independent names is a fundable strategy.

Stacking orthogonal ML alphas. Two ML models whose errors are uncorrelated combine like independent signals: averaging keeps the full signal while halving the independent noise, so for two equally-good orthogonal signals the combined IC rises by $\sqrt{2}$:

$\text{IC}_{\text{combined}} \approx \text{IC} \cdot \sqrt{2}.$

More generally, $n$ equally-good, mutually uncorrelated signals scale the combined IC by $\sqrt{n}$ — the same $\sqrt{\cdot}$ diversification math that scales the portfolio IR, now applied to signals. The catch is identical too: the bonus only fires on independent signals. Two gradient-boosted models trained on the same momentum and value features are not two signals — they’re one signal with two random seeds, correlated ~0.95, and stacking them buys you almost nothing. The IC jump comes from a genuinely different alpha: a model on order-flow imbalance, a model on filings sentiment, a model on a different horizon.

Worked example — two uncorrelated ML signals. Signal X (a tree ensemble on price/volume features) has IC = 0.03. Signal Y (a model on textual sentiment) also has IC = 0.03, and their forecast errors are uncorrelated. Equal-weight them:

$\text{IC}_{\text{combined}} \approx 0.03 \times \sqrt{2} = 0.03 \times 1.414 \approx 0.042.$

You lifted effective skill from 0.03 to 0.042 — a 41% jump — without finding a single new feature, just by combining orthogonally. Now suppose X and Y were actually 0.8-correlated (both really momentum in disguise). The effective $\sqrt{n}$ collapses toward $\sqrt{1}$, and the combined IC barely exceeds 0.03. Same two models, wildly different payoff. Orthogonality is the whole game — for ML alphas exactly as for hand-built ones.

When to use it

Lean on breadth whenever each ML forecast is weak (it always is) but you can apply it across hundreds of independent names and stack it with genuinely different alphas. It’s the wrong frame when your ‘many models’ are seed-variants of one model, or your ‘many names’ all share a factor — there, effective breadth collapses to a handful and no amount of headline count delivers the $\sqrt{N}$ you’re counting on.

Capacity & turnover

Analogy. A fresh ML signal is a fish that spoils in hours, not weeks — short-horizon models often predict the next few days sharply and then go stale. To capture it you must trade fast, and fast trading is a turnstile that charges you a toll on every pass. Trade often enough and the tolls eat the whole catch.

Definition — turnover and net alpha. Turnover is the fraction of the portfolio you buy and sell each period. ML signals, especially short-horizon ones, fire frequently and demand high turnover. Every trade pays two tolls:

• Transaction cost — the bid-ask spread plus commissions, a roughly fixed toll per round trip.
• Market impact — your own order pushes the price against you. Crucially, impact grows like the square root of size: $\text{impact} \approx k\sqrt{\text{size}/\text{ADV}}$, where ADV is average daily volume. Doubling an order does not double its impact cost — but it does keep rising, and at scale it dominates.

What you actually earn is net alpha = gross alpha − costs. A signal with a gorgeous gross Sharpe on paper can be flat or negative after costs. And here’s the punchline that destroys many ML strategies: as you put more capital to work, your orders grow relative to ADV, impact rises, and net alpha falls. The size at which net alpha hits zero is your capacity — the most money the strategy can run before it stops making money.

Worked example — net alpha vs. size, and where capacity bites. A short-horizon ML signal produces a gross alpha of 40 bps per trade. Cost per round trip is a fixed 3 bps of spread plus impact $\approx 12\sqrt{\text{participation}}$ bps, where participation is the order as a fraction of ADV. Step the capital up so each rebalance demands more of ADV:

Read the table top to bottom: a signal worth +35.8 bps net at $10M is worth ~0 bps at ~$9B. The gross alpha never changed — costs ate it as size grew. A high-Sharpe paper signal can be completely unprofitable at the size you want to run it. This is why ML quants must estimate capacity before raising capital, not after.

Signal decay, concept drift & retraining

Analogy. An ML alpha is an ice cube and a melting glacier at once. The ice cube is decay: the moment the model fires, the forecast is at full strength and shrinks every day you wait. The glacier is concept drift: the entire relationship the model learned — how features map to returns — slowly shifts under your feet as regimes change and other funds discover the same edge. The first you fight by trading promptly; the second you fight by retraining.

Alpha decay and the optimal horizon. A signal’s predictive power fades geometrically with holding horizon $h$:

$\text{IC}(h) = \text{IC}_0\, e^{-h/\tau}, \qquad \text{half-life} = \tau \ln 2 \approx 0.693\,\tau,$

where $\tau$ is the decay constant in days. ML signals often have a small $\tau$ — they’re fast, predicting days not months. Decay pushes you to trade fast; turnover costs (last section) push you to trade slow. The winner is a hump: net alpha per day peaks at an optimal holding horizon $h^*$ in the middle. Faster decay → $h^*$ earlier; higher cost → $h^*$ later.

Worked example — exponential IC decay. An ML signal has $\tau = 6$ days. Its half-life is $6 \times 0.693 = 4.2$ days — after barely four days the edge is half gone. Tabulating $\text{IC}(h)/\text{IC}_0 = e^{-h/6}$:

By day 20 the signal retains ~4% of its bite — noise. If your compliance/operations reality means you can only act a week after the model fires, you’ve surrendered most of the edge before placing the trade. Measure the decay curve, not a single headline IC, or you’ll quote a number you can never actually trade at.

Concept drift and walk-forward retraining. Decay is about one forecast going stale; concept drift is about the whole model going stale because the world changed. You combat it by retraining walk-forward: never train once and trade forever. Slide a training window forward through time, refit, and trade the next out-of-sample block — the same purged, embargoed discipline from the leakage lessons, now run repeatedly. Two window styles:

The single most important diagnostic: monitor live IC against backtest IC. If your backtest IC was 0.04 and the live, realized IC over the last quarter is ~0.00, the signal has either decayed, drifted, or been crowded out — and no retraining frequency fixes a signal the market has already arbitraged away. Live IC is the strategy’s pulse.

When to use it

Match retraining cadence to the drift speed, not a calendar habit: a fast-drifting micro-structure model may need monthly rolling refits, while a slow fundamental model can sit on an expanding window for a year. Use expanding windows when the relationship is stable and data is scarce; use rolling when regimes turn over and recent data is more representative than ancient history. Above all, let live IC ≈ 0 be the alarm that overrides any schedule — a dead signal doesn’t need retraining, it needs retiring.

Deployment discipline — the overfitting enemy, one last time

Analogy. You’ve spent the whole course refusing to fool yourself. Deployment is the final exam where it’s easiest to cheat by accident. It’s the dieter who weighs in honestly all month, then steps on the scale forty times on the last day until it reads what they want. The discipline that protected your model in research must survive contact with real capital.

The honest-deployment checklist. Each rule is a defense against a specific way the edge becomes a mirage:

• Lock the test set. The final out-of-sample block is touched once, at the very end. Every peek that informs a change contaminates it. If you’ve looked, it’s no longer out-of-sample — it’s training data wearing a disguise.
• Paper-trade before capital. Run the strategy live on real-time data with fake money first. This catches the gap between a clean backtest and messy reality — stale data, missed fills, costs you underestimated — before that gap costs you anything.
• Track live-vs-backtest, relentlessly. Plot realized live IC and net Sharpe against what the backtest promised. A persistent shortfall means the backtest was optimistic — almost always from costs, leakage, or overfitting you didn’t catch.
• Kill the strategy if live IC ≈ 0. This is the hardest rule to obey because you’re emotionally invested. But a signal whose live IC has flatlined is dead — decayed, drifted, or crowded out. Cut it. Hope is not a risk model.
• Never re-tune on the live period. The instant you adjust hyperparameters to “fix” disappointing live results, you’ve overfit to the one dataset that was supposed to judge you honestly. Changes must be validated on fresh out-of-sample data, never on the live tape you’re trying to explain away.
• Size to capacity. Run the strategy at the asset level where net alpha is still solidly positive — not at the level where net alpha is zero. Leaving capacity headroom is what keeps impact from quietly eating the edge.
• Budget for the deflated-Sharpe haircut. You tried hundreds of configurations; the best one’s backtest Sharpe is inflated by that search. The deflated Sharpe ratio discounts your headline Sharpe for the number of trials and the non-normality of returns. Deploy expecting the deflated number, not the seductive raw one — and you’ll be pleasantly un-surprised when live results land near it instead of crushed when they fall short of a fantasy.

The closing synthesis. Trace the whole course and one enemy appears at every step. In feature engineering, overfitting was inventing predictors from noise. In labeling, it was leaking the future through overlapping labels. In validation, it was ordinary k-fold pretending time doesn’t flow one way, defeated by purging and embargo. In backtest evaluation, it was the best of hundreds of trials masquerading as skill, deflated by the deflated Sharpe ratio. In feature importance, it was reading meaning into MDI inflated by noisy, correlated features. And here, in deployment, it’s sizing on miscalibrated levels, counting random seeds as breadth, ignoring costs and capacity, re-tuning on the live tape. Overfitting was the enemy from the first feature to the final fill. The entire discipline of this course is one sentence repeated in six dialects: don’t fool yourself, and be especially suspicious when the results look great.

Putting it together

The bridge from prediction to portfolio reads top to bottom. Take the ML model’s noisy forecast and turn it into a position — usually by ranking cross-sectionally and going long/short the extremes, beta-neutralized, because ML levels are miscalibrated and only the rank is trustworthy. Combine it with genuinely orthogonal ML alphas through the breadth engine (IR ≈ IC·√breadth), remembering that random seeds aren’t breadth. Respect turnover and capacity: a fast signal’s gross Sharpe is a fantasy until you subtract costs that rise like √(size), and capacity is where net alpha hits zero. Trade at the cost-aware horizon $h^*$ where the decay-vs-cost hump peaks, retrain walk-forward against concept drift, and monitor live IC as the strategy’s pulse. Then deploy with discipline — lock the test set, paper-trade, never re-tune on the live tape, size to capacity, and expect the deflated Sharpe. Overfitting was the enemy the whole way down; honesty is the only edge that survives contact with real money.

That’s the whole arc: from a column of forecasts that the market won’t accept as orders, to a hedged, cost-aware, capacity-respecting, continuously-monitored live position — built by a researcher who refused to fool themselves at every step. You’ve finished the content of Machine Learning for Alpha. What remains is to prove it stuck: head to this course’s Final Exam, a single graded run on the full pool of questions — one at a time, each answer locked the moment you submit it. No going back, no retries; just you and the material. Show that overfitting never got the better of you.