Quant Memo
Core

Crowding in ML-Driven Signals

When many desks train models on the same public features and similar data, their outputs converge even if the models themselves look different — and that convergence shows up as a shared, crowded trade rather than a diversified book of independent bets.

Prerequisites: Why ML Strategies Degrade Live, Turning a Model Prediction Into a Position

Two firms can build ML models that look nothing alike — one a gradient-boosted tree, the other a neural network — and still end up making almost the same bets. If both are trained on the same handful of publicly available data sources (price history, standard fundamentals, common alt-data vendors) and both are optimized to predict the same thing over the same horizon, their outputs will correlate heavily even though the model architectures differ, because the information going in is shared, not the code.

This is ML signal crowding: many participants converging on similar positions because they're all extracting similar patterns from similar data, regardless of how different their models look on paper.

Crowding lives in the data and the objective, not the algorithm. Two very different models fed the same features and trained to predict the same target will produce correlated trades, and that correlation is invisible if you only look at model architecture.

Why it matters more for ML than for classic factors

A value investor knows plenty of other people also buy cheap stocks; crowding in factor investing is a known, decades-old risk that portfolio construction routinely adjusts for. ML-driven signals often feel proprietary because the model itself — the specific network weights, the specific tree splits — is genuinely unique to the firm that built it. That uniqueness is real but largely beside the point: if the underlying data and target are common, the trades converge anyway, and the false sense of uniqueness makes the crowding harder to spot and correct for.

common price + fundamentals data tree model neural net linear model three different architectures, one shared crowded trade
Different model families trained on the same common inputs and the same prediction target end up correlated at the position level, even though nothing about their internals looks alike.

Worked example

Three quant funds each build a model predicting 5-day returns from a widely-licensed sentiment data vendor plus standard price and volume features. Fund A uses gradient boosting, Fund B a neural network, Fund C a linear ridge regression. Backtested independently, each model shows a healthy Sharpe ratio around 1.5. But their top-decile long positions overlap by 70% on any given day, because all three are picking up the same sentiment-vendor signal driving the same names. When the vendor's data quality degrades for two weeks after a methodology change, all three funds' returns drop together — not because their models broke independently, but because they were never really three independent bets.

What this means in practice

Before trusting an ML strategy's diversification benefit, check what data and target it shares with other signals already in the book — including signals run by other desks at the same firm, since internal crowding is just as real as crowding against the market. A cheap sanity check is correlating the model's daily position changes against a simple proxy built only from the same public data source; if the correlation is high, the model's apparent sophistication isn't buying much independence.

A high in-house Sharpe ratio does not rule out crowding — a crowded trade can still look profitable for years before the crowd unwinds together, at which point correlated deleveraging turns a modest drawdown into a sharp, synchronized one across every fund holding the same trade.

Related concepts

Practice in interviews

Further reading

  • Khandani & Lo, 'What Happened To The Quants In August 2007?'
ShareTwitterLinkedIn