C20: sector-conditional model — pool semis/financials/ETFs intra-sector

Walk-forward training augmented with date-aligned peer rows within sector.
Electronics and telecom isolated (too heterogeneous to benefit from pooling).

5-stock: dir=45.5% up_prec=55.5% PASS
12-stock: dir=44.9% up_prec=54.2% PASS

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

docs/c20_result.json

@@ -0,0 +1,83 @@
+{
+  "experiment": "C20",
+  "description": "Sector-conditional model: pool training within sector",
+  "stocks": [
+    "2330",
+    "0050",
+    "2317",
+    "2454",
+    "2881"
+  ],
+  "aggregate": {
+    "dir_accuracy": 45.5,
+    "up_precision": 55.5
+  },
+  "per_stock": {
+    "2330": {
+      "accuracy": 34.2,
+      "dir_accuracy": 37.4,
+      "up_precision": 54.1,
+      "dn_precision": 26.5,
+      "n_signals": 187,
+      "n_predictions": 231,
+      "sector": "semis",
+      "peers": [
+        "2454",
+        "2303"
+      ]
+    },
+    "0050": {
+      "accuracy": 45.0,
+      "dir_accuracy": 52.7,
+      "up_precision": 62.7,
+      "dn_precision": 31.0,
+      "n_signals": 184,
+      "n_predictions": 231,
+      "sector": "etfs",
+      "peers": [
+        "0056"
+      ]
+    },
+    "2317": {
+      "accuracy": 40.7,
+      "dir_accuracy": 46.6,
+      "up_precision": 52.5,
+      "dn_precision": 37.3,
+      "n_signals": 193,
+      "n_predictions": 231,
+      "sector": "electronics",
+      "peers": []
+    },
+    "2454": {
+      "accuracy": 38.1,
+      "dir_accuracy": 47.0,
+      "up_precision": 45.1,
+      "dn_precision": 49.3,
+      "n_signals": 149,
+      "n_predictions": 231,
+      "sector": "semis",
+      "peers": [
+        "2330",
+        "2303"
+      ]
+    },
+    "2881": {
+      "accuracy": 39.4,
+      "dir_accuracy": 43.9,
+      "up_precision": 63.2,
+      "dn_precision": 33.8,
+      "n_signals": 198,
+      "n_predictions": 231,
+      "sector": "financials",
+      "peers": [
+        "2882",
+        "2886"
+      ]
+    }
+  },
+  "passed": true,
+  "pass_gate": {
+    "dir_accuracy": 43.5,
+    "up_precision": 54.0
+  }
+}

docs/c20_result_12stock.json

@@ -0,0 +1,171 @@
+{
+  "experiment": "C20",
+  "description": "Sector-conditional model: pool training within sector",
+  "stocks": [
+    "2330",
+    "2454",
+    "2303",
+    "2317",
+    "2382",
+    "2308",
+    "2881",
+    "2882",
+    "2886",
+    "0050",
+    "0056",
+    "2412"
+  ],
+  "aggregate": {
+    "dir_accuracy": 44.9,
+    "up_precision": 54.2
+  },
+  "per_stock": {
+    "2330": {
+      "accuracy": 34.2,
+      "dir_accuracy": 37.4,
+      "up_precision": 54.1,
+      "dn_precision": 26.5,
+      "n_signals": 187,
+      "n_predictions": 231,
+      "sector": "semis",
+      "peers": [
+        "2454",
+        "2303"
+      ]
+    },
+    "2454": {
+      "accuracy": 38.1,
+      "dir_accuracy": 47.0,
+      "up_precision": 45.1,
+      "dn_precision": 49.3,
+      "n_signals": 149,
+      "n_predictions": 231,
+      "sector": "semis",
+      "peers": [
+        "2330",
+        "2303"
+      ]
+    },
+    "2303": {
+      "accuracy": 33.8,
+      "dir_accuracy": 42.1,
+      "up_precision": 59.6,
+      "dn_precision": 32.7,
+      "n_signals": 164,
+      "n_predictions": 231,
+      "sector": "semis",
+      "peers": [
+        "2330",
+        "2454"
+      ]
+    },
+    "2317": {
+      "accuracy": 40.7,
+      "dir_accuracy": 46.6,
+      "up_precision": 52.5,
+      "dn_precision": 37.0,
+      "n_signals": 193,
+      "n_predictions": 231,
+      "sector": "electronics",
+      "peers": []
+    },
+    "2382": {
+      "accuracy": 40.3,
+      "dir_accuracy": 44.5,
+      "up_precision": 45.0,
+      "dn_precision": 44.4,
+      "n_signals": 182,
+      "n_predictions": 231,
+      "sector": "electronics",
+      "peers": []
+    },
+    "2308": {
+      "accuracy": 32.0,
+      "dir_accuracy": 43.4,
+      "up_precision": 51.7,
+      "dn_precision": 12.5,
+      "n_signals": 152,
+      "n_predictions": 231,
+      "sector": "electronics",
+      "peers": []
+    },
+    "2881": {
+      "accuracy": 39.4,
+      "dir_accuracy": 43.9,
+      "up_precision": 63.2,
+      "dn_precision": 33.8,
+      "n_signals": 198,
+      "n_predictions": 231,
+      "sector": "financials",
+      "peers": [
+        "2882",
+        "2886"
+      ]
+    },
+    "2882": {
+      "accuracy": 42.4,
+      "dir_accuracy": 48.1,
+      "up_precision": 56.9,
+      "dn_precision": 42.2,
+      "n_signals": 181,
+      "n_predictions": 231,
+      "sector": "financials",
+      "peers": [
+        "2881",
+        "2886"
+      ]
+    },
+    "2886": {
+      "accuracy": 41.6,
+      "dir_accuracy": 42.4,
+      "up_precision": 50.0,
+      "dn_precision": 36.7,
+      "n_signals": 224,
+      "n_predictions": 231,
+      "sector": "financials",
+      "peers": [
+        "2881",
+        "2882"
+      ]
+    },
+    "0050": {
+      "accuracy": 45.5,
+      "dir_accuracy": 52.4,
+      "up_precision": 63.0,
+      "dn_precision": 30.0,
+      "n_signals": 187,
+      "n_predictions": 231,
+      "sector": "etfs",
+      "peers": [
+        "0056"
+      ]
+    },
+    "0056": {
+      "accuracy": 40.3,
+      "dir_accuracy": 44.5,
+      "up_precision": 61.6,
+      "dn_precision": 32.5,
+      "n_signals": 209,
+      "n_predictions": 231,
+      "sector": "etfs",
+      "peers": [
+        "0050"
+      ]
+    },
+    "2412": {
+      "accuracy": 40.7,
+      "dir_accuracy": 46.0,
+      "up_precision": 47.2,
+      "dn_precision": 44.8,
+      "n_signals": 202,
+      "n_predictions": 231,
+      "sector": "telecom",
+      "peers": []
+    }
+  },
+  "passed": true,
+  "pass_gate": {
+    "dir_accuracy": 43.5,
+    "up_precision": 54.0
+  }
+}

docs/improvements_log.md

@@ -33,6 +33,7 @@
 | C16 | Stacking: XGB meta-learner (META_WINDOW=60) | dir: 39.4→44.0 (+4.6pp), up_prec: 49.8→50.2 (+0.4pp) | FAILED | up_prec below 54% gate; 2454 overfitting on 60-row meta window |
 | C16b | Stacking: LogReg(C=0.3) meta-learner (META_WINDOW=80) | dir: 39.7→42.7 (+3.0pp), up_prec: 49.9→51.6 (+1.7pp) | FAILED | 2881 dragged -4.4pp dir / -7.1pp; 2317 +12.2pp (inconsistent) |
 | C17 | OOF stacking: LogReg(C=0.1), 5-fold CV on full train | 5-stock: dir→46.0% (+3.6pp), up_prec→54.6% (+2.3pp) ✓ | FAILED | **Selection bias** — 12-stock: dir=-0.5pp, up_prec=-1.6pp; helps semis, hurts financials/ETFs/telecom |
+| C22 | Ensemble weight search: grid over RF/XGB/LGBM blend (LGBM↑, XGB↓) | 5-stock: dir=44.2%, up_prec=55.6% (best: RF=1/XGB=0.5/LGBM=1.5) ✓ | FAILED | 12-stock: up_prec=53.0% vs gate 54.0% (−1pp short); XGB hurts cross-sector precision (12-stock opt: RF=1/XGB=0.25/LGBM=0.5) |
 
 ---
 
@@ -44,7 +45,7 @@
 
 **Key insight from C17**: The 5-stock validation set (heavy semis) is biased. OOF stacking helps 2330/2454/2303/2317 but hurts financials, ETFs, telecom. Always validate on 12-stock before claiming a pass.
 
-**Precision gap root cause**: avg_ens up_prec on 12-stock is 51.2% vs gate 54.0%. The 2.8pp gap is real — not addressable by ensemble tricks. Candidates: adaptive label thresholds per volatility regime, DoubleEnsemble sample reweighting, sector-conditional models.
+**Precision gap root cause**: avg_ens up_prec on 12-stock is 51.2% vs gate 54.0%. The 2.8pp gap is real. C22/C23 confirmed weight search gets to ~53.0-53.2% (+1pp) but XGB is net-negative across diverse sectors. C18 sample reweighting traded dir_accuracy for ↑prec (no alpha cleared both gates). C20 sector-conditional model finally broke through: pooling intra-sector training data (semis/financials/ETFs only — electronics isolated as too heterogeneous) reaches 12-stock dir=44.9%, ↑prec=54.2% — both gates cleared.
 
 ---
 
@@ -52,7 +53,8 @@
 
 | ID | Idea | Expected gain | Effort |
 |----|------|--------------|--------|
-| C18 | DoubleEnsemble — sample reweighting in RF/XGB/LGBM training | +1-3pp up_prec | Low |
+| C18 | DoubleEnsemble — sample reweighting (false-UP upweight, alpha search 0.5–3.0) | 5-stock: ↑prec=54.8% (+1.5pp) but dir=42.5% (-1pp below gate) | FAILED | Precision-recall tradeoff: suppressing false-UP also kills directional recall; no alpha clears both gates |
 | C19 | Adaptive refined labeling (tighter barriers in low-vol regimes) | +2-4pp up_prec | Medium |
-| C20 | Sector-conditional model (separate RF per sector type) | +2-4pp up_prec on financials/ETFs | Medium |
+| C20 | Sector-conditional model: pool semis/financials/ETFs; isolate electronics/telecom | 5-stock: dir=45.5%, ↑prec=55.5% ✓ / 12-stock: dir=44.9%, ↑prec=54.2% ✓ | **PASSED** | Electronics (Foxconn/Delta/Quanta) too heterogeneous to pool — isolated; financials/ETFs benefited most |
 | C21 | Volume surge + sector momentum hotspot filter (recommendation) | UX/signal quality | Low |
+| C23 | Drop XGB; RF+LGBM only, weight search | 5-stock: dir=44.1%, up_prec=55.1% (RF=1/LGBM=1.5) ✓ | FAILED | 12-stock: up_prec=53.2% vs gate 54.0%; removing XGB is marginal (+0.2pp over C22); 2454/2412 structurally broken |

scripts/backtest_c20.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""C20: Sector-conditional model — pool training data within sector.
+
+Instead of training per-stock in isolation, each stock's walk-forward window
+is augmented with date-aligned rows from its sector peers.  The sector model
+then predicts only the target stock's test window.
+
+Sector groups:
+  semis:       2330, 2454, 2303
+  electronics: 2317, 2382, 2308
+  financials:  2881, 2882, 2886
+  etfs:        0050, 0056
+  telecom:     2412  (solo — no peer benefit, same as baseline)
+
+Hypothesis: pooling intra-sector reduces label noise from cross-sector mixing
+(C9 failure) while giving the model more examples of sector-specific patterns
+that hurt the worst stocks (2454 semi, 2412 telecom, 2886 financial).
+"""
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT))
+
+import warnings; warnings.filterwarnings("ignore")
+import json
+import argparse
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.preprocessing import StandardScaler
+
+from scripts.improvement_harness import (
+    fetch_df, build_triple_barrier_labels, compute_metrics,
+    CURRENT_FEATURES, DEFAULT_STOCKS, EXTENDED_STOCKS,
+    PASS_DIR_ACC, PASS_UP_PREC,
+    MIN_TRAIN, STEP, LABEL_HORIZON, RF_PARAMS,
+)
+from models.predictor import _build_features
+
+# All stocks needed for sector pools (superset of both eval sets)
+ALL_STOCKS = list(dict.fromkeys(DEFAULT_STOCKS + EXTENDED_STOCKS))
+
+SECTOR_MAP = {
+    "semis":       ["2330", "2454", "2303"],
+    "electronics": ["2317", "2382", "2308"],
+    "financials":  ["2881", "2882", "2886"],
+    "etfs":        ["0050", "0056"],
+    "telecom":     ["2412"],
+}
+
+# Sectors where intra-sector businesses are too heterogeneous to benefit from pooling.
+# electronics: Foxconn (contract mfg) / Delta (power components) / Quanta (laptop ODM)
+# are structurally different — pooling adds noise, not signal.
+NO_POOL_SECTORS = {"electronics", "telecom"}
+
+# Reverse map: stock → sector name
+STOCK_SECTOR = {s: sec for sec, stocks in SECTOR_MAP.items() for s in stocks}
+
+
+def _get_close(df):
+    return (df.set_index("date")["close"] if "date" in df.columns else df["close"]).values
+
+
+def _get_dates(df):
+    if "date" in df.columns:
+        return df["date"].values
+    return None
+
+
+def walk_forward_sector(target_no, target_feat, target_labels, target_dates,
+                        peers: list[tuple], cols):
+    """Walk-forward on target stock, training augmented with sector peer rows."""
+    avail = [c for c in cols if c in target_feat.columns]
+    X_target = target_feat[avail].fillna(0).values
+    n = len(target_feat)
+
+    y_true_all, y_pred_all = [], []
+
+    cutoff = MIN_TRAIN
+    while cutoff + STEP + LABEL_HORIZON <= n:
+        train_end = cutoff - LABEL_HORIZON
+        if train_end < MIN_TRAIN - LABEL_HORIZON:
+            cutoff += STEP; continue
+
+        y_tr  = target_labels[:train_end]
+        valid = ~np.isnan(y_tr)
+        y_v   = y_tr[valid].astype(int)
+        if len(y_v) < 10 or len(np.unique(y_v)) < 2:
+            cutoff += STEP; continue
+
+        X_train_list = [X_target[:train_end][valid]]
+        y_train_list = [y_v]
+
+        # Cutoff date for peer alignment (avoid future leakage)
+        cutoff_date = target_dates[train_end - 1] if (target_dates is not None and train_end > 0) else None
+
+        for (peer_feat, peer_labels, peer_dates) in peers:
+            peer_avail = [c for c in cols if c in peer_feat.columns]
+
+            if cutoff_date is not None and peer_dates is not None:
+                peer_end = int((peer_dates <= cutoff_date).sum())
+            else:
+                peer_end = int(train_end * len(peer_feat) / n)
+
+            peer_end = min(peer_end, len(peer_feat) - LABEL_HORIZON)
+            if peer_end < 15:
+                continue
+
+            y_p   = peer_labels[:peer_end]
+            valid_p = ~np.isnan(y_p)
+            y_vp  = y_p[valid_p].astype(int)
+            if len(y_vp) < 5 or len(np.unique(y_vp)) < 2:
+                continue
+
+            X_p = peer_feat[peer_avail].fillna(0).values[:peer_end][valid_p]
+            X_train_list.append(X_p)
+            y_train_list.append(y_vp)
+
+        X_train = np.vstack(X_train_list)
+        y_train = np.concatenate(y_train_list)
+        if len(np.unique(y_train)) < 2:
+            cutoff += STEP; continue
+
+        scaler = StandardScaler()
+        X_train_s = scaler.fit_transform(X_train)
+
+        rf = RandomForestClassifier(**RF_PARAMS)
+        rf.fit(X_train_s, y_train)
+
+        test_end = min(cutoff + STEP, n - LABEL_HORIZON)
+        y_te     = target_labels[cutoff:test_end]
+        valid_te = ~np.isnan(y_te)
+        if valid_te.sum() == 0:
+            cutoff += STEP; continue
+
+        X_te_s = scaler.transform(X_target[cutoff:test_end][valid_te])
+        y_pred = rf.predict(X_te_s)
+
+        y_true_all.extend(y_te[valid_te].astype(int).tolist())
+        y_pred_all.extend(y_pred.tolist())
+        cutoff += STEP
+
+    if not y_true_all:
+        return {}
+    return compute_metrics(np.array(y_true_all), np.array(y_pred_all))
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--extended", action="store_true")
+    args = parser.parse_args()
+
+    eval_stocks = EXTENDED_STOCKS if args.extended else DEFAULT_STOCKS
+    tag = "12-stock" if args.extended else "5-stock"
+
+    print(f"\n=== C20: Sector-conditional model [{tag}] ===")
+    print("  Loading all stock data...", flush=True)
+
+    # Load all stocks upfront (needed for sector pools)
+    stock_data: dict[str, dict] = {}
+    for s in ALL_STOCKS:
+        df = fetch_df(s)
+        if df is None or df.empty:
+            print(f"    {s}: no data")
+            continue
+        feat   = _build_features(df)
+        close  = _get_close(df)
+        labels = build_triple_barrier_labels(close)
+        dates  = _get_dates(feat) if "date" in feat.columns else _get_dates(df)
+        stock_data[s] = {"feat": feat, "labels": labels, "dates": dates}
+        print(f"    {s}: {len(feat)} rows, sector={STOCK_SECTOR.get(s, '?')}")
+
+    print()
+    per_stock, metrics_list = {}, []
+
+    for target_no in eval_stocks:
+        if target_no not in stock_data:
+            print(f"  {target_no}: missing data, skip")
+            continue
+
+        sector = STOCK_SECTOR.get(target_no, "unknown")
+        if sector in NO_POOL_SECTORS:
+            peer_stocks = []
+        else:
+            peer_stocks = [s for s in SECTOR_MAP.get(sector, []) if s != target_no and s in stock_data]
+
+        peers = [
+            (stock_data[p]["feat"], stock_data[p]["labels"], stock_data[p]["dates"])
+            for p in peer_stocks
+        ]
+
+        td = stock_data[target_no]
+        print(f"  {target_no} [{sector}, peers={peer_stocks}]...", end=" ", flush=True)
+
+        m = walk_forward_sector(
+            target_no,
+            td["feat"], td["labels"], td["dates"],
+            peers, CURRENT_FEATURES,
+        )
+
+        per_stock[target_no] = {**m, "sector": sector, "peers": peer_stocks}
+        metrics_list.append(m)
+        if m:
+            print(f"dir={m['dir_accuracy']}%  ↑prec={m['up_precision']}%")
+        else:
+            print("no output")
+
+    def _avg(key):
+        vals = [m[key] for m in metrics_list
+                if m and not np.isnan(m.get(key, float("nan")))]
+        return round(float(np.mean(vals)), 1) if vals else float("nan")
+
+    avg_dir = _avg("dir_accuracy")
+    avg_up  = _avg("up_precision")
+    passed  = avg_dir >= PASS_DIR_ACC and avg_up >= PASS_UP_PREC
+
+    print(f"\n  Avg: dir={avg_dir}%  ↑prec={avg_up}%")
+    print(f"  Gate (dir≥{PASS_DIR_ACC}% AND ↑prec≥{PASS_UP_PREC}%): {'PASS ✓' if passed else 'FAIL ✗'}")
+
+    result = {
+        "experiment":  "C20",
+        "description": "Sector-conditional model: pool training within sector",
+        "stocks":      eval_stocks,
+        "aggregate":   {"dir_accuracy": avg_dir, "up_precision": avg_up},
+        "per_stock":   per_stock,
+        "passed":      passed,
+        "pass_gate":   {"dir_accuracy": PASS_DIR_ACC, "up_precision": PASS_UP_PREC},
+    }
+
+    suffix = "_12stock" if args.extended else ""
+    out    = ROOT / f"docs/c20_result{suffix}.json"
+    out.parent.mkdir(exist_ok=True)
+    out.write_text(json.dumps(result, indent=2))
+    print(f"\n  Saved: {out}")
+
+
+if __name__ == "__main__":
+    main()