"""Experiment runner: the 15-evaluation cross-validation harness. For a given model config, runs every (seed, fold) evaluation: 1. subject-level train/val/test split (from splits.make_folds) 2. fit tabular stats on TRAIN ONLY (no leakage) 3. build modality-appropriate datasets/loaders 4. train with early stopping on val Macro-F1 5. predict on the held-out test fold -> persist per-subject OOF rows Hyperparameters are frozen per config; the test fold is NEVER used for selection. Results land in results//: oof.csv (pooled predictions), runs.json (per-run metrics), summary.json (mean±std + bootstrap CI). XGBoost models take a separate sklearn path (fit/predict, no torch trainer). """ from __future__ import annotations import json from pathlib import Path import numpy as np import pandas as pd import torch from torch.utils.data import DataLoader from ..data.datasets import (SliceDataset, VolumeDataset, TabularDataset, collate, fit_tab_stats) from ..data.splits import make_folds, split_for, assert_no_leakage, SEEDS, N_FOLDS from ..models.registry import build_model from ..models.baselines_tab import make_xgb from ..training.config import TrainConfig from ..training.trainer import fit, predict from .metrics import compute_metrics from .stats import aggregate_runs, bootstrap_ci ROOT = Path(__file__).resolve().parents[3] RESULTS = ROOT / "results" def _make_dataset(cfg: TrainConfig, sub_df, tab_stats, augment): if cfg.modality == "tabular": return TabularDataset(sub_df, cfg.tab_features, tab_stats) if cfg.modality == "vol3d": target = "tf3d" if cfg.model in ("swin3d", "hcct", "vswin_lite") else "cnn3d" return VolumeDataset(sub_df, cfg.tab_features, tab_stats, target=target, augment=augment) return SliceDataset(sub_df, cfg.tab_features, tab_stats, planes=tuple(cfg.planes), n_slices=cfg.n_slices, modality=cfg.modality, augment=augment) def _loader(ds, cfg, shuffle): return DataLoader(ds, batch_size=cfg.batch_size, shuffle=shuffle, num_workers=cfg.num_workers, collate_fn=collate, pin_memory=True, drop_last=False) def _run_xgb(cfg, df, folds, feature_subset, device=None): """XGBoost path for tabular / confound baselines.""" oof_rows, run_metrics = [], [] for seed in SEEDS: for fold in range(N_FOLDS): tr, va, te = split_for(folds, df, seed, fold) assert_no_leakage(tr, va, te) train_df = df[df.subject_id.isin(tr + va)] test_df = df[df.subject_id.isin(te)] stats = fit_tab_stats(train_df, feature_subset) def X(sub): return np.stack([ [(sub.iloc[i][f] if not pd.isna(sub.iloc[i][f]) else stats[f]["median"]) for f in feature_subset] for i in range(len(sub)) ]).astype(np.float32) clf = make_xgb(seed=seed) clf.fit(X(train_df), train_df["class_id"].to_numpy()) prob = clf.predict_proba(X(test_df)) pred = prob.argmax(1) y = test_df["class_id"].to_numpy() run_metrics.append(compute_metrics(y, pred, prob)) for sid, yt, yp, pr in zip(test_df.subject_id, y, pred, prob): oof_rows.append({"subject_id": sid, "seed": seed, "fold": fold, "y_true": int(yt), "y_pred": int(yp), **{f"prob_{k}": float(pr[k]) for k in range(3)}}) return oof_rows, run_metrics def _run_torch(cfg, df, folds, device): oof_rows, run_metrics = [], [] for seed in SEEDS: for fold in range(N_FOLDS): torch.manual_seed(seed) tr, va, te = split_for(folds, df, seed, fold) assert_no_leakage(tr, va, te) train_df = df[df.subject_id.isin(tr)] val_df = df[df.subject_id.isin(va)] test_df = df[df.subject_id.isin(te)] tab_stats = fit_tab_stats(train_df, cfg.tab_features) counts = np.bincount(train_df["class_id"], minlength=3).tolist() dl_tr = _loader(_make_dataset(cfg, train_df, tab_stats, augment=True), cfg, True) dl_va = _loader(_make_dataset(cfg, val_df, tab_stats, augment=False), cfg, False) dl_te = _loader(_make_dataset(cfg, test_df, tab_stats, augment=False), cfg, False) cfg_run = TrainConfig(**{**cfg.to_dict(), "seed": seed}) model = build_model(cfg_run, n_tab_features=len(cfg.tab_features), pretrained=True) fit(model, dl_tr, dl_va, cfg_run, counts, device=device) sids, y, pred, prob = predict(model, dl_te, cfg.modality, device) run_metrics.append(compute_metrics(y, pred, prob)) for sid, yt, yp, pr in zip(sids, y, pred, prob): oof_rows.append({"subject_id": sid, "seed": seed, "fold": fold, "y_true": int(yt), "y_pred": int(yp), **{f"prob_{k}": float(pr[k]) for k in range(3)}}) del model if device == "cuda": torch.cuda.empty_cache() print(f" [{cfg.name}] seed={seed} fold={fold} " f"macro_f1={run_metrics[-1]['macro_f1']:.4f}", flush=True) return oof_rows, run_metrics def run_experiment(cfg: TrainConfig, subjects_csv=None, device="cuda", feature_subset=None) -> dict: subjects_csv = subjects_csv or (ROOT / "data" / "metadata" / "subjects_clean.csv") df = pd.read_csv(subjects_csv) folds = make_folds(df) if cfg.model == "xgboost": feats = feature_subset or list(cfg.tab_features) oof_rows, run_metrics = _run_xgb(cfg, df, folds, feats) else: oof_rows, run_metrics = _run_torch(cfg, df, folds, device) out_dir = RESULTS / cfg.name out_dir.mkdir(parents=True, exist_ok=True) oof = pd.DataFrame(oof_rows) oof.to_csv(out_dir / "oof.csv", index=False) summary = aggregate_runs(run_metrics) point, lo, hi = bootstrap_ci(oof) payload = { "name": cfg.name, "model": cfg.model, "n_runs": len(run_metrics), "summary": {k: {"mean": v[0], "std": v[1]} for k, v in summary.items()}, "macro_f1_bootstrap": {"point": point, "ci_lo": lo, "ci_hi": hi}, "config": cfg.to_dict(), } (out_dir / "runs.json").write_text(json.dumps(run_metrics, indent=2)) (out_dir / "summary.json").write_text(json.dumps(payload, indent=2, default=str)) print(f"[{cfg.name}] macro_f1 = {summary['macro_f1'][0]:.4f} ± " f"{summary['macro_f1'][1]:.4f} (CI {lo:.3f}-{hi:.3f})", flush=True) return payload