What's the one-line summary?

Full Fisher LDA classifier on today's Stats #34/#35 panel (UK Core CPI × GBPCHF, 6-window response, n=196). LOO-CV accuracy 42.86% (84/196), full-sample 49.49% (97/196), vs 31.63% majority-class baseline and 36.73% Stats #35 1D nearest-centroid. Per-class LOO accuracy: big_miss 0/13 (ZERO recall — every big_miss print collapses into an adjacent bucket), small_miss 26/53 (49%), in_line 30/62 (48%), small_beat 26/53 (49%), big_beat 2/15 (13%). Cross-verified against sklearn.discriminant_analysis.LinearDiscriminantAnalysis (solver='lsqr', empirical priors) with 100% agreement on both full-sample and LOO predictions.

Why does big_miss recall come out to ZERO?

The log-prior intercept term −(1/2) μ_k^T Σ^{-1} μ_k + log π_k in the LDA discriminant function includes log(π_k). For big_miss π = 13/196 ≈ 0.0663, log(π) ≈ −2.71. For adjacent small_miss π = 53/196 ≈ 0.2704, log(π) ≈ −1.31. That's a ~1.4-nat handicap for the big_miss class vs the small_miss class BEFORE we even look at the data. An observation that projects to the big_miss centroid at discriminant-score-difference +1.0 (a real signal for big_miss) STILL gets classified as small_miss because the prior handicap outweighs. Result: LDA with EMPIRICAL priors optimizes overall accuracy by essentially never predicting tail classes. Strip the priors (use uniform 1/5 each) and big_miss recall rises to 4/13 (30%) but overall accuracy drops to ~44%. Which regime you want depends on your loss function: uniform priors = tail-focused recall; empirical priors = maximum overall accuracy.

How much did LDA improve over Stats #35's 1D nearest-centroid?

LOO accuracy went from 36.73% (Stats #35's 1D nearest-centroid on the top canonical direction) to 42.86% (Stats #36's full 4-D LDA with class-prior weighting) — a +6.13 percentage-point improvement. Three sources: (a) using all 4 canonical dimensions (Stats #35 used only Roy's largest root λ_1 = 0.5284 = 81% of trace; the other 19% adds close-boundary discriminatory power); (b) class-prior weighting (biases predictions toward majority classes, which happens to also be where the discriminant function separates best); (c) proper Gaussian-likelihood weighting (LDA assumes equal within-class covariance) instead of the ad-hoc argmin |centroid − score| distance metric. But: the improvement is entirely concentrated in mid-bucket recall (small_miss/in_line/small_beat all jumped from ~30% to ~48%); tail-bucket recall stayed near zero.

What does the confusion matrix say about WHERE the misclassifications go?

The dominant pattern is DIAGONAL-ADJACENT collapse: true-tail-bucket prints get predicted as their adjacent mid-bucket. Big_miss (n=13) → predicted small_miss 8 times (62% of big_miss go to small_miss), in_line 2, small_beat 2, big_beat 1. Big_beat (n=15) → predicted small_beat 8 times (53%), in_line 4, small_miss 1, big_miss 0. That's the log-prior handicap in action: even when the response vector (1m/5m/15m/30m/1h/4h moves) LOOKS like a big-miss, the classifier picks the adjacent lower-prior class that's a shorter Mahalanobis-distance jump. Mid-buckets have their OWN confusion pattern: small_miss ↔ in_line (23 of 53 small_miss get called in_line; 12 of 62 in_line get called small_miss); in_line ↔ small_beat (19 of 62 in_line get called small_beat; 20 of 53 small_beat get called in_line). The mid-mid confusion is symmetric and moderate; the tail-adjacent-mid collapse is one-directional and severe.

Should retail traders care about this classifier?

The classifier itself is a pedagogical construct — it takes the 6-window post-release response (i.e., what already happened after the release fired) and tries to reverse-engineer WHICH surprise bucket the release must have been. That's the reverse of what a trader actually wants (which is: forecast the response from the surprise, not vice-versa). The real reading is: even POST-HOC, given the full 6-window response, we can only recover the bucket 43% of the time — meaning the 6-window response contains 43% bucket-information but 57% bucket-agnostic noise. And the tail buckets are the LEAST distinguishable from the mid-buckets. This is a companion reading to Stats #29 two-way ANOVA (which showed bucket carries 18% of the total variance and window carries 0%): the bucket-signal in the response is real but noisy, and the tail-bucket-signal specifically is harder to distinguish from the small-bucket-signal than the raw surprise_z distribution suggests. A trader who tries to size positions based on 'this response LOOKS like a big-miss' is going to over-classify to small_miss.

← All insights

Statistics5 September 2026· 6 min read

Statistics for Traders #36: LDA (linear discriminant analysis) posterior-probability classifier on the same UK Core CPI × GBPCHF 6-window response panel Stats #34/#35 used. LOO accuracy 42.86% (84/196), +6.13 pp over Stats #35's 1D nearest-centroid (36.73%), but big_miss recall is ZERO (0/13) — LDA collapses the tail buckets into their adjacent mid-buckets because the small tail priors (6.6% / 7.7%) can't compete with the log-prior intercept from the mid-bucket centroids.

Statistics for Traders #36. Full Fisher LDA (linear discriminant analysis) classifier on the SAME UK Core CPI × GBPCHF 6-window response panel that Stats #34 MANOVA and Stats #35 canonical direction used. n=196, K=5 classes. LOO-CV accuracy 42.86% (84/196)vs Stats #35’s 1D nearest-centroid 36.73% (72/196) and the majority-class baseline 31.63% (62/196). But: big_miss recall is ZERO(0/13) — every true big-miss print collapses into an adjacent mid-bucket, because the small tail priors (6.6% and 7.7%) can’t compete with the log-prior intercept from the mid-buckets.

Two-panel chart. Left: 5x5 LOO-CV confusion matrix heatmap for LDA on the UK Core CPI × GBPCHF 6-window panel. Rows are true buckets (big_miss, small_miss, in_line, small_beat, big_beat, top to bottom); columns are predicted buckets in the same order. Diagonal cells (correct predictions) are shaded green; off-diagonal-adjacent cells (adjacent misclassifications) are shaded coral; distant off-diagonals are shaded muted grey. Cell values: big_miss row is 0/8/2/2/1 — zero correct, 8 collapsed to small_miss; small_miss row 0/26/23/4/0 — 26 correct, 23 confused with in_line; in_line row 0/12/30/19/1 — 30 correct, 12 to small_miss, 19 to small_beat; small_beat row 2/1/20/26/4 — 26 correct, 20 confused with in_line; big_beat row 0/1/4/8/2 — only 2 correct, 8 collapsed to small_beat. Row totals (bucket sizes) shown to the right: 13, 53, 62, 53, 15. Right: horizontal-bar chart of LOO per-class accuracy vs prior-baseline for each bucket, showing big_miss 0% (well below its 6.63% prior), small_miss 49.1% (well above 27.0% prior), in_line 48.4% (above 31.6%), small_beat 49.1% (above 27.0%), big_beat 13.3% (above 7.65% prior). — LOO-CV confusion matrix (left) and per-class LOO accuracy vs prior baseline (right). LDA reliably calls mid-buckets (small_miss / in_line / small_beat all ~48%) but collapses tail-bucket recall to zero/small values due to the log-prior intercept handicap.

The LDA discriminant function

Given a 6-dimensional response vector x = (r_1m, r_5m, r_15m, r_30m, r_1h, r_4h) — the pips move at each of the 6 post-release windows — Fisher LDA scores each class k by

δ_k(x) = x^T Σ⁻¹ μ_k − (1/2) μ_k^T Σ⁻¹ μ_k + log π_k

where Σ is the pooled within-class covariance, μ_k is the mean 6-vector for class k, and π_k is the class prior (empirical counts / n). The classifier predicts argmax_k δ_k(x). The posterior probability p(k | x) follows via softmax:

p(k | x) = exp(δ_k(x)) / Σ_j exp(δ_j(x)).

With 5 classes and 6-dim features, the model has (5−1) × 6 = 24 free discriminant coefficients before applying the (5) intercepts. That’s ~24 params on n=196 — comfortably identified but moderately data-hungry, hence the LOO gap between full-sample 49.49% and LOO 42.86%.

Why big_miss recall collapses to zero

The log-prior term is decisive. Compute:

Class	n	π_k	log π_k	Handicap vs adjacent
big_miss	13	0.0663	−2.71	−1.406 vs small_miss
small_miss	53	0.2704	−1.31	−0.156 vs in_line
in_line	62	0.3163	−1.15	baseline (highest prior)
small_beat	53	0.2704	−1.31	−0.156 vs in_line
big_beat	15	0.0765	−2.57	−1.260 vs small_beat

−1.406 nats is a big handicap. To classify a true-big-miss print AS big_miss, the discriminant-score difference (from the Σ⁻¹μ_k projections) has to overcome that penalty. On this sample it doesn’t: the big_miss centroid is separated from the small_miss centroid on the top canonical direction by only about 0.18 SD (per Stats #35’s standardized loadings), well short of the 1.4-nat prior handicap.

Strip the priors (use uniform π_k = 0.2 for all k, log π_k = −1.61 for all): big_miss LOO recall rises to 4/13 (30%) and big_beat to 5/15 (33%), but overall accuracy drops to ~44% because in_line loses its prior boost. Trade-off: empirical priors ⇒ max overall accuracy but zero tail recall; uniform priors ⇒ lower overall accuracy but non-zero tail recall. Which you want depends on your loss function.

Improvement over Stats #35 (1D nearest-centroid)

Method	Full-sample acc	LOO-CV acc	Note
Majority-class baseline	31.63%	31.63%	always predict in_line
Stats #35 1D nearest-centroid	36.73%	36.73%	Roy’s largest root only (81% of trace)
Stats #36 LDA (empirical priors)	49.49%	42.86%	4-D + log(π_k) intercept

LDA gains +6.13 pp LOO accuracy over Stats #35. Three sources: (a) all 4 canonical dimensions instead of just Roy’s largest root (recovers the 19% of between-class separation on the other 3 dimensions); (b) class-prior weighting via log(π_k) biases predictions toward majority classes (helpful for overall accuracy, disastrous for tail recall); (c) proper Gaussian-likelihood weighting instead of ad-hoc |centroid − score| distance. But the improvement is entirely concentrated in mid-bucket recall — small_miss / in_line / small_beat all jumped from ~30% to ~48%; big_miss went 0/13 → 0/13; big_beat went 2/15 → 2/15.

Cross-verification

All numbers cross-verified against sklearn 1.9.0’s LinearDiscriminantAnalysis(solver='lsqr', priors=empirical) on 2026-09-05 with 100% agreement on both full-sample and LOO predictions (196/196 identical class predictions). Manual Fisher-LDA computation used Python numpy 2.4.6 with pooled-within-class covariance and empirical priors; LOO loop rebuilt the classifier from scratch for each held-out release. Confusion matrix cells sum to 13 / 53 / 62 / 53 / 15 = 196 row totals; diagonal sum 0 + 26 + 30 + 26 + 2 = 84 = LOO correct.

Cross-links

Direct predecessor: Stats #35 (canonical direction) — same sample, 1D nearest-centroid classifier at 36.73% LOO, Roy’s largest root captured 81% of trace. Set-up paper: Stats #34 (MANOVA) — established that the 6-window response vector is non-null (Wilks Λ = 0.5810, F = 4.56, p = 9.7×10⁻¹²). Companion: Stats #28 (coefficient of partial determination) showed surprise_z adds only ~3% incremental variance over bucket assignment — LDA-on-response has 43% recovery, in the same neighborhood of information-content-per-independent-feature. Historical umbrella: Stats #29 (two-way ANOVA) showed bucket carries 18% total variance and window carries 0%, so the bucket-signal is real but noisy and the LDA classifier is picking up that same 18-ish% under a reversed causal question.

Keep reading