Project 1 · Decision Tree: Stock Momentum

1. The Brief

The desk's question, in trader language: "Every morning I see RSI, MACD, the moving averages, volume. Which combinations of those numbers actually precede a good next quarter — and can you show me the rule?" That last clause is why this project is a decision tree and not a neural network: Chapter 16's tree is the model whose entire logic can be printed on one page (export_text) and argued over in a meeting. A desk can't interrogate 127 weights; it can interrogate "if ATR ≤ 6.94 and the 50-day average is above the 200-day, then…"

The plan, and where each course chapter plugs in:

The eight stocks — AAPL, MSFT, GOOGL, TSLA, JPM, XOM, JNJ, WMT — are deliberately cross-sector (tech, banks, energy, healthcare, retail) so the model cannot quietly become a sector bet. One honest design note carried over from the original project: the template's "fundamental" columns (P/E, ROE, growth, leverage…) are random placeholders, not real data — and §7 turns that flaw into one of the lesson's best experiments.

2. The Finance Primer — Reading a Chart Like an Analyst

Nothing in this section is machine learning. It is the vocabulary the rest of the lesson speaks — the five indicator families a technical analyst watches every morning, each reduced to one formula, one intuition, and one thing it catches that the others don't.

2.1 RSI — the momentum thermometer (0–100)

By hand, because the course always computes one first. Fourteen daily price changes:

2.2 MACD — trend, with a memory

2.3 The moving-average crossover — the golden cross

When the 50-day average crosses above the 200-day average ("golden cross"), medium-term buyers have overtaken long-term ones — a classic bull signal; the reverse is the "death cross". The feature is binary: MA_Crossover = 1 when SMA₅₀ > SMA₂₀₀, else 0. It is the slowest, most forgiving signal on the page — and the one with the longest warm-up (199 days of history before SMA₂₀₀ even exists).

2.4 ATR — how violent, not which way

2.5 Volume ratio — conviction

Price moves on unusually heavy volume carry more information than the same move on thin volume: someone big is acting. Volume_Ratio = today's volume ÷ 20-day average volume — 1.0 is an ordinary day, 2.0 means twice the usual crowd showed up. The last technical feature, Volatility (20-day rolling standard deviation of close), is ATR's cousin measured on closes alone.

2.6 The fundamental side — what the placeholders would have meant

The project template carries eight fundamental columns as random noise. Real versions would read like this to an analyst — and §8 discusses why using them properly is harder than it sounds:

3. From Prices to Features

The engineering loop runs per ticker — that word "per" is load-bearing (§4 explains what breaks without it). The complete, corrected feature block:

for ticker, g in df.groupby('Ticker'):
    g = g.sort_index().copy()                     # one ticker's history, in date order

    # trend
    g['SMA50']  = g['Close'].rolling(50).mean()   # 50-day simple moving average
    g['SMA200'] = g['Close'].rolling(200).mean()
    g['MA_Crossover'] = (g['SMA50'] > g['SMA200']).astype(float) \
                          .where(g['SMA200'].notna())   # NaN while SMAs warm up

    # momentum
    delta = g['Close'].diff()                     # day-over-day change
    gain  =  delta.where(delta > 0, 0).rolling(14).mean()
    loss  = (-delta.where(delta < 0, 0)).rolling(14).mean()
    g['RSI'] = 100 - 100 / (1 + gain / loss)
    g['MACD'] = g['Close'].ewm(span=12).mean() - g['Close'].ewm(span=26).mean()
    g['Momentum'] = g['Close'].pct_change(20) * 100      # 20-day % price change

    # volatility
    tr = pd.concat([g['High'] - g['Low'],
                    (g['High'] - g['Close'].shift()).abs(),
                    (g['Low']  - g['Close'].shift()).abs()], axis=1).max(axis=1)
    g['ATR'] = tr.rolling(14).mean()
    g['Volatility'] = g['Close'].rolling(20).std()

    # volume
    g['Volume_Ratio'] = g['Volume'] / g['Volume'].rolling(20).mean()

Listing 1 — Technical feature engineering, per ticker. Seven features from five columns.

Four pandas idioms do all the work, and each is worth reading slowly:

• .diff() — subtracts the previous row: daily price change. The seed of RSI.
• .rolling(n).mean() / .std() — a sliding n-day window; the first n−1 rows have no answer and become NaN. SMA₂₀₀ needs 199 prior days — the per-ticker warm-up that trims our dataset from 13,560 rows to 11,464.
• .ewm(span=n).mean() — the exponential moving average: every row gets a value from day one (weights just decay into the past), which is why MACD has no warm-up but SMA₂₀₀ does.
• .shift() — moves a series by one row; used here to fetch yesterday's close for the true range. Its negative sibling .shift(-63) fetches the future — the entire labelling mechanism, and the entire leakage risk, of §4.

One real row of the finished matrix, so the features stop being abstractions — AAPL, 25 January 2022:

Read it like the analyst who lived it: deeply oversold (RSI 15), below trend on MACD, still technically in a golden-cross regime — and the 20-day momentum had gone decisively negative. The next quarter lost a further 1.7%. One row, seven numbers, one label: that is the entire supervised-learning contract of this project, times eleven thousand.

4. Labelling the Future — Carefully

Supervised learning needs ground truth, and for momentum the truth arrives three months later. The label for day t is built from the price at day t+63 (three months of trading days):

Then the continuous forward return becomes a class. The template uses terciles — the 33rd and 67th percentiles of the whole dataset's forward returns:

A 31.7-point spread between class means — that is the prize the tree is trying to rank. And tercile labelling keeps the classes nearly balanced by construction (34.3% / 33.7% / 32.0%), so accuracy's majority baseline sits at 0.343 — the number every result in §6 must beat.

4.1 Three landmines in the template

The original project code ships with three genuine bugs around this labelling step. None of them crash — which is precisely why they are worth studying. All three were found by auditing, and all three are fixed in this lesson's canonical run.

1. The cross-ticker seam. The template concatenates all tickers into one frame and then calls shift(-63) and rolling(50). Rolling windows and forward shifts run straight across ticker boundaries: Apple's last trading days would be labelled with Microsoft's future prices, and its "50-day average" at the seam mixes two stocks' prices. Fix: every window and shift inside groupby('Ticker').
2. NaN swallowed into "Neutral". The last 63 days of each ticker have no future price, so their forward return is NaN. The template's np.where(fwd <= lo, 'Bearish', np.where(fwd >= hi, 'Bullish', 'Neutral')) sends NaN to the else-branch — NaN comparisons are False — quietly manufacturing ~500 fake "Neutral" labels for days whose truth is unknown. Fix: pd.cut, which maps NaN to NaN, then drop the unknowns (504 rows).
3. The fake golden cross. During the 199-day SMA200 warm-up, (SMA50 > SMA200) compares NaN to NaN — which is False — so MA_Crossover reads 0 ("death cross") for the first year of every ticker, when the honest value is "don't know". Fix: .where(g['SMA200'].notna()) keeps those rows NaN until the average exists.

Together the three fixes shrink the dataset from the template's effective 13,400 rows to 11,464 honest ones — the difference between 1,936 rows of contaminated or fake-label data and a clean slate. Chapter 31's lesson generalises: the bugs that cost you are the ones that don't raise exceptions.

5. The Model — Tuned Like Chapter 31 Taught

The classifier itself needs no re-teaching — Chapter 16 built trees from Gini impurity up, and Chapter 31 supplied the tuning discipline. What matters here is the grid, run for real on the 8,598-row training set:

param_grid = {
    'max_depth':        [3, 4, 5, 6, 7],      # five depths
    'min_samples_split':[10, 15, 20, 30],     # × four split floors
    'min_samples_leaf': [5, 10, 15],          # × three leaf floors
    'criterion':        ['gini', 'entropy'],  # × two impurities
}                                   # = 120 configurations

grid = GridSearchCV(DecisionTreeClassifier(random_state=42),
                    param_grid, cv=5, scoring='accuracy', n_jobs=-1)
grid.fit(X_train, y_train)         # 120 × 5 = 600 fits, all cores

Listing 2 — The tuning grid: 120 candidates × 5-fold CV.

Chapter 31's plateau, transplanted to finance: the top five candidates sit within 0.0014 of each other, the winner chose the shallowest impurity (gini) and the deepest depth offered (7) — and the split/leaf floors barely matter once leaves hold ≥10 trading days. A depth-7 tree with minimum-10-sample leaves is the champion: 82 leaves, each averaging about 105 training rows. When the top of the grid is flat, any resident of the plateau ships.

6. The Scoreboard

The tuned tree meets the 2,866 held-out days exactly once (Chapter 31's rule). The headline first, then the anatomy:

Now the metrics in the only language that matters on a desk — what does betting on this signal cost me?

And the single most expensive cell in Figure 3, read as a trade: 348 genuinely Bullish days were labelled Bearish. If the desk had shorted (or simply sat out) on those signals, it missed or bet against days that averaged +22.5% over the following quarter. Precision on the Bearish call and recall on the Bullish call are where the money lives — exactly the class-asymmetric costs Chapter 18 taught us to price before deploying anything.

7. A Trader Reads the Tree

The whole point of choosing this model: its logic can be printed. The champion's first three levels (the full tree is depth 7 with 82 leaves — Figure 4):

|--- ATR <= 6.94
|   |--- ATR <= 0.82
|   |   |--- MACD <= -0.45
|   |   |   |--- Volatility <= 0.69:  class: Bullish
|   |   |   |--- Volatility >  0.69:  [deeper]
|   |   |--- MACD > -0.45
|   |   |   |--- MA_Crossover <= 0.50: [deeper]
|   |   |   |--- MA_Crossover >  0.50: [deeper]
|   |--- ATR > 0.82 ... (calm-regime branches)
|--- ATR > 6.94
|   |--- MA_Crossover <= 0.50
|   |   |--- MACD <= 8.12 ...
|   |--- MA_Crossover > 0.50
|   |   |--- MACD <= -16.10:  class: Bullish
|   |   |--- MACD > -16.10 ...

Listing 3 — export_text(best_tree, max_depth=3), abbreviated. The tree's first question is about violence, not direction.

A trader's reading: the tree's first question is "how violent is this stock?" — ATR at the root — and only then does it ask about trend (MACD, golden cross). Even the counterintuitive leaf helps teach: in the high-ATR branch, days with extremely negative MACD (≤ −16, a severe drawdown) resolve to Bullish — the tree rediscovering mean-reversion inside turbulence: after a violent fall, the next quarter is more often a top-third outcome than a bottom-third one. Rules you can argue with are the product; that is why this project is a tree.

7.1 What mattered — and the noise experiment

The green bars are the lesson inside the lesson. The template's fundamental columns are random numbers, drawn uniform — and the tree, given fifteen features, allocated essentially zero decision weight to all eight of them (largest share 1.2%, one feature literally never used). Information gain cannot be counterfeited: if a column carries no mutual information with the label, splitting on it buys nothing. Replace those green bars with real, point-in-time fundamentals and the chart becomes the genuine experiment — does value+quality data add to what the chart already knows? That is the open door this project leaves for its Random Forest sequel.

8. Honest Limits — and the Professional Upgrades

The original assignment guide told students to expect 65–75% accuracy. Our tuned, bug-fixed, real-data tree scored 46.2% against a 34.3% baseline. Both numbers are correct — and the gap between expectation and reality is the most valuable content in this lesson. Why so hard?

• The market is mostly efficient at this horizon. Three-month ahead ranks are close to the information frontier of public chart data. A 12-point lift over baseline is not a failure; it is the honest size of the edge that seven technical indicators contain. (Enough to be interesting; nowhere near enough to trade unlevered and unhedged after costs.)
• Random splits flatter the model. Training on 2024–2026 rows while testing on 2020 rows lets the tree "know" regimes it shouldn't. Time-ordered evaluation would very likely shave points off — which is exactly why it must be done before believing any backtest.
• Dollar-scaled features leak ticker identity (the warning in §7). Part of ATR's 0.35 importance is stock-selection, not regime-reading.
• No transaction costs, no slippage, no shorting constraints — the label is a return tercile, not a tradable P&L. The capstone's money-metric discipline has not been applied here yet.

The upgrade list, in order of expected payoff:

1. Walk-forward split: train ≤ 2023, validate 2024, test 2025–26; then roll. Turns the evaluation from "can it memorise regimes" into "could it have made money in sequence".
2. Scale-free features: ATR/Close, MACD/Close, Volatility/Close. One-line change, removes the ticker-identity leak.
3. Real point-in-time fundamentals: P/E and ROE as they were on the day — not today's ratios pasted onto history, which would be textbook look-ahead bias (Chapter 3's rule wearing a valuation costume).
4. More names: 30–50 stocks (the guide's own advice) — more cross-sectional variety, less single-name regime risk.
5. An ensemble: the Random Forest on identical features is this project's designed sequel (Project 2) — same labels, same snapshot, one hypothesis: does averaging 100 noisy trees beat reading one honest tree?